diff --git a/app/lib/features/chat/domain/chat_list_activity.dart b/app/lib/features/chat/domain/chat_list_activity.dart new file mode 100644 index 00000000..138393a2 --- /dev/null +++ b/app/lib/features/chat/domain/chat_list_activity.dart @@ -0,0 +1,43 @@ +import '../../../core/api_gateway.dart'; + +/// One chat's live activity as the server observes it: a turn in flight and +/// how many background tasks (shells, background commands, subagents) still +/// run. It rides on each `chat_sessions` row as `activity` and is pushed to +/// every connection as `chat_activity` on each change. [seq] orders one +/// chat's snapshots across the list and the pushes; the larger one is newer. +typedef ChatListActivity = ({ + String sessionId, + bool turnRunning, + int backgroundTasks, + int seq, +}); + +/// Reads an `activity` row field or a `chat_activity` body. [sessionId] names +/// the row when the body omits it. Anything malformed is null, so an older +/// server (which sends neither) leaves the list exactly as before. +ChatListActivity? chatListActivityOf(Object? value, {String? sessionId}) { + if (value is! Map) return null; + final named = value['session_id']; + final id = sessionId ?? (named is String ? named : ''); + if (id.isEmpty) return null; + final tasks = value['background_tasks']; + final seq = value['seq']; + return ( + sessionId: id, + turnRunning: value['turn_running'] == true, + backgroundTasks: tasks is num && tasks > 0 ? tasks.toInt() : 0, + seq: seq is num ? seq.toInt() : 0, + ); +} + +/// The row keys the list controller derives from the activity. +JsonMap chatListActivityRowFields(ChatListActivity activity) => { + 'running': activity.turnRunning, + 'background_tasks': activity.backgroundTasks, +}; + +/// Running background tasks of a list row; 0 when unknown. +int chatSessionBackgroundTasks(JsonMap session) { + final tasks = session['background_tasks']; + return tasks is int && tasks > 0 ? tasks : 0; +} diff --git a/app/lib/features/chat/ui/sessions/chat_sessions_controller.dart b/app/lib/features/chat/ui/sessions/chat_sessions_controller.dart index 1ac13ab6..3cc0b53c 100644 --- a/app/lib/features/chat/ui/sessions/chat_sessions_controller.dart +++ b/app/lib/features/chat/ui/sessions/chat_sessions_controller.dart @@ -8,6 +8,7 @@ import '../../../../core/servers/server_scope.dart'; import '../../../../core/transport/connection_state.dart'; import '../../../attention/runtime/attention_ack_sync.dart'; import '../../data/chat_repository.dart'; +import '../../domain/chat_list_activity.dart'; import '../../domain/chat_sessions.dart'; import 'chat_session_local.dart'; import 'session_attention.dart'; @@ -65,6 +66,9 @@ class ChatSessionsController extends ChangeNotifier { Future _persistTail = Future.value(); int _runningRevision = 0; final Map _runningFrames = {}; + // The newest server activity applied per chat (list row or push), so an + // older snapshot that arrives later never replaces it. + final Map _activity = {}; StreamSubscription? _frameSubscription; String? activeSessionId; @@ -75,6 +79,9 @@ class ChatSessionsController extends ChangeNotifier { void _onFrame(JsonMap frame) { if (frame['type'] == 'chat_session_changed') return _sessionChanged(frame); + if (frame['type'] == 'chat_activity') { + return _activityChanged(frame['chat_activity']); + } final effect = chatSessionFrameEffect(frame); if (effect == null) return; final id = effect.sessionId; @@ -130,6 +137,58 @@ class ChatSessionsController extends ChangeNotifier { if (found) _notify(); } + /// The server pushed a chat's turn state and background-task count. It + /// reaches every connection, so every listed chat's spinner and + /// background-task badge follow it, not only the chat open here. A push + /// older than the snapshot already applied is ignored. + void _activityChanged(Object? body) { + final activity = chatListActivityOf(body); + if (activity == null || _disposed) return; + final id = activity.sessionId; + if (activity.seq <= (_activity[id]?.seq ?? 0)) return; + _activity[id] = activity; + _runningFrames[id] = ( + revision: ++_runningRevision, + running: activity.turnRunning, + ); + final fields = chatListActivityRowFields(activity); + var changed = false; + _sessions = [ + for (final row in _sessions) + if ('${row['id'] ?? ''}' == id && + (row['running'] != fields['running'] || + row['background_tasks'] != fields['background_tasks'])) + () { + changed = true; + return {...row, ...fields}; + }() + else + row, + ]; + if (changed) _notify(); + } + + /// A listed row with the newest activity known for it: the row's own + /// `activity` unless a newer push was already applied, then a turn frame + /// this connection saw during the read. An older server sends no + /// `activity`, so only the turn frames apply, as before. + JsonMap _withActivity(JsonMap row, int runningRevision) { + final id = '${row['id'] ?? ''}'; + var next = row; + final listed = chatListActivityOf(row['activity'], sessionId: id); + if (listed != null) { + final known = _activity[id]; + final activity = known != null && known.seq > listed.seq ? known : listed; + _activity[id] = activity; + next = {...row, ...chatListActivityRowFields(activity)}; + } + final frame = _runningFrames[id]; + if ((frame?.revision ?? 0) > runningRevision) { + next = {...next, 'running': frame!.running}; + } + return next; + } + void _bindAckSync(AttentionAckSync? sync) { if (identical(sync, _ackSync)) return; _ackSync?.removeListener(_ackChanged); @@ -246,6 +305,7 @@ class ChatSessionsController extends ChangeNotifier { if (identical(next.gateway, repository.gateway)) return; repository = next; _runningFrames.clear(); + _activity.clear(); _listenFrames(); _bindAckSync(attentionAckSyncOf(next.gateway) ?? _ackSync); refresh(); @@ -265,12 +325,7 @@ class ChatSessionsController extends ChangeNotifier { final sessions = await repository.sessions(); if (generation != _generation) return; _sessions = [ - for (final row in sessions) - if ((_runningFrames['${row['id'] ?? ''}']?.revision ?? 0) > - runningRevision) - {...row, 'running': _runningFrames['${row['id'] ?? ''}']!.running} - else - row, + for (final row in sessions) _withActivity(row, runningRevision), ]; _seedLocal(); _loading = false; diff --git a/app/lib/features/chat/ui/sessions/session_activity_badge.dart b/app/lib/features/chat/ui/sessions/session_activity_badge.dart new file mode 100644 index 00000000..75a51cf1 --- /dev/null +++ b/app/lib/features/chat/ui/sessions/session_activity_badge.dart @@ -0,0 +1,93 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +/// The corner badge a chat's avatar wears for its live activity: the +/// platform's activity indicator while a turn runs; otherwise, while +/// background tasks still run, a quiet muted glyph (never a second spinner). +/// Null when the chat is idle. +Widget? chatSessionActivityBadge({ + required bool cupertino, + required bool running, + required int backgroundTasks, +}) { + if (running) { + return Semantics( + key: const Key('chat-row-working'), + label: 'Chat is working', + child: _WorkingBadge(cupertino: cupertino), + ); + } + if (backgroundTasks <= 0) return null; + final label = 'Background tasks running ($backgroundTasks)'; + // Hover shows the tooltip on a pointer device; a touch long press stays the + // row's own gesture. + return Tooltip( + key: const Key('chat-row-background'), + message: label, + triggerMode: TooltipTriggerMode.manual, + excludeFromSemantics: true, + child: Semantics( + label: label, + child: _BackgroundBadge(cupertino: cupertino), + ), + ); +} + +/// The badge's own disc in the surface colour, so it reads over any avatar. +class _BadgeDisc extends StatelessWidget { + const _BadgeDisc({required this.cupertino, required this.child}); + + final bool cupertino; + final Widget child; + + @override + Widget build(BuildContext context) { + final background = cupertino + ? CupertinoColors.systemBackground.resolveFrom(context) + : Theme.of(context).colorScheme.surface; + return DecoratedBox( + decoration: BoxDecoration(color: background, shape: BoxShape.circle), + child: Padding(padding: const EdgeInsets.all(2), child: child), + ); + } +} + +class _WorkingBadge extends StatelessWidget { + const _WorkingBadge({required this.cupertino}); + + final bool cupertino; + + @override + Widget build(BuildContext context) { + return _BadgeDisc( + cupertino: cupertino, + child: cupertino + ? const CupertinoActivityIndicator(radius: 6) + : const SizedBox.square( + dimension: 12, + child: CircularProgressIndicator(strokeWidth: 2), + ), + ); + } +} + +class _BackgroundBadge extends StatelessWidget { + const _BackgroundBadge({required this.cupertino}); + + final bool cupertino; + + @override + Widget build(BuildContext context) { + final color = cupertino + ? CupertinoColors.secondaryLabel.resolveFrom(context) + : Theme.of(context).colorScheme.onSurfaceVariant; + return _BadgeDisc( + cupertino: cupertino, + child: Icon( + cupertino ? CupertinoIcons.ellipsis_circle_fill : Icons.pending, + size: 12, + color: color, + ), + ); + } +} diff --git a/app/lib/features/chat/ui/sessions/session_row_content.dart b/app/lib/features/chat/ui/sessions/session_row_content.dart index 4bfdea62..4e25f709 100644 --- a/app/lib/features/chat/ui/sessions/session_row_content.dart +++ b/app/lib/features/chat/ui/sessions/session_row_content.dart @@ -6,10 +6,12 @@ import '../../../../ui/layout/app_list_avatar.dart'; import '../../../../ui/layout/app_list_row.dart'; import '../../../../ui/text/relative_time_label.dart'; import '../../domain/chat_colors.dart'; +import '../../domain/chat_list_activity.dart'; import '../../domain/chat_sessions.dart'; import 'chat_adaptive.dart'; import 'chat_color_palette.dart'; import 'session_actions.dart'; +import 'session_activity_badge.dart'; import 'session_harness_icon.dart'; import 'session_row_style.dart'; @@ -68,6 +70,9 @@ class ChatSessionRow extends StatelessWidget { leading: ChatSessionAvatar( session: session, running: session['running'] == true && !unseen, + backgroundTasks: session['running'] == true + ? 0 + : chatSessionBackgroundTasks(session), selected: selected, ), // The star rides in the title's own text, so a narrow row ellipsises @@ -149,17 +154,20 @@ class _Star extends StatelessWidget { /// The chat's harness mark in a filled circle, like a contact avatar. A /// running chat carries a small activity badge on the avatar's corner instead -/// of a line of its own; a selected chat's avatar takes the accent fill. +/// of a line of its own, and an idle chat whose background tasks still run a +/// quieter one; a selected chat's avatar takes the accent fill. class ChatSessionAvatar extends StatelessWidget { const ChatSessionAvatar({ super.key, required this.session, this.running = false, + this.backgroundTasks = 0, this.selected = false, }); final JsonMap session; final bool running; + final int backgroundTasks; final bool selected; @override @@ -192,39 +200,12 @@ class ChatSessionAvatar extends StatelessWidget { return AppListAvatar( foreground: mark, background: fill, - badge: running - ? Semantics( - key: const Key('chat-row-working'), - label: 'Chat is working', - child: _WorkingBadge(cupertino: cupertino), - ) - : null, + badge: chatSessionActivityBadge( + cupertino: cupertino, + running: running, + backgroundTasks: backgroundTasks, + ), child: SessionHarnessIcon(session: session, color: mark), ); } } - -class _WorkingBadge extends StatelessWidget { - const _WorkingBadge({required this.cupertino}); - - final bool cupertino; - - @override - Widget build(BuildContext context) { - final background = cupertino - ? CupertinoColors.systemBackground.resolveFrom(context) - : Theme.of(context).colorScheme.surface; - return DecoratedBox( - decoration: BoxDecoration(color: background, shape: BoxShape.circle), - child: Padding( - padding: const EdgeInsets.all(2), - child: cupertino - ? const CupertinoActivityIndicator(radius: 6) - : const SizedBox.square( - dimension: 12, - child: CircularProgressIndicator(strokeWidth: 2), - ), - ), - ); - } -} diff --git a/app/notes/session-list-background-tasks.md b/app/notes/session-list-background-tasks.md index bd62d7da..ef41a1f6 100644 --- a/app/notes/session-list-background-tasks.md +++ b/app/notes/session-list-background-tasks.md @@ -1,35 +1,58 @@ -# Session list: background-task indicator (blocked on server data) +# Session list: turn and background-task indicators -Request: show a quieter indicator on a chat list row when the turn is not running -but the session still has live background work (shells, Claude background Bash, -subagents). The turn spinner would win. +Request: besides the turn spinner, show a quieter indicator on a chat list row +when the turn is idle but the session still runs background work (shells, +Claude Code background Bash and Agent/Task subagents, Codex command executions, +OpenCode shells). Also make the spinner reliable for every listed chat, not +only chats this connection opened. -Not implemented. The client cannot know this per listed chat without guessing. +Implemented, with an approved server change. -## What exists -- Background work is modelled server-side as shells for all three harnesses - (OpenCode shell API, Codex `commandExecution` items, Claude background Bash - and Agent/Task in `internal/claude/translate.go`). -- `chat_event` kind `shell` frames: sent only to subscribers of that session's - room (`chatHub.emitRoom`, `internal/server/chat_room.go`). The app subscribes - only the chat it opens; subscriptions end when the socket closes. -- `chat_shells` (`handleChatShells`, `internal/server/chat_shell_output.go`): - an on-demand per-session readback. It is not pushed, and for Codex/Claude it - goes through `chatManager.harness`, which can start the harness. +## Server +- `protocol.ChatSession.Activity` (`activity`: `turn_running`, + `background_tasks`, `seq`) is set on every `chat_sessions` row from the hub's + own state (`internal/server/chat_activity.go`, `handleChatSessions`). +- `chat_activity` is pushed to every connection (through `chatSessionChanges`) + when a session's turn starts or ends or its running-shell count changes. It + is computed under the hub mutex at those points only: turn admitted or + finished, step frames, shell frames, shell readback, and room release. Text + and tool chunks never push. `seq` starts from the wall clock in microseconds, + so it orders across a restart. +- Keep-alive: `keepUnattendedLocked` keeps an unwatched room while it holds + running shells, so their exits are seen and the badge clears. When the last + shell exits, the room is released at once (`emitRoom`) or by the reaper. + Bounds: the existing 16-room unattended cap, the 6-hour + `chatUnattendedTurnLimit` (measured from when the room became unattended), + and the harness itself. A Claude Code process exit now reports its running + background tasks as exited (`processExit`, `internal/claude`). A released + room reports 0 tasks rather than a stale count. -## What is missing -- `protocol.ChatSession` (`internal/protocol/chat.go`) has no background field, - and `handleChatSessions` (`internal/server/chat_sessions.go`) sets none. -- No push to every connection when a session's running-shell set changes - (`chat_session_changed` goes to all connections but carries no such field). -- `keepUnattendedLocked` (`internal/server/chat_unattended.go`) does not keep a - room alive for running shells, so after the last viewer leaves the server stops - observing that session's shell exits. +## App +- `ChatSessionsController` applies `chat_activity` and row `activity` by `seq` + (the larger wins), deriving `running` and `background_tasks` on the row. + The list re-reads on reconnect (the existing `syncToken`). A server without + `activity` leaves the list as before. +- `session_activity_badge.dart`: the turn spinner, or, when idle with tasks, + a muted `Icons.pending` / `CupertinoIcons.ellipsis_circle_fill` glyph with + tooltip and semantics "Background tasks running (N)". The tooltip shows on + hover only (`TooltipTriggerMode.manual`), so a touch long press stays the + row's own gesture. +- Fixture: `?chats=N&activity=1` in the capture app lists one running chat, + one with two background tasks and idle chats (`tool/perf/perf_fixture.dart`). -A server change that adds a count to the list row, sends it with -`chat_session_changed` (or a dedicated frame) on each running-set change, and keeps -observing sessions with live shells would let the client draw this accurately -through `chatSessionFrameEffect` and `session_row_content.dart`. +## Evidence +- Go: `chat_activity_test.go` covers the list payload, the pushes on turn start + and end and on task start and exit, unattended keep and release on exit, and + expiry of a task that never reports an exit. `background_tasks_test.go` covers + the Claude process exit. +- Flutter: `test/features/chat/ui/sessions/chat_sessions_activity_test.dart`. +- Captures (fixture app): Material phone 560x1000, Material desktop + 1280x900 with the hover tooltip, and Cupertino dark phone. -The existing turn spinner has the same limit: it follows only rooms this connection -subscribed to. +## Unverified +- Real harness behaviour. Shell start and exit events come from each adapter's + existing translation. Whether a real Codex or OpenCode background command + always reports its exit was not exercised against live harnesses here. +- Background Bash outliving a crashed Claude Code CLI. It is reported exited + on process exit, on the assumption that the CLI's tasks end with it. +- Device (Android/iOS) rendering; only the browser was captured. diff --git a/app/test/features/chat/ui/sessions/chat_sessions_activity_test.dart b/app/test/features/chat/ui/sessions/chat_sessions_activity_test.dart new file mode 100644 index 00000000..63e95324 --- /dev/null +++ b/app/test/features/chat/ui/sessions/chat_sessions_activity_test.dart @@ -0,0 +1,264 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/chat/data/chat_repository.dart'; +import 'package:pipelines_app/features/chat/domain/chat_list_activity.dart'; +import 'package:pipelines_app/features/chat/ui/sessions/chat_sessions_controller.dart'; +import 'package:pipelines_app/features/chat/ui/sessions/chat_sessions_screen.dart'; + +import 'chat_test_harness.dart'; +import 'fake_chat_gateway.dart'; + +/// The list shows every chat's live activity from the server: a spinner while +/// a turn runs, a quieter badge while only background tasks run, nothing when +/// idle. `chat_activity` pushes reach chats this device never opened, and an +/// older server (no `activity`) leaves the list as before. +JsonMap _row(String id, {JsonMap? activity}) => { + 'id': id, + 'title': 'Chat $id', + 'directory': '/w', + 'updated_at': 1000, + 'activity': ?activity, +}; + +JsonMap _activity({bool turn = false, int tasks = 0, int seq = 1}) => { + if (turn) 'turn_running': true, + if (tasks > 0) 'background_tasks': tasks, + 'seq': seq, +}; + +JsonMap _push( + String id, { + bool turn = false, + int tasks = 0, + required int seq, +}) => { + 'type': 'chat_activity', + 'chat_activity': { + 'session_id': id, + ..._activity(turn: turn, tasks: tasks, seq: seq), + }, +}; + +/// The row merges its semantics, so the badge's label is part of the row's. +Finder _label(int tasks) => find.bySemanticsLabel( + RegExp(RegExp.escape('Background tasks running ($tasks)')), +); + +Finder _badge(String id) => find.descendant( + of: find.byKey(Key('chat-row-$id')), + matching: find.byKey(const Key('chat-row-background')), +); + +Finder _spinner(String id) => find.descendant( + of: find.byKey(Key('chat-row-$id')), + matching: find.byKey(const Key('chat-row-working')), +); + +Future _pump( + WidgetTester tester, + FakeChatGateway fake, { + bool cupertino = false, +}) async { + final screen = ChatSessionsScreen( + gateway: fake, + onOpen: (_) {}, + localStore: MemoryChatSessionLocalStore(), + ); + await tester.pumpWidget( + cupertino + ? CupertinoApp(home: screen) + : MaterialApp( + theme: ThemeData(platform: TargetPlatform.android), + home: screen, + ), + ); + // A spinner never settles, so pump a few frames instead. + for (var i = 0; i < 5; i++) { + await tester.pump(const Duration(milliseconds: 50)); + } +} + +Future _frames(WidgetTester tester) async { + await tester.pump(); + await tester.pump(); +} + +void main() { + testWidgets( + 'listed activity draws a spinner, a background badge or nothing', + (tester) async { + final fake = FakeChatGateway() + ..sessionsReply = { + 'chat_sessions': [ + _row('run', activity: _activity(turn: true, tasks: 1)), + _row('bg', activity: _activity(tasks: 2)), + _row('idle', activity: _activity()), + ], + }; + await _pump(tester, fake); + + expect(_spinner('run'), findsOneWidget); + expect(_badge('run'), findsNothing, reason: 'the turn spinner wins'); + expect(_spinner('bg'), findsNothing); + expect(_badge('bg'), findsOneWidget); + expect(_spinner('idle'), findsNothing); + expect(_badge('idle'), findsNothing); + expect(_label(2), findsOneWidget); + final tooltip = tester.widget(_badge('bg')); + expect(tooltip.message, 'Background tasks running (2)'); + expect(tooltip.triggerMode, TooltipTriggerMode.manual); + expect( + find.descendant(of: _badge('bg'), matching: find.byIcon(Icons.pending)), + findsOneWidget, + ); + expect( + find.descendant( + of: _badge('bg'), + matching: find.byType(CircularProgressIndicator), + ), + findsNothing, + reason: 'the background badge is not a second spinner', + ); + }, + ); + + testWidgets('pushes move a chat this device never opened', (tester) async { + final fake = FakeChatGateway() + ..sessionsReply = { + 'chat_sessions': [_row('s1', activity: _activity(seq: 10))], + }; + await _pump(tester, fake); + expect(_spinner('s1'), findsNothing); + + fake.pushed.add(_push('s1', turn: true, seq: 11)); + await _frames(tester); + expect(_spinner('s1'), findsOneWidget); + + fake.pushed.add(_push('s1', tasks: 3, seq: 13)); + await _frames(tester); + expect(_spinner('s1'), findsNothing); + expect(_label(3), findsOneWidget); + + // A push older than the snapshot already applied is ignored. + fake.pushed.add(_push('s1', turn: true, seq: 12)); + await _frames(tester); + expect(_spinner('s1'), findsNothing); + expect(_badge('s1'), findsOneWidget); + + fake.pushed.add(_push('s1', seq: 14)); + await _frames(tester); + expect(_badge('s1'), findsNothing); + expect(_spinner('s1'), findsNothing); + expect(fake.count('chat_sessions'), 1); + }); + + testWidgets('an older server without activity keeps the old spinner', ( + tester, + ) async { + final fake = FakeChatGateway() + ..sessionsReply = { + 'chat_sessions': [_row('s1')], + }; + await _pump(tester, fake); + expect(_badge('s1'), findsNothing); + expect(_spinner('s1'), findsNothing); + fake.pushed.add({ + 'type': 'chat_event', + 'chat_event': { + 'session_id': 's1', + 'kind': 'step', + 'step': {'status': 'started'}, + }, + }); + await _frames(tester); + expect(_spinner('s1'), findsOneWidget); + expect(_badge('s1'), findsNothing); + }); + + testWidgets('the Cupertino host draws its own glyph', (tester) async { + final fake = FakeChatGateway() + ..sessionsReply = { + 'chat_sessions': [_row('bg', activity: _activity(tasks: 1))], + }; + await _pump(tester, fake, cupertino: true); + expect( + find.descendant( + of: _badge('bg'), + matching: find.byIcon(CupertinoIcons.ellipsis_circle_fill), + ), + findsOneWidget, + ); + expect(_label(1), findsOneWidget); + }); + + group('controller', () { + late FakeChatGateway fake; + late ChatSessionsController controller; + late List rows; + + setUp(() { + fake = FakeChatGateway(); + fake.sessionsHandler = () async => {'chat_sessions': rows}; + controller = ChatSessionsController( + ChatRepository(fake), + localStore: MemoryChatSessionLocalStore(), + ); + }); + tearDown(() => controller.dispose()); + + JsonMap row() => controller.sessions.single; + + test('a list read older than an applied push keeps the push', () async { + rows = [_row('s1', activity: _activity(seq: 5))]; + await controller.refresh(); + fake.pushed.add(_push('s1', tasks: 2, seq: 7)); + await Future.delayed(Duration.zero); + expect(chatSessionBackgroundTasks(row()), 2); + + rows = [_row('s1', activity: _activity(seq: 6))]; + await controller.refresh(); + expect(chatSessionBackgroundTasks(row()), 2); + expect(row()['running'], false); + }); + + test('a newer list read (a reconnect) replaces the pushed state', () async { + rows = [_row('s1', activity: _activity(seq: 5))]; + await controller.refresh(); + fake.pushed.add(_push('s1', turn: true, tasks: 2, seq: 7)); + await Future.delayed(Duration.zero); + expect(row()['running'], true); + + rows = [_row('s1', activity: _activity(seq: 90))]; + await controller.refresh(); + expect(row()['running'], false); + expect(chatSessionBackgroundTasks(row()), 0); + }); + }); + + test('chatListActivityOf reads rows and pushes and refuses malformed', () { + expect( + chatListActivityOf({ + 'turn_running': true, + 'background_tasks': 2, + 'seq': 9, + }, sessionId: 's1'), + (sessionId: 's1', turnRunning: true, backgroundTasks: 2, seq: 9), + ); + expect(chatListActivityOf({'session_id': 's2'}), ( + sessionId: 's2', + turnRunning: false, + backgroundTasks: 0, + seq: 0, + )); + expect(chatListActivityOf({'background_tasks': 1}), isNull); + expect(chatListActivityOf('nope', sessionId: 's1'), isNull); + expect( + chatListActivityOf({ + 'background_tasks': -4, + }, sessionId: 's1')?.backgroundTasks, + 0, + ); + }); +} diff --git a/app/tool/perf/perf_fixture.dart b/app/tool/perf/perf_fixture.dart index 48219e80..44db6ec0 100644 --- a/app/tool/perf/perf_fixture.dart +++ b/app/tool/perf/perf_fixture.dart @@ -10,6 +10,8 @@ // that harness's account quota after a chat subscribes. // `?colors=1` (with `?chats=N`) names the chats, stars and colours some of // them, and keeps colours picked with chat_color; +// `?activity=1` (with `?chats=N`) lists a running chat, one with +// background tasks and idle ones; // `?msgs=`, `?rich=1`, `?older=1`, `?live=N` vary the chat transcripts for // scroll captures (tool/perf/chat_scroll_fixture.dart). // `?question=` pushes an agent question (tool/perf/chat_question_fixture.dart). @@ -35,6 +37,18 @@ int get _chats => int.tryParse(_params['chats'] ?? '') ?? 0; bool get perfRunGraph => _params['graph'] == '1'; bool get _colors => _params['colors'] == '1'; +/// `?activity=1` (with `?chats=N`): the first chat's turn is running, the +/// second is idle with two background tasks, the rest are idle, as the +/// server's `activity` row field reports them. +JsonMap? _activityFor(int i) { + if (_params['activity'] != '1') return null; + return switch (i) { + 0 => {'turn_running': true, 'background_tasks': 1, 'seq': 3}, + 1 => {'background_tasks': 2, 'seq': 2}, + _ => {'seq': 1}, + }; +} + /// `?colors=1`: titles, directories, stars and colours per chat index. const _colorTitles = [ 'Release notes', @@ -61,6 +75,7 @@ JsonMap _chatRow(int i) { if (_harness != 'opencode') 'backend': _harness, 'resume_command': _resumeCommand(id), 'native_export': _harness == 'claude', + 'activity': ?_activityFor(i), }; } final color = _pickedColors.containsKey(id) @@ -75,6 +90,7 @@ JsonMap _chatRow(int i) { 'updated_at': DateTime.now().millisecondsSinceEpoch - (i + 1) * 600000, if (_colorStarred.contains(i)) 'starred': true, 'color': ?color, + 'activity': ?_activityFor(i), }; } diff --git a/docs/chat-backends.md b/docs/chat-backends.md index e3acd069..1a5ec940 100644 --- a/docs/chat-backends.md +++ b/docs/chat-backends.md @@ -95,6 +95,19 @@ Claude Code also accepts `/clear` in `-p --input-format stream-json` mode, but the CLI then picks the new session id itself. Re-keying keeps one path for all three harnesses and lets the server choose the id. +## Chat list activity + +Every `chat_sessions` row carries `activity` (turn running, running background +tasks), and `chat_activity` pushes each change to every connection (see +`docs/cli.md`). Background tasks are the same shells all three harnesses already +report: OpenCode shells, Codex `commandExecution` items, and Claude Code +background Bash and Agent/Task subagents. A chat whose last viewer left stays +observed while its tasks run, so their exits are seen. That is bounded by the +unattended limits (16 chats, 6 hours) and by the harness: when a Claude Code +process exits, its background tasks are reported exited because they ran inside +it. After an OpenCode or Codex stream reconnects, the shell set is re-read from +the harness. + ## Web interaction contract All advertised chat adapters (OpenCode V2, Codex and Claude Code) implement the diff --git a/docs/cli.md b/docs/cli.md index 01e7447d..fe609fd2 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -455,6 +455,20 @@ sessions pipeline runs create. The protocol types are: for the run that owns them. The list is fail-closed: with no registry and no store it returns an empty list, never the endpoint's whole session list. A session is never marked `busy`: any number of clients may watch and write one. + Each row carries `activity` (`turn_running`, `background_tasks`, `seq`): the + server's live view of the session. An older server omits it. +- `chat_activity` is pushed to every open connection, not only the chat's + watchers, when a session's turn starts or ends or its count of running + background tasks changes (shells, background commands, Claude Code background + Bash and subagents, Codex command executions). The body is `chat_activity` + (`session_id`, `turn_running`, `background_tasks`, `seq`). It is sent on those + transitions only, never per output chunk. `seq` increases with every change + and keeps increasing across a restart, so a client keeps the snapshot (list + row or push) with the larger `seq`. Background tasks are counted only while + the server observes the session: after a chat's last viewer leaves, the + server keeps observing it while its tasks run (bounded like an unattended + turn: at most 16 such chats and 6 hours). Once released it reports none + rather than a stale count. - `chat_subscribe` attaches a connection to one session's shared live stream (body `session_id`) and replays the session's still-pending approval requests, so every client that watches a session sees every frame any client's turn produces — the diff --git a/internal/claude/background_tasks_test.go b/internal/claude/background_tasks_test.go index 793c1334..31690a18 100644 --- a/internal/claude/background_tasks_test.go +++ b/internal/claude/background_tasks_test.go @@ -118,3 +118,35 @@ func TestForegroundCommandsAndAgentsFinishWithTheirResult(t *testing.T) { t.Fatalf("stray notifications list nothing, got %+v", shells) } } + +// Background commands and subagents run inside the CLI process, so a process +// that exits (crash, idle release, interrupt) ends them: each is reported as +// exited instead of staying "running" with nothing left to report its end. +func TestProcessExitEndsBackgroundTasks(t *testing.T) { + chat, s := backgroundSession(t) + s.handleLine(nil, toolUse(t, "toolu_bg", "Bash", map[string]any{"command": "sleep 600", "run_in_background": true})) + s.handleLine(nil, toolResult(t, "toolu_bg", "Command running in background with ID: b9. Output is being written to: /tmp/b9.output")) + if shells := running(t, chat); len(shells) != 1 { + t.Fatalf("the background command must be running first, got %+v", shells) + } + subs := attachTestSubs(s, 1) + defer detachTestSubs(s, subs) + proc := &process{session: s} + s.mu.Lock() + s.proc = proc + s.mu.Unlock() + + s.processExit(proc, nil) + + if shells := running(t, chat); len(shells) != 0 { + t.Fatalf("a process exit must end its background tasks, got %+v", shells) + } + select { + case frame := <-subs[0]: + if frame.Kind != protocol.ChatEventShell || frame.Shell == nil || frame.Shell.Status != protocol.ChatShellExited || frame.Shell.Command != "sleep 600" { + t.Fatalf("the exit is published as a shell exit, got %+v", frame) + } + default: + t.Fatal("no shell exit was published") + } +} diff --git a/internal/claude/process.go b/internal/claude/process.go index 907b86c3..898abd87 100644 --- a/internal/claude/process.go +++ b/internal/claude/process.go @@ -379,7 +379,14 @@ func (s *session) processExit(p *process, err error) { s.steered = 0 s.awaitFollowUp = false s.resetStreamLocked() + // Background commands and subagents run inside the CLI process, so its + // exit ends them: report each as exited, or it would stay "running" (in the + // chat list and in chat_shells) with nothing left to report its end. + ended := s.endShellsLocked() s.mu.Unlock() + for _, shell := range ended { + s.emit(protocol.ChatEventFrame{SessionID: s.id, Kind: protocol.ChatEventShell, Shell: shell}) + } if !running { return } diff --git a/internal/claude/translate.go b/internal/claude/translate.go index 314a6960..c017c529 100644 --- a/internal/claude/translate.go +++ b/internal/claude/translate.go @@ -791,6 +791,22 @@ func (s *session) finishNotifiedTask(line []byte) { )) } +// endShellsLocked marks every command still running as exited (with no exit +// code: none was reported) and returns their final states, sorted by id, for +// the caller to publish once s.mu is released. Callers hold s.mu. +func (s *session) endShellsLocked() []*protocol.ChatShell { + var ended []*protocol.ChatShell + for _, snapshot := range s.shells { + if snapshot.shell.Status != protocol.ChatShellRunning { + continue + } + snapshot.shell.Status = protocol.ChatShellExited + ended = append(ended, &protocol.ChatShell{ID: snapshot.shell.ID, Status: snapshot.shell.Status, Command: snapshot.shell.Command}) + } + sort.Slice(ended, func(i, j int) bool { return ended[i].ID < ended[j].ID }) + return ended +} + // finishBackgroundTasks marks the tasks a Claude Code task notification // reports as finished, and publishes each one's final state. func (s *session) finishBackgroundTasks(text string) { diff --git a/internal/protocol/chat.go b/internal/protocol/chat.go index 8db797c0..d7ef032d 100644 --- a/internal/protocol/chat.go +++ b/internal/protocol/chat.go @@ -85,6 +85,13 @@ const ( // shared list metadata (colour, star, title) changes, carrying the updated // registry row in ChatSession, so each device's list updates live. ChatSessionChanged = "chat_session_changed" + // ChatActivityChanged is pushed to every open connection (not only the + // session's room subscribers) when a chat's live activity changes: its turn + // starts or ends, or its count of running background tasks changes. The + // body is ChatActivity. It is sent on those transitions only, never per + // output chunk; a client applies a push only when its Seq is newer than the + // activity it already holds for that session. + ChatActivityChanged = "chat_activity" // ChatSubscribe attaches a connection to one session's shared live stream so // it receives every frame any client's turn produces (its own and the other // devices'), not only the frames of a turn it prompted itself. Any number of @@ -320,6 +327,26 @@ type ChatSession struct { // the operator started a fresh session. Clients replace the row with that // id by this one; it is never part of a listed row. PreviousID string `json:"previous_id,omitempty"` + // Activity is the server's live view of the session. A server that tracks + // it sets it on every chat_sessions row (its presence, even as an empty + // object, tells a client the server also pushes chat_activity). Older + // servers omit it. + Activity *ChatActivity `json:"activity,omitempty"` +} + +// ChatActivity is one session's live activity as the server observes it: a +// turn in flight, and how many background tasks (shells, background commands, +// subagents) the harness reports still running. It rides on chat_sessions rows +// and is pushed as chat_activity. Seq orders one session's snapshots across +// the list reply and the pushes (a later snapshot has a larger Seq, also +// across a server restart); a client keeps the snapshot with the largest Seq. +// Background tasks are counted only while the server observes the session's +// stream, so an unobserved session reports none rather than a stale count. +type ChatActivity struct { + SessionID string `json:"session_id,omitempty"` + TurnRunning bool `json:"turn_running,omitempty"` + BackgroundTasks int `json:"background_tasks,omitempty"` + Seq int64 `json:"seq,omitempty"` } // Chat export formats accepted by chat_export. diff --git a/internal/protocol/message.go b/internal/protocol/message.go index e8353824..3fcab7eb 100644 --- a/internal/protocol/message.go +++ b/internal/protocol/message.go @@ -198,6 +198,8 @@ type Message struct { // requests themselves ride on ChatQuery (the session id), matching // chat_messages/chat_interrupt. ChatClose *ChatCloseResult `json:"chat_close,omitempty"` + // ChatActivity is the chat_activity push: one session's live activity. + ChatActivity *ChatActivity `json:"chat_activity,omitempty"` // ChatAnswer is the chat_answer body; the form update arrives through the // normal chat_event stream. ChatAnswer *ChatAnswerRequest `json:"chat_answer,omitempty"` diff --git a/internal/server/chat_activity.go b/internal/server/chat_activity.go new file mode 100644 index 00000000..8e769949 --- /dev/null +++ b/internal/server/chat_activity.go @@ -0,0 +1,124 @@ +package server + +import ( + "time" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// Chat list activity: every listed chat shows whether its turn is running and +// whether background tasks (shells, background commands, subagents) are still +// running after the turn. Room frames reach only the connections that opened +// that chat, so the hub keeps a small per-session summary and pushes each +// change to every connection as chat_activity, and chat_sessions carries the +// current summary on each row. +// +// The summary is derived from the hub's own state only (no broker call, no +// I/O), under the hub mutex, at the points where that state changes: a turn +// admitted or finished, a step announcing or ending a turn, a shell starting +// or exiting, a shell readback reconciling the set, and a room released. +// Anything else, including every text or tool chunk, never touches it. +// +// A session's background tasks are counted only while it has a room, i.e. +// while the hub observes its stream (a viewer, or unattended observation, see +// chat_unattended.go). Once the room is released its shell exits are no +// longer seen, so the count drops to zero rather than going stale. + +// chatActivityLocked computes the session's current summary. Callers hold h.mu. +func (h *chatHub) chatActivityLocked(sessionID string) protocol.ChatActivity { + activity := protocol.ChatActivity{SessionID: sessionID} + room := h.rooms[sessionID] + if room == nil { + return activity + } + activity.TurnRunning = room.running || room.observedTurn + activity.BackgroundTasks = h.backgroundTasksLocked(sessionID) + return activity +} + +// backgroundTasksLocked counts the session's retained running shells. Callers +// hold h.mu. +func (h *chatHub) backgroundTasksLocked(sessionID string) int { + if turn := h.turns[sessionID]; turn != nil { + return len(turn.shells) + } + return 0 +} + +// noteActivityLocked recomputes the session's summary and, only when the turn +// state or the background-task count changed, records it under a new sequence +// number and pushes it to every connection. Callers hold h.mu; the push itself +// never blocks (chatSessionChanges writes on its own goroutines). +func (h *chatHub) noteActivityLocked(sessionID string) { + if sessionID == "" { + return + } + next := h.chatActivityLocked(sessionID) + previous := h.activity[sessionID] + if previous.TurnRunning == next.TurnRunning && previous.BackgroundTasks == next.BackgroundTasks { + return + } + if h.activity == nil { + h.activity = map[string]protocol.ChatActivity{} + } + next.Seq = h.nextActivitySeqLocked() + // The record keeps the last sequence of an idle session too, so a list + // row's Seq never moves backwards behind a push a client already applied. + // It holds one small entry per session that was ever active. + h.activity[sessionID] = next + h.sessionChanges.broadcastActivity(next) +} + +// nextActivitySeqLocked returns a strictly increasing sequence. It starts from +// the wall clock in microseconds (exact in a JavaScript number) so snapshots +// after a server restart still order after the ones a client held before. +func (h *chatHub) nextActivitySeqLocked() int64 { + if h.activitySeq == 0 { + h.activitySeq = time.Now().UnixMicro() + } + h.activitySeq++ + return h.activitySeq +} + +// activitySnapshot returns the current summary of each session in ids, each +// with the sequence of its last recorded change. A session that has not +// changed since this server started carries the current sequence instead, so +// it still orders after anything a client kept from a previous server process +// and before any later push. +func (h *chatHub) activitySnapshot(ids []string) map[string]protocol.ChatActivity { + out := make(map[string]protocol.ChatActivity, len(ids)) + if h == nil { + return out + } + h.mu.Lock() + defer h.mu.Unlock() + if h.activitySeq == 0 { + h.activitySeq = time.Now().UnixMicro() + } + for _, id := range ids { + activity := h.chatActivityLocked(id) + activity.Seq = h.activitySeq + if recorded, ok := h.activity[id]; ok { + activity.Seq = recorded.Seq + } + out[id] = activity + } + return out +} + +// broadcastActivity pushes one session's activity to every connection, +// including the one whose action caused it (it has no reply carrying it). +func (c *chatSessionChanges) broadcastActivity(activity protocol.ChatActivity) { + c.mu.Lock() + targets := make([]func(protocol.Message) error, 0, len(c.clients)) + for _, write := range c.clients { + targets = append(targets, write) + } + c.mu.Unlock() + for _, write := range targets { + body := activity + go func() { + _ = write(protocol.Message{Type: protocol.ChatActivityChanged, ChatActivity: &body}) + }() + } +} diff --git a/internal/server/chat_activity_test.go b/internal/server/chat_activity_test.go new file mode 100644 index 00000000..0fd72740 --- /dev/null +++ b/internal/server/chat_activity_test.go @@ -0,0 +1,184 @@ +package server + +import ( + "context" + "testing" + "time" + + "github.com/coder/websocket" + "github.com/coder/websocket/wsjson" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// listedObservedChat is an observedChat whose endpoint lists ses_1, so +// chat_sessions returns its registry row. +type listedObservedChat struct{ *observedChat } + +func (c listedObservedChat) Sessions(context.Context) ([]protocol.ChatSession, error) { + return []protocol.ChatSession{{ID: "ses_1"}}, nil +} + +// readActivity reads raw frames until the next chat_activity push. +func readActivity(t *testing.T, ctx context.Context, conn *websocket.Conn) protocol.ChatActivity { + t.Helper() + for { + var message protocol.Message + if err := wsjson.Read(ctx, conn, &message); err != nil { + t.Fatalf("read (waiting for chat_activity): %v", err) + } + if message.Type == protocol.ChatActivityChanged { + if message.ChatActivity == nil { + t.Fatal("chat_activity without a body") + } + return *message.ChatActivity + } + } +} + +func shellFrame(id, status string) protocol.ChatEventFrame { + return protocol.ChatEventFrame{SessionID: "ses_1", Kind: protocol.ChatEventShell, Shell: &protocol.ChatShell{ID: id, Status: status, Command: "sleep 600"}} +} + +func listActivity(t *testing.T, ctx context.Context, conn *websocket.Conn) *protocol.ChatActivity { + t.Helper() + writeChat(t, ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "list"}) + reply := readUntil(t, ctx, conn, protocol.ChatSessions) + if len(reply.ChatSessions) != 1 || reply.ChatSessions[0].ID != "ses_1" { + t.Fatalf("chat_sessions = %+v", reply.ChatSessions) + } + return reply.ChatSessions[0].Activity +} + +// A connection that never opened the chat still learns, from chat_activity, +// when its turn starts and ends and how many background tasks run, and the +// list carries the same summary with the same sequence. Output chunks push +// nothing. After the last viewer leaves, the session stays observed while a +// background task runs, and is released (pushing an idle summary) once the +// last one exits. +func TestChatActivityReachesEveryConnection(t *testing.T) { + fastUnattended(t) + t.Setenv("PIPELINES_NTFY_URL", "") + store := unattendedStore(t, false) + broker := newObservedChat() + server := startQueueServer(t, listedObservedChat{broker}, store) + viewer := dialChatConn(t, server.ctx, server.srv) + list := dialChatConn(t, server.ctx, server.srv) + + // A session that never changed still carries a sequence (this server's + // current one), so it orders after anything kept from an earlier process. + initial := listActivity(t, server.ctx, list) + if initial == nil || initial.TurnRunning || initial.BackgroundTasks != 0 || initial.Seq == 0 { + t.Fatalf("idle row activity = %+v, want an empty summary with a sequence", initial) + } + + sendPrompt(t, server.ctx, viewer, "p1", "build it", "op-1") + started := readActivity(t, server.ctx, list) + if started.SessionID != "ses_1" || !started.TurnRunning || started.BackgroundTasks != 0 || started.Seq <= initial.Seq { + t.Fatalf("turn start push = %+v", started) + } + broker.push(stepFrameFor(protocol.ChatStepStarted, "turn_1")) + broker.push(textFrame("Working on it.")) + broker.push(shellFrame("sh_1", protocol.ChatShellRunning)) + withTask := readActivity(t, server.ctx, list) + if !withTask.TurnRunning || withTask.BackgroundTasks != 1 || withTask.Seq <= started.Seq { + t.Fatalf("background task push = %+v (after %+v); a text chunk or the re-announced turn must push nothing", withTask, started) + } + broker.push(stepFrameFor(protocol.ChatStepEnded, "turn_1")) + ended := readActivity(t, server.ctx, list) + if ended.TurnRunning || ended.BackgroundTasks != 1 || ended.Seq <= withTask.Seq { + t.Fatalf("turn end push = %+v", ended) + } + if got := listActivity(t, server.ctx, list); got == nil || got.TurnRunning || got.BackgroundTasks != 1 || got.Seq != ended.Seq { + t.Fatalf("listed activity = %+v, want %+v", got, ended) + } + + viewer.CloseNow() + time.Sleep(100 * time.Millisecond) // let the server notice the disconnect + if active, _ := broker.streams(); active != 1 { + t.Fatalf("a running background task was not observed after the viewer left: %d streams", active) + } + broker.push(shellFrame("sh_1", protocol.ChatShellExited)) + idle := readActivity(t, server.ctx, list) + if idle.TurnRunning || idle.BackgroundTasks != 0 || idle.Seq <= ended.Seq { + t.Fatalf("task exit push = %+v", idle) + } + waitFor(t, "observer released", func() bool { active, _ := broker.streams(); return active == 0 }) + if got := listActivity(t, server.ctx, list); got == nil || got.BackgroundTasks != 0 || got.Seq != idle.Seq { + t.Fatalf("listed activity after release = %+v, want %+v", got, idle) + } +} + +// A background task that never reports its exit does not hold the observer +// forever: it is released after chatUnattendedTurnLimit, and the list then +// reports no tasks rather than a stale count. +func TestChatUnreportedBackgroundTaskIsReleased(t *testing.T) { + fastUnattended(t) + t.Setenv("PIPELINES_NTFY_URL", "") + limit := chatUnattendedTurnLimit + chatUnattendedTurnLimit = 300 * time.Millisecond + t.Cleanup(func() { chatUnattendedTurnLimit = limit }) + store := unattendedStore(t, false) + broker := newObservedChat() + server := startQueueServer(t, listedObservedChat{broker}, store) + viewer := dialChatConn(t, server.ctx, server.srv) + list := dialChatConn(t, server.ctx, server.srv) + // A reply proves the connection reached its read loop, where it is + // attached to the pushes. + listActivity(t, server.ctx, list) + sendPrompt(t, server.ctx, viewer, "p1", "build it", "op-1") + readActivity(t, server.ctx, list) + broker.push(stepFrameFor(protocol.ChatStepStarted, "turn_1")) + broker.push(shellFrame("sh_1", protocol.ChatShellRunning)) + readActivity(t, server.ctx, list) + broker.push(stepFrameFor(protocol.ChatStepEnded, "turn_1")) + readActivity(t, server.ctx, list) + viewer.CloseNow() + time.Sleep(100 * time.Millisecond) + if active, _ := broker.streams(); active != 1 { + t.Fatalf("background task not observed: %d", active) + } + released := readActivity(t, server.ctx, list) + if released.TurnRunning || released.BackgroundTasks != 0 { + t.Fatalf("release push = %+v", released) + } + waitFor(t, "observer released", func() bool { active, _ := broker.streams(); return active == 0 }) + if got := listActivity(t, server.ctx, list); got == nil || got.BackgroundTasks != 0 { + t.Fatalf("listed activity after expiry = %+v", got) + } +} + +// The hub keeps an unattended room for background tasks only: an idle room +// with none is released when its last client leaves, a room with one is kept. +func TestChatBackgroundTasksKeepUnattendedRoom(t *testing.T) { + fastUnattended(t) + h := newChatHub() + defer func() { + h.mu.Lock() + for _, room := range h.rooms { + room.cancel() + } + h.mu.Unlock() + }() + for _, tasks := range []int{0, 1} { + id := "ses_idle" + if tasks > 0 { + id = "ses_task" + } + h.mu.Lock() + room := h.roomLocked(id) + if tasks > 0 { + h.turnLocked(id).applyShell(&protocol.ChatShell{ID: "sh_1", Status: protocol.ChatShellRunning}) + } + sub := &chatSub{hub: h, room: room, clientID: "c", ch: make(chan protocol.Message, 1), done: make(chan struct{})} + room.subs["c"] = sub + h.mu.Unlock() + h.detach(id, sub) + h.mu.Lock() + kept := h.rooms[id] == room + h.mu.Unlock() + if kept != (tasks > 0) { + t.Fatalf("%d background tasks: kept=%v", tasks, kept) + } + } +} diff --git a/internal/server/chat_adopt_backend_test.go b/internal/server/chat_adopt_backend_test.go index 8f28c417..8c54f75b 100644 --- a/internal/server/chat_adopt_backend_test.go +++ b/internal/server/chat_adopt_backend_test.go @@ -33,7 +33,7 @@ func TestChatAdoptRecordsTheOwningHarness(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatAdopt || response.ChatSession == nil { diff --git a/internal/server/chat_busy_resume_test.go b/internal/server/chat_busy_resume_test.go index 22461571..8e747494 100644 --- a/internal/server/chat_busy_resume_test.go +++ b/internal/server/chat_busy_resume_test.go @@ -42,7 +42,7 @@ func subscribeChat(t *testing.T, ctx context.Context, conn *websocket.Conn, id s t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatSubscribe || ack.ID != id { @@ -55,7 +55,7 @@ func readStepStarted(t *testing.T, ctx context.Context, conn *websocket.Conn) { t.Helper() for { var message protocol.Message - if err := wsjson.Read(ctx, conn, &message); err != nil { + if err := readTestFrame(ctx, conn, &message); err != nil { t.Fatalf("no step-started frame: %v", err) } event := message.ChatEvent @@ -89,7 +89,7 @@ func TestChatSubscribeIdleHarnessReplaysNoTurn(t *testing.T) { defer cancel() for { var message protocol.Message - err := wsjson.Read(readCtx, conn, &message) + err := readTestFrame(readCtx, conn, &message) if err != nil { if !errors.Is(readCtx.Err(), context.DeadlineExceeded) { t.Fatalf("read: %v", err) diff --git a/internal/server/chat_close_test.go b/internal/server/chat_close_test.go index a88924af..9fd6faf3 100644 --- a/internal/server/chat_close_test.go +++ b/internal/server/chat_close_test.go @@ -25,7 +25,7 @@ func TestChatCloseRecordsClosedState(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatClose || response.ID != "cl1" { @@ -56,7 +56,7 @@ func TestChatCloseRecordsClosedState(t *testing.T) { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "l1"}); err != nil { t.Fatal(err) } - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 1 { @@ -86,7 +86,7 @@ func TestChatCloseStopsRunningTurn(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conns[0], &ack); err != nil { + if err := readTestFrame(ctx, conns[0], &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt { @@ -99,7 +99,7 @@ func TestChatCloseStopsRunningTurn(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conns[1], &response); err != nil { + if err := readTestFrame(ctx, conns[1], &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatClose || response.ID != "cl1" { @@ -139,7 +139,7 @@ func TestChatCloseKeepsSessionAndMessages(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatClose { @@ -157,7 +157,7 @@ func TestChatCloseKeepsSessionAndMessages(t *testing.T) { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "ms1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil { t.Fatal(err) } - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatMessages || len(response.ChatMessages) != 1 || response.ChatMessages[0].ID != "m1" { @@ -185,7 +185,7 @@ func TestChatReopenClearsClosedState(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatReopen || response.ID != "op1" || response.ChatSession == nil { @@ -220,7 +220,7 @@ func TestChatPromptReopensClosedSession(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt { @@ -247,7 +247,7 @@ func TestChatCloseRefusesNonOperatorSession(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "not an operator") { @@ -276,7 +276,7 @@ func TestChatCloseRejectsInvalidInput(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "bad" { @@ -291,7 +291,7 @@ func TestChatCloseRejectsInvalidInput(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(noRegCtx, noRegConn, &response); err != nil { + if err := readTestFrame(noRegCtx, noRegConn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "registry") { @@ -304,7 +304,7 @@ func TestChatCloseRejectsInvalidInput(t *testing.T) { if err := wsjson.Write(noBrokerCtx, noBrokerConn, protocol.Message{Type: protocol.ChatClose, ID: "nb", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil { t.Fatal(err) } - if err := wsjson.Read(noBrokerCtx, noBrokerConn, &response); err != nil { + if err := readTestFrame(noBrokerCtx, noBrokerConn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") { diff --git a/internal/server/chat_color_test.go b/internal/server/chat_color_test.go index 2c177808..d2b08c7b 100644 --- a/internal/server/chat_color_test.go +++ b/internal/server/chat_color_test.go @@ -18,7 +18,7 @@ func chatColorRequest(id, session string, color *string) protocol.Message { func readMessage(t *testing.T, ctx context.Context, conn *websocket.Conn) protocol.Message { t.Helper() var message protocol.Message - if err := wsjson.Read(ctx, conn, &message); err != nil { + if err := readTestFrame(ctx, conn, &message); err != nil { t.Fatal(err) } return message diff --git a/internal/server/chat_export_test.go b/internal/server/chat_export_test.go index c08588e4..1cdb047a 100644 --- a/internal/server/chat_export_test.go +++ b/internal/server/chat_export_test.go @@ -6,8 +6,6 @@ import ( "strings" "testing" - "github.com/coder/websocket/wsjson" - "git.a-wan.net/alan/pipelines/internal/protocol" ) @@ -59,7 +57,7 @@ func exportFixture(t *testing.T, backend string) (*pagedChat, context.Context, f writeChat(t, ctx, conn, message) for { var reply protocol.Message - if err := wsjson.Read(ctx, conn, &reply); err != nil { + if err := readTestFrame(ctx, conn, &reply); err != nil { t.Fatalf("read reply to %s: %v", message.ID, err) } if reply.ID == message.ID { diff --git a/internal/server/chat_hub.go b/internal/server/chat_hub.go index d68feabd..807fea5e 100644 --- a/internal/server/chat_hub.go +++ b/internal/server/chat_hub.go @@ -63,6 +63,10 @@ type chatHub struct { unattended chatUnattendedTimings // sessionChanges pushes shared list metadata changes to every connection. sessionChanges chatSessionChanges + // activity/activitySeq are the last chat-list activity pushed per session + // and its sequence source (chat_activity.go). + activity map[string]protocol.ChatActivity + activitySeq int64 } // chatPart is the retained form of one part. Text and reasoning deltas append to diff --git a/internal/server/chat_live_test.go b/internal/server/chat_live_test.go index 716ba7c2..9aea0469 100644 --- a/internal/server/chat_live_test.go +++ b/internal/server/chat_live_test.go @@ -220,7 +220,7 @@ func readChatResponse(t *testing.T, ctx context.Context, ws *websocket.Conn) ([] func readChatMessage(t *testing.T, ctx context.Context, ws *websocket.Conn) protocol.Message { t.Helper() var message protocol.Message - if err := wsjson.Read(ctx, ws, &message); err != nil { + if err := readTestFrame(ctx, ws, &message); err != nil { t.Fatalf("read: %v", err) } if message.Type == protocol.Error { diff --git a/internal/server/chat_multiclient_test.go b/internal/server/chat_multiclient_test.go index 864809b2..53890952 100644 --- a/internal/server/chat_multiclient_test.go +++ b/internal/server/chat_multiclient_test.go @@ -224,7 +224,7 @@ func readUntil(t *testing.T, ctx context.Context, conn *websocket.Conn, want str t.Helper() for { var message protocol.Message - if err := wsjson.Read(ctx, conn, &message); err != nil { + if err := readTestFrame(ctx, conn, &message); err != nil { t.Fatalf("read (waiting for %s): %v", want, err) } if message.Type == protocol.Error { @@ -242,7 +242,7 @@ func nextEvent(t *testing.T, ctx context.Context, conn *websocket.Conn) protocol t.Helper() for { var message protocol.Message - if err := wsjson.Read(ctx, conn, &message); err != nil { + if err := readTestFrame(ctx, conn, &message); err != nil { t.Fatalf("read event: %v", err) } if message.Type == protocol.Error { @@ -259,7 +259,7 @@ func nextPermission(t *testing.T, ctx context.Context, conn *websocket.Conn, req t.Helper() for { var message protocol.Message - if err := wsjson.Read(ctx, conn, &message); err != nil { + if err := readTestFrame(ctx, conn, &message); err != nil { t.Fatalf("read permission: %v", err) } if message.Type == protocol.Error { @@ -420,7 +420,7 @@ func TestChatApprovalFirstAnswerWins(t *testing.T) { // The tablet's later answer is refused, and it never reaches the agent. writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatReply, ID: "a2", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionAlways, Client: "Pixel 10 Pro Fold"}}) var refused protocol.Message - if err := wsjson.Read(ctx, tablet, &refused); err != nil { + if err := readTestFrame(ctx, tablet, &refused); err != nil { t.Fatal(err) } if refused.Type != protocol.Error || !strings.Contains(refused.Error, "already answered by Pixel 9") { @@ -484,7 +484,7 @@ func TestChatQueuedPromptFailureSurfaced(t *testing.T) { for { var message protocol.Message - if err := wsjson.Read(ctx, tablet, &message); err != nil { + if err := readTestFrame(ctx, tablet, &message); err != nil { t.Fatalf("read (waiting for the queued prompt failure): %v", err) } if message.Type != protocol.Error { diff --git a/internal/server/chat_queue_test.go b/internal/server/chat_queue_test.go index 820cd128..246f673f 100644 --- a/internal/server/chat_queue_test.go +++ b/internal/server/chat_queue_test.go @@ -11,7 +11,6 @@ import ( "time" "github.com/coder/websocket" - "github.com/coder/websocket/wsjson" "git.a-wan.net/alan/pipelines/internal/opencode" "git.a-wan.net/alan/pipelines/internal/pipeline" @@ -236,7 +235,7 @@ func TestChatSubscribeListsQueuedPromptsAndUnqueueRemoves(t *testing.T) { sawUser := false for { var message protocol.Message - if err := wsjson.Read(server.ctx, reloaded, &message); err != nil { + if err := readTestFrame(server.ctx, reloaded, &message); err != nil { t.Fatalf("no delivery reported: %v", err) } if event := message.ChatEvent; event != nil && event.Kind == protocol.ChatEventUser && event.OperationID == "op-3" { @@ -259,7 +258,7 @@ func TestChatSubscribeListsQueuedPromptsAndUnqueueRemoves(t *testing.T) { writeChat(t, server.ctx, reloaded, protocol.Message{Type: protocol.ChatUnqueue, ID: "rm-late", ChatUnqueue: &protocol.ChatUnqueueRequest{SessionID: "ses_1", OperationID: "op-3"}}) for { var message protocol.Message - if err := wsjson.Read(server.ctx, reloaded, &message); err != nil { + if err := readTestFrame(server.ctx, reloaded, &message); err != nil { t.Fatal(err) } if message.ID == "rm-late" { diff --git a/internal/server/chat_room.go b/internal/server/chat_room.go index e9e69ee2..99909e17 100644 --- a/internal/server/chat_room.go +++ b/internal/server/chat_room.go @@ -346,6 +346,8 @@ func (h *chatHub) releaseRoomLocked(room *chatRoom) { h.clearCompactionLocked(room) delete(h.rooms, room.sessionID) room.cancel() + // An unobserved session reports no turn and no background tasks. + h.noteActivityLocked(room.sessionID) // ReleaseShells is a local identity-cache operation (no broker I/O). // Complete it before a reconnect can acquire this session's new room. if releaser, ok := room.broker.(chatShellReleaser); ok { @@ -477,6 +479,16 @@ func (h *chatHub) emitRoom(source *chatRoom, frame protocol.ChatEventFrame) { h.releaseRoomLocked(room) } } + if frame.Kind == protocol.ChatEventStep || frame.Kind == protocol.ChatEventShell { + h.noteActivityLocked(frame.SessionID) + } + // An unwatched room kept only for its background tasks is done once the + // last of them exits. + if room != nil && frame.Kind == protocol.ChatEventShell && frame.Shell != nil && frame.Shell.Status != protocol.ChatShellRunning && + room.watching && len(room.subs) == 0 && len(room.queue) == 0 && h.rooms[room.sessionID] == room && !h.keepUnattendedLocked(room, false, true) { + room.watching = false + h.releaseRoomLocked(room) + } // Shell replay and live lifecycle delivery must enqueue in the same order // as folding. Otherwise an exit can overtake an older running replay. if (frame.Kind == protocol.ChatEventShell || frame.Kind == protocol.ChatEventCompaction || frame.Kind == protocol.ChatEventUsage) && !buffered { @@ -557,6 +569,7 @@ func (h *chatHub) replaceShellsLocked(sessionID string, shells []protocol.ChatSh for i := range shells { turn.applyShell(&shells[i]) } + h.noteActivityLocked(sessionID) } // finishTurnLocked marks the room's turn finished and releases the turn runner's @@ -570,6 +583,7 @@ func (h *chatHub) finishTurnLocked(room *chatRoom) { close(room.turnDone) room.turnDone = nil } + h.noteActivityLocked(room.sessionID) // A queue held behind a turn this room only observed advances now. signalWake(room.wake) } @@ -774,6 +788,7 @@ func (h *chatHub) nextPrompt(room *chatRoom) (*chatQueuedPrompt, chan struct{}, room.nativeTurnID = "" room.turnDone = make(chan struct{}) done := room.turnDone + h.noteActivityLocked(room.sessionID) h.mu.Unlock() return p, done, true } else { diff --git a/internal/server/chat_sessions.go b/internal/server/chat_sessions.go index 22df7edf..387759d4 100644 --- a/internal/server/chat_sessions.go +++ b/internal/server/chat_sessions.go @@ -86,6 +86,20 @@ func handleChatSessions(ctx context.Context, request protocol.Message, broker ch session.Color = operator.Color response.ChatSessions = append(response.ChatSessions, session) } + // Each row carries the hub's live activity (turn running, background + // tasks), read once for the whole list after the broker call; later + // changes arrive as chat_activity pushes. + if hub != nil { + ids := make([]string, len(response.ChatSessions)) + for i := range response.ChatSessions { + ids[i] = response.ChatSessions[i].ID + } + activity := hub.activitySnapshot(ids) + for i := range response.ChatSessions { + row := activity[response.ChatSessions[i].ID] + response.ChatSessions[i].Activity = &row + } + } _ = write(response) } diff --git a/internal/server/chat_shell_output_test.go b/internal/server/chat_shell_output_test.go index 7c66d48a..5961c26b 100644 --- a/internal/server/chat_shell_output_test.go +++ b/internal/server/chat_shell_output_test.go @@ -11,7 +11,6 @@ import ( "time" "github.com/coder/websocket" - "github.com/coder/websocket/wsjson" "git.a-wan.net/alan/pipelines/internal/opencode" "git.a-wan.net/alan/pipelines/internal/protocol" @@ -273,7 +272,7 @@ func dialShellOutputWebsocket(t *testing.T, ctx context.Context, srv *httptest.S func readShellOutputMessage(t *testing.T, ctx context.Context, ws *websocket.Conn) protocol.Message { t.Helper() var message protocol.Message - if err := wsjson.Read(ctx, ws, &message); err != nil { + if err := readTestFrame(ctx, ws, &message); err != nil { t.Fatal(err) } return message diff --git a/internal/server/chat_shell_reconcile_test.go b/internal/server/chat_shell_reconcile_test.go index 9ada615b..57ac3cc6 100644 --- a/internal/server/chat_shell_reconcile_test.go +++ b/internal/server/chat_shell_reconcile_test.go @@ -47,7 +47,7 @@ func TestChatShellReconciliationScratchServer(t *testing.T) { read := func() protocol.Message { t.Helper() var m protocol.Message - if err := wsjson.Read(ctx, conn, &m); err != nil { + if err := readTestFrame(ctx, conn, &m); err != nil { t.Fatal(err) } return m @@ -215,6 +215,11 @@ func TestChatShellReconciliationBarrier(t *testing.T) { } } sub.close() + if status == protocol.ChatShellRunning { + // Running background tasks keep the room observing with no + // client (chat_unattended.go); release it to end the stream. + releaseKeptRoom(t, h, sub.room) + } shellBarrierWait(t, b.stopped) }) } @@ -257,5 +262,20 @@ func TestChatShellReconciliationCancelReconnectBarrier(t *testing.T) { t.Fatalf("reconnect state = %+v", got) } newSub.close() + releaseKeptRoom(t, h, newSub.room) shellBarrierWait(t, next.stopped) } + +// releaseKeptRoom asserts room is still kept observing after its last client +// left (it holds running background tasks) and releases it. +func releaseKeptRoom(t *testing.T, h *chatHub, room *chatRoom) { + t.Helper() + h.mu.Lock() + kept := h.rooms[room.sessionID] == room && room.watching + room.watching = false + h.releaseRoomLocked(room) + h.mu.Unlock() + if !kept { + t.Fatal("a room with running background tasks was not kept observing") + } +} diff --git a/internal/server/chat_test.go b/internal/server/chat_test.go index 4c80df85..46af3bb9 100644 --- a/internal/server/chat_test.go +++ b/internal/server/chat_test.go @@ -428,7 +428,7 @@ func readChatTurn(t *testing.T, ctx context.Context, conn *websocket.Conn) []pro var frames []protocol.ChatEventFrame for { var message protocol.Message - if err := wsjson.Read(ctx, conn, &message); err != nil { + if err := readTestFrame(ctx, conn, &message); err != nil { t.Fatal(err) } if message.Type == protocol.Error { @@ -452,7 +452,7 @@ func TestChatModelsAndSwitch(t *testing.T) { t.Fatal(err) } var reply protocol.Message - if err := wsjson.Read(ctx, conn, &reply); err != nil { + if err := readTestFrame(ctx, conn, &reply); err != nil { t.Fatal(err) } if reply.Type != protocol.ChatModels || len(reply.ChatModels) != 1 || reply.ChatModels[0].ID != "m1" { @@ -461,7 +461,7 @@ func TestChatModelsAndSwitch(t *testing.T) { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatModelSelect, ID: "r2", ModelRequest: &protocol.ChatModelRequest{SessionID: "ses_1", Provider: "p1", Model: "m1"}}); err != nil { t.Fatal(err) } - if err := wsjson.Read(ctx, conn, &reply); err != nil { + if err := readTestFrame(ctx, conn, &reply); err != nil { t.Fatal(err) } if reply.Type != protocol.ChatModelSelect || reply.ModelRequest == nil || reply.ModelRequest.Model != "m1" { @@ -487,7 +487,7 @@ func TestChatPromptWritesAttachmentAndForwardsLocalFile(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.Error != "" { @@ -517,7 +517,7 @@ func TestChatPromptStreamsEvents(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { @@ -558,7 +558,7 @@ func TestChatPromptRejectsInvalidSession(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "bad" { @@ -578,7 +578,7 @@ func TestChatPromptRejectsOversizedText(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "64 KiB") { @@ -595,7 +595,7 @@ func TestChatPromptWithoutBroker(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") { @@ -611,7 +611,7 @@ func TestChatMessagesResumesRetainedState(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } readChatTurn(t, ctx, conn) @@ -619,7 +619,7 @@ func TestChatMessagesResumesRetainedState(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatMessages || response.ID != "r2" || response.ChatHistory == nil { @@ -692,7 +692,7 @@ func TestChatMessagesReturnsBrokerHistory(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatMessages || response.ID != "r2" { @@ -735,7 +735,7 @@ func TestChatMessagesThroughRealAdapter(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatMessages || response.ID != "r2" { @@ -758,7 +758,7 @@ func TestChatMessagesRejectsInvalidSession(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "bad" { @@ -782,7 +782,7 @@ func TestChatDisconnectCancelsStream(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } select { @@ -815,7 +815,7 @@ func TestChatInterruptAndReply(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatInterrupt || response.ID != "i1" { @@ -824,7 +824,7 @@ func TestChatInterruptAndReply(t *testing.T) { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "p1", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}}); err != nil { t.Fatal(err) } - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatReply || response.ID != "p1" { @@ -909,7 +909,7 @@ func TestChatInterruptEndsRunningPrompt(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { @@ -917,7 +917,7 @@ func TestChatInterruptEndsRunningPrompt(t *testing.T) { } // The first text delta proves the turn is live and the subscription attached. var first protocol.Message - if err := wsjson.Read(ctx, conn, &first); err != nil { + if err := readTestFrame(ctx, conn, &first); err != nil { t.Fatal(err) } if first.Type != protocol.ChatEvent || first.ChatEvent == nil || first.ChatEvent.Kind != protocol.ChatEventText || first.ChatEvent.Delta != "working" { @@ -934,7 +934,7 @@ func TestChatInterruptEndsRunningPrompt(t *testing.T) { var acked, ended bool for !acked || !ended { var message protocol.Message - if err := wsjson.Read(ctx, conn, &message); err != nil { + if err := readTestFrame(ctx, conn, &message); err != nil { t.Fatal(err) } if message.Type == protocol.Error { @@ -974,7 +974,7 @@ func TestChatInterruptRejectsInvalidSession(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "bad" { @@ -994,7 +994,7 @@ func TestChatInterruptWithoutBroker(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") { @@ -1012,7 +1012,7 @@ func TestChatInterruptErrorReported(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "i1" || !strings.Contains(response.Error, "already finished") { @@ -1261,7 +1261,7 @@ func TestChatPromptStreamsShellFrame(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } frames := readChatTurn(t, ctx, conn) @@ -1289,7 +1289,7 @@ func TestChatSubscribeReplaysRunningShell(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conns[0], &ack); err != nil { + if err := readTestFrame(ctx, conns[0], &ack); err != nil { t.Fatal(err) } frames := readChatTurn(t, ctx, conns[0]) @@ -1307,14 +1307,14 @@ func TestChatSubscribeReplaysRunningShell(t *testing.T) { t.Fatal(err) } var subscription protocol.Message - if err := wsjson.Read(ctx, conns[1], &subscription); err != nil { + if err := readTestFrame(ctx, conns[1], &subscription); err != nil { t.Fatal(err) } if subscription.Type != protocol.ChatSubscribe || subscription.ID != "sub1" { t.Fatalf("subscribe ack = %+v", subscription) } var replayed protocol.Message - if err := wsjson.Read(ctx, conns[1], &replayed); err != nil { + if err := readTestFrame(ctx, conns[1], &replayed); err != nil { t.Fatal(err) } if replayed.Type != protocol.ChatEvent || replayed.ChatEvent == nil || replayed.ChatEvent.Kind != protocol.ChatEventShell { @@ -1338,14 +1338,14 @@ func TestChatSubscribeKeepsStreamWhenShellReadbackFails(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatSubscribe || ack.ID != "sub1" { t.Fatalf("subscribe ack = %+v", ack) } var limited protocol.Message - if err := wsjson.Read(ctx, conn, &limited); err != nil { + if err := readTestFrame(ctx, conn, &limited); err != nil { t.Fatal(err) } if limited.Type != protocol.Error || limited.Error != "background shell visibility is limited" { @@ -1369,7 +1369,7 @@ func TestChatPromptSubscribesBeforePrompt(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } readChatTurn(t, ctx, conn) @@ -1422,7 +1422,7 @@ func realAdapterChat(t *testing.T, frames []string) []protocol.ChatEventFrame { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { @@ -1509,7 +1509,7 @@ func TestChatPromptRejectsEmptyText(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "empty" { @@ -1536,7 +1536,7 @@ func TestChatCreateRecordsOperatorSession(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatCreate || response.ID != "c1" || response.ChatSession == nil { @@ -1582,7 +1582,7 @@ func TestChatCreateEphemeralSessionIsNeverListed(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } // The session is real and usable: it is created, bootstrapped and echoed. @@ -1858,7 +1858,7 @@ func TestChatCreateDirectoryResolution(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if tc.wantErr != "" { @@ -1908,7 +1908,7 @@ func TestChatDirectoriesHomeThenBoundedRecents(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatDirectories || response.ID != "d1" { @@ -1992,7 +1992,7 @@ func TestChatSessionsListsOperatorSessionsOnly(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatSessions || response.ID != "s1" { @@ -2028,7 +2028,7 @@ func TestChatSessionsNeverListsUntagged(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 0 { @@ -2061,7 +2061,7 @@ func TestChatSessionsMostRecentlyUsedFirst(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if len(response.ChatSessions) != 2 { @@ -2086,7 +2086,7 @@ func TestChatSessionsFailsClosedWithoutOwnership(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 0 { @@ -2119,14 +2119,14 @@ func TestChatPromptPushesPermissionAndForwardsReply(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { t.Fatalf("prompt ack = %+v", ack) } var permission protocol.Message - if err := wsjson.Read(ctx, conn, &permission); err != nil { + if err := readTestFrame(ctx, conn, &permission); err != nil { t.Fatal(err) } if permission.Type == protocol.Error { @@ -2143,7 +2143,7 @@ func TestChatPromptPushesPermissionAndForwardsReply(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatReply || response.ID != "p1" { @@ -2227,7 +2227,7 @@ func TestChatDisconnectCancelsPermissionPoller(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } select { @@ -2273,11 +2273,11 @@ func TestChatPermissionPollErrorSurfaced(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "permission poll") { @@ -2304,7 +2304,7 @@ func TestChatReplyRejectsInvalidInput(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "bad" { @@ -2324,7 +2324,7 @@ func TestChatReplyWithoutBroker(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") { @@ -2346,7 +2346,7 @@ func TestChatPermissionUnsupportedBackendIsQuiet(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { @@ -2356,7 +2356,7 @@ func TestChatPermissionUnsupportedBackendIsQuiet(t *testing.T) { readCtx, cancel := context.WithTimeout(ctx, 300*time.Millisecond) defer cancel() var unexpected protocol.Message - if err := wsjson.Read(readCtx, conn, &unexpected); err == nil { + if err := readTestFrame(readCtx, conn, &unexpected); err == nil { t.Fatalf("unsupported permission surface must not write a frame, got %+v", unexpected) } if calls, _ := broker.permissionQuery(); calls != 1 { @@ -2379,7 +2379,7 @@ func TestChatAdoptRecordsEndpointSession(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatAdopt || response.ID != "a1" || response.ChatSession == nil { @@ -2410,7 +2410,7 @@ func TestChatAdoptRecordsEndpointSession(t *testing.T) { t.Fatal(err) } var listed protocol.Message - if err := wsjson.Read(ctx, conn, &listed); err != nil { + if err := readTestFrame(ctx, conn, &listed); err != nil { t.Fatal(err) } if listed.Type != protocol.ChatSessions || len(listed.ChatSessions) != 1 || listed.ChatSessions[0].ID != "ses_existing" || listed.ChatSessions[0].Directory != "/work/existing" || listed.ChatSessions[0].Tag != protocol.ChatSessionTagOperator { @@ -2422,7 +2422,7 @@ func TestChatAdoptRecordsEndpointSession(t *testing.T) { t.Fatal(err) } var ack protocol.Message - if err := wsjson.Read(ctx, conn, &ack); err != nil { + if err := readTestFrame(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "p1" { @@ -2451,7 +2451,7 @@ func TestChatAdoptMissingIDRecordsNothing(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "ses_missing") { @@ -2480,7 +2480,7 @@ func TestChatAdoptRefusesEmptyDirectory(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "directory") { @@ -2516,7 +2516,7 @@ func TestChatAdoptRejectsInvalidInputBeforeBroker(t *testing.T) { t.Fatal(err) } var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err := readTestFrame(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error { diff --git a/internal/server/chat_unattended.go b/internal/server/chat_unattended.go index 76507903..05719cc1 100644 --- a/internal/server/chat_unattended.go +++ b/internal/server/chat_unattended.go @@ -11,15 +11,17 @@ import ( // stream while the session has a room. A room normally lives while a client // watches the chat, but the operator relies on these notifications precisely // when no app is open. So a room whose last client leaves stays observing, -// unattended, while its turn is in flight or it holds an unanswered question -// or approval, and is torn down once that work is done. The same unattended +// unattended, while its turn is in flight, it holds an unanswered question or +// approval, or background tasks it started are still running (so the chat list +// sees them finish), and is torn down once that work is done. The same unattended // observation is started at server start for sessions whose harness reports a // running turn, so a reply that finishes after a restart still notifies. // // Resources are bounded: at most chatUnattendedLimit rooms are kept without a // client (rooms holding queued prompts are not counted: they were always kept -// until delivered), a stuck turn is released after chatUnattendedTurnLimit, -// and an idle session is never observed. +// until delivered), a stuck turn or a background task that never reports an +// exit is released after chatUnattendedTurnLimit, and an idle session is never +// observed. // chatUnattendedLimit bounds the rooms kept observing with no client attached // and no queued prompt. @@ -63,13 +65,21 @@ type chatTurnProber interface { // keepUnattendedLocked reports whether a room with no client still has work // the operator must hear about: a turn in flight (the runner's, or one its // stream announced), an unresolved approval or question, or a harness that -// reports its own turn running (busy, read by the caller off the hub mutex). +// reports its own turn running (busy, read by the caller off the hub mutex), +// or background tasks still running. // hold honours the start-up settle window. Queued prompts are the caller's // concern. Callers hold h.mu. func (h *chatHub) keepUnattendedLocked(room *chatRoom, busy, hold bool) bool { if room.running || room.observedTurn || busy || len(room.pending) > 0 || len(room.forms) > 0 { return true } + // Running background tasks keep the stream observed so their exits are + // seen and the chat list's indicator clears. This is bounded like a turn: + // the unattended room limit, the chatUnattendedTurnLimit expiry, and the + // harness itself (a Claude Code process that exits ends its tasks). + if h.backgroundTasksLocked(room.sessionID) > 0 { + return true + } return hold && h.clock().Before(room.holdUntil) } @@ -167,7 +177,7 @@ func (h *chatHub) reapUnattended(room *chatRoom) bool { return false } if expired { - log.Printf("chat session %s: released the unattended observer after %s without the turn ending", room.sessionID, h.unattended.turnLimit) + log.Printf("chat session %s: released the unattended observer after %s without its turn or background tasks ending", room.sessionID, h.unattended.turnLimit) } room.watching = false h.releaseRoomLocked(room) diff --git a/internal/server/search_chats_test.go b/internal/server/search_chats_test.go index f8d6e803..6b5737de 100644 --- a/internal/server/search_chats_test.go +++ b/internal/server/search_chats_test.go @@ -6,7 +6,6 @@ import ( "time" "github.com/coder/websocket" - "github.com/coder/websocket/wsjson" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" @@ -68,7 +67,7 @@ func readReply(t *testing.T, ctx context.Context, conn *websocket.Conn, id strin t.Helper() for { var reply protocol.Message - if err := wsjson.Read(ctx, conn, &reply); err != nil { + if err := readTestFrame(ctx, conn, &reply); err != nil { t.Fatalf("read reply %s: %v", id, err) } if reply.ID == id { @@ -140,7 +139,7 @@ func TestChatSearchBudgetNeverBlocksOtherReplies(t *testing.T) { chatSearch(t, ctx, conn, "c1", "flaky") writeChat(t, ctx, conn, protocol.Message{Type: protocol.Ping, ID: "p1"}) var first protocol.Message - if err := wsjson.Read(ctx, conn, &first); err != nil { + if err := readTestFrame(ctx, conn, &first); err != nil { t.Fatal(err) } if first.ID != "p1" { diff --git a/internal/server/ws_read_test.go b/internal/server/ws_read_test.go new file mode 100644 index 00000000..fc53abe7 --- /dev/null +++ b/internal/server/ws_read_test.go @@ -0,0 +1,32 @@ +package server + +import ( + "context" + "encoding/json" + + "github.com/coder/websocket" + "github.com/coder/websocket/wsjson" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// readTestFrame reads the next websocket frame into v like wsjson.Read, but +// skips chat_activity pushes. Those reach every connection whenever any +// chat's turn or background-task count changes, so tests that read one +// connection's replies in order would otherwise see them interleaved. Tests of +// chat_activity itself read the raw stream. +func readTestFrame(ctx context.Context, conn *websocket.Conn, v any) error { + for { + var raw json.RawMessage + if err := wsjson.Read(ctx, conn, &raw); err != nil { + return err + } + var head struct { + Type string `json:"type"` + } + if json.Unmarshal(raw, &head) == nil && head.Type == protocol.ChatActivityChanged { + continue + } + return json.Unmarshal(raw, v) + } +}