From de0c06cec19bd5ca76f921719de1e7f4e68d39f8 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sat, 7 Nov 2026 00:46:02 +0000 Subject: [PATCH 1/4] Chat: slash focuses the composer; Ctrl+Tab over one pane toggles recent chats A bare / typed outside any text field puts the keyboard in the active chat's composer through the existing focus request, after the frame, so the slash is not typed into it. Ctrl+Tab with a single pane now swaps in the chat shown before the current one and back; two or more panes keep cycling panes. The visit remembers its shown chats most-recent-first, dropping closed, /new-moved and other-server ids. --- app/lib/features/chat/chat_screen_keys.dart | 96 +++++++++ .../features/chat/chat_screen_workspace.dart | 26 +-- app/lib/features/chat/screen.dart | 10 +- app/notes/chat-keyboard-focus.md | 26 +++ .../chat/chat_keyboard_focus_test.dart | 190 ++++++++++++++++++ 5 files changed, 335 insertions(+), 13 deletions(-) create mode 100644 app/lib/features/chat/chat_screen_keys.dart create mode 100644 app/notes/chat-keyboard-focus.md create mode 100644 app/test/features/chat/chat_keyboard_focus_test.dart diff --git a/app/lib/features/chat/chat_screen_keys.dart b/app/lib/features/chat/chat_screen_keys.dart new file mode 100644 index 00000000..2d4535a9 --- /dev/null +++ b/app/lib/features/chat/chat_screen_keys.dart @@ -0,0 +1,96 @@ +part of 'screen.dart'; + +/// How many chats the visit remembers for Ctrl+Tab over a single pane. +const chatRecentSessionLimit = 8; + +/// Keys the Chat destination answers from anywhere in it, also while the +/// sidebar or a toolbar owns focus: a bare `/` puts the keyboard in the open +/// chat's composer, and Ctrl+Tab over a single pane returns to the chat shown +/// before it (and back again). Both are handled before the focus tree, like +/// the workspace's pane cycling, and leave other destinations, popups, +/// dialogs and any focused text field alone. +mixin _ChatScreenKeys on State, _ChatScreenWorkspace { + void _open(JsonMap session, {bool focusComposer}); + + /// The chats this visit has shown in the workspace, most recent first; the + /// active one leads it. In memory only: a reopened app starts afresh. + final List _recentSessions = []; + + /// Moves the active pane's chat to the front. Called on every workspace + /// change, including a restored layout, so the chat opened before the + /// current one is always the second entry. + @override + void _noteRecentSession() { + final id = _workspace.activePane?.sessionId; + if (id == null || id.isEmpty || _recentSessions.firstOrNull == id) return; + _recentSessions + ..remove(id) + ..insert(0, id); + if (_recentSessions.length > chatRecentSessionLimit) { + _recentSessions.removeLast(); + } + } + + /// Drops [id]: a closed chat, or one `/new` moved to a fresh session. + void _forgetRecentSession(String id) => _recentSessions.remove(id); + + /// Drops every remembered chat: ids belong to one server. + @override + void _forgetRecentSessions() => _recentSessions.clear(); + + /// Over a single pane, opens the chat shown before the active one with its + /// composer focused; false when this visit has shown no other chat. + @override + bool _toggleRecentChat() { + final current = _workspace.activePane?.sessionId; + final previous = _recentSessions + .where((id) => id != current) + .firstOrNull; + if (previous == null) return false; + _open(_rowFor(previous) ?? {'id': previous}, focusComposer: true); + return true; + } + + /// Whether the shown destination is Chat with no popup, dialog or other + /// route over it, so a key pressed now is meant for the open chat. + @override + bool _chatOwnsKeyboard() { + final destination = ShellBarScope.maybeOf(context)?.registry.focus; + if (destination != null && destination != AppDestination.chat) return false; + final focusContext = FocusManager.instance.primaryFocus?.context; + final route = focusContext == null + ? ModalRoute.of(context) + : ModalRoute.of(focusContext); + return route is! PopupRoute && (route == null || route.isCurrent); + } + + /// A bare `/` typed outside any text field focuses the active chat's + /// composer. The composer takes focus after this frame (see + /// [ChatComposerFocusRequests]), once the host has finished delivering the + /// keystroke, so the slash itself is not typed into it. Inside a text field + /// (the composer, a dialog's field) `/` stays an ordinary character. + bool _slashFocusKey(KeyEvent event) { + final keyboard = HardwareKeyboard.instance; + if (event is! KeyDownEvent || + event.character != '/' || + keyboard.isControlPressed || + keyboard.isMetaPressed || + keyboard.isAltPressed || + !_workspaceVisible) { + return false; + } + final id = _workspace.activePane?.sessionId; + if (id == null || _textFieldHasFocus() || !_chatOwnsKeyboard()) { + return false; + } + _composerFocus.request(id); + return true; + } + + /// Whether an editable text control holds focus, wherever it is. + bool _textFieldHasFocus() { + final context = FocusManager.instance.primaryFocus?.context; + final editable = context?.findAncestorWidgetOfExactType(); + return editable != null && !editable.readOnly; + } +} diff --git a/app/lib/features/chat/chat_screen_workspace.dart b/app/lib/features/chat/chat_screen_workspace.dart index 07456661..eea0bb68 100644 --- a/app/lib/features/chat/chat_screen_workspace.dart +++ b/app/lib/features/chat/chat_screen_workspace.dart @@ -4,6 +4,10 @@ part of 'screen.dart'; mixin _ChatScreenWorkspace on State { Map get _openedSessions; ChatComposerFocusRequests get _composerFocus; + bool _chatOwnsKeyboard(); + bool _toggleRecentChat(); + void _noteRecentSession(); + void _forgetRecentSessions(); JsonMap? _rowFor(String id); void _back(); bool get _pageOpen; @@ -89,6 +93,7 @@ mixin _ChatScreenWorkspace on State { _workspaceBinding = null; if (_workspaceScope != null && scope != _workspaceScope) { _workspace.restoreLayout(ChatWorkspaceSnapshot.fromLayout(null, null)!); + _forgetRecentSessions(); _workspaceVisible = false; _usedWorkspace = true; _sidebarMode = ChatSidebarMode.expanded; @@ -111,7 +116,9 @@ mixin _ChatScreenWorkspace on State { String _workspaceSignature = ''; /// Ctrl+Tab cycles retained panes even when the sidebar or toolbar owns - /// focus. Command+Tab stays with the operating system's application switcher. + /// focus. Over a single pane it swaps in the chat shown before this one + /// instead, and back again (see [_toggleRecentChat]). Command+Tab stays + /// with the operating system's application switcher. bool _cycleChatKey(KeyEvent event) { final keyboard = HardwareKeyboard.instance; if (event is! KeyDownEvent || @@ -120,19 +127,12 @@ mixin _ChatScreenWorkspace on State { keyboard.isMetaPressed || keyboard.isAltPressed || !_workspaceVisible || - _workspace.paneCount == 0) { - return false; - } - final destination = ShellBarScope.maybeOf(context)?.registry.focus; - if (destination != null && destination != AppDestination.chat) return false; - final focusContext = FocusManager.instance.primaryFocus?.context; - final route = focusContext == null - ? ModalRoute.of(context) - : ModalRoute.of(focusContext); - if (route is PopupRoute || (route != null && !route.isCurrent)) { + _workspace.paneCount == 0 || + !_chatOwnsKeyboard()) { return false; } final panes = _workspace.panes; + if (panes.length == 1 && _toggleRecentChat()) return true; final active = panes.indexWhere( (pane) => pane.id == _workspace.activePaneId, ); @@ -156,7 +156,9 @@ mixin _ChatScreenWorkspace on State { } void _workspaceChanged() { - if (!mounted || _workspaceBinding?.isRestoring == true) return; + if (!mounted) return; + _noteRecentSession(); + if (_workspaceBinding?.isRestoring == true) return; final signature = '${_workspace.activePaneId}:${_workspace.panes.map((p) => '${p.id}=${p.sessionId}').join(',')}'; if (_workspaceSignature == signature) return; diff --git a/app/lib/features/chat/screen.dart b/app/lib/features/chat/screen.dart index d67fbc9d..3dfbc011 100644 --- a/app/lib/features/chat/screen.dart +++ b/app/lib/features/chat/screen.dart @@ -35,6 +35,7 @@ import 'ui/sessions/chat_sessions_body.dart'; import 'ui/sessions/chat_sessions_controller.dart'; import 'ui/sessions/chat_sessions_screen.dart'; +part 'chat_screen_keys.dart'; part 'chat_screen_workspace.dart'; /// The Chat destination's list/detail switch. @@ -73,7 +74,8 @@ class ChatScreen extends StatefulWidget { State createState() => _ChatScreenState(); } -class _ChatScreenState extends State with _ChatScreenWorkspace { +class _ChatScreenState extends State + with _ChatScreenWorkspace, _ChatScreenKeys { /// The list's controller, shared with the mounted list screen. The list /// screen refreshes it on mount and swaps its repository when the socket is /// replaced; this destination lists created rows and re-reads after a @@ -141,10 +143,12 @@ class _ChatScreenState extends State with _ChatScreenWorkspace { _workspace.open(initial); _workspaceVisible = true; _publishedWorkspaceSession = initial; + _noteRecentSession(); } _workspace.addListener(_workspaceChanged); _bindWorkspacePersistence(); HardwareKeyboard.instance.addHandler(_cycleChatKey); + HardwareKeyboard.instance.addHandler(_slashFocusKey); // Seen from now on, so the press that chooses the first chat counts. LastPointerKind.instance; _sessions.addListener(_nextChanged); @@ -201,6 +205,7 @@ class _ChatScreenState extends State with _ChatScreenWorkspace { void _openBySelection(JsonMap session) => _open(session, focusComposer: chatSelectionFocusesComposer(session)); + @override void _open(JsonMap session, {bool focusComposer = false}) { final id = '${session['id'] ?? ''}'; if (id.isEmpty) return; @@ -254,6 +259,7 @@ class _ChatScreenState extends State with _ChatScreenWorkspace { if (accepted != null) _acceptedModels[id] = accepted; _startNotice = (id: id, notice: notice); _openedSessions[id] = {...session}..remove('running'); + _forgetRecentSession(previousId); _workspace.replaceSession(previousId, id); if (_workspace.paneCount == 0) _open(session); } @@ -271,6 +277,7 @@ class _ChatScreenState extends State with _ChatScreenWorkspace { /// `/close` was accepted: the conversation leaves, back to the list, which /// re-reads the closed row. void _closed(String sessionId) { + _forgetRecentSession(sessionId); for (final pane in _workspace.panes .where((pane) => pane.sessionId == sessionId) @@ -391,6 +398,7 @@ class _ChatScreenState extends State with _ChatScreenWorkspace { @override void dispose() { HardwareKeyboard.instance.removeHandler(_cycleChatKey); + HardwareKeyboard.instance.removeHandler(_slashFocusKey); _page.dispose(); _workspaceBinding?.dispose(); _workspace.removeListener(_workspaceChanged); diff --git a/app/notes/chat-keyboard-focus.md b/app/notes/chat-keyboard-focus.md new file mode 100644 index 00000000..2b7faa40 --- /dev/null +++ b/app/notes/chat-keyboard-focus.md @@ -0,0 +1,26 @@ +# Slash focuses the composer; Ctrl+Tab over one pane toggles recent chats + +`lib/features/chat/chat_screen_keys.dart` (a part of `screen.dart`) adds two +Chat-destination keys, registered on `HardwareKeyboard` for the screen's +lifetime like the pane cycling in `chat_screen_workspace.dart`: + +- A bare `/` (matched on the typed character, so it follows the keyboard + layout; Ctrl/Alt/Meta chords are left alone, Ctrl+/ stays the shell's Search) + requests focus for the active pane's composer through the existing + `ChatComposerFocusRequests`. The composer takes it after the frame, once the + host has finished delivering the keystroke, so the slash is not typed into + it. Nothing happens while any editable text field has focus, while a popup + or dialog is open, or on another destination. +- Ctrl+Tab (and Ctrl+Shift+Tab) over a single pane swaps in the chat shown + before the active one, composer focused, and back again. With no earlier + chat this visit it still just focuses the composer; with two or more panes + the existing pane cycling is unchanged. + +The visit keeps a most-recent-first list of the chats the workspace has shown +(bounded to eight, in memory). It is noted on every workspace change, including +a restored layout and the routed first chat; a chat `/close`d or moved by +`/new` is dropped, and a server switch clears it. + +Tests: `test/features/chat/chat_keyboard_focus_test.dart`. Widget tests cannot +show a browser's text insertion, so "the slash is not typed" rests on the +post-frame focus request; the composer text is asserted empty. diff --git a/app/test/features/chat/chat_keyboard_focus_test.dart b/app/test/features/chat/chat_keyboard_focus_test.dart new file mode 100644 index 00000000..f5fbbce2 --- /dev/null +++ b/app/test/features/chat/chat_keyboard_focus_test.dart @@ -0,0 +1,190 @@ +import 'package:flutter/material.dart'; +import 'package:flutter/services.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/chat/screen.dart'; +import 'package:pipelines_app/features/chat/ui/sessions/session_actions.dart'; +import 'package:pipelines_app/features/chat/workspace/chat_workspace.dart'; +import 'package:pipelines_app/shell/adaptive_shell.dart'; +import 'package:pipelines_app/shell/destination.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +import 'conversation/chat_thread_fixtures.dart'; + +class _Gateway extends FakeChatGateway { + @override + Future call(String type, [JsonMap fields = const {}]) { + if (type == 'chat_sessions') { + return Future.value({ + 'chat_sessions': [ + for (final id in ['a', 'b', 'c']) {'id': id, 'title': 'Chat $id'}, + ], + }); + } + if (type == 'chat_shells') return Future.value({'chat_shells': []}); + return super.call(type, fields); + } +} + +Finder _input(String id) => find.descendant( + of: find.byKey(ValueKey('chat-composer-$id')), + matching: find.byType(EditableText), +); +EditableText _editable(WidgetTester tester, String id) => + tester.widget(_input(id)); +Finder _actions(String id) => find.byWidgetPredicate( + (widget) => widget is SessionActionsButton && widget.session['id'] == id, +); +ChatWorkspaceController _workspace(WidgetTester tester) => + tester.widget(find.byType(ChatWorkspace)).controller; + +Future _setup(WidgetTester tester) async { + SharedPreferences.setMockInitialValues({}); + tester.view.physicalSize = const Size(1800, 1000); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.reset); + final gateway = _Gateway()..history = (_) async => chatPage([]); + addTearDown(gateway.close); + await tester.pumpWidget( + MaterialApp( + home: AdaptiveShell( + destination: AppDestination.chat, + destinationBodies: { + AppDestination.chat: (_) => ChatScreen(gateway: gateway), + }, + ), + ), + ); + await tester.pumpAndSettle(); +} + +Future _openRow(WidgetTester tester, String id) async { + await tester.tap(find.byKey(Key('chat-row-$id'))); + await tester.pumpAndSettle(); +} + +/// Puts focus on a sidebar control, outside every text field. +Future _focusSidebar(WidgetTester tester) async { + final icon = find + .descendant(of: _actions('a'), matching: find.byType(Icon)) + .first; + Focus.of(tester.element(icon)).requestFocus(); + await tester.pumpAndSettle(); +} + +Future _slash(WidgetTester tester) async { + final handled = await tester.sendKeyEvent(LogicalKeyboardKey.slash); + await tester.pumpAndSettle(); + return handled; +} + +Future _controlTab(WidgetTester tester, {bool shift = false}) async { + await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft); + if (shift) await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft); + await tester.sendKeyEvent(LogicalKeyboardKey.tab); + if (shift) await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft); + await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft); + await tester.pumpAndSettle(); +} + +void main() { + testWidgets('slash outside a text field focuses the composer, untyped', ( + tester, + ) async { + await _setup(tester); + await _openRow(tester, 'a'); + await _focusSidebar(tester); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isFalse); + + expect(await _slash(tester), isTrue); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isTrue); + expect(_editable(tester, 'a').controller.text, isEmpty); + + // Inside the composer a slash is an ordinary character for the field. + expect(await _slash(tester), isFalse); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isTrue); + + // Shift+/ (a question mark) and Alt+/ are not the shortcut; Ctrl+/ is + // the shell's own Search chord. + await _focusSidebar(tester); + await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft); + await tester.sendKeyEvent(LogicalKeyboardKey.slash, character: '?'); + await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft); + await tester.sendKeyDownEvent(LogicalKeyboardKey.altLeft); + await tester.sendKeyEvent(LogicalKeyboardKey.slash); + await tester.sendKeyUpEvent(LogicalKeyboardKey.altLeft); + await tester.pumpAndSettle(); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isFalse); + await tester.pumpWidget(const SizedBox.shrink()); + }); + + testWidgets('slash leaves a dialog text field and a popup alone', ( + tester, + ) async { + await _setup(tester); + await _openRow(tester, 'a'); + await tester.tap(_actions('a')); + await tester.pumpAndSettle(); + expect(await _slash(tester), isFalse); + expect(find.text('Rename…'), findsOneWidget); + await tester.tap(find.text('Rename…')); + await tester.pumpAndSettle(); + final dialogField = find.descendant( + of: find.byType(Dialog), + matching: find.byType(EditableText), + ); + expect(dialogField, findsOneWidget); + await tester.tap(dialogField); + await tester.pumpAndSettle(); + expect(await _slash(tester), isFalse); + expect(find.byType(Dialog), findsOneWidget); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isFalse); + await tester.pumpWidget(const SizedBox.shrink()); + }); + + testWidgets('Control Tab over one pane returns to the previous chat', ( + tester, + ) async { + await _setup(tester); + await _openRow(tester, 'a'); + final workspace = _workspace(tester); + // Nothing shown before: the chord only focuses the composer. + await _controlTab(tester); + expect(workspace.activePane?.sessionId, 'a'); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isTrue); + + await _openRow(tester, 'b'); + await tester.enterText(_input('b'), 'Draft B'); + await _focusSidebar(tester); + for (final id in ['a', 'b', 'a']) { + await _controlTab(tester); + expect(workspace.paneCount, 1); + expect(workspace.activePane?.sessionId, id); + expect(_editable(tester, id).focusNode.hasPrimaryFocus, isTrue); + } + await _controlTab(tester, shift: true); + expect(workspace.activePane?.sessionId, 'b'); + expect(_editable(tester, 'b').controller.text, 'Draft B'); + + // A third chat makes the pair c and b; a is no longer one step away. + await _openRow(tester, 'c'); + await _controlTab(tester); + expect(workspace.activePane?.sessionId, 'b'); + await _controlTab(tester); + expect(workspace.activePane?.sessionId, 'c'); + + // Two panes cycle the panes as before, not the history. + await tester.tap(_actions('a')); + await tester.pumpAndSettle(); + await tester.tap(find.text('Open to the right')); + await tester.pumpAndSettle(); + expect(workspace.paneCount, 2); + expect(workspace.activePane?.sessionId, 'a'); + await _controlTab(tester); + expect(workspace.activePane?.sessionId, 'c'); + await _controlTab(tester); + expect(workspace.activePane?.sessionId, 'a'); + expect(workspace.paneCount, 2); + await tester.pumpWidget(const SizedBox.shrink()); + }); +} From 5e1498c4b22dd897fef65812d82e88961107f254 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sat, 7 Nov 2026 00:48:12 +0000 Subject: [PATCH 2/4] Chat composer: accent focus ring and wider desktop bottom margin While the field has focus the composer pill shows a thin translucent ring and soft glow in the chat's accent (its own colour, else the theme primary), fading in and out; nothing is drawn unfocused. On desktop hosts the composer keeps 24 px from the window's bottom edge instead of 12 (phones unchanged), split by the same host test as Enter-sends. --- .../chat/conversation/chat_composer_bar.dart | 75 +++++++++--- .../chat/conversation/chat_thread_view.dart | 1 + .../conversation/composer_focus_ring.dart | 82 +++++++++++++ .../chat_composer_bottom_margin_test.dart | 68 +++++++++++ .../chat_composer_focus_ring_test.dart | 109 ++++++++++++++++++ 5 files changed, 320 insertions(+), 15 deletions(-) create mode 100644 app/lib/features/chat/conversation/composer_focus_ring.dart create mode 100644 app/test/features/chat/conversation/chat_composer_bottom_margin_test.dart create mode 100644 app/test/features/chat/conversation/chat_composer_focus_ring_test.dart diff --git a/app/lib/features/chat/conversation/chat_composer_bar.dart b/app/lib/features/chat/conversation/chat_composer_bar.dart index d227f6ea..37fcac64 100644 --- a/app/lib/features/chat/conversation/chat_composer_bar.dart +++ b/app/lib/features/chat/conversation/chat_composer_bar.dart @@ -26,6 +26,8 @@ import '../../../ui/adaptive/glass_pill.dart'; import 'chat_reading_width.dart'; import 'composer_focus_request.dart'; import 'composer_focus_restore.dart'; +import 'composer_focus_ring.dart'; +import '../ui/sessions/chat_color_palette.dart'; /// The composer's placeholder when the chat names no working directory. const String chatComposerPlaceholder = 'Message the agent'; @@ -48,6 +50,22 @@ bool chatEnterSends([TargetPlatform? platform]) { return target != TargetPlatform.android && target != TargetPlatform.iOS; } +/// The composer's gap above the bottom of the window (or its bottom safe +/// area) on a phone, where it sits just over the keyboard or home indicator. +const double kChatComposerBottomMargin = 12; + +/// The same gap on a desktop host (native or a desktop browser), whose +/// window's bottom edge is a hard frame under a pointer: the composer keeps +/// more room from it so it does not read as stuck to the edge. +const double kChatComposerDesktopBottomMargin = 24; + +/// The composer's bottom gap on [platform] (the running host by default), +/// split between phones and desktops as [chatEnterSends] is. +double chatComposerBottomMargin([TargetPlatform? platform]) => + chatEnterSends(platform) + ? kChatComposerDesktopBottomMargin + : kChatComposerBottomMargin; + /// The single primary control's words while a turn is and is not running. const String chatSendLabel = 'Send'; const String chatStopLabel = 'Stop'; @@ -102,8 +120,13 @@ class ChatComposerBar extends StatefulWidget { this.placeholder = chatComposerPlaceholder, this.enterSends, this.images, + this.chatColor, }); + /// The chat's colour name (see `chatSessionColor`), the accent of the + /// field's focus ring; null takes the host's primary colour. + final String? chatColor; + /// The transcript's image cache, told about uploaded files so the sent turn /// shows them without a round trip. final ChatAttachmentImages? images; @@ -716,7 +739,12 @@ class _ChatComposerBarState extends State { constraints: const BoxConstraints(maxWidth: kChatReadingWidth), child: Padding( key: const Key('chat-composer'), - padding: const EdgeInsetsDirectional.fromSTEB(16, 8, 16, 12), + padding: EdgeInsetsDirectional.fromSTEB( + 16, + 8, + 16, + chatComposerBottomMargin(), + ), child: Column( mainAxisSize: MainAxisSize.min, crossAxisAlignment: CrossAxisAlignment.stretch, @@ -787,22 +815,39 @@ class _ChatComposerBarState extends State { ); } + static const OutlinedBorder _pillShape = RoundedRectangleBorder( + borderRadius: BorderRadius.all(Radius.circular(28)), + ); + /// The field and its controls in one frosted-glass surface floating over /// the transcript, so the composer reads as a single input rather than a - /// row of separate controls, and the conversation shows through it. - Widget _pill(BuildContext context, bool cupertino, Widget child) => GlassPill( - key: const Key('chat-composer-pill'), - cupertino: cupertino, - shape: const RoundedRectangleBorder( - borderRadius: BorderRadius.all(Radius.circular(28)), - ), - // The end controls keep the same gap from the pill's sides as from its - // bottom (and its top while the field is one line). - child: Padding( - padding: const EdgeInsets.all(GlassBarMetrics.fieldEdgeGap), - child: child, - ), - ); + /// row of separate controls, and the conversation shows through it. While + /// the field has focus the pill's edge takes the chat's accent. + Widget _pill(BuildContext context, bool cupertino, Widget child) => + ComposerFocusRing( + focus: _focus, + accent: _accent(context, cupertino), + shape: _pillShape, + child: GlassPill( + key: const Key('chat-composer-pill'), + cupertino: cupertino, + shape: _pillShape, + // The end controls keep the same gap from the pill's sides as from + // its bottom (and its top while the field is one line). + child: Padding( + padding: const EdgeInsets.all(GlassBarMetrics.fieldEdgeGap), + child: child, + ), + ), + ); + + /// The chat's accent: its own colour's shade for this host and brightness, + /// else the host's primary colour. + Color _accent(BuildContext context, bool cupertino) => + chatColorShade(context, widget.chatColor) ?? + (cupertino + ? CupertinoTheme.of(context).primaryColor + : Theme.of(context).colorScheme.primary); /// The attach control: a host button that opens the picker, disabled when the /// host has no picker or one prompt is already awaiting its reply. diff --git a/app/lib/features/chat/conversation/chat_thread_view.dart b/app/lib/features/chat/conversation/chat_thread_view.dart index 79e85230..69dbfb0a 100644 --- a/app/lib/features/chat/conversation/chat_thread_view.dart +++ b/app/lib/features/chat/conversation/chat_thread_view.dart @@ -937,6 +937,7 @@ class _ChatThreadViewState extends State { placeholder: chatComposerPlaceholderFor( '${widget.session?['directory'] ?? ''}', ), + chatColor: chatSessionColor(widget.session), backgroundTasks: ChatBackgroundTasks( key: ValueKey('chat-background-tasks-${widget.sessionId}'), gateway: widget.gateway, diff --git a/app/lib/features/chat/conversation/composer_focus_ring.dart b/app/lib/features/chat/conversation/composer_focus_ring.dart new file mode 100644 index 00000000..3454efb2 --- /dev/null +++ b/app/lib/features/chat/conversation/composer_focus_ring.dart @@ -0,0 +1,82 @@ +import 'package:flutter/widgets.dart'; + +/// The composer's focus indication: a thin ring in the chat's accent colour +/// along the pill's edge and a soft glow of the same colour outside it, so +/// a focused field shows as such without relying on its caret alone. Both +/// fade in and out with focus; at rest unfocused nothing visible is drawn. +/// +/// The accent is the chat's own colour (its highlight in the list) when it +/// has one, else the host's primary colour, never the pill's background: the +/// ring is translucent so the same tint stays subtle on a light and a dark +/// pill. +class ComposerFocusRing extends StatelessWidget { + const ComposerFocusRing({ + super.key, + required this.focus, + required this.accent, + required this.shape, + required this.child, + }); + + /// The field's focus node; the ring follows its [FocusNode.hasFocus]. + final FocusNode focus; + + /// The chat's accent, at full opacity; the ring and glow fade it. + final Color accent; + + /// The pill's shape, so the ring hugs its edge. + final OutlinedBorder shape; + final Widget child; + + /// How long the ring takes to appear or fade. + static const Duration duration = Duration(milliseconds: 160); + + /// The ring's stroke, drawn just inside the pill's edge over its hairline. + static const double ringWidth = 1.5; + + /// The accent's opacity in the ring while focused. + static const double ringOpacity = 0.6; + + /// The accent's opacity in the glow while focused. + static const double glowOpacity = 0.18; + + /// The glow's blur radius; it spreads [glowSpread] past the pill first. + static const double glowBlur = 12; + static const double glowSpread = 1; + + @override + Widget build(BuildContext context) => ListenableBuilder( + listenable: focus, + child: child, + builder: (context, child) { + final focused = focus.hasFocus; + // Both decorations keep the same shape, shadow and stroke while only + // their colours change, so the container lerps them into one fade. + return AnimatedContainer( + key: const Key('chat-composer-focus-ring'), + duration: duration, + curve: Curves.easeOutCubic, + decoration: ShapeDecoration( + shape: shape, + shadows: [ + BoxShadow( + color: accent.withValues(alpha: focused ? glowOpacity : 0), + blurRadius: glowBlur, + spreadRadius: glowSpread, + ), + ], + ), + // Over the child: the pill's fill would otherwise cover the ring. + foregroundDecoration: ShapeDecoration( + shape: shape.copyWith( + side: BorderSide( + color: accent.withValues(alpha: focused ? ringOpacity : 0), + width: ringWidth, + ), + ), + ), + child: child, + ); + }, + ); +} diff --git a/app/test/features/chat/conversation/chat_composer_bottom_margin_test.dart b/app/test/features/chat/conversation/chat_composer_bottom_margin_test.dart new file mode 100644 index 00000000..1eff3734 --- /dev/null +++ b/app/test/features/chat/conversation/chat_composer_bottom_margin_test.dart @@ -0,0 +1,68 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_composer_bar.dart'; + +import 'chat_composer_bar_fixtures.dart'; + +/// The phones: Fuchsia counts as a keyboard host (Enter sends), like desktop. +final _phones = TargetPlatformVariant({ + TargetPlatform.android, + TargetPlatform.iOS, +}); + +double _bottomMargin(WidgetTester tester) { + final padding = tester.widget( + find.byKey(const Key('chat-composer')), + ); + return (padding.padding as EdgeInsetsDirectional).bottom; +} + +void main() { + test('phones keep the close bottom margin, desktops a wider one', () { + expect( + chatComposerBottomMargin(TargetPlatform.android), + kChatComposerBottomMargin, + ); + expect( + chatComposerBottomMargin(TargetPlatform.iOS), + kChatComposerBottomMargin, + ); + for (final desktop in [ + TargetPlatform.macOS, + TargetPlatform.windows, + TargetPlatform.linux, + ]) { + expect( + chatComposerBottomMargin(desktop), + kChatComposerDesktopBottomMargin, + ); + } + expect( + kChatComposerDesktopBottomMargin, + greaterThan(kChatComposerBottomMargin), + ); + }); + + group('rendered composer', () { + late ComposerBarGateway gateway; + + setUp(() => gateway = ComposerBarGateway()..page = fixtureTurn()); + tearDown(() => gateway.close()); + + testWidgets( + 'keeps more room from a desktop window bottom', + (tester) async { + await tester.pumpWidget(composerThread(gateway)); + await tester.pumpAndSettle(); + expect(_bottomMargin(tester), kChatComposerDesktopBottomMargin); + }, + variant: TargetPlatformVariant.desktop(), + ); + + testWidgets('stays close to a phone bottom', (tester) async { + await tester.pumpWidget(composerThread(gateway)); + await tester.pumpAndSettle(); + expect(_bottomMargin(tester), kChatComposerBottomMargin); + }, variant: _phones); + }); +} diff --git a/app/test/features/chat/conversation/chat_composer_focus_ring_test.dart b/app/test/features/chat/conversation/chat_composer_focus_ring_test.dart new file mode 100644 index 00000000..cec806fd --- /dev/null +++ b/app/test/features/chat/conversation/chat_composer_focus_ring_test.dart @@ -0,0 +1,109 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/chat/conversation/composer_focus_ring.dart'; +import 'package:pipelines_app/features/chat/ui/sessions/chat_color_palette.dart'; + +import 'chat_composer_bar_fixtures.dart'; + +/// The focus ring wrapping the composer pill: its outer glow and inner ring. +({Color glow, BorderSide side}) _ring(WidgetTester tester) { + final container = tester.widget( + find.byKey(const Key('chat-composer-focus-ring')), + ); + final glow = (container.decoration! as ShapeDecoration).shadows!.single; + final shape = (container.foregroundDecoration! as ShapeDecoration).shape; + return (glow: glow.color, side: (shape as RoundedRectangleBorder).side); +} + +Future _focusField(WidgetTester tester) async { + await tester.tap(find.byKey(const Key('chat-composer-field'))); + await tester.pumpAndSettle(); +} + +void main() { + late ComposerBarGateway gateway; + + setUp(() => gateway = ComposerBarGateway()..page = fixtureTurn()); + tearDown(() => gateway.close()); + + testWidgets('unfocused composer draws no ring or glow', (tester) async { + await tester.pumpWidget(composerThread(gateway)); + await tester.pumpAndSettle(); + + final ring = _ring(tester); + expect(ring.side.color.a, 0); + expect(ring.glow.a, 0); + expect(ring.side.width, ComposerFocusRing.ringWidth); + }); + + testWidgets('focused composer takes the primary colour as its ring', ( + tester, + ) async { + await tester.pumpWidget(composerThread(gateway)); + await tester.pumpAndSettle(); + await _focusField(tester); + + final primary = Theme.of( + tester.element(find.byKey(const Key('chat-composer-field'))), + ).colorScheme.primary; + final ring = _ring(tester); + expect( + ring.side.color, + primary.withValues(alpha: ComposerFocusRing.ringOpacity), + ); + expect(ring.glow, primary.withValues(alpha: ComposerFocusRing.glowOpacity)); + expect(ring.side.width, ComposerFocusRing.ringWidth); + }); + + testWidgets('a coloured chat lends its own shade to the ring', ( + tester, + ) async { + await tester.pumpWidget( + composerThread(gateway, session: {'id': 's', 'color': 'teal'}), + ); + await tester.pumpAndSettle(); + await _focusField(tester); + + final teal = chatColorShade( + tester.element(find.byKey(const Key('chat-composer-field'))), + 'teal', + )!; + expect( + _ring(tester).side.color, + teal.withValues(alpha: ComposerFocusRing.ringOpacity), + ); + }); + + testWidgets('the ring fades out again when focus leaves', (tester) async { + await tester.pumpWidget(composerThread(gateway)); + await tester.pumpAndSettle(); + await _focusField(tester); + expect(_ring(tester).side.color.a, greaterThan(0)); + + FocusManager.instance.primaryFocus?.unfocus(); + // One frame applies the focus change, the next rebuilds the ring towards + // its unfocused decoration, which the container then animates into. + await tester.pump(); + await tester.pump(); + expect(_ring(tester).side.color.a, 0); + await tester.pumpAndSettle(); + expect(_ring(tester).glow.a, 0); + }); + + testWidgets('Cupertino composer rings in the theme primary colour', ( + tester, + ) async { + await tester.pumpWidget(composerThread(gateway, cupertino: true)); + await tester.pumpAndSettle(); + await _focusField(tester); + + final primary = CupertinoTheme.of( + tester.element(find.byKey(const Key('chat-composer-field'))), + ).primaryColor; + expect( + _ring(tester).side.color, + primary.withValues(alpha: ComposerFocusRing.ringOpacity), + ); + }); +} From bfe89432bbae44f33dc0531bd55a7b2aad38380a Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sat, 7 Nov 2026 00:53:15 +0000 Subject: [PATCH 3/4] Add contained home file endpoint --- docs/notes/files-panel.md | 7 ++ internal/server/AGENTS.md | 1 + internal/server/chat_sessions.go | 6 +- internal/server/home_files.go | 123 +++++++++++++++++++++++++++++ internal/server/home_files_test.go | 88 +++++++++++++++++++++ internal/server/websocket.go | 1 + 6 files changed, 225 insertions(+), 1 deletion(-) create mode 100644 docs/notes/files-panel.md create mode 100644 internal/server/home_files.go create mode 100644 internal/server/home_files_test.go diff --git a/docs/notes/files-panel.md b/docs/notes/files-panel.md new file mode 100644 index 00000000..13953836 --- /dev/null +++ b/docs/notes/files-panel.md @@ -0,0 +1,7 @@ +# Files panel + +The server's `GET /files?path=...` endpoint serves one regular file for the +client files panel. Paths may be absolute or `~`-prefixed, and are resolved +through the operator home directory; cleaned paths and symlinks are required to +remain inside that home subtree. Directories, special files, and escape paths +are refused. Add `download=1` to request attachment disposition. diff --git a/internal/server/AGENTS.md b/internal/server/AGENTS.md index 5ee21a79..58f1d490 100644 --- a/internal/server/AGENTS.md +++ b/internal/server/AGENTS.md @@ -17,6 +17,7 @@ go test ./... # ~1 min for everything; `gofmt -l .` must print - `internal/server/websocket.go` — the `/connect` transport and the request dispatch. Envelope validation lives here; every command returns its own typed reply. +- `internal/server/home_files.go` — the contained `/files` endpoint for regular files under the operator home. - `internal/server/runner.go` — run execution: the stage loop, stage outcomes, budgets, retries, ownership and settlement. This is where a run's state changes. - `internal/server/runevents.go` — the push hub: subscriptions scoped per workspace, per-run frames, diff --git a/internal/server/chat_sessions.go b/internal/server/chat_sessions.go index a8de3eca..c788fab6 100644 --- a/internal/server/chat_sessions.go +++ b/internal/server/chat_sessions.go @@ -442,7 +442,7 @@ func resolveChatDirectory(directory string) (string, error) { // location. It is resolved through the standard library so it never falls back // to the process working directory. func OperatorHomeDirectory() (string, error) { - home, err := os.UserHomeDir() + home, err := operatorHomeDirectory() if err != nil { return "", errors.New("resolve operator home directory: " + err.Error()) } @@ -451,3 +451,7 @@ func OperatorHomeDirectory() (string, error) { } return home, nil } + +// operatorHomeDirectory is a seam for tests of filesystem endpoints that are +// rooted at the operator's home directory. +var operatorHomeDirectory = os.UserHomeDir diff --git a/internal/server/home_files.go b/internal/server/home_files.go new file mode 100644 index 00000000..ab5bef59 --- /dev/null +++ b/internal/server/home_files.go @@ -0,0 +1,123 @@ +package server + +import ( + "errors" + "io" + "mime" + "net/http" + "os" + "path/filepath" + "strings" +) + +func serveHomeFile(w http.ResponseWriter, r *http.Request) { + home, err := OperatorHomeDirectory() + if err != nil { + http.NotFound(w, r) + return + } + serveHomeFileFrom(w, r, home) +} + +func serveHomeFileFrom(w http.ResponseWriter, r *http.Request, home string) { + home = filepath.Clean(home) + realHome, err := filepath.EvalSymlinks(home) + if err != nil { + http.NotFound(w, r) + return + } + target, err := expandHomePath(home, r.URL.Query().Get("path")) + if err != nil { + http.Error(w, "file not found", http.StatusNotFound) + return + } + _, realTarget, err := resolveInsideHome(realHome, target) + if err != nil { + if strings.Contains(err.Error(), "outside the home directory") { + http.Error(w, "file access denied", http.StatusForbidden) + } else { + http.NotFound(w, r) + } + return + } + info, err := os.Stat(realTarget) + if err != nil { + http.NotFound(w, r) + return + } + if info.IsDir() || !info.Mode().IsRegular() { + http.NotFound(w, r) + return + } + if specialFilesystem(realTarget) { + http.Error(w, "file access denied", http.StatusForbidden) + return + } + file, err := os.Open(realTarget) + if err != nil { + if errors.Is(err, os.ErrPermission) { + http.Error(w, "file access denied", http.StatusForbidden) + } else { + http.NotFound(w, r) + } + return + } + defer file.Close() + + w.Header().Set("Cache-Control", "private, no-cache") + w.Header().Set("X-Content-Type-Options", "nosniff") + contentType := mime.TypeByExtension(filepath.Ext(realTarget)) + if contentType == "" { + var sample [512]byte + n, readErr := file.Read(sample[:]) + if readErr != nil && !errors.Is(readErr, io.EOF) { + http.NotFound(w, r) + return + } + contentType = http.DetectContentType(sample[:n]) + if _, err := file.Seek(0, io.SeekStart); err != nil { + http.NotFound(w, r) + return + } + } + if contentType == "" { + contentType = "application/octet-stream" + } + w.Header().Set("Content-Type", contentType) + disposition := "inline" + if r.URL.Query().Get("download") == "1" { + disposition = "attachment" + } + w.Header().Set("Content-Disposition", contentDisposition(disposition, filepath.Base(realTarget))) + http.ServeContent(w, r, filepath.Base(realTarget), info.ModTime(), file) +} + +func contentDisposition(kind, filename string) string { + // The ASCII fallback keeps older clients useful; filename* preserves the + // actual name for clients that implement RFC 6266/RFC 5987. + fallback := strings.Map(func(r rune) rune { + if r < 0x20 || r > 0x7e || r == '"' || r == '\\' { + return '_' + } + return r + }, filename) + if fallback == "" { + fallback = "file" + } + return kind + `; filename="` + fallback + `"; filename*=UTF-8''` + rfc5987(filename) +} + +func rfc5987(value string) string { + const hex = "0123456789ABCDEF" + var b strings.Builder + for _, c := range []byte(value) { + if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || strings.ContainsRune("!#$&+-.^_`|~", rune(c)) { + b.WriteByte(c) + } else { + b.WriteByte('%') + b.WriteByte(hex[c>>4]) + b.WriteByte(hex[c&15]) + } + } + return b.String() +} diff --git a/internal/server/home_files_test.go b/internal/server/home_files_test.go new file mode 100644 index 00000000..c393defc --- /dev/null +++ b/internal/server/home_files_test.go @@ -0,0 +1,88 @@ +package server + +import ( + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "testing" +) + +func TestServeHomeFile(t *testing.T) { + root := t.TempDir() + home := filepath.Join(root, "home") + outside := filepath.Join(root, "outside.txt") + if err := os.Mkdir(home, 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(home, "hello.txt"), []byte("hello file contents"), 0o644); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(home, "résumé"), []byte("plain"), 0o644); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(outside, []byte("outside"), 0o644); err != nil { + t.Fatal(err) + } + if err := os.Symlink(outside, filepath.Join(home, "escape")); err != nil { + t.Fatal(err) + } + originalHomeDirectory := operatorHomeDirectory + operatorHomeDirectory = func() (string, error) { return home, nil } + t.Cleanup(func() { operatorHomeDirectory = originalHomeDirectory }) + t.Run("operator home seam", func(t *testing.T) { + recorder := httptest.NewRecorder() + serveHomeFile(recorder, httptest.NewRequest(http.MethodGet, "/files?path=~/hello.txt", nil)) + if recorder.Code != http.StatusOK || recorder.Body.String() != "hello file contents" { + t.Fatalf("response = %d %q", recorder.Code, recorder.Body.String()) + } + }) + + tests := []struct { + name string + path string + want int + }{ + {"happy path", "~/hello.txt", http.StatusOK}, + {"directory refused", "~", http.StatusNotFound}, + {"dot dot refused", filepath.Join(home, "..", "outside.txt"), http.StatusForbidden}, + {"symlink refused", "~/escape", http.StatusForbidden}, + {"missing file", "~/missing", http.StatusNotFound}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + req := httptest.NewRequest(http.MethodGet, "/files?path="+tc.path, nil) + recorder := httptest.NewRecorder() + serveHomeFileFrom(recorder, req, home) + if recorder.Code != tc.want { + t.Fatalf("status = %d, want %d", recorder.Code, tc.want) + } + }) + } + + t.Run("download disposition and range", func(t *testing.T) { + req := httptest.NewRequest(http.MethodGet, "/files?path=~/hello.txt&download=1", nil) + req.Header.Set("Range", "bytes=0-4") + recorder := httptest.NewRecorder() + serveHomeFileFrom(recorder, req, home) + if recorder.Code != http.StatusPartialContent || recorder.Body.String() != "hello" { + t.Fatalf("response = %d %q, want 206 hello", recorder.Code, recorder.Body.String()) + } + if got := recorder.Header().Get("Content-Disposition"); got != `attachment; filename="hello.txt"; filename*=UTF-8''hello.txt` { + t.Fatalf("disposition = %q", got) + } + if recorder.Header().Get("Content-Type") != "text/plain; charset=utf-8" { + t.Fatalf("content type = %q", recorder.Header().Get("Content-Type")) + } + }) + + t.Run("non ASCII disposition", func(t *testing.T) { + req := httptest.NewRequest(http.MethodGet, "/files?path=~/r%C3%A9sum%C3%A9", nil) + recorder := httptest.NewRecorder() + serveHomeFileFrom(recorder, req, home) + if !strings.Contains(recorder.Header().Get("Content-Disposition"), "filename*=UTF-8''r%C3%A9sum%C3%A9") { + t.Fatal(recorder.Header().Get("Content-Disposition")) + } + }) +} diff --git a/internal/server/websocket.go b/internal/server/websocket.go index 71e032c2..efece1a5 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -154,6 +154,7 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin } runs.serveArtifact(w, r) }) + mux.HandleFunc("GET /files", serveHomeFile) mux.HandleFunc("POST /chat-uploads", serveChatUpload) mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") From c4ccbb3f9511da09e59ebaf7dd4c6d206f4955fa Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sat, 7 Nov 2026 00:54:36 +0000 Subject: [PATCH 4/4] Add file size and modified time to directory listings --- docs/notes/files-panel.md | 3 +++ internal/protocol/directories.go | 14 +++++++---- internal/server/directory_listing.go | 11 +++++++-- internal/server/directory_listing_test.go | 30 +++++++++++++++++++++++ 4 files changed, 51 insertions(+), 7 deletions(-) create mode 100644 docs/notes/files-panel.md diff --git a/docs/notes/files-panel.md b/docs/notes/files-panel.md new file mode 100644 index 00000000..df31cda5 --- /dev/null +++ b/docs/notes/files-panel.md @@ -0,0 +1,3 @@ +# Files panel + +- Directory listings now include file `size` and RFC3339 UTC `modified` metadata. diff --git a/internal/protocol/directories.go b/internal/protocol/directories.go index 24e9a43e..71f32393 100644 --- a/internal/protocol/directories.go +++ b/internal/protocol/directories.go @@ -3,8 +3,9 @@ package protocol // Directory browsing for the chat folder picker. A client sends // Message{Type: ListDirectory, ID: , 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. +// restricted to the server user's home directory subtree, returns names, kinds, +// and file metadata (never file contents), and is bounded by +// DirectoryListingMaxEntries. const ( ListDirectory = "list_directory" DirectoryListing = "directory_listing" @@ -23,8 +24,8 @@ type DirectoryListRequest struct { // 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. +// case-insensitively. Entries include file size and modification time when +// available; file contents are never returned, and files are not selectable. type DirectoryListingResult struct { Path string `json:"path"` Home string `json:"home"` @@ -35,11 +36,14 @@ type DirectoryListingResult struct { // 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. +// directory containing .git; Hidden marks a dot-name. Size and Modified are +// populated for files; directories have no file metadata. 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"` + Size int64 `json:"size,omitempty"` + Modified string `json:"modified,omitempty"` } diff --git a/internal/server/directory_listing.go b/internal/server/directory_listing.go index 6b8af91c..1117305d 100644 --- a/internal/server/directory_listing.go +++ b/internal/server/directory_listing.go @@ -8,6 +8,7 @@ import ( "path/filepath" "sort" "strings" + "time" "git.a-wan.net/alan/pipelines/internal/protocol" ) @@ -131,8 +132,8 @@ func describePathError(path string, err error) 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. +// directories first then case-insensitively, and caps the result. No file is +// opened. func readDirectoryEntries(realHome, realDir, shown string, maxEntries int) ([]protocol.DirectoryEntry, bool, error) { dir, err := os.Open(realDir) if err != nil { @@ -191,6 +192,12 @@ func describeEntry(realHome, realDir, shown string, item fs.DirEntry) protocol.D entry.IsDir = true } } + if !entry.IsDir { + if info, err := item.Info(); err == nil { + entry.Size = info.Size() + entry.Modified = info.ModTime().UTC().Format(time.RFC3339) + } + } if entry.IsDir { if _, err := os.Lstat(filepath.Join(full, ".git")); err == nil { entry.IsGitRepo = true diff --git a/internal/server/directory_listing_test.go b/internal/server/directory_listing_test.go index ccaf183b..b0eddf2a 100644 --- a/internal/server/directory_listing_test.go +++ b/internal/server/directory_listing_test.go @@ -6,6 +6,7 @@ import ( "path/filepath" "strings" "testing" + "time" "git.a-wan.net/alan/pipelines/internal/protocol" "github.com/coder/websocket/wsjson" @@ -95,6 +96,35 @@ func TestListDirectorySubdirectoryHasParent(t *testing.T) { } } +func TestListDirectoryFileMetadata(t *testing.T) { + home, _ := newListingHome(t) + file := filepath.Join(home, "Notes.txt") + modified := time.Date(2024, time.March, 14, 15, 9, 26, 0, time.UTC) + if err := os.Chtimes(file, modified, modified); err != nil { + t.Fatal(err) + } + + listing, err := listHomeDirectory(home, "~", protocol.DirectoryListingMaxEntries) + if err != nil { + t.Fatal(err) + } + var gotFile, gotDir protocol.DirectoryEntry + for _, entry := range listing.Entries { + switch entry.Name { + case "Notes.txt": + gotFile = entry + case "repo": + gotDir = entry + } + } + if gotFile.Size != int64(len("secret contents")) || gotFile.Modified != modified.Format(time.RFC3339) { + t.Fatalf("file metadata = %+v", gotFile) + } + if gotDir.Size != 0 || gotDir.Modified != "" { + t.Fatalf("directory metadata = %+v", gotDir) + } +} + func TestListDirectoryRefusesPathsOutsideHome(t *testing.T) { home, outside := newListingHome(t) if err := os.Symlink(outside, filepath.Join(home, "escape")); err != nil {