Add a home-restricted folder picker to the new-chat dialog

Server: list_directory returns a directory_listing (path, home, parent,
entries with is_dir/is_git_repo/hidden, truncated) confined to the server
user's home subtree after cleaning and resolving symlinks, refusing pseudo
filesystems and capping entries at 2000. Documented in docs/cli.md.

App: "Choose folder…" in the create dialog opens a picker (full-screen page
on phones, large dialog on wide windows, Material and Cupertino) with
breadcrumbs, filter, Show hidden, git badges, dimmed files, recent folders,
inline errors and "Start chat here". The probe app gains a folder fixture
for captures.
This commit is contained in:
2026-11-01 21:51:48 +00:00
parent eadd017bdc
commit eed3806efb
25 changed files with 2333 additions and 9 deletions
@@ -0,0 +1,112 @@
import '../../../core/api_gateway.dart';
/// One name in a `directory_listing` reply. Only directories are selectable;
/// files are listed for context.
class DirectoryEntry {
const DirectoryEntry({
required this.name,
required this.path,
required this.isDir,
required this.isGitRepo,
required this.hidden,
});
factory DirectoryEntry.fromJson(JsonMap json) => DirectoryEntry(
name: '${json['name'] ?? ''}',
path: '${json['path'] ?? ''}',
isDir: json['is_dir'] == true,
isGitRepo: json['is_git_repo'] == true,
hidden: json['hidden'] == true,
);
final String name;
final String path;
final bool isDir;
final bool isGitRepo;
final bool hidden;
}
/// The server's home-restricted listing of one folder.
class DirectoryListing {
const DirectoryListing({
required this.path,
required this.home,
required this.parent,
required this.entries,
this.truncated = false,
});
/// Reads the `directory_listing` body; a reply without one is a protocol
/// error, never an empty folder.
factory DirectoryListing.fromReply(JsonMap reply) {
final body = reply['directory_listing'];
if (body is! Map || body['path'] is! String || body['home'] is! String) {
throw StateError('Server did not return a directory listing.');
}
final entries = body['entries'];
return DirectoryListing(
path: body['path'] as String,
home: body['home'] as String,
parent: body['parent'] is String ? body['parent'] as String : null,
entries: [
if (entries is List)
for (final entry in entries)
if (entry is Map) DirectoryEntry.fromJson(entry.cast()),
],
truncated: body['truncated'] == true,
);
}
final String path;
final String home;
final String? parent;
final List<DirectoryEntry> entries;
final bool truncated;
}
/// One breadcrumb: its visible label and the folder it opens.
typedef FolderCrumb = ({String label, String path});
/// The crumbs from home (`~`) down to [path]. A path outside [home] yields
/// home alone, because the picker never lists outside it.
List<FolderCrumb> folderCrumbs(String home, String path) {
final crumbs = <FolderCrumb>[(label: '~', path: home)];
if (!isInsideHome(home, path) || path == home) return crumbs;
final base = home.endsWith('/') ? home : '$home/';
var current = home;
for (final part in path.substring(base.length).split('/')) {
if (part.isEmpty) continue;
current = current.endsWith('/') ? '$current$part' : '$current/$part';
crumbs.add((label: part, path: current));
}
return crumbs;
}
/// Whether [path] is [home] or a folder below it, compared lexically.
bool isInsideHome(String home, String path) {
if (home.isEmpty) return false;
if (path == home) return true;
final base = home.endsWith('/') ? home : '$home/';
return path.startsWith(base);
}
/// [path] shown relative to home (`~/src/app`), or as sent when outside it.
String homeRelativeLabel(String home, String path) {
if (path == home) return '~';
if (!isInsideHome(home, path)) return path;
final base = home.endsWith('/') ? home : '$home/';
return '~/${path.substring(base.length)}';
}
/// Sends `list_directory`; an omitted [path] lists the server user's home.
Future<DirectoryListing> listDirectory(
ApiGateway gateway, [
String? path,
]) async {
final reply = await gateway.call('list_directory', {
'list_directory': {
if (path != null && path.trim().isNotEmpty) 'path': path.trim(),
},
});
return DirectoryListing.fromReply(reply);
}
@@ -0,0 +1,138 @@
import 'package:flutter/foundation.dart';
import '../../../../core/api_gateway.dart';
import '../../data/directory_listing.dart';
/// The folder picker's state: the last listing, the folder being loaded, an
/// inline error, the hidden toggle and the filter. Listing goes through the
/// server's home-restricted `list_directory`; nothing is guessed locally.
class FolderPickerController extends ChangeNotifier {
FolderPickerController({
required this.gateway,
this.initialPath,
this.recentFolders = const [],
});
final ApiGateway gateway;
final String? initialPath;
/// Every recent chat folder the server reported; [recents] filters them.
final List<String> recentFolders;
DirectoryListing? _listing;
String? _error;
String? _failedPath;
bool _loading = false;
bool _showHidden = false;
String _filter = '';
int _request = 0;
bool _disposed = false;
DirectoryListing? get listing => _listing;
String? get error => _error;
bool get loading => _loading;
bool get showHidden => _showHidden;
String get filter => _filter;
/// The home directory once any listing has arrived.
String? get home => _listing?.home;
/// The folder "Start chat here" would use: only a successfully listed one.
String? get selectable => _loading || _error != null ? null : _listing?.path;
bool get atHome => _listing != null && _listing!.parent == null;
/// Recent chat folders inside home, offered only at the home level.
List<String> get recents {
final listing = _listing;
if (listing == null || listing.parent != null || _error != null) {
return const [];
}
return [
for (final path in recentFolders)
if (path != listing.home && isInsideHome(listing.home, path)) path,
];
}
/// The visible entries: hidden names only when toggled on, then the filter
/// (case-insensitive substring). Folders stay ahead of files as sent.
List<DirectoryEntry> get entries {
final listing = _listing;
if (listing == null) return const [];
final needle = _filter.trim().toLowerCase();
return [
for (final entry in listing.entries)
if ((_showHidden || !entry.hidden) &&
(needle.isEmpty || entry.name.toLowerCase().contains(needle)))
entry,
];
}
/// How many hidden names the toggle currently conceals.
int get hiddenCount =>
_showHidden ? 0 : (_listing?.entries.where((e) => e.hidden).length ?? 0);
Future<void> start() => open(initialPath);
/// Lists [path] (home when null). A failure keeps the previous listing for
/// the breadcrumbs and Back, and shows the server's words inline.
Future<void> open(String? path) async {
final request = ++_request;
_loading = true;
_error = null;
_failedPath = path;
_notify();
try {
final next = await listDirectory(gateway, path);
if (_disposed || request != _request) return;
_listing = next;
_filter = '';
_failedPath = null;
} catch (error) {
if (_disposed || request != _request) return;
_error = '$error';
} finally {
if (!_disposed && request == _request) {
_loading = false;
_notify();
}
}
}
Future<void> retry() => open(_failedPath ?? _listing?.path ?? initialPath);
/// Back: dismiss an error first, then go up one folder. Returns false at
/// home, where Back leaves the picker.
bool up() {
if (_error != null && _listing != null) {
_error = null;
_failedPath = null;
_notify();
return true;
}
final parent = _listing?.parent;
if (parent == null) return false;
open(parent);
return true;
}
void setShowHidden(bool value) {
_showHidden = value;
_notify();
}
void setFilter(String value) {
_filter = value;
_notify();
}
void _notify() {
if (!_disposed) notifyListeners();
}
@override
void dispose() {
_disposed = true;
super.dispose();
}
}
@@ -0,0 +1,194 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../data/directory_listing.dart';
import 'folder_picker_controller.dart';
import 'folder_picker_status.dart';
/// The body: loading, the inline error, or recent folders (home level only)
/// followed by the current folder's folders and its dimmed, unselectable files.
class FolderPickerList extends StatelessWidget {
const FolderPickerList({
super.key,
required this.cupertino,
required this.controller,
});
final bool cupertino;
final FolderPickerController controller;
@override
Widget build(BuildContext context) {
final listing = controller.listing;
if (controller.error != null) {
return FolderPickerError(cupertino: cupertino, controller: controller);
}
if (listing == null) {
return FolderPickerLoading(cupertino: cupertino);
}
final entries = controller.entries;
final recents = controller.filter.trim().isEmpty
? controller.recents
: const <String>[];
final rows = <Widget>[
if (controller.loading) FolderPickerLoadingBar(cupertino: cupertino),
if (recents.isNotEmpty) ...[
FolderSectionHeader(cupertino: cupertino, text: 'Recent folders'),
for (final path in recents)
_RecentRow(
cupertino: cupertino,
label: homeRelativeLabel(listing.home, path),
onTap: () => controller.open(path),
),
FolderSectionHeader(
cupertino: cupertino,
text: 'In ${homeRelativeLabel(listing.home, listing.path)}',
),
],
for (final entry in entries)
_EntryRow(
cupertino: cupertino,
entry: entry,
onTap: entry.isDir ? () => controller.open(entry.path) : null,
),
if (entries.isEmpty)
FolderPickerNote(
cupertino: cupertino,
text: controller.filter.trim().isNotEmpty
? 'Nothing here matches “${controller.filter.trim()}”.'
: controller.hiddenCount > 0
? 'Only hidden items here. Turn on Show hidden to see them.'
: 'This folder is empty.',
),
if (listing.truncated)
FolderPickerNote(
cupertino: cupertino,
text:
'This folder is large; only the first entries are shown. '
'Use the filter or type the path instead.',
),
];
return ListView(
key: ValueKey('folder-list-${listing.path}'),
children: rows,
);
}
}
class _RecentRow extends StatelessWidget {
const _RecentRow({
required this.cupertino,
required this.label,
required this.onTap,
});
final bool cupertino;
final String label;
final VoidCallback onTap;
@override
Widget build(BuildContext context) {
if (cupertino) {
return CupertinoListTile(
leading: const Icon(CupertinoIcons.clock),
title: Text(label),
trailing: const CupertinoListTileChevron(),
onTap: onTap,
);
}
return ListTile(
leading: const Icon(Icons.history),
title: Text(label),
trailing: const Icon(Icons.chevron_right),
onTap: onTap,
);
}
}
class _EntryRow extends StatelessWidget {
const _EntryRow({
required this.cupertino,
required this.entry,
required this.onTap,
});
final bool cupertino;
final DirectoryEntry entry;
final VoidCallback? onTap;
@override
Widget build(BuildContext context) {
final folder = entry.isDir;
final trailing = folder
? Row(
mainAxisSize: MainAxisSize.min,
children: [
if (entry.isGitRepo) FolderGitBadge(cupertino: cupertino),
const SizedBox(width: 4),
cupertino
? const CupertinoListTileChevron()
: const Icon(Icons.chevron_right),
],
)
: null;
if (cupertino) {
final dim = CupertinoColors.tertiaryLabel.resolveFrom(context);
return CupertinoListTile(
key: ValueKey('folder-entry-${entry.path}'),
leading: Icon(
folder ? CupertinoIcons.folder_fill : CupertinoIcons.doc,
color: folder ? null : dim,
),
title: Text(entry.name, style: folder ? null : TextStyle(color: dim)),
trailing: trailing,
onTap: onTap,
);
}
return ListTile(
key: ValueKey('folder-entry-${entry.path}'),
enabled: folder,
leading: Icon(
folder ? Icons.folder : Icons.insert_drive_file_outlined,
color: folder ? Theme.of(context).colorScheme.primary : null,
),
title: Text(entry.name),
trailing: trailing,
onTap: onTap,
);
}
}
/// The small "git" mark on a repository folder.
class FolderGitBadge extends StatelessWidget {
const FolderGitBadge({super.key, required this.cupertino});
final bool cupertino;
@override
Widget build(BuildContext context) {
if (!cupertino) {
final scheme = Theme.of(context).colorScheme;
return Badge(
label: const Text('git'),
backgroundColor: scheme.secondaryContainer,
textColor: scheme.onSecondaryContainer,
);
}
return DecoratedBox(
decoration: BoxDecoration(
color: CupertinoColors.systemGrey5.resolveFrom(context),
borderRadius: BorderRadius.circular(6),
),
child: Padding(
padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 1),
child: Text(
'git',
style: TextStyle(
fontSize: 12,
color: CupertinoColors.secondaryLabel.resolveFrom(context),
),
),
),
);
}
}
@@ -0,0 +1,152 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../../../core/api_gateway.dart';
import '../../data/directory_listing.dart';
import '../sessions/chat_adaptive.dart';
import 'folder_picker_controller.dart';
import 'folder_picker_list.dart';
import 'folder_picker_parts.dart';
const String folderPickerTitle = 'Choose folder';
const String folderPickerStartLabel = 'Start chat here';
/// The folder picker: breadcrumbs, a filter and hidden toggle, the current
/// folder's entries and a prominent "Start chat here". It pops with the chosen
/// absolute path; Back climbs one folder and leaves only at home.
class FolderPickerPage extends StatefulWidget {
const FolderPickerPage({
super.key,
required this.gateway,
this.initialPath,
this.recents = const [],
});
final ApiGateway gateway;
final String? initialPath;
final List<String> recents;
@override
State<FolderPickerPage> createState() => _FolderPickerPageState();
}
class _FolderPickerPageState extends State<FolderPickerPage> {
late final FolderPickerController _controller = FolderPickerController(
gateway: widget.gateway,
initialPath: widget.initialPath,
recentFolders: widget.recents,
);
final _filter = TextEditingController();
String? _shownPath;
@override
void initState() {
super.initState();
_controller.addListener(_changed);
_controller.start();
}
void _changed() {
final path = _controller.listing?.path;
if (path != _shownPath) {
_shownPath = path;
_filter.clear();
}
setState(() {});
}
@override
void dispose() {
_controller.removeListener(_changed);
_controller.dispose();
_filter.dispose();
super.dispose();
}
void _back() {
if (!_controller.up()) Navigator.pop(context);
}
void _start() {
final path = _controller.selectable;
if (path != null) Navigator.pop(context, path);
}
@override
Widget build(BuildContext context) {
final cupertino =
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
final body = Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
FolderBreadcrumbs(cupertino: cupertino, controller: _controller),
FolderPickerToolbar(
cupertino: cupertino,
controller: _controller,
filter: _filter,
),
Expanded(
child: FolderPickerList(
cupertino: cupertino,
controller: _controller,
),
),
FolderStartBar(
cupertino: cupertino,
path: _controller.selectable,
home: _controller.home,
onStart: _start,
),
],
);
return PopScope(
canPop: _controller.atHome && _controller.error == null,
onPopInvokedWithResult: (didPop, _) {
if (!didPop) _back();
},
child: cupertino ? _cupertino(context, body) : _material(body),
);
}
Widget _material(Widget body) {
return Scaffold(
appBar: AppBar(
leading: BackButton(onPressed: _back),
title: const Text(folderPickerTitle),
actions: [
TextButton(
onPressed: () => Navigator.pop(context),
child: const Text('Cancel'),
),
],
),
body: SafeArea(top: false, child: body),
);
}
Widget _cupertino(BuildContext context, Widget body) {
final parent = _controller.listing?.parent;
final home = _controller.home;
return CupertinoPageScaffold(
navigationBar: CupertinoNavigationBar(
automaticallyImplyLeading: false,
leading: CupertinoNavigationBarBackButton(
onPressed: _back,
previousPageTitle: parent == null || home == null
? 'Back'
: folderCrumbs(home, parent).last.label,
),
middle: const Text(folderPickerTitle),
trailing: CupertinoButton(
padding: EdgeInsets.zero,
onPressed: () => Navigator.pop(context),
child: const Text('Cancel'),
),
),
child: DefaultTextStyle(
style: CupertinoTheme.of(context).textTheme.textStyle,
child: SafeArea(child: body),
),
);
}
}
@@ -0,0 +1,268 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../data/directory_listing.dart';
import 'folder_picker_controller.dart';
/// The path from `~` to the current folder; every crumb but the last opens
/// that folder. It scrolls so the current folder stays visible.
class FolderBreadcrumbs extends StatelessWidget {
const FolderBreadcrumbs({
super.key,
required this.cupertino,
required this.controller,
});
final bool cupertino;
final FolderPickerController controller;
@override
Widget build(BuildContext context) {
final listing = controller.listing;
if (listing == null) return const SizedBox.shrink();
final crumbs = folderCrumbs(listing.home, listing.path);
final children = <Widget>[];
for (var i = 0; i < crumbs.length; i++) {
final crumb = crumbs[i];
final last = i == crumbs.length - 1;
if (i > 0) {
children.add(
Icon(
cupertino ? CupertinoIcons.chevron_right : Icons.chevron_right,
size: 16,
),
);
}
children.add(
Semantics(
label: last ? 'Current folder ${crumb.label}' : 'Open ${crumb.label}',
button: !last,
excludeSemantics: true,
child: _crumb(context, crumb, last),
),
);
}
return Padding(
padding: const EdgeInsets.symmetric(horizontal: 8),
// Reversed so a deep path keeps the current folder in view; the
// viewport-wide minimum keeps a short path aligned to the start.
child: LayoutBuilder(
builder: (context, constraints) => SingleChildScrollView(
scrollDirection: Axis.horizontal,
reverse: true,
child: ConstrainedBox(
constraints: BoxConstraints(minWidth: constraints.maxWidth),
child: Row(children: children),
),
),
),
);
}
Widget _crumb(BuildContext context, FolderCrumb crumb, bool last) {
final text = Text(
crumb.label,
style: last ? const TextStyle(fontWeight: FontWeight.w600) : null,
);
final home = crumb.label == '~' && crumb.path == controller.home;
final label = home
? Row(
mainAxisSize: MainAxisSize.min,
children: [
Icon(cupertino ? CupertinoIcons.house : Icons.home_outlined),
const SizedBox(width: 4),
text,
],
)
: text;
final onPressed = last ? null : () => controller.open(crumb.path);
if (cupertino) {
return CupertinoButton(
key: ValueKey('folder-crumb-${crumb.path}'),
padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 8),
onPressed: onPressed,
disabledColor: CupertinoColors.transparent,
child: last
? DefaultTextStyle.merge(
style: TextStyle(
color: CupertinoColors.label.resolveFrom(context),
),
child: label,
)
: label,
);
}
return TextButton(
key: ValueKey('folder-crumb-${crumb.path}'),
onPressed: onPressed,
style: last
? TextButton.styleFrom(
disabledForegroundColor: Theme.of(context).colorScheme.onSurface,
)
: null,
child: label,
);
}
}
/// The filter field for the current folder and the "Show hidden" toggle.
class FolderPickerToolbar extends StatelessWidget {
const FolderPickerToolbar({
super.key,
required this.cupertino,
required this.controller,
required this.filter,
});
final bool cupertino;
final FolderPickerController controller;
final TextEditingController filter;
@override
Widget build(BuildContext context) {
final hiddenLabel = controller.hiddenCount > 0
? 'Show hidden (${controller.hiddenCount})'
: 'Show hidden';
final field = cupertino
? CupertinoSearchTextField(
key: const Key('folder-picker-filter'),
controller: filter,
placeholder: 'Filter this folder',
onChanged: controller.setFilter,
)
: TextField(
key: const Key('folder-picker-filter'),
controller: filter,
onChanged: controller.setFilter,
decoration: InputDecoration(
isDense: true,
prefixIcon: const Icon(Icons.search),
hintText: 'Filter this folder',
border: const OutlineInputBorder(),
suffixIcon: filter.text.isEmpty
? null
: IconButton(
tooltip: 'Clear filter',
icon: const Icon(Icons.clear),
onPressed: () {
filter.clear();
controller.setFilter('');
},
),
),
);
final toggle = cupertino
? Semantics(
label: 'Show hidden',
toggled: controller.showHidden,
excludeSemantics: true,
child: GestureDetector(
onTap: () => controller.setShowHidden(!controller.showHidden),
child: Row(
mainAxisSize: MainAxisSize.min,
children: [
Text(hiddenLabel),
const SizedBox(width: 6),
CupertinoSwitch(
key: const Key('folder-picker-hidden'),
value: controller.showHidden,
onChanged: controller.setShowHidden,
),
],
),
),
)
: FilterChip(
key: const Key('folder-picker-hidden'),
label: Text(hiddenLabel),
selected: controller.showHidden,
onSelected: controller.setShowHidden,
);
return Padding(
padding: const EdgeInsets.fromLTRB(16, 4, 16, 8),
child: Wrap(
spacing: 12,
runSpacing: 8,
crossAxisAlignment: WrapCrossAlignment.center,
children: [
ConstrainedBox(
constraints: const BoxConstraints(maxWidth: 420),
child: field,
),
toggle,
],
),
);
}
}
/// The prominent confirm: names the folder and starts the chat there. It is
/// disabled until a folder is listed (never while loading or after an error).
class FolderStartBar extends StatelessWidget {
const FolderStartBar({
super.key,
required this.cupertino,
required this.path,
required this.home,
required this.onStart,
});
final bool cupertino;
final String? path;
final String? home;
final VoidCallback onStart;
@override
Widget build(BuildContext context) {
final where = path == null || home == null
? 'No folder selected'
: 'Start in ${homeRelativeLabel(home!, path!)}';
final onPressed = path == null ? null : onStart;
final button = cupertino
? CupertinoButton.filled(
key: const Key('folder-picker-start'),
onPressed: onPressed,
child: const Text('Start chat here'),
)
: FilledButton.icon(
key: const Key('folder-picker-start'),
onPressed: onPressed,
icon: const Icon(Icons.chat_bubble_outline),
label: const Text('Start chat here'),
);
final content = Padding(
padding: const EdgeInsets.fromLTRB(16, 8, 16, 12),
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Text(
where,
key: const Key('folder-picker-where'),
maxLines: 1,
overflow: TextOverflow.ellipsis,
),
const SizedBox(height: 8),
button,
],
),
);
if (cupertino) {
return DecoratedBox(
decoration: BoxDecoration(
border: Border(
top: BorderSide(
color: CupertinoColors.separator.resolveFrom(context),
width: 0,
),
),
),
child: content,
);
}
return Material(
color: Theme.of(context).colorScheme.surfaceContainer,
child: content,
);
}
}
@@ -0,0 +1,70 @@
import 'dart:math' as math;
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../../../core/api_gateway.dart';
import '../sessions/chat_adaptive.dart';
import 'folder_picker_page.dart';
/// At or above this window width the picker is a large dialog over the create
/// dialog; below it, a full-screen page.
const double folderPickerDialogBreakpoint = 720;
/// The wide dialog's bounds, kept here so the page itself stays content-sized.
const double _dialogMaxWidth = 760;
const double _dialogMaxHeight = 900;
/// Opens the folder picker and resolves to the chosen absolute folder, or
/// null when the operator cancels. [initialPath] opens there when the server
/// can list it; [recents] are offered as quick picks at the home level.
Future<String?> showFolderPicker(
BuildContext context, {
required ApiGateway gateway,
String? initialPath,
List<String> recents = const [],
}) {
final cupertino = chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
final size = MediaQuery.sizeOf(context);
final wide = size.width >= folderPickerDialogBreakpoint;
final navigator = Navigator.of(context, rootNavigator: true);
Widget page(BuildContext _) => FolderPickerPage(
gateway: gateway,
initialPath: initialPath,
recents: recents,
);
if (!wide) {
return navigator.push<String>(
cupertino
? CupertinoPageRoute(fullscreenDialog: true, builder: page)
: MaterialPageRoute(fullscreenDialog: true, builder: page),
);
}
Widget bounded(BuildContext context) {
final window = MediaQuery.sizeOf(context);
return SizedBox(
width: math.min(_dialogMaxWidth, window.width - 64),
height: math.min(_dialogMaxHeight, window.height * 0.85),
child: page(context),
);
}
if (cupertino) {
return showCupertinoDialog<String>(
context: context,
useRootNavigator: true,
builder: (context) => Center(
child: ClipRRect(
borderRadius: BorderRadius.circular(14),
child: bounded(context),
),
),
);
}
return showDialog<String>(
context: context,
useRootNavigator: true,
builder: (context) =>
Dialog(clipBehavior: Clip.antiAlias, child: bounded(context)),
);
}
@@ -0,0 +1,164 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../data/directory_listing.dart';
import 'folder_picker_controller.dart';
/// First load: a centred native activity indicator.
class FolderPickerLoading extends StatelessWidget {
const FolderPickerLoading({super.key, required this.cupertino});
final bool cupertino;
@override
Widget build(BuildContext context) {
return Center(
child: Semantics(
label: 'Loading folder',
child: cupertino
? const CupertinoActivityIndicator()
: const CircularProgressIndicator(),
),
);
}
}
/// A later load keeps the previous listing on screen under a thin indicator.
class FolderPickerLoadingBar extends StatelessWidget {
const FolderPickerLoadingBar({super.key, required this.cupertino});
final bool cupertino;
@override
Widget build(BuildContext context) {
return Semantics(
label: 'Loading folder',
child: cupertino
? const Padding(
padding: EdgeInsets.all(8),
child: CupertinoActivityIndicator(),
)
: const LinearProgressIndicator(),
);
}
}
/// The server's refusal shown in place (outside home, permission denied,
/// missing folder), with Retry, Back to the last good folder, and Home.
class FolderPickerError extends StatelessWidget {
const FolderPickerError({
super.key,
required this.cupertino,
required this.controller,
});
final bool cupertino;
final FolderPickerController controller;
@override
Widget build(BuildContext context) {
final color = cupertino
? CupertinoColors.systemRed.resolveFrom(context)
: Theme.of(context).colorScheme.error;
final listing = controller.listing;
final actions = <(String, VoidCallback)>[
('Retry', controller.retry),
if (listing != null)
(
'Back to ${homeRelativeLabel(listing.home, listing.path)}',
controller.up,
),
if (!controller.atHome || listing == null)
('Go to home', () => controller.open(null)),
];
return SingleChildScrollView(
padding: const EdgeInsets.all(24),
child: Column(
crossAxisAlignment: CrossAxisAlignment.center,
children: [
Icon(
cupertino
? CupertinoIcons.exclamationmark_triangle
: Icons.error_outline,
color: color,
),
const SizedBox(height: 8),
Text(
"Can't open this folder",
style: const TextStyle(fontWeight: FontWeight.w600),
textAlign: TextAlign.center,
),
const SizedBox(height: 4),
Text(
controller.error ?? '',
key: const Key('folder-picker-error'),
textAlign: TextAlign.center,
style: TextStyle(color: color),
),
const SizedBox(height: 12),
Wrap(
spacing: 8,
alignment: WrapAlignment.center,
children: [
for (final (label, onPressed) in actions)
cupertino
? CupertinoButton(onPressed: onPressed, child: Text(label))
: TextButton(onPressed: onPressed, child: Text(label)),
],
),
],
),
);
}
}
/// A section label above recent folders and the folder's own entries.
class FolderSectionHeader extends StatelessWidget {
const FolderSectionHeader({
super.key,
required this.cupertino,
required this.text,
});
final bool cupertino;
final String text;
@override
Widget build(BuildContext context) {
final style = cupertino
? TextStyle(
fontSize: 13,
color: CupertinoColors.secondaryLabel.resolveFrom(context),
)
: Theme.of(context).textTheme.labelLarge?.copyWith(
color: Theme.of(context).colorScheme.primary,
);
return Padding(
padding: const EdgeInsets.fromLTRB(16, 12, 16, 4),
child: Text(text, style: style),
);
}
}
/// A quiet explanatory line (empty folder, no matches, truncated listing).
class FolderPickerNote extends StatelessWidget {
const FolderPickerNote({
super.key,
required this.cupertino,
required this.text,
});
final bool cupertino;
final String text;
@override
Widget build(BuildContext context) {
final color = cupertino
? CupertinoColors.secondaryLabel.resolveFrom(context)
: Theme.of(context).colorScheme.onSurfaceVariant;
return Padding(
padding: const EdgeInsets.all(16),
child: Text(text, style: TextStyle(color: color)),
);
}
}
@@ -6,6 +6,9 @@ import 'chat_adaptive.dart';
/// The web's directory prompt, also the directory picker's label.
const String chatCreatePrompt = 'Where should this chat live?';
/// Opens the folder picker from the create dialog.
const String chatChooseFolderLabel = 'Choose folder…';
/// The home choice: shown as `Home (~)` and sent as the `~` the server
/// documents.
const String chatHomeDirectory = '~';
@@ -49,6 +52,7 @@ class ChatCatalogFields extends StatelessWidget {
required this.onDirectory,
required this.onBackend,
required this.onRetry,
this.onBrowse,
});
final bool loading;
@@ -61,6 +65,9 @@ class ChatCatalogFields extends StatelessWidget {
final ValueChanged<String> onBackend;
final VoidCallback onRetry;
/// Opens the folder picker; null hides the "Choose folder" action.
final VoidCallback? onBrowse;
@override
Widget build(BuildContext context) {
final cupertino =
@@ -85,13 +92,42 @@ class ChatCatalogFields extends StatelessWidget {
onSelected: onDirectory,
)
else
MaterialPickerField(
fieldKey: const Key('chat-create-server-directory'),
label: chatCreatePrompt,
value: directory,
values: choices,
labelOf: directoryLabel,
onSelected: onDirectory,
// Keyed by the value so a folder chosen in the picker replaces the
// dropdown's retained initial value.
KeyedSubtree(
key: ValueKey('chat-create-directory-$directory'),
child: MaterialPickerField(
fieldKey: const Key('chat-create-server-directory'),
label: chatCreatePrompt,
value: directory,
values: choices,
labelOf: directoryLabel,
onSelected: onDirectory,
),
),
if (onBrowse != null)
Align(
alignment: AlignmentDirectional.centerStart,
child: cupertino
? CupertinoButton(
key: const Key('chat-create-choose-folder'),
padding: const EdgeInsets.symmetric(vertical: 4),
onPressed: onBrowse,
child: const Row(
mainAxisSize: MainAxisSize.min,
children: [
Icon(CupertinoIcons.folder),
SizedBox(width: 6),
Flexible(child: Text(chatChooseFolderLabel)),
],
),
)
: TextButton.icon(
key: const Key('chat-create-choose-folder'),
onPressed: onBrowse,
icon: const Icon(Icons.folder_open),
label: const Text(chatChooseFolderLabel),
),
),
if (backends.length > 1)
if (cupertino)
@@ -7,7 +7,9 @@ import '../../../../core/api_gateway.dart';
import '../../../../core/servers/server_scope.dart';
import '../../data/chat_create_prompt_store.dart';
import '../../data/chat_repository.dart';
import '../../data/directory_listing.dart';
import '../../domain/chat_commands.dart';
import '../folder_picker/folder_picker_route.dart';
import 'chat_adaptive.dart';
import 'chat_create_dialog_frame.dart';
import 'chat_create_fields.dart';
@@ -17,7 +19,8 @@ import 'chat_prompt_chooser.dart';
const String chatCreateInstructionsHelper =
"Preloaded as this chat's session instructions. The agent still reads the "
"repository's AGENTS.md and skills.";
const String chatCreateModelNote = "New chats start with the server's default model.";
const String chatCreateModelNote =
"New chats start with the server's default model.";
class ChatDraft {
const ChatDraft({
@@ -211,6 +214,43 @@ class _CreateChatDialogState extends State<CreateChatDialog> {
});
}
/// Opens the folder picker at the current folder when it is inside home,
/// with the server's recent chat folders as quick picks, and makes the
/// chosen folder this chat's directory.
Future<void> _browse() async {
final home = _directories.isEmpty ? null : _directories.first;
final current = _directory;
final initial =
home != null &&
current != null &&
current != chatHomeDirectory &&
isInsideHome(home, current)
? current
: null;
final chosen = await showFolderPicker(
context,
gateway: widget.repository.gateway,
initialPath: initial,
recents: _directories.skip(1).toList(),
);
if (!mounted || chosen == null || _submitting) return;
setState(() {
if (chosen == home) {
_directory = chatHomeDirectory;
} else {
if (!_directories.contains(chosen)) {
_directories = [
..._directories.take(1),
chosen,
..._directories.skip(1),
];
}
_directory = chosen;
}
});
_choiceChanged();
}
Future<void> _submit() async {
if (!_catalogReady || _submitting) return;
if (!_promptReady) {
@@ -284,6 +324,7 @@ class _CreateChatDialogState extends State<CreateChatDialog> {
_choiceChanged();
},
onRetry: _loadCatalog,
onBrowse: _submitting ? null : _browse,
),
const SizedBox(height: 12),
const Text('Name'),
+18
View File
@@ -0,0 +1,18 @@
# New-chat folder picker
The create dialog has a "Choose folder…" action under the directory dropdown. It
opens `lib/features/chat/ui/folder_picker/`: a full-screen page below 720 px, a
large dialog above it (Material and Cupertino). The picker opens at `~`, or at
the dialog's current folder when that folder is inside home. Recent chat folders
from `chat_directories` show as quick picks at the home level. The page has a
breadcrumb from `~`, a filter field, a "Show hidden" toggle, folders with a git
badge, and dimmed files. Back climbs one folder. Server refusals (outside home,
permission denied) show inline with Retry, Back and Go to home. "Start chat
here" fills the directory and returns to the dialog. The dropdown is still there
as the other way to choose.
Server: `list_directory` / `directory_listing` (docs/cli.md, Chat sessions).
Evidence: `/tmp/folder-picker-evidence/{material,cupertino}-{560,880}x1000/`,
made with the capture kit over the probe app (fixture in `tool/probe_folder_fixture.dart`)
and the script `/tmp/folder-picker-evidence/flow.json`.
@@ -0,0 +1,52 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/data/directory_listing.dart';
void main() {
test('parses the directory_listing reply, null parent at home', () {
final listing = DirectoryListing.fromReply({
'type': 'directory_listing',
'directory_listing': {
'path': '/home/op',
'home': '/home/op',
'parent': null,
'entries': [
{
'name': 'src',
'path': '/home/op/src',
'is_dir': true,
'is_git_repo': true,
'hidden': false,
},
{'name': '.zshrc', 'path': '/home/op/.zshrc', 'hidden': true},
],
'truncated': true,
},
});
expect(listing.parent, isNull);
expect(listing.truncated, isTrue);
expect(listing.entries.first.isGitRepo, isTrue);
expect(listing.entries.last.isDir, isFalse);
expect(listing.entries.last.hidden, isTrue);
});
test('a reply without a listing is an error, not an empty folder', () {
expect(
() => DirectoryListing.fromReply({'type': 'pong'}),
throwsStateError,
);
});
test('crumbs run from ~ to the folder', () {
expect(folderCrumbs('/home/op', '/home/op/a/b'), [
(label: '~', path: '/home/op'),
(label: 'a', path: '/home/op/a'),
(label: 'b', path: '/home/op/a/b'),
]);
expect(folderCrumbs('/home/op', '/home/opal'), [
(label: '~', path: '/home/op'),
]);
expect(isInsideHome('/home/op', '/home/opal'), isFalse);
expect(homeRelativeLabel('/home/op', '/home/op/a'), '~/a');
expect(homeRelativeLabel('/home/op', '/srv'), '/srv');
});
}
@@ -0,0 +1,84 @@
import 'dart:async';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/core/transport/connection_state.dart';
const fakeHome = '/home/op';
JsonMap _entry(
String parent,
String name, {
bool dir = true,
bool git = false,
}) => {
'name': name,
'path': '$parent/$name',
'is_dir': dir,
'is_git_repo': git,
'hidden': name.startsWith('.'),
};
/// A server-shaped home tree for `list_directory`; anything else is refused
/// with the server's words, like the real handler.
final Map<String, List<JsonMap>> fakeTree = {
fakeHome: [
_entry(fakeHome, '.config'),
_entry(fakeHome, 'projects'),
_entry(fakeHome, 'src', git: true),
_entry(fakeHome, '.zshrc', dir: false),
_entry(fakeHome, 'notes.txt', dir: false),
],
'$fakeHome/projects': [
_entry('$fakeHome/projects', 'app', git: true),
_entry('$fakeHome/projects', 'web'),
_entry('$fakeHome/projects', 'README.md', dir: false),
],
'$fakeHome/projects/app': [_entry('$fakeHome/projects/app', 'lib')],
'$fakeHome/projects/web': const [],
'$fakeHome/src': const [],
};
String? _parent(String path) {
if (path == fakeHome) return null;
return path.substring(0, path.lastIndexOf('/'));
}
/// Answers `list_directory` from [fakeTree] and records requested paths.
class FakeDirectoryGateway implements ApiGateway {
final requests = <String?>[];
/// Paths that are refused like the server refuses a locked folder.
final denied = <String>{'$fakeHome/locked'};
@override
Stream<JsonMap> get frames => const Stream.empty();
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
if (type != 'list_directory') {
throw ProtocolError('Fake does not implement $type');
}
final body = fields['list_directory'] as Map? ?? const {};
final requested = body['path'] as String?;
requests.add(requested);
final path = requested == null || requested == '~' ? fakeHome : requested;
if (denied.contains(path)) throw ProtocolError('permission denied: $path');
if (path != fakeHome && !path.startsWith('$fakeHome/')) {
throw ProtocolError(
'path $path is outside the home directory $fakeHome; only folders '
'inside home can be listed',
);
}
final entries = fakeTree[path];
if (entries == null) throw ProtocolError('$path does not exist');
return {
'type': 'directory_listing',
'directory_listing': {
'path': path,
'home': fakeHome,
'parent': _parent(path),
'entries': entries,
},
};
}
}
@@ -0,0 +1,237 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/ui/folder_picker/folder_picker_route.dart';
import 'fake_directory_gateway.dart';
/// Hosts a button that opens the picker and records what it returns.
class _Launcher extends StatelessWidget {
const _Launcher({
required this.gateway,
required this.onResult,
this.initialPath,
this.recents = const [],
});
final FakeDirectoryGateway gateway;
final ValueChanged<String?> onResult;
final String? initialPath;
final List<String> recents;
@override
Widget build(BuildContext context) {
return Center(
child: CupertinoButton(
child: const Text('Open picker'),
onPressed: () async => onResult(
await showFolderPicker(
context,
gateway: gateway,
initialPath: initialPath,
recents: recents,
),
),
),
);
}
}
enum _Host { material, cupertino }
Future<void> _pump(
WidgetTester tester,
_Host host,
Widget launcher, {
Size size = const Size(420, 900),
}) async {
tester.view.physicalSize = size;
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
await tester.pumpWidget(
host == _Host.material
? MaterialApp(
theme: ThemeData(platform: TargetPlatform.android),
home: Scaffold(body: launcher),
)
: CupertinoApp(home: CupertinoPageScaffold(child: launcher)),
);
await tester.tap(find.text('Open picker'));
await tester.pumpAndSettle();
}
Finder _crumb(String path) => find.byKey(ValueKey('folder-crumb-$path'));
void main() {
for (final host in _Host.values) {
testWidgets('${host.name}: opens at home, navigates, jumps up and returns '
'the folder', (tester) async {
final gateway = FakeDirectoryGateway();
String? result = 'unset';
await _pump(
tester,
host,
_Launcher(gateway: gateway, onResult: (value) => result = value),
);
expect(gateway.requests, [null]);
expect(find.text('Choose folder'), findsOneWidget);
expect(find.text('projects'), findsOneWidget);
expect(find.text('src'), findsOneWidget);
expect(find.text('git'), findsOneWidget);
expect(find.text('notes.txt'), findsOneWidget);
expect(find.text('Start in ~'), findsOneWidget);
await tester.tap(find.text('projects'));
await tester.pumpAndSettle();
expect(gateway.requests.last, '$fakeHome/projects');
expect(find.text('app'), findsOneWidget);
expect(find.text('README.md'), findsOneWidget);
expect(find.text('Start in ~/projects'), findsOneWidget);
await tester.tap(find.text('app'));
await tester.pumpAndSettle();
expect(find.text('lib'), findsOneWidget);
// The home crumb jumps straight back up two levels.
await tester.tap(_crumb(fakeHome));
await tester.pumpAndSettle();
expect(gateway.requests.last, fakeHome);
expect(find.text('Start in ~'), findsOneWidget);
// Back climbs one folder instead of leaving the picker.
await tester.tap(find.text('projects'));
await tester.pumpAndSettle();
await tester.tap(find.text('web'));
await tester.pumpAndSettle();
expect(find.text('This folder is empty.'), findsOneWidget);
await tester.tap(
host == _Host.material
? find.byType(BackButton)
: find.byType(CupertinoNavigationBarBackButton),
);
await tester.pumpAndSettle();
expect(find.text('Start in ~/projects'), findsOneWidget);
expect(result, 'unset');
await tester.tap(find.byKey(const Key('folder-picker-start')));
await tester.pumpAndSettle();
expect(result, '$fakeHome/projects');
expect(find.text('Choose folder'), findsNothing);
});
testWidgets('${host.name}: hidden toggle and filter', (tester) async {
final gateway = FakeDirectoryGateway();
await _pump(tester, host, _Launcher(gateway: gateway, onResult: (_) {}));
expect(find.text('.config'), findsNothing);
expect(find.text('.zshrc'), findsNothing);
expect(find.text('Show hidden (2)'), findsOneWidget);
await tester.tap(find.byKey(const Key('folder-picker-hidden')));
await tester.pumpAndSettle();
expect(find.text('.config'), findsOneWidget);
expect(find.text('.zshrc'), findsOneWidget);
await tester.enterText(
find.byKey(const Key('folder-picker-filter')),
'PRO',
);
await tester.pumpAndSettle();
expect(find.text('projects'), findsOneWidget);
expect(find.text('src'), findsNothing);
await tester.enterText(
find.byKey(const Key('folder-picker-filter')),
'zzz',
);
await tester.pumpAndSettle();
expect(find.textContaining('Nothing here matches'), findsOneWidget);
});
testWidgets('${host.name}: a refused folder is shown inline and home '
'recovers', (tester) async {
final gateway = FakeDirectoryGateway();
String? result = 'unset';
await _pump(
tester,
host,
_Launcher(
gateway: gateway,
initialPath: '/etc',
onResult: (value) => result = value,
),
);
expect(find.textContaining('outside the home directory'), findsOneWidget);
expect(find.text('No folder selected'), findsOneWidget);
await tester.tap(find.byKey(const Key('folder-picker-start')));
await tester.pumpAndSettle();
expect(result, 'unset');
await tester.tap(find.text('Go to home'));
await tester.pumpAndSettle();
expect(find.text('projects'), findsOneWidget);
gateway.denied.add('$fakeHome/projects');
await tester.tap(find.text('projects'));
await tester.pumpAndSettle();
expect(
find.text('permission denied: $fakeHome/projects'),
findsOneWidget,
);
await tester.tap(find.text('Back to ~'));
await tester.pumpAndSettle();
expect(find.text('projects'), findsOneWidget);
expect(find.text('Start in ~'), findsOneWidget);
});
}
testWidgets('opens at an initial folder and offers recents at home', (
tester,
) async {
final gateway = FakeDirectoryGateway();
await _pump(
tester,
_Host.material,
_Launcher(
gateway: gateway,
initialPath: '$fakeHome/projects',
recents: const ['$fakeHome/projects/app', '/elsewhere'],
onResult: (_) {},
),
);
expect(gateway.requests, ['$fakeHome/projects']);
expect(find.text('Recent folders'), findsNothing);
await tester.tap(_crumb(fakeHome));
await tester.pumpAndSettle();
expect(find.text('Recent folders'), findsOneWidget);
expect(find.text('~/projects/app'), findsOneWidget);
expect(find.text('/elsewhere'), findsNothing);
await tester.tap(find.text('~/projects/app'));
await tester.pumpAndSettle();
expect(find.text('lib'), findsOneWidget);
});
for (final host in _Host.values) {
testWidgets('${host.name}: wide windows get a dialog, phones a page', (
tester,
) async {
final gateway = FakeDirectoryGateway();
await _pump(
tester,
host,
_Launcher(gateway: gateway, onResult: (_) {}),
size: const Size(1000, 900),
);
final page = tester.getSize(find.text('Choose folder'));
expect(page.width, greaterThan(0));
final scaffoldType = host == _Host.material
? Scaffold
: CupertinoPageScaffold;
final picker = find.ancestor(
of: find.text('Choose folder'),
matching: find.byType(scaffoldType),
);
expect(tester.getSize(picker.first).width, lessThan(1000));
expect(
host == _Host.material ? find.byType(Dialog) : find.byType(ClipRRect),
findsWidgets,
);
});
}
}
@@ -0,0 +1,88 @@
import 'package:flutter/widgets.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import '../folder_picker/fake_directory_gateway.dart';
import 'chat_test_harness.dart';
import 'fake_chat_gateway.dart';
/// A chat gateway whose `list_directory` answers come from the fake home tree.
FakeChatGateway _gateway(FakeDirectoryGateway directories) {
final gateway = FakeChatGateway();
gateway.directoriesHandler = () async => {
'chat_directories': [fakeHome, '$fakeHome/projects/app', '/srv/other'],
};
gateway.actionHandler = (type, fields) => directories.call(type, fields);
return gateway;
}
void main() {
final hosts = <String, Future<void> Function(WidgetTester, FakeChatGateway)>{
'material': (tester, gateway) => pumpMaterialChat(tester, gateway),
'cupertino': (tester, gateway) => pumpCupertinoChat(tester, gateway),
'ios material': (tester, gateway) => pumpIosMaterialChat(tester, gateway),
};
for (final MapEntry(key: name, value: pump) in hosts.entries) {
testWidgets('$name: Choose folder fills the directory and creates there', (
tester,
) async {
usePhoneSurface(tester);
final directories = FakeDirectoryGateway();
final gateway = _gateway(directories);
await pump(tester, gateway);
await tester.tap(find.byKey(const Key('chat-new-chat')));
await tester.pumpAndSettle();
await tester.tap(find.byKey(const Key('chat-create-choose-folder')));
await tester.pumpAndSettle();
// Opened at home (the dialog's current choice is ~) with the recent
// folder inside home offered first.
expect(directories.requests, [null]);
expect(find.text('Recent folders'), findsOneWidget);
expect(find.text('~/projects/app'), findsOneWidget);
expect(find.text('/srv/other'), findsNothing);
await tester.tap(find.text('projects'));
await tester.pumpAndSettle();
await tester.tap(find.text('web'));
await tester.pumpAndSettle();
await tester.tap(find.byKey(const Key('folder-picker-start')));
await tester.pumpAndSettle();
expect(find.text('Choose folder'), findsNothing);
expect(find.text('Start in $fakeHome/projects/web'), findsOneWidget);
await tester.tap(find.byKey(const Key('chat-create-confirm')));
await tester.pumpAndSettle();
final fields =
gateway.lastFields('chat_create')!['chat_create']! as JsonMap;
expect(fields['directory'], '$fakeHome/projects/web');
expect(fields['title'], 'Web OpenCode');
});
}
testWidgets('the picker reopens at the chosen folder; cancel keeps it', (
tester,
) async {
usePhoneSurface(tester);
final directories = FakeDirectoryGateway();
final gateway = _gateway(directories);
await pumpMaterialChat(tester, gateway);
await tester.tap(find.byKey(const Key('chat-new-chat')));
await tester.pumpAndSettle();
await tester.tap(find.byKey(const Key('chat-create-choose-folder')));
await tester.pumpAndSettle();
await tester.tap(find.text('src'));
await tester.pumpAndSettle();
await tester.tap(find.byKey(const Key('folder-picker-start')));
await tester.pumpAndSettle();
expect(find.text('Start in $fakeHome/src'), findsOneWidget);
await tester.tap(find.byKey(const Key('chat-create-choose-folder')));
await tester.pumpAndSettle();
expect(directories.requests.last, '$fakeHome/src');
await tester.tap(find.text('Cancel').last);
await tester.pumpAndSettle();
expect(find.text('Start in $fakeHome/src'), findsOneWidget);
});
}
+103
View File
@@ -0,0 +1,103 @@
// Fixture replies for the new-chat folder picker in the capture probe app
// (`search_selection_probe_entry.dart`). They answer `chat_sessions`,
// `chat_directories`, `chat_backends` and `list_directory` with server-shaped
// bodies over an invented home tree, so `/chat` → New chat → Choose folder can
// be rendered and captured without any server.
import 'package:pipelines_app/core/api_gateway.dart';
const probeHome = '/home/operator';
JsonMap _entry(
String parent,
String name, {
bool dir = true,
bool git = false,
}) => {
'name': name,
'path': '$parent/$name',
'is_dir': dir,
'is_git_repo': git,
'hidden': name.startsWith('.'),
};
final Map<String, List<JsonMap>> _tree = {
probeHome: [
for (final name in ['.cache', '.config', '.ssh']) _entry(probeHome, name),
_entry(probeHome, 'Desktop'),
_entry(probeHome, 'Documents'),
_entry(probeHome, 'Downloads'),
_entry(probeHome, 'notes', git: true),
_entry(probeHome, 'Private'),
_entry(probeHome, 'repos'),
_entry(probeHome, '.zshrc', dir: false),
_entry(probeHome, 'todo.md', dir: false),
],
'$probeHome/repos': [
_entry('$probeHome/repos', 'dotfiles', git: true),
_entry('$probeHome/repos', 'pipelines', git: true),
_entry('$probeHome/repos', 'scratch'),
_entry('$probeHome/repos', 'website', git: true),
_entry('$probeHome/repos', 'README.txt', dir: false),
],
'$probeHome/repos/pipelines': [
for (final name in ['.git', '.github'])
_entry('$probeHome/repos/pipelines', name),
for (final name in ['app', 'cmd', 'docs', 'internal', 'web'])
_entry('$probeHome/repos/pipelines', name),
for (final name in ['AGENTS.md', 'go.mod', 'README.md'])
_entry('$probeHome/repos/pipelines', name, dir: false),
],
};
/// The reply for a folder-picker request, or null when [request] is not one.
JsonMap? probeFolderReply(JsonMap request) {
final id = request['id'];
switch ('${request['type']}') {
case 'chat_sessions':
return {'id': id, 'type': 'chat_sessions', 'chat_sessions': const []};
case 'chat_directories':
return {
'id': id,
'type': 'chat_directories',
'chat_directories': [probeHome, '$probeHome/repos/pipelines'],
};
case 'chat_backends':
return {
'id': id,
'type': 'chat_backends',
'chat_backends': ['opencode', 'claude', 'codex'],
};
case 'list_directory':
final body = request['list_directory'];
final requested = body is Map ? body['path'] as String? : null;
final path = requested == null || requested == '~'
? probeHome
: requested;
final entries = _tree[path];
if (path == '$probeHome/Private') {
return {'id': id, 'type': 'error', 'error': 'permission denied: $path'};
}
if (path != probeHome && !path.startsWith('$probeHome/')) {
return {
'id': id,
'type': 'error',
'error':
'path $path is outside the home directory $probeHome; only '
'folders inside home can be listed',
};
}
return {
'id': id,
'type': 'directory_listing',
'directory_listing': {
'path': path,
'home': probeHome,
'parent': path == probeHome
? null
: path.substring(0, path.lastIndexOf('/')),
'entries': entries ?? const [],
},
};
}
return null;
}
+4 -1
View File
@@ -27,6 +27,8 @@ import 'package:flutter/widgets.dart';
import 'package:web/web.dart' as web;
import 'package:web_socket_channel/web_socket_channel.dart';
import 'probe_folder_fixture.dart';
/// The run every run-scoped hit names. Its recorded sequences are deliberately
/// not its row indexes (plan 5, build 2, plan 1), exactly like the unit
/// fixture, so a selection has to resolve the recorded sequence.
@@ -395,7 +397,8 @@ JsonMap? probeReply(JsonMap request) {
},
};
default:
return error('Fixture does not implement $type');
return probeFolderReply(request) ??
error('Fixture does not implement $type');
}
}
+17
View File
@@ -482,6 +482,23 @@ sessions pipeline runs create. The protocol types are:
(currently 8). It is a dedicated request so the create dialog can load the
choices without first listing sessions; `chat_sessions` stays a pure session
list.
- `list_directory` backs the app's "Choose folder" picker. The request body is
`list_directory: {"path": "..."}`; `path` is optional, absolute or starting
with `~` (`~` or `~/sub`), and defaults to the server user's home. The reply
is `directory_listing: {"path", "home", "parent", "entries", "truncated"}`:
`path` is the absolute, cleaned directory (expressed under `home`), `parent` is
`null` at the home root, and each entry is
`{"name", "path", "is_dir", "is_git_repo", "hidden"}` — directories first,
then files, each group sorted case-insensitively. Files are names only (never
contents) and are not selectable; `is_git_repo` marks a directory containing
`.git`; `hidden` marks a dot-name. Listing is confined to the home subtree:
the path is cleaned and its symlinks resolved first, so `..`, an absolute path
outside home, or a symlink that escapes home is refused with an `error` frame
("... is outside the home directory ..."); a symlink entry that escapes home is
listed only as a plain name. Kernel pseudo filesystems (proc, sysfs, devfs and
similar) are refused, permission problems are reported as
`permission denied: <path>`, and a reply carries at most 2000 entries with
`truncated: true` when more exist.
- `chat_adopt` takes a `session_id` that already exists on the configured
endpoint and records it in the operator session registry, using the endpoint's
own directory and title (never a guess or the server's working directory). The
+45
View File
@@ -0,0 +1,45 @@
package protocol
// Directory browsing for the chat folder picker. A client sends
// Message{Type: ListDirectory, ID: <opaque>, ListDirectory: &DirectoryListRequest{Path: ...}}
// and the server echoes the ID on a DirectoryListing reply. Listing is
// restricted to the server user's home directory subtree, returns names and
// kinds only (never file contents) and is bounded by DirectoryListingMaxEntries.
const (
ListDirectory = "list_directory"
DirectoryListing = "directory_listing"
)
// DirectoryListingMaxEntries caps the entries one directory_listing returns;
// a larger directory sets Truncated.
const DirectoryListingMaxEntries = 2000
// DirectoryListRequest is the list_directory body. Path is absolute or starts
// with "~" ("~" or "~/sub"); an omitted or empty path lists the home directory.
type DirectoryListRequest struct {
Path string `json:"path,omitempty"`
}
// DirectoryListingResult is the directory_listing reply. Path is the absolute,
// cleaned directory listed (expressed under Home), Parent is null at the home
// root, and Entries are directories first, then files, each group sorted
// case-insensitively. Files are listed by name only so a picker can show
// context; they are not selectable.
type DirectoryListingResult struct {
Path string `json:"path"`
Home string `json:"home"`
Parent *string `json:"parent"`
Entries []DirectoryEntry `json:"entries"`
Truncated bool `json:"truncated,omitempty"`
}
// DirectoryEntry is one listed name. IsDir is true only for a directory (or a
// symlink to one) that stays inside the home subtree; IsGitRepo marks a
// directory containing .git; Hidden marks a dot-name.
type DirectoryEntry struct {
Name string `json:"name"`
Path string `json:"path"`
IsDir bool `json:"is_dir"`
IsGitRepo bool `json:"is_git_repo"`
Hidden bool `json:"hidden"`
}
+4
View File
@@ -234,6 +234,10 @@ type Message struct {
ChatShellOutputQuery *ChatShellOutputQuery `json:"chat_shell_output_query,omitempty"`
ChatShells []ChatShell `json:"chat_shells,omitempty"`
ChatShellOutput *ChatShellOutputPage `json:"chat_shell_output,omitempty"`
// ListDirectory is the list_directory body and DirectoryListing its reply:
// the home-restricted folder picker listing (see directories.go).
ListDirectory *DirectoryListRequest `json:"list_directory,omitempty"`
DirectoryListing *DirectoryListingResult `json:"directory_listing,omitempty"`
// ChatAttachmentImageRequest is the chat_attachment_image body and
// ChatAttachmentImage its reply.
ChatAttachmentImageRequest *ChatAttachmentImageRequest `json:"chat_attachment_image_request,omitempty"`
+26
View File
@@ -0,0 +1,26 @@
//go:build darwin
package server
import "syscall"
// specialFilesystem reports whether path lives on a pseudo filesystem (devfs,
// autofs, fdesc) that a folder picker must never list.
func specialFilesystem(path string) bool {
var stat syscall.Statfs_t
if err := syscall.Statfs(path, &stat); err != nil {
return false
}
name := make([]byte, 0, len(stat.Fstypename))
for _, c := range stat.Fstypename {
if c == 0 {
break
}
name = append(name, byte(c))
}
switch string(name) {
case "devfs", "autofs", "fdesc":
return true
}
return false
}
+31
View File
@@ -0,0 +1,31 @@
//go:build linux
package server
import "syscall"
// Filesystem magic numbers (linux/magic.h) for kernel pseudo filesystems that
// a folder picker must never list.
var specialFilesystemMagic = map[int64]struct{}{
0x9fa0: {}, // proc
0x62656572: {}, // sysfs
0x1cd1: {}, // devpts
0x64626720: {}, // debugfs
0x74726163: {}, // tracefs
0x27e0eb: {}, // cgroup
0x63677270: {}, // cgroup2
0xf97cff8c: {}, // selinuxfs
0x73636673: {}, // securityfs
0xcafe4a11: {}, // bpf
0x65735546: {}, // fuse control
}
// specialFilesystem reports whether path lives on a kernel pseudo filesystem.
func specialFilesystem(path string) bool {
var stat syscall.Statfs_t
if err := syscall.Statfs(path, &stat); err != nil {
return false
}
_, ok := specialFilesystemMagic[int64(stat.Type)]
return ok
}
+6
View File
@@ -0,0 +1,6 @@
//go:build !linux && !darwin
package server
// specialFilesystem has no pseudo-filesystem probe on this platform.
func specialFilesystem(string) bool { return false }
+200
View File
@@ -0,0 +1,200 @@
package server
import (
"errors"
"io"
"io/fs"
"os"
"path/filepath"
"sort"
"strings"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// directoryListingScanLimit bounds how many names one list_directory reads
// before sorting, so a huge directory cannot make the server read without end.
// The reply itself is capped at protocol.DirectoryListingMaxEntries.
const directoryListingScanLimit = 5 * protocol.DirectoryListingMaxEntries
// handleDirectoryListing answers list_directory. It returns true when the
// request was a list_directory and has been answered.
func handleDirectoryListing(request protocol.Message, write func(protocol.Message) error) bool {
if request.Type != protocol.ListDirectory {
return false
}
path := ""
if request.ListDirectory != nil {
path = request.ListDirectory.Path
}
home, err := OperatorHomeDirectory()
if err == nil {
var listing protocol.DirectoryListingResult
listing, err = listHomeDirectory(home, path, protocol.DirectoryListingMaxEntries)
if err == nil {
_ = write(protocol.Message{Type: protocol.DirectoryListing, ID: request.ID, DirectoryListing: &listing})
return true
}
}
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return true
}
// listHomeDirectory lists one directory inside home. The requested path is
// cleaned and its symlinks resolved before the containment check, so neither
// ".." nor a symlink can escape home. The listed path is reported under home
// (as the operator sees it) even when home itself is reached through a link.
func listHomeDirectory(home, requested string, maxEntries int) (protocol.DirectoryListingResult, error) {
home = filepath.Clean(home)
realHome, err := filepath.EvalSymlinks(home)
if err != nil {
return protocol.DirectoryListingResult{}, errors.New("resolve home directory: " + err.Error())
}
target, err := expandHomePath(home, requested)
if err != nil {
return protocol.DirectoryListingResult{}, err
}
rel, realTarget, err := resolveInsideHome(realHome, target)
if err != nil {
return protocol.DirectoryListingResult{}, err
}
shown := filepath.Join(home, rel)
info, err := os.Stat(realTarget)
if err != nil {
return protocol.DirectoryListingResult{}, describePathError(shown, err)
}
if !info.IsDir() {
return protocol.DirectoryListingResult{}, errors.New(shown + " is not a directory")
}
if specialFilesystem(realTarget) {
return protocol.DirectoryListingResult{}, errors.New(shown + " is on a special filesystem and cannot be listed")
}
entries, truncated, err := readDirectoryEntries(realHome, realTarget, shown, maxEntries)
if err != nil {
return protocol.DirectoryListingResult{}, err
}
result := protocol.DirectoryListingResult{Path: shown, Home: home, Entries: entries, Truncated: truncated}
if rel != "." {
parent := filepath.Dir(shown)
result.Parent = &parent
}
return result, nil
}
// expandHomePath turns "", "~" and "~/sub" into paths under home and requires
// anything else to be absolute. "~user" forms are refused.
func expandHomePath(home, requested string) (string, error) {
requested = strings.TrimSpace(requested)
switch {
case requested == "" || requested == "~":
return home, nil
case strings.HasPrefix(requested, "~/"):
return filepath.Join(home, requested[2:]), nil
case strings.HasPrefix(requested, "~"):
return "", errors.New("path " + requested + " must be absolute or start with ~/")
case !filepath.IsAbs(requested):
return "", errors.New("path " + requested + " must be absolute or start with ~")
}
return filepath.Clean(requested), nil
}
// resolveInsideHome resolves every symlink in target and returns its path
// relative to realHome, refusing anything outside the home subtree.
func resolveInsideHome(realHome, target string) (string, string, error) {
realTarget, err := filepath.EvalSymlinks(target)
if err != nil {
return "", "", describePathError(target, err)
}
rel, ok := relInside(realHome, realTarget)
if !ok {
return "", "", errors.New("path " + target + " is outside the home directory " + realHome + "; only folders inside home can be listed")
}
return rel, realTarget, nil
}
func relInside(root, path string) (string, bool) {
rel, err := filepath.Rel(root, path)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
return "", false
}
return rel, true
}
func describePathError(path string, err error) error {
switch {
case errors.Is(err, fs.ErrPermission):
return errors.New("permission denied: " + path)
case errors.Is(err, fs.ErrNotExist):
return errors.New(path + " does not exist")
}
return errors.New(path + " is not available: " + err.Error())
}
// readDirectoryEntries reads at most directoryListingScanLimit names, sorts
// directories first then case-insensitively, and caps the result. Only names
// and kinds are read; no file is opened.
func readDirectoryEntries(realHome, realDir, shown string, maxEntries int) ([]protocol.DirectoryEntry, bool, error) {
dir, err := os.Open(realDir)
if err != nil {
return nil, false, describePathError(shown, err)
}
defer dir.Close()
items, err := dir.ReadDir(directoryListingScanLimit + 1)
if err != nil && !errors.Is(err, io.EOF) {
return nil, false, describePathError(shown, err)
}
truncated := len(items) > directoryListingScanLimit
if truncated {
items = items[:directoryListingScanLimit]
}
entries := make([]protocol.DirectoryEntry, 0, len(items))
for _, item := range items {
entries = append(entries, describeEntry(realHome, realDir, shown, item))
}
sort.SliceStable(entries, func(i, j int) bool {
a, b := entries[i], entries[j]
if a.IsDir != b.IsDir {
return a.IsDir
}
la, lb := strings.ToLower(a.Name), strings.ToLower(b.Name)
if la != lb {
return la < lb
}
return a.Name < b.Name
})
if len(entries) > maxEntries {
entries = entries[:maxEntries]
truncated = true
}
return entries, truncated, nil
}
// describeEntry classifies one name. A symlink counts as a directory only when
// it resolves to a directory still inside home; one that escapes is shown as a
// plain, non-selectable name. Devices, sockets and pipes are plain names too.
func describeEntry(realHome, realDir, shown string, item fs.DirEntry) protocol.DirectoryEntry {
name := item.Name()
entry := protocol.DirectoryEntry{Name: name, Path: filepath.Join(shown, name), Hidden: strings.HasPrefix(name, ".")}
full := filepath.Join(realDir, name)
switch {
case item.IsDir():
entry.IsDir = true
case item.Type()&fs.ModeSymlink != 0:
resolved, err := filepath.EvalSymlinks(full)
if err != nil {
break
}
if _, ok := relInside(realHome, resolved); !ok {
break
}
if info, err := os.Stat(resolved); err == nil && info.IsDir() {
entry.IsDir = true
}
}
if entry.IsDir {
if _, err := os.Lstat(filepath.Join(full, ".git")); err == nil {
entry.IsGitRepo = true
}
}
return entry
}
+232
View File
@@ -0,0 +1,232 @@
package server
import (
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"git.a-wan.net/alan/pipelines/internal/protocol"
"github.com/coder/websocket/wsjson"
)
// newListingHome builds a scratch home: folders of mixed case, a hidden folder,
// a git repository, files, and an outside directory next to (not inside) home.
func newListingHome(t *testing.T) (home, outside string) {
t.Helper()
root := t.TempDir()
home = filepath.Join(root, "home")
outside = filepath.Join(root, "outside")
for _, dir := range []string{"zeta", "Alpha", "beta", ".config", "repo/.git", "repo/src"} {
mustMkdir(t, filepath.Join(home, dir))
}
mustMkdir(t, outside)
for _, file := range []string{"Notes.txt", "a.md", ".profile", "repo/README.md"} {
if err := os.WriteFile(filepath.Join(home, file), []byte("secret contents"), 0o644); err != nil {
t.Fatal(err)
}
}
return home, outside
}
func mustMkdir(t *testing.T, path string) {
t.Helper()
if err := os.MkdirAll(path, 0o755); err != nil {
t.Fatal(err)
}
}
func entryNames(entries []protocol.DirectoryEntry) []string {
names := make([]string, 0, len(entries))
for _, entry := range entries {
names = append(names, entry.Name)
}
return names
}
func TestListDirectoryHomeSortsDirectoriesFirstAndMarksHiddenAndRepos(t *testing.T) {
home, _ := newListingHome(t)
for _, requested := range []string{"", "~", home, home + "/"} {
listing, err := listHomeDirectory(home, requested, protocol.DirectoryListingMaxEntries)
if err != nil {
t.Fatalf("%q: %v", requested, err)
}
if listing.Path != home || listing.Home != home || listing.Parent != nil || listing.Truncated {
t.Fatalf("%q: header = %+v", requested, listing)
}
got := strings.Join(entryNames(listing.Entries), ",")
if want := ".config,Alpha,beta,repo,zeta,.profile,a.md,Notes.txt"; got != want {
t.Fatalf("%q: order = %s, want %s", requested, got, want)
}
}
listing, _ := listHomeDirectory(home, "~", protocol.DirectoryListingMaxEntries)
byName := map[string]protocol.DirectoryEntry{}
for _, entry := range listing.Entries {
byName[entry.Name] = entry
}
if e := byName[".config"]; !e.Hidden || !e.IsDir || e.IsGitRepo {
t.Fatalf(".config = %+v", e)
}
if e := byName["repo"]; !e.IsDir || !e.IsGitRepo || e.Hidden || e.Path != filepath.Join(home, "repo") {
t.Fatalf("repo = %+v", e)
}
if e := byName["Notes.txt"]; e.IsDir || e.Hidden {
t.Fatalf("Notes.txt = %+v", e)
}
if e := byName[".profile"]; e.IsDir || !e.Hidden {
t.Fatalf(".profile = %+v", e)
}
}
func TestListDirectorySubdirectoryHasParent(t *testing.T) {
home, _ := newListingHome(t)
for _, requested := range []string{"~/repo", filepath.Join(home, "repo"), filepath.Join(home, "beta", "..", "repo")} {
listing, err := listHomeDirectory(home, requested, protocol.DirectoryListingMaxEntries)
if err != nil {
t.Fatalf("%q: %v", requested, err)
}
if listing.Path != filepath.Join(home, "repo") || listing.Parent == nil || *listing.Parent != home {
t.Fatalf("%q: header = %+v", requested, listing)
}
if got := strings.Join(entryNames(listing.Entries), ","); got != ".git,src,README.md" {
t.Fatalf("%q: entries = %s", requested, got)
}
}
}
func TestListDirectoryRefusesPathsOutsideHome(t *testing.T) {
home, outside := newListingHome(t)
if err := os.Symlink(outside, filepath.Join(home, "escape")); err != nil {
t.Fatal(err)
}
if err := os.Symlink(filepath.Join(home, "repo"), filepath.Join(home, "inside")); err != nil {
t.Fatal(err)
}
for _, requested := range []string{
outside,
filepath.Join(home, ".."),
filepath.Join(home, "..", "outside"),
"~/..",
"~/../outside",
"~/escape",
filepath.Join(home, "escape"),
"/",
} {
_, err := listHomeDirectory(home, requested, protocol.DirectoryListingMaxEntries)
if err == nil || !strings.Contains(err.Error(), "outside the home directory") {
t.Fatalf("%q: err = %v, want outside-home refusal", requested, err)
}
}
for _, requested := range []string{"relative/path", "~root", "~/missing"} {
if _, err := listHomeDirectory(home, requested, protocol.DirectoryListingMaxEntries); err == nil {
t.Fatalf("%q listed, want an error", requested)
}
}
if _, err := listHomeDirectory(home, "~/Notes.txt", protocol.DirectoryListingMaxEntries); err == nil || !strings.Contains(err.Error(), "not a directory") {
t.Fatalf("file listed: %v", err)
}
// An escaping link is listed only as a non-selectable name; a link that
// stays inside home is a directory and lists under its home-relative path.
listing, err := listHomeDirectory(home, "~", protocol.DirectoryListingMaxEntries)
if err != nil {
t.Fatal(err)
}
for _, entry := range listing.Entries {
if entry.Name == "escape" && entry.IsDir {
t.Fatalf("escaping link marked as a directory: %+v", entry)
}
if entry.Name == "inside" && (!entry.IsDir || !entry.IsGitRepo) {
t.Fatalf("inside link = %+v", entry)
}
}
inside, err := listHomeDirectory(home, "~/inside", protocol.DirectoryListingMaxEntries)
if err != nil || inside.Path != filepath.Join(home, "repo") {
t.Fatalf("inside link listing = %+v, %v", inside, err)
}
}
func TestListDirectoryPermissionDenied(t *testing.T) {
if os.Geteuid() == 0 {
t.Skip("root ignores directory permissions")
}
home, _ := newListingHome(t)
locked := filepath.Join(home, "locked")
mustMkdir(t, locked)
if err := os.Chmod(locked, 0); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = os.Chmod(locked, 0o755) })
_, err := listHomeDirectory(home, "~/locked", protocol.DirectoryListingMaxEntries)
if err == nil || !strings.Contains(err.Error(), "permission denied") {
t.Fatalf("err = %v, want permission denied", err)
}
}
func TestListDirectoryTruncatesAtTheCap(t *testing.T) {
home, _ := newListingHome(t)
big := filepath.Join(home, "big")
for i := 0; i < 6; i++ {
mustMkdir(t, filepath.Join(big, fmt.Sprintf("d%d", i)))
if err := os.WriteFile(filepath.Join(big, fmt.Sprintf("f%d", i)), nil, 0o644); err != nil {
t.Fatal(err)
}
}
listing, err := listHomeDirectory(home, "~/big", 4)
if err != nil {
t.Fatal(err)
}
if !listing.Truncated || strings.Join(entryNames(listing.Entries), ",") != "d0,d1,d2,d3" {
t.Fatalf("listing = %+v", listing)
}
full, err := listHomeDirectory(home, "~/big", 12)
if err != nil || full.Truncated || len(full.Entries) != 12 {
t.Fatalf("exact-cap listing = %+v, %v", full, err)
}
}
// TestListDirectoryOverWebsocket pins the wire: list_directory replies with a
// directory_listing echoing the request id, and a refusal is an error frame.
func TestListDirectoryOverWebsocket(t *testing.T) {
home, outside := newListingHome(t)
t.Setenv("HOME", home)
ctx, _, conn := dialChatOptions(t, Options{})
request := protocol.Message{Type: protocol.ListDirectory, ID: "l1", ListDirectory: &protocol.DirectoryListRequest{Path: "~/repo"}}
if err := wsjson.Write(ctx, conn, request); err != nil {
t.Fatal(err)
}
var reply protocol.Message
if err := wsjson.Read(ctx, conn, &reply); err != nil {
t.Fatal(err)
}
if reply.Type != protocol.DirectoryListing || reply.ID != "l1" || reply.DirectoryListing == nil {
t.Fatalf("reply = %+v", reply)
}
if got := reply.DirectoryListing; got.Path != filepath.Join(home, "repo") || got.Home != home || got.Parent == nil || *got.Parent != home {
t.Fatalf("listing = %+v", got)
}
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ListDirectory, ID: "l2"}); err != nil {
t.Fatal(err)
}
var raw map[string]any
if err := wsjson.Read(ctx, conn, &raw); err != nil {
t.Fatal(err)
}
body, _ := raw["directory_listing"].(map[string]any)
if raw["id"] != "l2" || body == nil || body["path"] != home {
t.Fatalf("home reply = %+v", raw)
}
if parent, present := body["parent"]; !present || parent != nil {
t.Fatalf("home parent must be an explicit null: %+v", body)
}
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ListDirectory, ID: "l3", ListDirectory: &protocol.DirectoryListRequest{Path: outside}}); err != nil {
t.Fatal(err)
}
var refusal protocol.Message
if err := wsjson.Read(ctx, conn, &refusal); err != nil {
t.Fatal(err)
}
if refusal.Type != protocol.Error || refusal.ID != "l3" || !strings.Contains(refusal.Error, "outside the home directory") {
t.Fatalf("refusal = %+v", refusal)
}
}
+3
View File
@@ -221,6 +221,9 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
if handleChat(connCtx, request, options.Chat, hub, registry, clientID, write) {
continue
}
if handleDirectoryListing(request, write) {
continue
}
if handleNotificationSettings(ctx, request, settingsStore, write) {
continue
}