Merge main into chat tab re-tap

This commit is contained in:
2026-11-12 03:52:20 +00:00
66 changed files with 4417 additions and 530 deletions
+3 -1
View File
@@ -376,7 +376,9 @@ class _PipelinesAppState extends State<PipelinesApp>
},
sessionTitle: _chatSessionTitle,
openChat: (id) {
if (mounted) _delegate.goTo(AppRoute.chatSession(id));
if (!mounted) return;
widget.servers?.requestChatOpen(id);
_delegate.goTo(AppRoute.chatSession(id));
},
bridge: _notifications.bridge,
);
+36 -29
View File
@@ -5,6 +5,7 @@ import '../../core/servers/server_context.dart';
import '../../shell/destination.dart';
import '../../shell/detail_page.dart';
import 'chat_runtime.dart';
import 'conversation/chat_seen_interaction.dart';
import 'conversation/chat_thread_view.dart';
import 'conversation/composer_focus_request.dart';
import 'workspace/chat_pane_commands.dart';
@@ -79,36 +80,42 @@ Widget buildChatPaneContent({
child: ServerContext.forServer(
context,
runtime.serverIdFor(sessionId),
ChatThreadView(
key: ValueKey<String>('chat-session-$sessionId'),
gateway: runtime.gatewayFor(sessionId),
ChatSeenInteraction(
sessionId: sessionId,
title: '${row?['title'] ?? ''}'.trim(),
session: row,
syncToken: placement.syncToken,
scrollPositions: runtime.scrollPositions,
transcripts: runtime.transcripts,
initialNotice: start != null && start.id == sessionId
? start.notice
: null,
onBack: placement.onBack,
onModelChanged: (applied) =>
runtime.modelChanged(sessionId, applied),
onModeChanged: (mode, name) =>
runtime.acceptMode(sessionId, mode, name),
onEffortChanged: (state) => runtime.acceptEffort(sessionId, state),
onNewSession: placement.onNewSession,
onSessionRenamed: (title) => runtime.acceptRename(sessionId, title),
onSessionClosed: placement.onSessionClosed,
onColorSelected: (color) =>
runtime.sessions.setColor(sessionId, color),
onNextChat: placement.onNextChat,
useNativeBack: placement.useNativeBack,
pasteTarget: placement.pasteTarget,
ownsPasteWhenFocused: placement.ownsPasteWhenFocused,
showBackButton: placement.showBackButton,
paneControls: placement.paneControls?.call(context) ?? const [],
paneCommands: placement.paneCommands,
onInteract: () => runtime.sessions.reportInteraction(sessionId),
child: ChatThreadView(
key: ValueKey<String>('chat-session-$sessionId'),
gateway: runtime.gatewayFor(sessionId),
sessionId: sessionId,
title: '${row?['title'] ?? ''}'.trim(),
session: row,
syncToken: placement.syncToken,
scrollPositions: runtime.scrollPositions,
transcripts: runtime.transcripts,
initialNotice: start != null && start.id == sessionId
? start.notice
: null,
onBack: placement.onBack,
onModelChanged: (applied) =>
runtime.modelChanged(sessionId, applied),
onModeChanged: (mode, name) =>
runtime.acceptMode(sessionId, mode, name),
onEffortChanged: (state) =>
runtime.acceptEffort(sessionId, state),
onNewSession: placement.onNewSession,
onSessionRenamed: (title) =>
runtime.acceptRename(sessionId, title),
onSessionClosed: placement.onSessionClosed,
onColorSelected: (color) =>
runtime.sessions.setColor(sessionId, color),
onNextChat: placement.onNextChat,
useNativeBack: placement.useNativeBack,
pasteTarget: placement.pasteTarget,
ownsPasteWhenFocused: placement.ownsPasteWhenFocused,
showBackButton: placement.showBackButton,
paneControls: placement.paneControls?.call(context) ?? const [],
paneCommands: placement.paneCommands,
),
),
),
);
@@ -46,6 +46,7 @@ mixin _ChatScreenFloat on State<ChatScreen>, _ChatScreenWorkspace {
final pane = _workspace.detach(paneId);
if (pane == null) return;
widget.windows?.float(pane.sessionId);
_syncOpenWorkspace();
// Floating the last tiled chat leaves the list, as closing it does.
if (_workspace.paneCount == 0) _back();
}
@@ -61,6 +62,7 @@ mixin _ChatScreenFloat on State<ChatScreen>, _ChatScreenWorkspace {
_floatPane(pane.id);
} else {
windows.float(id);
_syncOpenWorkspace();
}
}
@@ -69,6 +71,7 @@ mixin _ChatScreenFloat on State<ChatScreen>, _ChatScreenWorkspace {
_workspaceVisible = true;
if (!_pageOpen && showsListBesideDetail(context)) _usedWorkspace = true;
_workspace.dock(sessionId);
_syncOpenWorkspace();
_composerFocus.request(sessionId);
}
@@ -80,11 +80,61 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
void _openSidebarSession(JsonMap session);
final ChatWorkspaceController _workspace = ChatWorkspaceController();
ChatOpenWorkspaceController? _openWorkspace;
bool _applyingServerWorkspace = false;
ChatWorkspaceBinding? _workspaceBinding;
String? _workspaceScope;
Iterable<ChatOpenWorkspaceEntry> _serverWorkspaceEntries() sync* {
final floating =
widget.windows?.floatingSessionIds.toSet() ?? const <String>{};
for (final pane in _workspace.panes) {
yield ChatOpenWorkspaceEntry(
pane.sessionId,
floating: floating.contains(pane.sessionId),
);
}
for (final sessionId in floating) {
if (!_workspace.holdsSession(sessionId)) {
yield ChatOpenWorkspaceEntry(sessionId, floating: true);
}
}
}
/// Sends this device's open chats to the server, unless the change is the
/// server's own snapshot being applied.
void _syncOpenWorkspace() {
if (_applyingServerWorkspace) return;
_openWorkspace?.replace(_serverWorkspaceEntries());
}
/// Binds the server's open-chat set for [widget.gateway], disposing the
/// previous binding (its subscription and queued writes) first. A
/// federated list spans several servers, so it keeps its local layout.
void _bindOpenWorkspace({required Future<void> after}) {
_openWorkspace?.dispose();
_openWorkspace = null;
_openWorkspaceApplied = false;
if (!widget.persistWorkspace || widget.gateway is FederatedChatGateway) {
return;
}
final open = ChatOpenWorkspaceController(gateway: widget.gateway)
..onChanged = _applyOpenWorkspace;
_openWorkspace = open;
// Seed from the restored local layout once it is restored.
unawaited(
after.then((_) async {
if (!mounted || open.disposed) return;
await open.start(local: _serverWorkspaceEntries());
}),
);
}
void _bindWorkspacePersistence() {
if (!widget.persistWorkspace) return;
if (!widget.persistWorkspace) {
_bindOpenWorkspace(after: Future.value());
return;
}
final scope = serverStorageScope(serverIdentity(widget.gateway));
_workspaceScope = scope;
_workspaceBinding = ChatWorkspaceBinding(
@@ -112,19 +162,105 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
_publishWorkspaceRoute();
},
);
unawaited(
_workspaceBinding!.start(initialSessionId: widget.initialSessionId),
_bindOpenWorkspace(
after: _workspaceBinding!.start(
initialSessionId: widget.initialSessionId,
),
);
}
/// Whether a server snapshot was applied since binding. The first one keeps
/// the chat this visit was opened on (a deep link) and adds it if absent.
bool _openWorkspaceApplied = false;
/// Applies the server's membership: windows and panes for chats it no
/// longer lists close, floating state follows it, and tiled chats take its
/// order while this device's split geometry stays.
void _applyOpenWorkspace(ChatOpenWorkspaceSnapshot snapshot) {
if (!mounted) return;
final initial = widget.initialSessionId ?? '';
final first = !_openWorkspaceApplied;
final keepInitial =
first &&
initial.isNotEmpty &&
!snapshot.entries.any((entry) => entry.sessionId == initial);
_openWorkspaceApplied = true;
if (keepInitial) {
snapshot = ChatOpenWorkspaceSnapshot(snapshot.revision, [
...snapshot.entries,
ChatOpenWorkspaceEntry(initial),
]);
}
_applyingServerWorkspace = true;
try {
final windows = widget.windows;
if (windows != null) {
final entriesBySession = {
for (final entry in snapshot.entries) entry.sessionId: entry,
};
for (final window in windows.windows.toList()) {
if (!entriesBySession.containsKey(window.contentId)) {
windows.manager.close(window.id);
}
}
for (final entry in snapshot.entries) {
final localWindow = windows.windows
.where((window) => window.contentId == entry.sessionId)
.firstOrNull;
if (entry.floating && localWindow == null) {
final pane = _workspace.panes
.where((pane) => pane.sessionId == entry.sessionId)
.firstOrNull;
if (pane != null) _workspace.close(pane.id);
windows.float(entry.sessionId);
} else if (!entry.floating && localWindow != null) {
windows.dock(localWindow);
}
}
}
_workspace.reconcileSessions(
snapshot.entries
.where((entry) => !entry.floating)
.map((entry) => entry.sessionId),
);
if (keepInitial) {
final pane = _workspace.panes
.where((pane) => pane.sessionId == initial)
.firstOrNull;
if (pane != null) _workspace.activate(pane.id);
}
if (_workspace.paneCount == 0 && _workspaceVisible) _back();
} finally {
_applyingServerWorkspace = false;
}
// The first snapshot shows the server's chats as a restored layout does;
// later ones never pull this device into a chat another one opened.
if (first && _workspace.paneCount > 0 && !_workspaceVisible) {
setState(() {
_usedWorkspace = true;
_workspaceVisible = true;
});
_publishWorkspaceRoute();
}
if (keepInitial) _syncOpenWorkspace();
}
bool _updateWorkspacePersistence(ChatScreen oldWidget) {
final scope = serverStorageScope(serverIdentity(widget.gateway));
if (oldWidget.persistWorkspace == widget.persistWorkspace &&
(!widget.persistWorkspace || scope == _workspaceScope)) {
// Another connection to the same server: only the open-chat sync
// follows the gateway.
if (widget.persistWorkspace &&
!identical(oldWidget.gateway, widget.gateway)) {
_bindOpenWorkspace(after: Future.value());
}
return false;
}
_workspaceBinding?.dispose();
_workspaceBinding = null;
_openWorkspace?.dispose();
_openWorkspace = null;
if (_workspaceScope != null && scope != _workspaceScope) {
_workspace.restoreLayout(ChatWorkspaceSnapshot.fromLayout(null, null)!);
_workspaceVisible = false;
@@ -200,6 +336,7 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
'${_workspace.activePaneId}:${_workspace.panes.map((p) => '${p.id}=${p.sessionId}').join(',')}';
if (_workspaceSignature == signature) return;
_workspaceSignature = signature;
_syncOpenWorkspace();
void update() {
if (!mounted) return;
setState(() {});
@@ -5,6 +5,7 @@ import 'package:flutter/material.dart';
import '../../../core/api_gateway.dart';
import 'chat_background_tasks_controller.dart';
import 'chat_background_tasks_dialog.dart';
import 'chat_task_spinner.dart';
/// Compact live task count: a quiet control inside the composer beside Send,
/// shown only while tasks run. Details live only in its modal.
@@ -146,10 +147,13 @@ class _ChatBackgroundTasksState extends State<ChatBackgroundTasks> {
visualDensity: VisualDensity.compact,
),
onPressed: _open,
icon: Icon(
automationOnly ? Icons.schedule : Icons.layers_outlined,
size: 16,
),
// The layers turn only while a task runs; automations stay still.
icon: automationOnly
? const Icon(Icons.schedule, size: 16)
: ChatTaskSpinner(
spinning: count > 0,
child: const Icon(Icons.layers_outlined, size: 16),
),
label: caption(),
);
return Padding(
@@ -5,7 +5,6 @@ import 'package:flutter/material.dart';
import '../../../ui/scale/ui_scale.dart';
import '../../../ui/motion/surface_visibility.dart';
import 'chat_stop_icon.dart';
import 'package:flutter/services.dart';
import '../../../core/api_gateway.dart';
@@ -30,6 +29,7 @@ import 'composer_focus_request.dart';
import 'composer_focus_restore.dart';
import 'chat_bar_tint.dart';
import 'composer_focus_ring.dart';
import 'composer_running_border.dart';
import '../shell/chat_shell_command.dart';
import '../shell/chat_shell_mode_indicator.dart';
@@ -70,8 +70,10 @@ double chatComposerBottomMargin([TargetPlatform? platform]) =>
? kChatComposerDesktopBottomMargin
: kChatComposerBottomMargin;
/// The single primary control's words while a turn is and is not running.
/// The single primary control's words.
const String chatSendLabel = 'Send';
/// The chat's More-menu word for stopping a running turn.
const String chatStopLabel = 'Stop';
/// The primary control's words while the draft is a `!` shell command.
@@ -95,7 +97,8 @@ const String chatQueuedNotice =
'Queued — it will send when the current turn finishes.';
/// The foot of one conversation: a native multiline field and Send control,
/// with a separate Stop while a turn runs, driven by [ChatComposerController].
/// driven by [ChatComposerController]. A running turn shows a travelling
/// border, not a stop control.
///
/// The field owns only its [TextEditingController] and focus; the durable draft
/// text lives in the composer controller, so a live transcript rebuild never
@@ -153,7 +156,7 @@ class ChatComposerBar extends StatefulWidget {
/// session (null) keeps those commands on the unavailable report.
final ChatCommandActions? commands;
/// The thread controller's running bit; shows Stop without hiding Send.
/// The thread controller's running bit; shows the running border.
final bool running;
/// The host picker seam; production uses [hostChatAttachmentPicker].
@@ -400,6 +403,13 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
);
}
/// Whether a send completes the palette's highlighted row instead of running
/// the draft. A draft that already names a whole command (`/stop`) runs on
/// the first send; only a partial word is completed first.
bool _paletteCompletes() =>
_paletteCommands().isNotEmpty &&
chatCommandNamed(widget.composer.draft) == null;
/// The recorded commands matching the current draft while the palette is
/// open. A dismissed or completed draft keeps its palette closed until the
/// operator types something newer.
@@ -512,8 +522,8 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
(keyboard.isShiftPressed || keyboard.isAltPressed)) {
return;
}
final commands = _paletteCommands();
if (commands.isNotEmpty) {
if (_paletteCompletes()) {
final commands = _paletteCommands();
_completeCommand(commands[_selectedCommand % commands.length]);
return;
}
@@ -943,10 +953,6 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
),
child: widget.backgroundTasks!,
),
if (widget.running) ...[
_primary(context, stop: true),
const SizedBox(width: 4),
],
_primary(context),
],
),
@@ -973,21 +979,41 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
/// the transcript, so the composer reads as a single input rather than a
/// row of separate controls, and the conversation shows through it. While
/// the field has focus a ring in the chat's colour runs along its edge.
Widget _pill(BuildContext context, Widget child) => ComposerFocusRing(
focus: _focus,
accent: chatFocusRingColor(context, widget.chatColor),
shape: _pillShape,
child: GlassPill(
key: const Key('chat-composer-pill'),
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,
),
),
);
///
/// While a turn runs a highlight travels around the same edge
/// ([ComposerRunningBorder]); it is mounted only for that time.
Widget _pill(BuildContext context, Widget child) {
final accent = chatFocusRingColor(context, widget.chatColor);
return Stack(
children: [
ComposerFocusRing(
focus: _focus,
accent: accent,
shape: _pillShape,
child: GlassPill(
key: const Key('chat-composer-pill'),
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,
),
),
),
if (widget.running)
Positioned.fill(
child: IgnorePointer(
child: ComposerRunningBorder(
shape: _pillShape,
primary: accent,
tertiary: Theme.of(context).colorScheme.tertiary,
),
),
),
],
);
}
/// 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.
@@ -1167,21 +1193,19 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
);
}
Widget _primary(BuildContext context, {bool stop = false}) {
/// The single primary control: Send (or Run command for a `!` draft). A
/// prompt sent while a turn runs takes the server's queued-prompt path; the
/// running turn is stopped by Escape twice, `/stop`, or the More menu.
Widget _primary(BuildContext context) {
final composer = widget.composer;
final enabled = stop
? !composer.stopping
: !_uploading &&
!_shellStarting &&
!composer.sending &&
composer.draft.trim().isNotEmpty;
final enabled =
!_uploading &&
!_shellStarting &&
!composer.sending &&
composer.draft.trim().isNotEmpty;
void press() {
if (stop) {
unawaited(composer.stop());
return;
}
final commands = _paletteCommands();
if (commands.isNotEmpty) {
if (_paletteCompletes()) {
final commands = _paletteCommands();
_completeCommand(commands[_selectedCommand % commands.length]);
} else if (chatDraftIsShell(composer.draft)) {
unawaited(_runShellDraft());
@@ -1192,36 +1216,23 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
}
}
// Sending while the turn runs uses the server's existing queued-prompt path.
// Stopping is always a separate, explicitly named action.
final label = stop
? chatStopLabel
: chatDraftIsShell(composer.draft)
final label = chatDraftIsShell(composer.draft)
? chatRunShellLabel
: chatSendLabel;
final key = Key(stop ? 'chat-composer-stop' : 'chat-composer-primary');
// A coloured chat's send button takes the chat's colour (its seeded
// primary, like the focus ring); stop stays the host's error red.
// primary, like the focus ring).
final tinted = chatSchemeOf(context, widget.chatColor);
final scheme = Theme.of(context).colorScheme;
return IconButton.filled(
key: key,
key: const Key('chat-composer-primary'),
tooltip: label,
style: stop
? IconButton.styleFrom(
backgroundColor: scheme.error,
foregroundColor: scheme.onError,
)
: tinted == null
style: tinted == null
? null
: IconButton.styleFrom(
backgroundColor: tinted.primary,
foregroundColor: tinted.onPrimary,
),
onPressed: enabled ? press : null,
icon: stop
? const ChatStopIcon(child: Icon(Icons.stop))
: const Icon(Icons.arrow_upward),
icon: const Icon(Icons.arrow_upward),
);
}
@@ -0,0 +1,119 @@
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
/// The longest gap between two Escape presses that still stops a running turn.
const Duration chatEscapeStopWindow = Duration(seconds: 1);
/// The hint shown after the first Escape while a turn runs.
const String chatEscapeStopHint = 'Press Esc again to stop';
/// Two presses of Escape stop a running turn: the first shows [chatEscapeStopHint]
/// and the second, inside [chatEscapeStopWindow], stops it. Pure timing, so the
/// clock is the caller's.
class ChatEscapeStopTracker {
DateTime? _firstAt;
/// Records one plain Escape press at [now]. Returns true when it completes a
/// pair; a press that completes nothing starts a new pair.
bool press(DateTime now) {
final first = _firstAt;
if (first != null && now.difference(first) <= chatEscapeStopWindow) {
_firstAt = null;
return true;
}
_firstAt = now;
return false;
}
/// Forgets a pending first press, for example once the turn has ended.
void reset() => _firstAt = null;
}
/// Lets two presses of Escape stop the turn while focus is anywhere inside
/// [child] (the composer or the transcript). It only consumes Escape while
/// [running]; an idle chat, and any Escape a descendant already handled (a
/// command palette, a notice), pass through untouched.
class ChatEscapeStop extends StatefulWidget {
const ChatEscapeStop({
super.key,
required this.running,
required this.onStop,
required this.child,
this.clock = DateTime.now,
});
final bool running;
/// Stops the running turn; called on the second press.
final VoidCallback onStop;
/// Injected time source, so tests control the window.
final DateTime Function() clock;
final Widget child;
@override
State<ChatEscapeStop> createState() => _ChatEscapeStopState();
}
class _ChatEscapeStopState extends State<ChatEscapeStop> {
final ChatEscapeStopTracker _tracker = ChatEscapeStopTracker();
@override
void didUpdateWidget(covariant ChatEscapeStop oldWidget) {
super.didUpdateWidget(oldWidget);
if (!widget.running) _tracker.reset();
}
KeyEventResult _onKeyEvent(FocusNode node, KeyEvent event) {
if (event.logicalKey != LogicalKeyboardKey.escape || !widget.running) {
return KeyEventResult.ignored;
}
final keyboard = HardwareKeyboard.instance;
if (keyboard.isControlPressed ||
keyboard.isMetaPressed ||
keyboard.isShiftPressed ||
keyboard.isAltPressed) {
return KeyEventResult.ignored;
}
// Holding Escape is one press, and releasing it is not a press at all.
if (event is! KeyDownEvent) {
return event is KeyRepeatEvent
? KeyEventResult.handled
: KeyEventResult.ignored;
}
if (_tracker.press(widget.clock())) {
_tracker.reset();
_hideHint();
widget.onStop();
} else {
_showHint();
}
return KeyEventResult.handled;
}
void _showHint() {
final messenger = ScaffoldMessenger.maybeOf(context);
if (messenger == null) return;
messenger
..hideCurrentSnackBar()
..showSnackBar(
const SnackBar(
key: Key('chat-escape-stop-hint'),
content: Text(chatEscapeStopHint),
duration: chatEscapeStopWindow,
behavior: SnackBarBehavior.floating,
),
);
}
void _hideHint() => ScaffoldMessenger.maybeOf(context)?.hideCurrentSnackBar();
@override
Widget build(BuildContext context) => Focus(
canRequestFocus: false,
skipTraversal: true,
onKeyEvent: _onKeyEvent,
child: widget.child,
);
}
@@ -0,0 +1,128 @@
import 'package:flutter/rendering.dart' show ScrollDirection;
import 'package:flutter/services.dart'
show HardwareKeyboard, KeyDownEvent, KeyEvent;
import 'package:flutter/widgets.dart';
import '../../../core/servers/server_context.dart';
import '../../settings/server_connections.dart';
/// Reports the user's own actions in one open chat, so the chat can be read.
///
/// Counted: a pointer press anywhere in the pane (click or tap, which also
/// makes it the active pane), a user-driven scroll of its transcript, a key
/// press while focus is inside it (typing, Tab), focus arriving in it from a
/// key press outside it (Tab into the pane), and a notification tap that
/// opened it. Showing the pane, rebuilding it, receiving content, or focus
/// moved in code with no key press does not report anything. [onInteract]
/// decides whether the window is focused.
class ChatSeenInteraction extends StatefulWidget {
const ChatSeenInteraction({
super.key,
required this.sessionId,
required this.onInteract,
required this.child,
});
final String sessionId;
final VoidCallback onInteract;
final Widget child;
@override
State<ChatSeenInteraction> createState() => _ChatSeenInteractionState();
}
class _ChatSeenInteractionState extends State<ChatSeenInteraction> {
ServerConnections? _connections;
/// True from a key-down until the next frame. Focus changes are applied in a
/// microtask queued by the key dispatch, which runs before that frame, so a
/// focus change caused by the key sees the flag. A focus change with no key
/// press (restoration, code-driven focus) never does.
bool _keyDownInProgress = false;
@override
void initState() {
super.initState();
HardwareKeyboard.instance.addHandler(_onKeyEvent);
}
bool _onKeyEvent(KeyEvent event) {
if (event is KeyDownEvent && !_keyDownInProgress) {
_keyDownInProgress = true;
WidgetsBinding.instance.addPostFrameCallback((_) {
_keyDownInProgress = false;
});
WidgetsBinding.instance.scheduleFrame();
}
return false;
}
void _onFocusChange(bool hasFocus) {
if (hasFocus && _keyDownInProgress) widget.onInteract();
}
@override
void didChangeDependencies() {
super.didChangeDependencies();
final connections = ServerContext.maybeOf(context)?.notifier;
if (identical(connections, _connections)) return;
_connections?.removeListener(_takeNotificationOpen);
_connections = connections;
connections?.addListener(_takeNotificationOpen);
_takeNotificationOpen();
}
@override
void didUpdateWidget(covariant ChatSeenInteraction oldWidget) {
super.didUpdateWidget(oldWidget);
if (oldWidget.sessionId != widget.sessionId) _takeNotificationOpen();
}
@override
void dispose() {
HardwareKeyboard.instance.removeHandler(_onKeyEvent);
_connections?.removeListener(_takeNotificationOpen);
super.dispose();
}
/// A notification tap that named this chat is the user opening it. It is
/// reported after the frame, so the list has taken the chat as active first.
void _takeNotificationOpen() {
final connections = _connections;
if (connections == null ||
!connections.takeChatOpenIntent(widget.sessionId)) {
return;
}
WidgetsBinding.instance.addPostFrameCallback((_) {
if (mounted) widget.onInteract();
});
}
static bool _userScrolled(ScrollNotification notification) =>
(notification is UserScrollNotification &&
notification.direction != ScrollDirection.idle) ||
(notification is ScrollStartNotification &&
notification.dragDetails != null);
@override
Widget build(BuildContext context) => Listener(
behavior: HitTestBehavior.translucent,
onPointerDown: (_) => widget.onInteract(),
child: NotificationListener<ScrollNotification>(
onNotification: (notification) {
if (_userScrolled(notification)) widget.onInteract();
return false;
},
child: Focus(
canRequestFocus: false,
skipTraversal: true,
onFocusChange: _onFocusChange,
onKeyEvent: (node, event) {
if (event is KeyDownEvent) widget.onInteract();
return KeyEventResult.ignored;
},
child: widget.child,
),
),
);
}
@@ -1,48 +0,0 @@
import 'package:flutter/widgets.dart';
/// Slow, continuous progress motion confined to the Stop glyph. The native
/// button, hit target and semantics never rotate. TickerMode pauses hidden UI.
class ChatStopIcon extends StatefulWidget {
const ChatStopIcon({super.key, required this.child});
final Widget child;
static const period = Duration(seconds: 8);
@override
State<ChatStopIcon> createState() => _ChatStopIconState();
}
class _ChatStopIconState extends State<ChatStopIcon>
with SingleTickerProviderStateMixin {
late final _rotation = AnimationController(
vsync: this,
duration: ChatStopIcon.period,
);
@override
void didChangeDependencies() {
super.didChangeDependencies();
if (MediaQuery.maybeDisableAnimationsOf(context) ?? false) {
_rotation.stop();
_rotation.value = 0;
} else if (!_rotation.isAnimating) {
_rotation.repeat();
}
}
@override
void dispose() {
_rotation.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) => RepaintBoundary(
key: const Key('chat-stop-paint-boundary'),
child: RotationTransition(
key: const Key('chat-stop-rotation'),
turns: _rotation,
child: widget.child,
),
);
}
@@ -0,0 +1,71 @@
import 'package:flutter/widgets.dart';
/// Turns [child] once every [period] while [spinning]; static otherwise. With
/// reduced motion it never turns. Hidden UI is silenced by TickerMode.
class ChatTaskSpinner extends StatefulWidget {
const ChatTaskSpinner({
super.key,
required this.spinning,
required this.child,
});
final bool spinning;
final Widget child;
/// One full turn while tasks run.
static const Duration period = Duration(milliseconds: 2500);
@override
State<ChatTaskSpinner> createState() => _ChatTaskSpinnerState();
}
class _ChatTaskSpinnerState extends State<ChatTaskSpinner>
with SingleTickerProviderStateMixin {
late final AnimationController _turns = AnimationController(
vsync: this,
duration: ChatTaskSpinner.period,
);
bool _reduced = false;
@override
void initState() {
super.initState();
_sync();
}
@override
void didChangeDependencies() {
super.didChangeDependencies();
_reduced = MediaQuery.maybeDisableAnimationsOf(context) ?? false;
_sync();
}
@override
void didUpdateWidget(covariant ChatTaskSpinner oldWidget) {
super.didUpdateWidget(oldWidget);
_sync();
}
void _sync() {
if (widget.spinning && !_reduced) {
if (!_turns.isAnimating) _turns.repeat();
} else {
_turns
..stop()
..value = 0;
}
}
@override
void dispose() {
_turns.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) => RotationTransition(
key: const Key('chat-background-tasks-spinner'),
turns: _turns,
child: widget.child,
);
}
@@ -42,6 +42,7 @@ import 'chat_background_tasks.dart';
import 'chat_command_actions.dart';
import 'chat_composer_bar.dart';
import 'chat_composer_controller.dart';
import 'chat_escape_stop.dart';
import 'chat_delivery_indicator.dart';
import 'chat_draft_store.dart';
import 'chat_effort_control.dart';
@@ -1383,7 +1384,13 @@ class _ChatThreadViewState extends State<ChatThreadView> {
// The bar and the jump control float over the transcript and the
// composer sits below it; the wheel over them scrolls it, as a page
// scrolls under fixed bars.
final column = VerticalWheelForwarder(controller: _scroll, child: page);
// Two Escape presses stop a running turn while the conversation has
// the keyboard; the wheel over the page still scrolls it.
final column = ChatEscapeStop(
running: _controller.running,
onStop: _stopTurn,
child: VerticalWheelForwarder(controller: _scroll, child: page),
);
final wideFiles =
_filesVisible && MediaQuery.sizeOf(context).width >= 700;
_reportCenterStageFilesWidth();
@@ -1482,6 +1489,15 @@ class _ChatThreadViewState extends State<ChatThreadView> {
],
moreActions: [
?widget.sidebarControl,
// Touch devices have no Escape key; the menu is their way to stop.
if (_controller.running)
ChatBarAction(
key: const Key('chat-thread-stop-menu'),
label: chatStopLabel,
identifier: 'chat-thread-stop',
onPressed: _stopTurn,
materialIcon: Icons.stop,
),
// A window's own title bar names the chat, and its narrow action
// bar has no room for the title that opens the details.
if (WindowScope.maybeOf(context) != null)
@@ -1537,6 +1553,9 @@ class _ChatThreadViewState extends State<ChatThreadView> {
onChanged: widget.onModeChanged,
);
/// Stops the running turn, as the composer's `/stop` does.
void _stopTurn() => unawaited(_composer.stop());
void _runShellFromMenu() => unawaited(
runChatShellFromMenu(context, _shellRuns, showNotice: _showCommandNotice),
);
@@ -0,0 +1,146 @@
import 'dart:math' as math;
import 'package:flutter/material.dart';
/// The composer's "agent is working" edge: a soft highlight that travels once
/// around the pill's rounded border in [primary] and [tertiary], with a faint
/// glow beneath it. Mount it only while a turn runs; disposing it stops the
/// animation, so the border ends cleanly with the turn.
///
/// With reduced motion (the platform's disable-animations setting) it draws
/// a static, evenly highlighted border instead and never ticks.
class ComposerRunningBorder extends StatefulWidget {
const ComposerRunningBorder({
super.key,
required this.shape,
required this.primary,
required this.tertiary,
});
/// The pill's shape, so the highlight follows its edge.
final OutlinedBorder shape;
final Color primary;
final Color tertiary;
/// One lap of the highlight around the border.
static const Duration period = Duration(seconds: 4);
/// The stroke drawn just inside the pill's edge.
static const double strokeWidth = 2;
/// The static border's opacity under reduced motion.
static const double staticOpacity = 0.7;
@override
State<ComposerRunningBorder> createState() => _ComposerRunningBorderState();
}
class _ComposerRunningBorderState extends State<ComposerRunningBorder>
with SingleTickerProviderStateMixin {
late final AnimationController _lap = AnimationController(
vsync: this,
duration: ComposerRunningBorder.period,
);
bool _reduced = false;
@override
void initState() {
super.initState();
_lap.repeat();
}
@override
void didChangeDependencies() {
super.didChangeDependencies();
final reduced = MediaQuery.maybeDisableAnimationsOf(context) ?? false;
if (reduced == _reduced) return;
_reduced = reduced;
if (reduced) {
_lap.stop();
} else {
_lap.repeat();
}
}
@override
void dispose() {
_lap.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) => RepaintBoundary(
key: const Key('chat-composer-running-border'),
child: CustomPaint(
painter: _RunningBorderPainter(
shape: widget.shape,
primary: widget.primary,
tertiary: widget.tertiary,
lap: _reduced ? null : _lap,
),
),
);
}
class _RunningBorderPainter extends CustomPainter {
_RunningBorderPainter({
required this.shape,
required this.primary,
required this.tertiary,
required this.lap,
}) : super(repaint: lap);
final OutlinedBorder shape;
final Color primary;
final Color tertiary;
/// The lap's progress, or null for the static reduced-motion border.
final Animation<double>? lap;
@override
void paint(Canvas canvas, Size size) {
if (size.isEmpty) return;
const width = ComposerRunningBorder.strokeWidth;
final rect = Offset.zero & size;
final path = shape.getOuterPath(rect.deflate(width / 2));
final glow = Paint()
..style = PaintingStyle.stroke
..strokeWidth = width * 3
..maskFilter = const MaskFilter.blur(BlurStyle.normal, 4);
final line = Paint()
..style = PaintingStyle.stroke
..strokeWidth = width;
final progress = lap?.value;
if (progress == null) {
final solid = primary.withValues(
alpha: ComposerRunningBorder.staticOpacity,
);
glow.color = solid.withValues(alpha: solid.a * .4);
line.color = solid;
} else {
final shader = SweepGradient(
colors: [
primary.withValues(alpha: 0),
primary,
tertiary,
tertiary.withValues(alpha: 0),
primary.withValues(alpha: 0),
],
stops: const [0, .12, .24, .38, 1],
transform: GradientRotation(progress * 2 * math.pi),
).createShader(rect);
glow.shader = shader;
line.shader = shader;
}
canvas
..drawPath(path, glow)
..drawPath(path, line);
}
@override
bool shouldRepaint(_RunningBorderPainter oldDelegate) =>
oldDelegate.shape != shape ||
oldDelegate.primary != primary ||
oldDelegate.tertiary != tertiary ||
oldDelegate.lap != lap;
}
+3
View File
@@ -31,6 +31,8 @@ import 'workspace/chat_float_shortcut.dart';
import 'workspace/chat_workspace_binding.dart';
import 'workspace/chat_workspace_snapshot.dart';
import 'workspace/chat_workspace_store.dart';
import 'workspace/chat_open_workspace_controller.dart';
import 'workspace/chat_open_workspace_gateway.dart';
import 'conversation/chat_bar_tint.dart';
import 'conversation/chat_pane_picker.dart';
import 'conversation/chat_add_pane_picker.dart';
@@ -383,6 +385,7 @@ class _ChatScreenState extends State<ChatScreen>
HardwareKeyboard.instance.removeHandler(_slashFocusKey);
_page.dispose();
_workspaceBinding?.dispose();
_openWorkspace?.dispose();
_unbindWindows();
_workspace.removeListener(_workspaceChanged);
_workspace.dispose();
@@ -0,0 +1,46 @@
import 'package:flutter/widgets.dart';
/// Whether the app window is focused and visible: the only state in which a
/// chat can be read. A backgrounded or unfocused window never marks a chat
/// seen, so a reply that arrives there stays New until the user interacts.
class ChatSeenFocus extends ChangeNotifier {
ChatSeenFocus({bool focused = true}) {
_focused = focused;
}
/// The app's own focus, driven by the framework's lifecycle state. A null
/// lifecycle state (before the first report) counts as focused, so a window
/// that starts visible is not stuck unread.
static final ChatSeenFocus app = ChatSeenFocus._observingApp();
factory ChatSeenFocus._observingApp() {
final focus = ChatSeenFocus(
focused: _isFocusedState(WidgetsBinding.instance.lifecycleState),
);
WidgetsBinding.instance.addObserver(_LifecycleFocus(focus));
return focus;
}
late bool _focused;
bool get focused => _focused;
set focused(bool value) {
if (value == _focused) return;
_focused = value;
notifyListeners();
}
static bool _isFocusedState(AppLifecycleState? state) =>
state == null || state == AppLifecycleState.resumed;
}
class _LifecycleFocus with WidgetsBindingObserver {
_LifecycleFocus(this._focus);
final ChatSeenFocus _focus;
@override
void didChangeAppLifecycleState(AppLifecycleState state) {
_focus.focused = ChatSeenFocus._isFocusedState(state);
}
}
@@ -12,6 +12,7 @@ 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_seen_focus.dart';
import 'chat_session_local.dart';
import 'session_attention.dart';
@@ -23,8 +24,10 @@ import 'session_attention.dart';
/// read watermark are local.
///
/// With an [AttentionAckSync] (bound to the gateway by the app, or passed in),
/// reading is shared: opening a chat acknowledges a `chat_seen` watermark to
/// every device, and a watermark acknowledged elsewhere that is newer than this
/// reading is shared: a user interaction with a chat (opening it, or acting in
/// its pane while the window is focused, see [reportInteraction]) acknowledges
/// a `chat_seen` watermark to every device. Being visible, restored or
/// receiving a reply never does. A watermark acknowledged elsewhere that is newer than this
/// device's own clears the chat's New badge here. The local store remains the
/// offline cache of both.
class ChatSessionsController extends ChangeNotifier {
@@ -33,8 +36,10 @@ class ChatSessionsController extends ChangeNotifier {
ChatSessionLocalStore? localStore,
AttentionAckSync? ackSync,
int Function()? nowMillis,
ChatSeenFocus? seenFocus,
this.activeAckDelay = const Duration(milliseconds: 1500),
}) : _localStore =
}) : _focus = seenFocus ?? ChatSeenFocus.app,
_localStore =
localStore ??
(repository.gateway is FederatedChatGateway
? FederatedChatSessionLocalStore(
@@ -46,12 +51,27 @@ class ChatSessionsController extends ChangeNotifier {
),
)),
_nowMillis = nowMillis ?? _wallClockMillis {
_focus.addListener(_focusChanged);
_listenFrames();
_bindAckSync(ackSync ?? attentionAckSyncOf(repository.gateway));
}
static int _wallClockMillis() => DateTime.now().millisecondsSinceEpoch;
final ChatSeenFocus _focus;
/// The open chat the user has interacted with while the window was focused.
/// Only such a chat acknowledges new content as it arrives; any other reply
/// in the open chat stays New until the next interaction. Cleared when the
/// window loses focus or another chat becomes the open one.
final Set<String> _engaged = {};
void _focusChanged() {
if (_focus.focused) return;
_engaged.clear();
_cancelPendingActiveAck();
}
/// How long the open chat stays quiet before its new content is
/// acknowledged to the other devices; streaming text arrives in many frames.
final Duration activeAckDelay;
@@ -61,6 +81,8 @@ class ChatSessionsController extends ChangeNotifier {
final int Function() _nowMillis;
AttentionAckSync? _ackSync;
Timer? _activeAck;
// The chat whose quiet-period acknowledgement [_activeAck] is waiting on.
String? _pendingAckId;
ChatSessionLocal _local = const ChatSessionLocal();
final Map<String, String> _actionErrors = {};
List<JsonMap> _sessions = const [];
@@ -78,7 +100,17 @@ class ChatSessionsController extends ChangeNotifier {
// older snapshot that arrives later never replaces it.
final Map<String, ChatListActivity> _activity = {};
StreamSubscription<JsonMap>? _frameSubscription;
String? activeSessionId;
String? _activeSessionId;
/// The chat open above the list. Opening another chat ends the engagement
/// with the previous one; setting the same id changes nothing.
String? get activeSessionId => _activeSessionId;
set activeSessionId(String? id) {
if (id == _activeSessionId) return;
_activeSessionId = id;
_engaged.clear();
_cancelPendingActiveAck();
}
void _listenFrames() {
_frameSubscription?.cancel();
@@ -98,8 +130,14 @@ class ChatSessionsController extends ChangeNotifier {
final row = session.first;
if (row['closed_at'] != null || row['closed'] == true) return;
if (effect.running != null) _setRunning(id, effect.running!);
if (effect.attention && id != activeSessionId) unawaited(_markUnseen(id));
if (effect.attention && id == activeSessionId) _scheduleActiveAck(id);
if (!effect.attention) return;
if (id == activeSessionId && _focus.focused && _engaged.contains(id)) {
_scheduleActiveAck(id);
} else {
// Passive: the window is unfocused, or the chat was open with no
// interaction since, so the reply is New until the user acts.
unawaited(_markUnseen(id));
}
}
/// Another device changed a chat's shared colour, star or title: the row
@@ -210,12 +248,45 @@ class ChatSessionsController extends ChangeNotifier {
void _scheduleActiveAck(String id) {
if (_ackSync == null) return;
_activeAck?.cancel();
_pendingAckId = id;
_activeAck = Timer(activeAckDelay, () {
if (_disposed || id != activeSessionId) return;
_activeAck = null;
_pendingAckId = null;
// Losing focus or the chat during the quiet period ends the engagement;
// [_cancelPendingActiveAck] has already marked the reply New by then.
if (_disposed || id != activeSessionId || !_engaged.contains(id)) return;
unawaited(_acknowledgeSeen(id, 0));
});
}
/// Ends a quiet period that has not fired yet. The reply it was waiting on
/// arrived while the user was engaged, but the engagement ends before the
/// quiet period does, so that reply is marked New here rather than dropped.
void _cancelPendingActiveAck() {
final pending = _pendingAckId;
if (pending == null) return;
_activeAck?.cancel();
_activeAck = null;
_pendingAckId = null;
unawaited(_markUnseen(pending));
}
/// The user acted in [id]: a click, tap, scroll, key press in its pane, or
/// opening it. Only while the window is focused; a passive state is ignored.
/// Everything up to the latest message is marked seen and acknowledged to
/// every device. Repeated interactions (every scroll tick) send nothing once
/// the chat is engaged and has no unread content.
void reportInteraction(String id) {
if (_disposed || id.isEmpty || !_focus.focused) return;
final firstInChat = id == activeSessionId && _engaged.add(id);
if (!firstInChat && !_local.isUnseen(id)) return;
final row = _sessions.where((row) => '${row['id'] ?? ''}' == id);
final updatedAt = row.isEmpty
? 0
: chatSessionMillis(row.first['updated_at']);
unawaited(_acknowledgeSeen(id, updatedAt));
}
/// Applies watermarks acknowledged on any device: one newer than this
/// device's own marks the chat read here (clearing its New badge) and raises
/// the local watermark, so a later badge is not cleared by the same ack.
@@ -265,9 +336,9 @@ class ChatSessionsController extends ChangeNotifier {
Future<void> _markUnseen(String id) async {
await _ensureLocal();
// Loading device preferences may race an operator opening this chat. The
// open is authoritative even when the triggering frame arrived first.
if (_disposed || id == activeSessionId) return;
// Loading device preferences may race an operator engaging this chat. The
// interaction is authoritative even when the triggering frame arrived first.
if (_disposed || (id == activeSessionId && _engaged.contains(id))) return;
final next = _local.markUnseen(id);
if (identical(next, _local)) return;
_local = next;
@@ -443,11 +514,15 @@ class ChatSessionsController extends ChangeNotifier {
_notify();
}
/// Records that this device has read [session]'s current recency.
/// Records that this device has read [session]'s current recency. Called
/// only for the user's own open (a list row, a shortcut, a notification), so
/// it also engages the chat. Showing a chat that was already open, such as a
/// restored layout, never calls this.
Future<void> markOpened(JsonMap session) async {
final id = '${session['id'] ?? ''}';
if (id.isEmpty) return;
activeSessionId = id;
if (_focus.focused) _engaged.add(id);
await _ensureLocal();
if (_disposed) return;
final updatedAt = chatSessionMillis(session['updated_at']);
@@ -564,6 +639,7 @@ class ChatSessionsController extends ChangeNotifier {
unawaited(_frameSubscription?.cancel());
_activeAck?.cancel();
_ackSync?.removeListener(_ackChanged);
_focus.removeListener(_focusChanged);
super.dispose();
}
}
@@ -112,7 +112,6 @@ class _ChatSessionsScreenState extends State<ChatSessionsScreen> {
final _search = TextEditingController();
late final ChatSectionFolds _folds = widget.folds ?? ChatSectionFolds();
Timer? _undoTimer;
String? _markedActiveSessionId;
@override
void initState() {
@@ -123,7 +122,6 @@ class _ChatSessionsScreenState extends State<ChatSessionsScreen> {
/// Reports the loaded rows at the end of the frame: the destination learns a
/// routed row without this screen calling back inside its own build.
void _reportSessions() {
_markActiveSessionRead();
if (widget.onSessions == null) return;
WidgetsBinding.instance.addPostFrameCallback((_) {
if (!mounted) return;
@@ -131,28 +129,10 @@ class _ChatSessionsScreenState extends State<ChatSessionsScreen> {
});
}
void _markActiveSessionRead() {
final id = widget.activeSessionId;
if (id == null) {
_markedActiveSessionId = null;
return;
}
if (id == _markedActiveSessionId) return;
for (final session in _controller.sessions) {
if (_sessionId(session) != id) continue;
// Mark synchronously so row activation and subsequent list notifications
// cannot write the same read watermark twice.
_markedActiveSessionId = id;
unawaited(_controller.markOpened(session));
return;
}
}
@override
void didUpdateWidget(covariant ChatSessionsScreen oldWidget) {
super.didUpdateWidget(oldWidget);
_controller.activeSessionId = widget.activeSessionId;
_markActiveSessionRead();
if (oldWidget.gateway != widget.gateway) {
_controller.replaceRepository(ChatRepository(widget.gateway));
} else if (oldWidget.syncToken != widget.syncToken) {
@@ -252,10 +232,8 @@ class _ChatSessionsScreenState extends State<ChatSessionsScreen> {
if (session != null && mounted) widget.onOpen(session);
}
void _markOpened(JsonMap session) {
_markedActiveSessionId = _sessionId(session);
unawaited(_controller.markOpened(session));
}
void _markOpened(JsonMap session) =>
unawaited(_controller.markOpened(session));
void _openBeside(JsonMap session) {
_markOpened(session);
@@ -75,6 +75,9 @@ class ChatWindows {
Iterable<WindowEntry> get windows =>
manager.windows.where((w) => w.kind == chatWindowKind);
Iterable<String> get floatingSessionIds =>
windows.map((window) => window.contentId);
/// Registers the kind and starts answering the chord. Call before the
/// manager restores, so saved chat windows are kept.
void start() {
@@ -0,0 +1,115 @@
import 'dart:async';
import '../../../core/api_gateway.dart';
import 'chat_open_workspace_gateway.dart';
/// Keeps one device's open chats in step with the server's open-chat set.
///
/// Writes are serialized: one is in flight at a time, and changes made while
/// it is pending coalesce into the latest full snapshot, sent next from the
/// revision the reply reported. Every reply and push is reconciled by server
/// revision, so a late or reordered one never overwrites newer state. A
/// snapshot from another device (or a refused stale write) wins over local
/// changes not yet sent, and reaches [onChanged].
class ChatOpenWorkspaceController {
ChatOpenWorkspaceController({required ApiGateway gateway})
: _gateway = ChatOpenWorkspaceGateway(gateway);
final ChatOpenWorkspaceGateway _gateway;
StreamSubscription<ChatOpenWorkspaceSnapshot>? _subscription;
bool _disposed = false;
bool _writing = false;
List<ChatOpenWorkspaceEntry>? _pending;
ChatOpenWorkspaceSnapshot? _current;
/// Applies a server snapshot to the device's panes and windows.
void Function(ChatOpenWorkspaceSnapshot snapshot)? onChanged;
/// The latest server revision this device has seen; 0 before any.
int get revision => _current?.revision ?? 0;
/// Whether the server answered, so local changes are sent. Before that (or
/// against a server without the request) the device keeps its own layout.
bool get ready => _current != null;
bool get disposed => _disposed;
/// Subscribes to pushes, then seeds the server from [local] (the device's
/// restored layout, migrated once from the old local snapshot) or, with no
/// local chats, reads the server's set. The server's answer is applied.
Future<void> start({
Iterable<ChatOpenWorkspaceEntry> local = const [],
}) async {
if (_subscription != null || _disposed) return;
_subscription = _gateway.changes.listen(_accept);
final entries = local.toList(growable: false);
ChatOpenWorkspaceSnapshot? snapshot;
try {
snapshot = entries.isEmpty
? await _gateway.read()
: await _gateway.replace(entries, seed: true);
} on Object {
return;
}
if (snapshot != null) _accept(snapshot, force: true);
}
/// Sends the device's full open-chat set. Ignored until [ready]; coalesced
/// while a write is in flight.
void replace(Iterable<ChatOpenWorkspaceEntry> entries) {
if (_disposed || !ready) return;
_pending = entries.toList(growable: false);
if (!_writing) unawaited(_drain());
}
Future<void> _drain() async {
_writing = true;
try {
while (!_disposed) {
final sent = _pending;
_pending = null;
if (sent == null) return;
final current = _current;
if (current != null && current.sameEntries(sent)) continue;
ChatOpenWorkspaceSnapshot? reply;
try {
reply = await _gateway.replace(sent, baseRevision: revision);
} on Object {
reply = null;
}
if (_disposed || reply == null || reply.revision < revision) continue;
if (reply.rejected) {
// Another change landed first: the server's state wins over this
// write and anything queued behind it.
_accept(reply, force: true);
} else {
// The server may have left out closed or unknown chats. This device
// keeps showing them (a closed chat can still be read here); the
// other devices never receive them.
_current = reply;
}
}
} finally {
_writing = false;
}
}
void _accept(ChatOpenWorkspaceSnapshot snapshot, {bool force = false}) {
if (_disposed) return;
final current = _current;
if (current != null &&
(snapshot.revision < current.revision ||
(!force && snapshot.revision == current.revision))) {
return;
}
_current = snapshot;
_pending = null;
onChanged?.call(snapshot);
}
void dispose() {
_disposed = true;
_pending = null;
onChanged = null;
unawaited(_subscription?.cancel());
_subscription = null;
}
}
@@ -0,0 +1,107 @@
import '../../../core/api_gateway.dart';
/// One chat in the server-owned open-chat set: its session and whether it is
/// floating. Geometry stays on the device.
class ChatOpenWorkspaceEntry {
const ChatOpenWorkspaceEntry(this.sessionId, {this.floating = false});
final String sessionId;
final bool floating;
Map<String, dynamic> toJson() => {
'session_id': sessionId,
if (floating) 'floating': true,
};
static ChatOpenWorkspaceEntry? fromJson(Object? value) {
if (value is! Map) return null;
final id = '${value['session_id'] ?? ''}'.trim();
return id.isEmpty
? null
: ChatOpenWorkspaceEntry(id, floating: value['floating'] == true);
}
}
/// The complete open-chat set at one server revision. [rejected] marks the
/// reply to a write from a stale base: the write was not applied and this is
/// the current state.
class ChatOpenWorkspaceSnapshot {
const ChatOpenWorkspaceSnapshot(
this.revision,
this.entries, {
this.rejected = false,
});
final int revision;
final List<ChatOpenWorkspaceEntry> entries;
final bool rejected;
bool sameEntries(Iterable<ChatOpenWorkspaceEntry> other) {
final list = other.toList(growable: false);
if (list.length != entries.length) return false;
for (var i = 0; i < list.length; i++) {
if (list[i].sessionId != entries[i].sessionId ||
list[i].floating != entries[i].floating) {
return false;
}
}
return true;
}
static ChatOpenWorkspaceSnapshot? fromJson(Object? value) {
if (value is! Map || value['entries'] is! List) return null;
final entries = <ChatOpenWorkspaceEntry>[];
for (final item in value['entries'] as List) {
final entry = ChatOpenWorkspaceEntry.fromJson(item);
if (entry == null ||
entries.any((old) => old.sessionId == entry.sessionId)) {
return null;
}
entries.add(entry);
}
if (entries.length > 64) return null;
return ChatOpenWorkspaceSnapshot(
(value['revision'] as num?)?.toInt() ?? 0,
List.unmodifiable(entries),
rejected: value['rejected'] == true,
);
}
}
/// The `chat_open_workspace` request and its `chat_open_workspace_changed`
/// push, decoded.
class ChatOpenWorkspaceGateway {
ChatOpenWorkspaceGateway(this.gateway);
final ApiGateway gateway;
/// The current snapshot, without changing it.
Future<ChatOpenWorkspaceSnapshot?> read() async {
final response = await gateway.call('chat_open_workspace');
return ChatOpenWorkspaceSnapshot.fromJson(response['chat_open_workspace']);
}
/// Replaces the set, derived from [baseRevision]. A [seed] applies only
/// when the server never stored a set and otherwise returns the stored one.
Future<ChatOpenWorkspaceSnapshot?> replace(
Iterable<ChatOpenWorkspaceEntry> entries, {
int baseRevision = 0,
bool seed = false,
}) async {
final response = await gateway.call('chat_open_workspace', {
'chat_open_workspace_request': {
'entries': entries
.map((entry) => entry.toJson())
.toList(growable: false),
'base_revision': baseRevision,
if (seed) 'seed': true,
},
});
return ChatOpenWorkspaceSnapshot.fromJson(response['chat_open_workspace']);
}
Stream<ChatOpenWorkspaceSnapshot> get changes async* {
await for (final frame in gateway.frames) {
if (frame['type'] != 'chat_open_workspace_changed') continue;
final snapshot = ChatOpenWorkspaceSnapshot.fromJson(
frame['chat_open_workspace'],
);
if (snapshot != null) yield snapshot;
}
}
}
@@ -1,6 +1,7 @@
import 'package:flutter/foundation.dart';
import 'chat_workspace_nodes.dart';
import 'chat_workspace_reconcile.dart';
import 'chat_workspace_snapshot.dart';
export 'chat_workspace_nodes.dart';
@@ -203,6 +204,23 @@ class ChatWorkspaceController extends ChangeNotifier {
_changed();
}
/// Tiles exactly [sessionIds] in order, as the server's open-chat set
/// names them, keeping this device's geometry (see
/// [reconcileChatWorkspaceTree]). Floating membership is the window host's.
void reconcileSessions(Iterable<String> sessionIds) {
final wanted = <String>[];
final seen = <String>{};
for (final id in sessionIds) {
if (id.isNotEmpty && seen.add(id)) wanted.add(id);
}
final next = reconcileChatWorkspaceTree(_root, wanted, _id);
if (identical(next, _root)) return;
_root = next;
final ids = panes.map((pane) => pane.id).toSet();
if (!ids.contains(_active)) _active = ids.firstOrNull;
_changed();
}
void replaceSession(String oldId, String newId) {
if (oldId == newId || newId.isEmpty || _replaceFloating(oldId, newId)) {
return;
@@ -0,0 +1,118 @@
import 'chat_workspace_nodes.dart';
/// Returns [root] tiled with exactly [wanted] (distinct session ids) in
/// order, keeping the local geometry: panes whose chat left are removed with
/// their splits, surviving panes keep their ids and split sizes and move
/// between slots to follow the order, and new chats split off the last pane.
/// Returns [root] itself when it already matches.
ChatWorkspaceNode? reconcileChatWorkspaceTree(
ChatWorkspaceNode? root,
List<String> wanted,
String Function(String kind) newId,
) {
if (wanted.isEmpty) return null;
final keep = wanted.toSet();
final seen = <String>{};
var node = root == null ? null : _retain(root, keep, seen);
final leaves = node == null ? <ChatWorkspacePane>[] : _leaves(node).toList();
final bySession = {for (final pane in leaves) pane.sessionId: pane};
final order = wanted.where(bySession.containsKey).toList();
var slot = 0;
if (node != null) {
node = _reorder(node, () => bySession[order[slot++]]!);
}
for (final id in wanted.where((id) => !bySession.containsKey(id))) {
final added = ChatWorkspacePane(newId('pane'), id);
if (node == null) {
node = added;
continue;
}
final last = _leaves(node).last;
node = _swapLeaf(
node,
last.id,
ChatWorkspaceSplit(newId('split'), ChatSplitAxis.horizontal, last, added),
);
}
return _same(node, root) ? root : node;
}
Iterable<ChatWorkspacePane> _leaves(ChatWorkspaceNode node) sync* {
if (node is ChatWorkspacePane) yield node;
if (node is ChatWorkspaceSplit) {
yield* _leaves(node.first);
yield* _leaves(node.second);
}
}
/// Drops panes outside [keep] and repeats of a session already kept.
ChatWorkspaceNode? _retain(
ChatWorkspaceNode node,
Set<String> keep,
Set<String> seen,
) {
if (node is ChatWorkspacePane) {
return keep.contains(node.sessionId) && seen.add(node.sessionId)
? node
: null;
}
final split = node as ChatWorkspaceSplit;
final first = _retain(split.first, keep, seen);
final second = _retain(split.second, keep, seen);
if (first == null) return second;
if (second == null) return first;
return ChatWorkspaceSplit(
split.id,
split.axis,
first,
second,
ratio: split.ratio,
);
}
ChatWorkspaceNode _reorder(
ChatWorkspaceNode node,
ChatWorkspacePane Function() next,
) {
if (node is ChatWorkspacePane) return next();
final split = node as ChatWorkspaceSplit;
final first = _reorder(split.first, next);
return ChatWorkspaceSplit(
split.id,
split.axis,
first,
_reorder(split.second, next),
ratio: split.ratio,
);
}
ChatWorkspaceNode _swapLeaf(
ChatWorkspaceNode node,
String id,
ChatWorkspaceNode replacement,
) {
if (node.id == id) return replacement;
if (node is! ChatWorkspaceSplit) return node;
return ChatWorkspaceSplit(
node.id,
node.axis,
_swapLeaf(node.first, id, replacement),
_swapLeaf(node.second, id, replacement),
ratio: node.ratio,
);
}
bool _same(ChatWorkspaceNode? a, ChatWorkspaceNode? b) {
if (a == null || b == null) return a == b;
if (a is ChatWorkspacePane && b is ChatWorkspacePane) {
return a.id == b.id && a.sessionId == b.sessionId;
}
if (a is ChatWorkspaceSplit && b is ChatWorkspaceSplit) {
return a.id == b.id &&
a.axis == b.axis &&
a.ratio == b.ratio &&
_same(a.first, b.first) &&
_same(a.second, b.second);
}
return false;
}
@@ -125,6 +125,7 @@ class _RunDetailViewState extends State<RunDetailView> {
titleSemanticLabel: 'Run title $title',
onBack: widget.onBack,
actions: [more],
hideNavigation: true,
child: detail,
);
}
@@ -168,6 +169,7 @@ class _RunDetailViewState extends State<RunDetailView> {
return ShellBar(
title: 'Run',
onBack: widget.onBack,
hideNavigation: true,
child: _placeholderBody(loading, message),
);
}
@@ -46,6 +46,23 @@ class ServerConnections extends ChangeNotifier {
return true;
}
String? _chatOpenId;
/// A chat the user opened from a notification. The tap is the user's own
/// interaction, so the chat it opens is read; a route restored without a tap
/// never sets this.
void requestChatOpen(String sessionId) {
_chatOpenId = sessionId;
notifyListeners();
}
/// Consumes the notification open of [sessionId], once.
bool takeChatOpenIntent(String sessionId) {
if (sessionId.isEmpty || sessionId != _chatOpenId) return false;
_chatOpenId = null;
return true;
}
/// Keep the intent outside the app that selecting another machine disposes.
Future<bool> requestNewChat(String id) async {
if (_busy || _disposed) return false;
+18 -12
View File
@@ -8,6 +8,7 @@ import 'attention_badge.dart';
import 'destination.dart';
import 'list_detail.dart';
import 'navigation_rail.dart';
import 'shell_navigation_bar.dart';
import 'shell_rail_scope.dart';
import 'list_pane_widths.dart';
import 'shell_bar.dart';
@@ -167,7 +168,6 @@ class _AdaptiveShellState extends State<AdaptiveShell> {
// only after the outgoing page has finished its native animation.
// Settings is shown as a page of the Pipelines tab: the tab bar keeps
// Pipelines selected and the bar offers Back to it.
final index = shellTabDestinations.indexOf(shellTabFor(_selected));
final page = !shellTabDestinations.contains(_selected);
final details = destinationDetails(_selected);
final contents = AppDestination.values.map((destination) {
@@ -193,23 +193,29 @@ class _AdaptiveShellState extends State<AdaptiveShell> {
// Only the bar shows the registry's state, so a published bar or badge
// rebuilds its bar alone; the destinations and scaffold stay as built.
_bar.focus = _selected;
// One floating glass tab bar at every width: sized to its tabs at the
// right edge, near the thumb. Content keeps the whole width and scrolls
// behind it, learning the bar's height as its bottom media padding.
// A phone (narrower than the list-detail split) gets a full-width Material
// NavigationBar at the bottom, with Settings as its last destination. Wider
// windows without the rail keep the floating glass tab bar, which the list
// beside an open item needs (see below). Content keeps the whole width and
// scrolls behind the bar, learning its height as its bottom media padding.
// Neither scaffold's structure depends on the width, so resizing never
// remounts a destination.
//
// While the tab shows its list beside an open item the bar moves under
// the leading edge of the list pane, so the open item
// keeps its whole height: the list clears the bar and the item clears
// only the system inset (see ListDetailPanes). The bar keeps its place
// in the tree, so a split never replays its entrance.
// remounts a destination. Pushed detail routes cover the shell, and a
// bar-less spec (a chat workspace) hides the bar.
final phone = !showsListBesideDetail(context);
final bar = ListenableBuilder(
listenable: Listenable.merge([_bar.badges, _bar.bar, _paneWidths]),
builder: (context, _) {
if (_bar.specFor(_selected)?.hideNavigation ?? false) {
return const SizedBox.shrink();
}
if (phone) {
return ShellNavigationBar(
selected: _selected,
icon: (destination) =>
_icon(destination, destinationDetails(destination).icon),
onSelected: _tapDestination,
);
}
// On a wide window the bar stays under the list column even when no
// item is open (Search, a list alone), so it never jumps sides. A page
// (Settings) has no list column, so its bar stays at the right edge.
@@ -221,7 +227,7 @@ class _AdaptiveShellState extends State<AdaptiveShell> {
alignment: AlignmentDirectional.bottomStart,
child: FloatingDestinationBar(
showLabels: true,
currentIndex: index,
currentIndex: shellTabDestinations.indexOf(shellTabFor(_selected)),
onTap: (value) => _tapDestination(shellTabDestinations[value]),
items: _destinationItems(),
alignment: split ? AlignmentDirectional.bottomStart : null,
+64
View File
@@ -0,0 +1,64 @@
import 'package:flutter/material.dart';
import 'destination.dart';
/// The destinations the phone's bottom bar offers, in order: the tabs, then
/// Settings. The rail pins Settings at its foot; a narrow window has no foot,
/// so Settings is the bar's last destination and is selected while it is open.
const List<AppDestination> shellBarDestinations = [
...shellTabDestinations,
AppDestination.settings,
];
/// The phone layout's bottom navigation: a full-width Material
/// [NavigationBar] with an icon and a label per destination, the current
/// destination marked by the bar's indicator.
///
/// [icon] builds each destination's icon (its running, needs-you or unread
/// badge included), the same builder the desktop rail uses, so both layouts
/// show the same counts. [selected] is the shell's destination. A re-tap of
/// the selected destination still calls [onSelected], which is how the shell's
/// destination-reselected hook fires.
///
/// The bar keeps the bottom system inset (gesture bar) clear and leaves while
/// the keyboard is open, so a field's text is never covered by the bar.
class ShellNavigationBar extends StatelessWidget {
const ShellNavigationBar({
super.key,
required this.selected,
required this.icon,
required this.onSelected,
});
final AppDestination selected;
final Widget Function(AppDestination destination) icon;
final ValueChanged<AppDestination> onSelected;
@override
Widget build(BuildContext context) {
// The keyboard takes the bottom of the window: the bar leaves with it.
if (MediaQuery.viewInsetsOf(context).bottom > 0) {
return const SizedBox.shrink();
}
return SafeArea(
top: false,
child: NavigationBar(
key: const ValueKey('shell.navigation-bar'),
selectedIndex: shellBarDestinations.indexOf(selected),
onDestinationSelected: (value) =>
onSelected(shellBarDestinations[value]),
destinations: [
for (final destination in shellBarDestinations)
NavigationDestination(
icon: KeyedSubtree(
key: ValueKey('shell.destination.${destination.name}'),
child: icon(destination),
),
label: destinationDetails(destination).label,
tooltip: destinationDetails(destination).label,
),
],
),
);
}
}
+63
View File
@@ -0,0 +1,63 @@
# Server-authoritative open chat workspace
## Behaviour
The authenticated `/connect` protocol stores one bounded ordered open-chat set
per server scope (`default`). Entries hold only an operator session id and a
floating bit; split ratios, pane ids and window rectangles stay on the device.
* `chat_open_workspace` without `chat_open_workspace_request` reads the set.
With a request it replaces the set as a compare-and-swap on `base_revision`:
a write from a stale base is not applied and the reply carries the current
set with `rejected: true`. Each stored change increments `revision`; an
identical write stores nothing.
* `seed: true` applies only when the server never stored a set (even an
emptied set wins over an old device-local snapshot), so the migration from
the old local layout happens once.
* Stored changes are pushed to every other connection as
`chat_open_workspace_changed`. Pushes run on separate goroutines and can
arrive out of order; clients keep the highest revision.
* Only recorded, not-closed operator chats are kept (registry check; the broker
is not asked, so validation never starts a harness). `chat_close` drops the
chat and pushes the new revision to every connection. A new connection
prunes stale entries and pushes the result to all connections, else sends
the current set to the new connection only (reconnect catch-up).
App (`ChatOpenWorkspaceController`): one write in flight at a time; later
changes coalesce into the newest full set, sent from the revision of the last
reply. Pushes and replies with a lower (or, for pushes, equal) revision are
ignored. A push or a rejected reply wins over unsent local changes. After the
local layout is restored, the device seeds (or, with no chats, reads) and
applies the answer; the first answer keeps a deep-linked chat. Server drops in
a successful reply are not applied locally, so a closed chat can still be read
on the device that opened it, but no other device receives it. Remote
membership is applied with `reconcileChatWorkspaceTree`: removed chats' panes
go, survivors keep pane ids and split sizes and move to follow the order, new
chats split off the last pane. The controller is disposed on a server or
gateway rebind. A federated (all-servers) list keeps its local layout.
Ctrl+Tab: main's behaviour (floating chats when shown, else visible panes) is
kept; the single-pane recent-chat swap is removed there.
## Verification
* Go: `internal/pipeline` `TestChatOpenWorkspace*` (seed once, stale revision,
remove, bounds); `internal/server` `TestChatOpenWorkspaceSyncsEveryConnection`
(two connections get the same snapshot, stale write rejected, reorder,
close pruned and pushed to both, closed chat not restorable) and
`TestChatOpenWorkspacePrunesOnConnectForEveryone`.
* App: `test/features/chat/workspace/chat_open_workspace_controller_test.dart`
(serialized writes, late reply vs newer push, rejected write, dispose),
`chat_workspace_reconcile_test.dart`, and
`test/features/chat/chat_open_workspace_sync_test.dart` (seed migration,
remote removal drops the pane, server set wins over an old local snapshot,
rebind disposes the old sync).
* Live two-client check (2026-11-12): server built from this worktree, run on
an OS-assigned loopback port with a scratch HOME/XDG and database, three
scratch operator rows; a Node script drove two websocket clients through
read, open, reorder, stale write, float, pane close, `chat_close`, write-back
of the closed chat, and an out-of-band close pruned on a third connection.
All 16 checks passed (`RESULT: PASS`); every connection received the same
revisions. The scratch server and its own OpenCode child were stopped.
Not verified: rendered UI captures and on-device behaviour.
@@ -0,0 +1,110 @@
# Chat seen only after a real interaction
A chat's `chat_seen` watermark (which clears its phone notifications on every
device) is now sent only after the user acts in that chat while the app window
is focused. Showing, restoring or receiving a reply in an open chat is no
longer enough.
## Before
- `ChatSessionsScreen` called `markOpened` for the open chat on every list
update and widget change, so a chat left open on one device (the Mac) was
marked seen within about a second.
- Any reply in the open chat scheduled an acknowledgement after a 1.5 s quiet
period, whether or not the user was there.
## After
| State | Seen sent? | Why |
| --- | --- | --- |
| Reply while the window is unfocused / backgrounded | no | `ChatSeenFocus` is not `resumed`; the chat is marked locally unread. |
| Layout restored on start with a chat open | no | The screen only sets the open id; it no longer calls `markOpened`. |
| Open chat, no interaction since, reply arrives | no | Not engaged; reply is marked locally unread. |
| Open chat idle for minutes | no | Same as above; nothing schedules an acknowledgement. |
| Engaged chat, window then unfocused, refocused without input, reply | no | Losing focus clears the engagement. |
| Engaged chat, reply still in its quiet period, then focus lost | no | The pending acknowledgement is cancelled and the reply is marked locally unread at once. |
| Engaged chat, reply still in its quiet period, then another chat opened | no | Same cancel path; the reply stays New. |
| Reply in a chat that is not open | no (New badge) | Unchanged behaviour. |
| Click / tap in the pane | yes | `ChatSeenInteraction` pointer listener. |
| User scroll (drag, wheel) of the transcript | yes | Scroll notifications. Programmatic scroll is ignored. |
| Key press with focus in the pane (typing, Tab) | yes | `Focus.onKeyEvent` on the pane. |
| Keyboard focus moved into the pane by a key press outside it (Tab) | yes | `HardwareKeyboard` flags the key-down; the pane's `Focus.onFocusChange` reports when focus arrives during it. |
| Focus moved into the pane in code, no key press (restore, autofocus) | no | No key-down in progress, so nothing is reported. |
| Opening from the list / shortcut | yes | `markOpened` (unchanged call site, now the only open path). |
| Notification tap that opened the chat | yes | `ServerConnections.requestChatOpen` / `takeChatOpenIntent`. |
| Engaged chat, reply arrives | yes, after 1.5 s quiet | Existing quiet-period ack, now gated on engagement. |
Once the user interacts, the chat is marked seen up to now (the server lifts
it to the registry recency). Repeated interactions in an already-engaged, read
chat send nothing further.
## Where
- `lib/features/chat/ui/sessions/chat_seen_focus.dart`: window focus from the
framework lifecycle (`resumed` = focused).
- `lib/features/chat/ui/sessions/chat_sessions_controller.dart`:
`reportInteraction`, the engagement set (cleared on focus loss or when the
open chat changes), and the passive/active split in the frame path. A reply
waiting in its quiet period is tracked (`_pendingAckId`); focus loss or a
chat change cancels that wait and marks the reply New (`_cancelPendingActiveAck`)
instead of letting the timer drop it silently.
- `lib/features/chat/conversation/chat_seen_interaction.dart`: the region
wrapped around each open conversation pane.
- `lib/features/chat/chat_pane_content.dart`: wraps the pane.
- `lib/features/chat/ui/sessions/chat_sessions_screen.dart`: removed the
passive mark-read on rebuild and restore.
- `lib/features/settings/server_connections.dart` and
`lib/application/pipelines_app.dart`: the notification-open intent.
No server or web change: the server is untouched and still clears app
notifications on the watermark.
## Tests (focused)
- `test/features/chat/ui/sessions/chat_seen_interaction_test.dart` (15 tests):
passive cases (unfocused reply, restored layout, idle open chat,
background then refocus, reply in another chat, reply after leaving an
engaged chat, interaction while unfocused, a reply still in its quiet period
when focus is lost or another chat is opened, and the restored layout through
`ChatSessionsScreen`) and interaction cases (interaction in an unread open
chat, opening from the list, reply after an interaction, repeated
interactions, interaction in a non-open chat).
- `test/features/chat/conversation/chat_seen_interaction_test.dart` (9 tests):
showing the pane, programmatic scroll, and code-driven focus into the pane
report nothing; click, user drag, mouse wheel, key press, Tab from outside
into the pane, and notification open each report.
- Last run: the two focused files above, 24 passed, 0 failed (memwatch PASS,
peak 943 MB, names only the two intended paths). `tool/analyze.sh`: clean.
- Existing suites that touch the list, controller or server connections
(`chat_seen_sync_test`, `chat_active_session_test`, `chat_active_selection_test`,
`chat_sessions_screen_test`, `chat_sessions_lifecycle_test`,
`chat_sessions_activity_test`, `chat_new_session_controller_test`,
`chat_runtime_test`, `chat_floating_pane_test`, `chat_windows_test`,
`chat_color_test`, `chat_star_optimistic_test`, `chat_state_legibility_test`,
`chat_visibility_marker_test`, `chat_add_pane_picker_test`,
`chat_session_local_state_test`, `server_connections_recovery_test`) pass
unchanged, except one expectation (below).
- Land-gate fix: `test/features/chat/ui/sessions/chat_sessions_live_new_test.dart`
"a tool call and reply in the open chat stay read on leaving" failed in the
full `test/features test/shell test/ui test/core` run. The chat was open with
no user interaction, so under the new rule the reply is not seen. The test
was renamed to "...stay New on leaving without interaction" and now expects
the `chat-row-unread` dot and `isUnseen('s1')` after the chat is left. Its
open-chat assertion (no dot while open) is unchanged. This is the one
behaviour change the task asked for; no other expectation changed.
- Focused rerun after that fix: `chat_sessions_live_new_test.dart`,
`conversation/chat_seen_interaction_test.dart`,
`ui/sessions/chat_seen_interaction_test.dart`: 34 passed, 0 failed (memwatch
PASS, peak 1182 MB, names only those three paths). `tool/analyze.sh`: clean.
## Limitations
- Focus is `resumed` only. On web a backgrounded tab reports `hidden` and
should count as unfocused; an unfocused window with no lifecycle change is
not detected there. Verify on the device or in the browser.
- Only the chat-question notification path (`ChatQuestionNotices`) is wired as
a notification open. Run-level notifications do not name a chat.
- Interactions are reported at the pane level. A chat in a floating window
uses the same pane content, so it is covered, but this was not exercised on
a device.
- No browser or device capture was taken (ui-review owns that).
+75
View File
@@ -0,0 +1,75 @@
# Composer running state: border, Escape stop, tasks spinner
## Changes
- **Stop button removed.** The composer no longer shows a Stop control while a
turn runs; Send stays as before (queued/steered prompts unchanged).
`chat_stop_icon.dart` and its test are deleted (their only user was the button).
- **Running border.** `composer_running_border.dart` draws a sweep highlight
(theme primary = chat focus accent, tertiary) once around the pill's rounded
edge, 4 s per lap, with a faint blur glow. Mounted only while `running`, so
disposal stops the ticker when the turn ends. Reduced motion
(`MediaQuery.disableAnimations`) draws a static highlighted border and never ticks.
- **Escape stop.** `chat_escape_stop.dart` wraps the conversation column in
`chat_thread_view.dart`. Two plain Escape presses within 1 s stop a running turn
(`composer.stop()`); the first shows the snackbar "Press Esc again to stop".
Escape is consumed only while running; a descendant that handles Escape first
(command palette, notice) never counts. Held Escape counts as one press.
- **`/stop`.** Already existed (`chat_commands.dart`); unchanged. Typing `/stop`
and sending runs it on the first send. A partial word (`/sto`) still
completes the palette row first (`_paletteCompletes`).
- **More menu Stop.** `chat_thread_view.dart` adds a `Stop` item to the header's
More menu while a turn runs (`key chat-thread-stop-menu`). It is shown on every
platform, so touch devices without a keyboard can stop.
- **Tasks spinner.** `chat_task_spinner.dart` turns the layers icon once per
2.5 s while at least one background task runs; static otherwise and under
reduced motion. Automation-only state keeps its static schedule icon.
## Focused tests (memwatch, from app/)
| Run | Paths | Result |
|---|---|---|
| 1 | `chat_escape_stop_test`, `chat_task_spinner_test`, `chat_composer_running_test`, `chat_thread_stop_menu_test`, `chat_composer_bar_state_test`, `chat_command_palette_test` | PASS 46/46 |
| 2 | Affected users: `chat_background_tasks_*` (4), `chat_thread_view_test`, `chat_thread_header_test`, `chat_composer_*` (bar, focus ring, enter, paste, attachment send, bottom margin), `chat_busy_resume`, `chat_response_pending`, `chat_live_reasoning`, `chat_floating_chrome`, `chat_server_queue`, `chat_delivery`, `composer_focus_restore`, `chat_unfocused_paste_routing`, `chat_floating_pane`, `chat_next_chat`, `chat_shell_composer`, `glass_bar` | PASS 169/169 |
`tool/analyze.sh` (whole app): clean, exit 0.
## Land-gate fix (visit 2)
`chat_permission_card_test.dart`: "a turn waiting on a pending card hides the
running indicator but keeps Stop" asserted a `Stop` tooltip on the composer,
which this change removes by design. It now asserts no `chat-composer-stop`
and that Stop is in the More menu, before and after the permission resolves.
Expectations for behaviour this change did not touch are unchanged.
| Run | Paths | Result |
|---|---|---|
| 3 | `chat_permission_card_test`, `chat_thread_stop_menu_test` | PASS 15/15 |
| 4 | all six focused paths above (escape, spinner, running, stop menu, bar state, permission card) | PASS 44/44 |
`tool/analyze.sh`: clean, exit 0.
## Affected states (widget tests)
- Running: no `chat-composer-stop`; Send present; border present; no interrupt sent.
- Turn ended: border gone; no animation ticker left.
- Reduced motion while running: border present, zero tickers.
- `/stop` (one send) interrupts; the notice shows.
- Esc once: hint shown, no interrupt. Esc twice (within 1 s): one interrupt.
Esc idle: nothing. Esc with palette open: palette closes and does not count.
- Transcript-level focus: Esc twice stops (`ChatEscapeStop` unit test). A
descendant-handled Esc never counts.
- More menu: Stop present while running and triggers the interrupt; absent when idle.
- Tasks icon: spins while a task runs; static at rest; reduced motion never turns.
## Limitations
- Not captured or reviewed visually (ui-review owns that). The border's colours
and glow strength in light and dark are unverified by eye.
- Escape stop is verified with synthetic key events in widget tests, not on a
physical keyboard or a device. Touch devices are covered by the More menu item
only; no device was tested.
- The More menu Stop item is shown on every platform while running, not only on
touch devices.
- A partial command word (`/sto`) still needs two sends (palette completes, then
runs); a fully typed `/stop` runs on one send.
+94
View File
@@ -0,0 +1,94 @@
# Phone bottom navigation bar
Replaces the floating round destination pill on phone-width windows (narrower
than the 600 px list-detail split) with a full-width Material 3 `NavigationBar`:
Pipelines, Runs, Chat, Search, Settings, each with icon, label and the rail's
badges. Wider windows keep the floating bar (the list beside an open item needs
it) and the rail keeps its existing layout.
## Changed paths
- `app/lib/shell/shell_navigation_bar.dart` (new): `ShellNavigationBar`, the
phone bar. Reuses `destinationDetails`, `shellTabDestinations` and the shell's
badge icon builder. Settings is its fifth destination. Wrapped in `SafeArea`
(bottom only). Returns nothing while the keyboard is open
(`viewInsets.bottom > 0`).
- `app/lib/shell/adaptive_shell.dart`: phone path uses the new bar; the floating
bar stays for wider non-rail windows; `hideNavigation` specs still hide the bar.
Pushed detail routes already cover the shell, so the bar stays hidden there.
- Tests: `test/shell/shell_navigation_bar_test.dart` (new, 7 cases),
`test/shell/shell_bar_test.dart`, `test/shell/floating_tab_bar_test.dart`,
`test/shell/attention_badge_test.dart`, `test/shell/navigation_rail_test.dart`,
`test/shell/split_destination_bar_test.dart`,
`test/application/settings_page_test.dart`, `test/widget_test.dart`,
`test/perf/background_work_bench_test.dart` (counts `ShellNavigationBar`
rebuilds now, since the pill is no longer built on phones).
## Behaviour decisions
- Re-tap: `ShellNavigationBar` calls `onSelected` on every tap, including the
shown destination, so `AdaptiveShell._select` (and its `onDestinationSelected`
callback) fires on re-tap. Run 404's hook is not in this branch; nothing to
rename.
- Settings selected: the bar marks Settings (index 4) while the Settings page is
open. The Pipelines gear stays in the Pipelines toolbar.
- Keyboard: the bar leaves whenever the keyboard is open on a phone, not only in
chat. Chat on phone already hides it through its workspace `hideNavigation`.
## Focused results
Command: `tool/memwatch/full.sh` with one quoted path list (new shell test, the
shell and application users of the bar, `widget_test`, two features/chat files,
perf bench). The verdict line named only those paths.
- Final run: 129 passed, 2 failed. Both failures are
`test/application/search_wiring_test.dart` ("field and artifact hits select
their run detail selection", "an abandoned selection does not replay on run
reopen"). They also fail on an untouched base worktree (HEAD 9bb87e51, detached
temporary worktree, removed afterwards), with the same `ok` EditableText
assertion. They are pre-existing and unrelated to the bar.
- New file alone: `shell_navigation_bar_test.dart` 7/7 passed.
- `tool/analyze.sh`: clean (0 errors, 0 warnings, 0 infos) after the final edits.
## Affected UI states (not captured here)
- Phone (390 px) bar, each of Pipelines, Runs, Chat, Search, Settings selected:
covered by widget tests for selection, not rendered.
- Badges: running count on Runs, unread on Chat (widget tests).
- Keyboard open: bar absent (widget test).
- Pushed detail route: bar absent (existing test, `shell_bar_test.dart`).
- Chat workspace: bar absent (existing `hideNavigation`).
- Light and dark captures: NOT produced. Capture belongs to ui-review.
## Limitations
- No device or browser verification of the bar. Its metrics (80 dp `NavigationBar`
height, SafeArea) and the gesture-inset clearance are verified only in widget
tests with the padding faked.
- Settings-as-destination on the phone bar is new behaviour; the Pipelines gear
is still present.
- Medium widths (600 px to the rail threshold) keep the floating pill, by design.
## Land-gate fix (visit 2)
- Failure: `test/ui/adaptive/floating_tab_motion_test.dart` ("switching the shell
tabs never replays the main bar's entrance") ran the shell at 560 px, which is a
phone now and shows the `NavigationBar`, so no `GlassPill` existed (`StateError:
No element`).
- Fix (test only): that one test now sets a 640 px window, above the 600 px split
and below the rail threshold, so it still exercises the floating bar it covers.
No expectation changed; the other six tests in the file are untouched.
- Focused result: `tool/memwatch/full.sh 'test/ui/adaptive/floating_tab_motion_test.dart'`
→ PASS 7 passed, 0 failed (verdict named only that path).
- `tool/analyze.sh`: clean.
- The full gate suite was not re-run here (the land stage runs it).
## Review fix (implement visit 3): run detail hides the phone bar
- Failure: on a phone, a run detail (loaded, and the loading/failed placeholder)
still showed the `NavigationBar`, because both `ShellBar`s in
`lib/features/runs/ui/run_detail_view.dart` lacked `hideNavigation`.
- Fix: `hideNavigation: true` on the detail `ShellBar` and on the placeholder
`ShellBar`. Nothing else changed.
- Regression test: new `test/features/runs/ui/run_detail_phone_navigation_test.dart`
mounts `RunDetailView` in `AdaptiveShell` at 390×844. It asserts no
`NavigationBar` for the loaded detail and for the placeholder, and keeps a
control that the runs list still shows the bar.
- Negative check: with the two `hideNavigation` lines removed, the two detail
tests fail and the control passes; the fix was then restored.
- Focused result: `tool/memwatch/full.sh 'test/features/runs/ui/run_detail_phone_navigation_test.dart test/features/runs/ui/run_detail_widget_test.dart'`
→ PASS 5 passed, 0 failed (verdict named only those two paths).
- `tool/analyze.sh`: clean.
- Not captured here (ui-review owns captures).
+12 -12
View File
@@ -46,9 +46,9 @@ void main() {
return provider;
}
int selectedTab(WidgetTester tester) => tester
.widget<FloatingDestinationBar>(find.byType(FloatingDestinationBar))
.currentIndex;
// The phone's bar marks the destination shown: Settings while it is open.
int selectedTab(WidgetTester tester) =>
tester.widget<NavigationBar>(find.byType(NavigationBar)).selectedIndex;
// A phone's Pipelines bar keeps the gear; a wide window's rail offers
// Settings instead (see the wide test below).
@@ -60,17 +60,17 @@ void main() {
location: '/pipelines',
size: size,
);
// Four tabs; Settings is none of them.
// Four tabs and Settings as the bar's last destination.
expect(
tester
.widget<FloatingDestinationBar>(find.byType(FloatingDestinationBar))
.items
.map((item) => item.label),
['Pipelines', 'Runs', 'Chat', 'Search'],
.widget<NavigationBar>(find.byType(NavigationBar))
.destinations
.map((item) => (item as NavigationDestination).label),
['Pipelines', 'Runs', 'Chat', 'Search', 'Settings'],
);
expect(
find.byKey(const ValueKey('shell.destination.settings')),
findsNothing,
findsOneWidget,
);
expect(find.byKey(const ValueKey('shell.back')), findsNothing);
@@ -86,10 +86,10 @@ void main() {
expect(find.text('Quick switch animation'), findsOneWidget);
await selectSettingsTopic(tester, 'Connection');
expect(find.text('Server URL'), findsOneWidget);
// A page of Pipelines: Back in its bar, Pipelines still selected.
// A page of Pipelines: Back in its bar, Settings selected in the bar.
expect(find.byKey(const ValueKey('shell.back')), findsOneWidget);
expect(find.byKey(const ValueKey('shell.search')), findsNothing);
expect(selectedTab(tester), 0);
expect(selectedTab(tester), 4);
expect(tester.takeException(), isNull);
await tester.tap(find.byKey(const ValueKey('shell.back')));
@@ -164,7 +164,7 @@ void main() {
await tester.pump();
expect(find.byType(SettingsScreen), findsOneWidget);
expect(find.byKey(const ValueKey('shell.back')), findsOneWidget);
expect(selectedTab(tester), 0);
expect(selectedTab(tester), 4);
final handled = await tester.binding.handlePopRoute();
expect(handled, isTrue, reason: 'Back closes the page, not the app');
@@ -0,0 +1,205 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/core/servers/server_scope.dart';
import 'package:pipelines_app/features/chat/screen.dart';
import 'package:pipelines_app/features/chat/workspace/chat_workspace.dart';
import 'package:pipelines_app/features/chat/workspace/chat_workspace_store.dart';
import 'package:pipelines_app/shell/adaptive_shell.dart';
import 'package:pipelines_app/shell/destination.dart';
import 'conversation/chat_thread_fixtures.dart';
/// A chat server that keeps the open-chat set with the real revision rules:
/// a seed applies only to a never-stored set, a write from a stale base is
/// refused with the current set.
class _Server extends FakeChatGateway {
_Server({this.revision = 0, List<String> open = const []})
: open = List.of(open);
int revision;
List<String> open;
final writes = <List<String>>[];
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) {
if (type == 'chat_sessions') {
return Future.value({
'chat_sessions': [
for (final id in ['a', 'b', 'c', 'd'])
{'id': id, 'title': 'Chat $id'},
],
});
}
if (type == 'chat_shells') return Future.value({'chat_shells': []});
if (type == 'chat_open_workspace') return Future.value(_workspace(fields));
return super.call(type, fields);
}
JsonMap _workspace(JsonMap fields) {
final request = fields['chat_open_workspace_request'] as Map?;
var rejected = false;
if (request != null) {
final ids = [
for (final entry in request['entries'] as List)
'${entry['session_id']}',
];
writes.add(ids);
if (request['seed'] == true) {
if (revision == 0) {
open = ids;
revision = 1;
}
} else if (request['base_revision'] != revision) {
rejected = true;
} else {
open = ids;
revision++;
}
}
return {
'type': 'chat_open_workspace',
'chat_open_workspace': _body(rejected),
};
}
JsonMap _body([bool rejected = false]) => {
'revision': revision,
'entries': [
for (final id in open) {'session_id': id},
],
if (rejected) 'rejected': true,
};
/// Another device (or the server) changed the set.
void change(List<String> ids) {
open = List.of(ids);
revision++;
emitRaw({
'type': 'chat_open_workspace_changed',
'chat_open_workspace': _body(),
});
}
}
ChatWorkspaceController _workspace(WidgetTester tester) =>
tester.widget<ChatWorkspace>(find.byType(ChatWorkspace)).controller;
List<String> _open(WidgetTester tester) =>
_workspace(tester).panes.map((pane) => pane.sessionId).toList();
Future<void> _mount(WidgetTester tester, _Server server) async {
await tester.pumpWidget(
MaterialApp(
home: AdaptiveShell(
destination: AppDestination.chat,
destinationBodies: {
AppDestination.chat: (_) =>
ChatScreen(gateway: server, persistWorkspace: true),
},
),
),
);
await tester.pumpAndSettle();
}
_Server _server(
String identity, {
int revision = 0,
List<String> open = const [],
}) {
final server = _Server(revision: revision, open: open)
..history = (_) async => chatPage([]);
bindServerIdentity(server, identity);
addTearDown(server.close);
return server;
}
void _saveLocal(String identity, List<String> ids) {
final saved = ChatWorkspaceController()..open(ids.first);
for (final id in ids.skip(1)) {
saved.splitActive(id, ChatSplitAxis.horizontal);
}
SharedPreferences.setMockInitialValues({
scopedServerKey(chatWorkspacePreferenceKey, identity): saved
.snapshot()!
.encode(),
});
}
void main() {
testWidgets(
'the local layout seeds a new server and remote removal drops its pane',
(tester) async {
tester.view.physicalSize = const Size(1800, 1000);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
_saveLocal('server-a', ['a', 'b']);
final server = _server('server-a');
await _mount(tester, server);
expect(server.revision, 1);
expect(server.open, ['a', 'b']);
expect(_open(tester), ['a', 'b']);
server.change(['b']);
await tester.pumpAndSettle();
expect(_open(tester), ['b']);
// Applying the server's change is not written back.
expect(server.writes, hasLength(1));
await tester.pumpWidget(const SizedBox.shrink());
await tester.pumpAndSettle();
},
);
testWidgets('an existing server set wins over an old local snapshot', (
tester,
) async {
tester.view.physicalSize = const Size(1800, 1000);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
_saveLocal('server-a', ['a']);
final server = _server('server-a', revision: 3, open: ['b', 'c']);
await _mount(tester, server);
expect(_open(tester), ['b', 'c']);
expect(server.open, ['b', 'c']);
expect(server.revision, 3);
// A local change is sent from the server's revision and accepted.
_workspace(tester).close(_workspace(tester).panes.first.id);
await tester.pumpAndSettle();
expect(server.open, ['c']);
expect(server.revision, 4);
await tester.pumpWidget(const SizedBox.shrink());
await tester.pumpAndSettle();
});
testWidgets('rebinding to another server disposes the old sync', (
tester,
) async {
tester.view.physicalSize = const Size(1800, 1000);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
SharedPreferences.setMockInitialValues({});
final first = _server('server-a', revision: 1, open: ['a']);
final second = _server('server-b', revision: 1, open: ['c']);
await _mount(tester, first);
expect(_open(tester), ['a']);
await _mount(tester, second);
expect(_open(tester), ['c']);
// The old server's pushes no longer reach this screen.
first.change(['a', 'b', 'd']);
await tester.pumpAndSettle();
expect(_open(tester), ['c']);
// The new server's do, and local changes go only to it.
second.change(['c', 'd']);
await tester.pumpAndSettle();
expect(_open(tester), ['c', 'd']);
final firstWrites = first.writes.length;
_workspace(tester).close(_workspace(tester).panes.last.id);
await tester.pumpAndSettle();
expect(second.open, ['c']);
expect(first.writes, hasLength(firstWrites));
await tester.pumpWidget(const SizedBox.shrink());
await tester.pumpAndSettle();
});
}
@@ -22,7 +22,7 @@ void main() {
tearDown(() => gateway.close());
testWidgets(
'Stop stays beside Send while running and interrupts this session',
'a running turn shows no stop button; Send stays and nothing interrupts',
(tester) async {
await tester.pumpWidget(
composerThread(gateway, newOperationId: nextOperation),
@@ -35,18 +35,9 @@ void main() {
await tester.pump();
expect(find.byTooltip(chatSendLabel), findsOneWidget);
expect(find.byTooltip(chatStopLabel), findsOneWidget);
final button = tester.widget<IconButton>(
find.byKey(const Key('chat-composer-stop')),
);
final scheme = Theme.of(
tester.element(find.byKey(const Key('chat-composer-stop'))),
).colorScheme;
expect(button.style?.backgroundColor?.resolve({}), scheme.error);
await tester.tap(find.byKey(const Key('chat-composer-stop')));
await tester.pumpAndSettle();
expect(gateway.interruptBodies.single, {'session_id': 's'});
expect(find.byKey(const Key('chat-composer-stop')), findsNothing);
expect(find.byTooltip(chatStopLabel), findsNothing);
expect(gateway.interruptBodies, isEmpty);
expect(gateway.promptBodies, isEmpty);
},
);
@@ -190,7 +181,7 @@ void main() {
reply.complete({'chat_queued': true});
await tester.pumpAndSettle();
expect(fieldText(tester), 'Newer draft');
expect(find.byKey(const Key('chat-composer-stop')), findsOneWidget);
expect(find.byKey(const Key('chat-composer-stop')), findsNothing);
expect(gateway.interruptBodies, isEmpty);
},
);
@@ -213,7 +204,7 @@ void main() {
text,
);
await tester.pump();
expect(find.byKey(const Key('chat-composer-stop')), findsOneWidget);
expect(find.byKey(const Key('chat-composer-stop')), findsNothing);
await tester.tap(find.byKey(const Key('chat-composer-primary')));
await tester.pumpAndSettle();
expect(fieldText(tester), '');
@@ -228,7 +219,7 @@ void main() {
'op/2',
]);
expect(gateway.interruptBodies, isEmpty);
expect(find.byKey(const Key('chat-composer-stop')), findsOneWidget);
expect(find.byKey(const Key('chat-composer-stop')), findsNothing);
});
testWidgets('the composer wraps at 320 logical px with 2x text', (
@@ -267,6 +258,6 @@ void main() {
expect(tester.takeException(), isNull);
expect(find.byKey(const Key('chat-composer')), findsOneWidget);
expect(find.byKey(const Key('chat-composer-primary')), findsOneWidget);
expect(find.byKey(const Key('chat-composer-stop')), findsOneWidget);
expect(find.byKey(const Key('chat-composer-stop')), findsNothing);
});
}
@@ -0,0 +1,161 @@
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/conversation/chat_command_palette.dart';
import 'package:pipelines_app/features/chat/conversation/chat_composer_bar.dart';
import 'package:pipelines_app/features/chat/conversation/chat_escape_stop.dart';
import 'chat_composer_bar_fixtures.dart';
import 'chat_thread_fixtures.dart';
Finder get _border => find.byKey(const Key('chat-composer-running-border'));
Future<ComposerBarGateway> _pumpThread(WidgetTester tester) async {
final gateway = ComposerBarGateway()..page = fixtureTurn();
addTearDown(gateway.close);
await tester.pumpWidget(
composerThread(gateway, newOperationId: () => 'op/1'),
);
await tester.pumpAndSettle();
return gateway;
}
/// Starts a turn. The border repeats for as long as it runs, so the test
/// settles by pumping a frame, never by waiting for the tree to go quiet.
Future<void> _startTurn(WidgetTester tester, ComposerBarGateway gateway) async {
gateway.emitEvent(chatStepFrame('running'));
await tester.pump();
await tester.pump();
}
Future<void> _endTurn(WidgetTester tester, ComposerBarGateway gateway) async {
gateway.emitEvent(chatStepFrame('ended'));
await tester.pump();
await tester.pump();
}
void _reducedMotion(bool reduced) =>
TestWidgetsFlutterBinding.ensureInitialized()
.platformDispatcher
.accessibilityFeaturesTestValue = FakeAccessibilityFeatures(
disableAnimations: reduced,
);
void main() {
tearDown(() => _reducedMotion(false));
testWidgets('the border travels while a turn runs and is gone after it', (
tester,
) async {
_reducedMotion(false);
final gateway = await _pumpThread(tester);
expect(_border, findsNothing);
await _startTurn(tester, gateway);
expect(_border, findsOneWidget);
expect(tester.binding.transientCallbackCount, greaterThan(0));
await _endTurn(tester, gateway);
expect(_border, findsNothing);
expect(tester.binding.transientCallbackCount, 0);
});
testWidgets('reduced motion draws the static border and never ticks', (
tester,
) async {
_reducedMotion(true);
final gateway = await _pumpThread(tester);
await _startTurn(tester, gateway);
expect(_border, findsOneWidget);
expect(tester.binding.transientCallbackCount, 0);
await tester.pump(const Duration(seconds: 2));
expect(tester.binding.transientCallbackCount, 0);
});
testWidgets('no stop button appears while a turn runs', (tester) async {
final gateway = await _pumpThread(tester);
await _startTurn(tester, gateway);
expect(find.byKey(const Key('chat-composer-stop')), findsNothing);
expect(find.byKey(const Key('chat-composer-primary')), findsOneWidget);
});
testWidgets('/stop sent in the composer stops the running turn', (
tester,
) async {
final gateway = await _pumpThread(tester);
await _startTurn(tester, gateway);
await tester.enterText(
find.byKey(const Key('chat-composer-field')),
'/stop',
);
await tester.pump();
// A draft that already names /stop runs on the first send.
await tester.tap(find.byKey(const Key('chat-composer-primary')));
await tester.pump();
await tester.pump();
expect(gateway.interruptBodies, [
{'session_id': 's'},
]);
expect(gateway.promptBodies, isEmpty);
expect(find.text(chatStopCommandNotice), findsOneWidget);
});
testWidgets('two Escapes from the composer stop the turn', (tester) async {
final gateway = await _pumpThread(tester);
await _startTurn(tester, gateway);
await tester.tap(find.byKey(const Key('chat-composer-field')));
await tester.pump();
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(gateway.interruptBodies, isEmpty);
expect(find.text(chatEscapeStopHint), findsOneWidget);
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
await tester.pump();
expect(gateway.interruptBodies, [
{'session_id': 's'},
]);
});
testWidgets('a single Escape does not stop the turn', (tester) async {
final gateway = await _pumpThread(tester);
await _startTurn(tester, gateway);
await tester.tap(find.byKey(const Key('chat-composer-field')));
await tester.pump();
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
await tester.pump(const Duration(seconds: 2));
expect(gateway.interruptBodies, isEmpty);
});
testWidgets('Escape closes the command palette first and does not count', (
tester,
) async {
final gateway = await _pumpThread(tester);
await _startTurn(tester, gateway);
await tester.enterText(find.byKey(const Key('chat-composer-field')), '/');
await tester.pump();
expect(find.byType(ChatCommandPalette), findsOneWidget);
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(find.byType(ChatCommandPalette), findsNothing);
expect(gateway.interruptBodies, isEmpty);
// The palette's Escape was not the first of a pair; this one is.
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(gateway.interruptBodies, isEmpty);
});
testWidgets('Escape does nothing while no turn runs', (tester) async {
final gateway = await _pumpThread(tester);
await tester.tap(find.byKey(const Key('chat-composer-field')));
await tester.pump();
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(gateway.interruptBodies, isEmpty);
expect(find.text(chatEscapeStopHint), findsNothing);
});
}
@@ -0,0 +1,169 @@
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/conversation/chat_escape_stop.dart';
void main() {
group('ChatEscapeStopTracker', () {
test('a second press inside the window completes a pair', () {
final tracker = ChatEscapeStopTracker();
final start = DateTime(2026, 11, 12, 10);
expect(tracker.press(start), isFalse);
expect(
tracker.press(start.add(const Duration(milliseconds: 900))),
isTrue,
);
});
test('a press after the window starts a new pair', () {
final tracker = ChatEscapeStopTracker();
final start = DateTime(2026, 11, 12, 10);
expect(tracker.press(start), isFalse);
expect(tracker.press(start.add(const Duration(seconds: 2))), isFalse);
expect(
tracker.press(start.add(const Duration(seconds: 2, milliseconds: 500))),
isTrue,
);
});
test('reset forgets a pending first press', () {
final tracker = ChatEscapeStopTracker();
final start = DateTime(2026, 11, 12, 10);
tracker.press(start);
tracker.reset();
expect(
tracker.press(start.add(const Duration(milliseconds: 100))),
isFalse,
);
});
});
group('ChatEscapeStop', () {
late DateTime now;
late int stops;
setUp(() {
now = DateTime(2026, 11, 12, 10);
stops = 0;
});
Widget host({required bool running, Widget? child}) => MaterialApp(
home: Scaffold(
body: ChatEscapeStop(
running: running,
onStop: () => stops++,
clock: () => now,
child: child ?? const TextField(key: Key('field')),
),
),
);
testWidgets('a single Escape shows the hint and does not stop', (
tester,
) async {
await tester.pumpWidget(host(running: true));
await tester.tap(find.byKey(const Key('field')));
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(stops, 0);
expect(find.text(chatEscapeStopHint), findsOneWidget);
});
testWidgets('two Escapes within a second stop the turn once', (
tester,
) async {
await tester.pumpWidget(host(running: true));
await tester.tap(find.byKey(const Key('field')));
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
now = now.add(const Duration(milliseconds: 400));
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(stops, 1);
expect(find.text(chatEscapeStopHint), findsNothing);
});
testWidgets('two Escapes more than a second apart do not stop', (
tester,
) async {
await tester.pumpWidget(host(running: true));
await tester.tap(find.byKey(const Key('field')));
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
now = now.add(const Duration(milliseconds: 1500));
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(stops, 0);
});
testWidgets('an idle chat ignores Escape', (tester) async {
await tester.pumpWidget(host(running: false));
await tester.tap(find.byKey(const Key('field')));
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(stops, 0);
expect(find.text(chatEscapeStopHint), findsNothing);
});
testWidgets('focus on the transcript counts the same as the composer', (
tester,
) async {
await tester.pumpWidget(
host(
running: true,
child: const Focus(
autofocus: true,
child: SizedBox(width: 10, height: 10),
),
),
);
await tester.pump();
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(stops, 1);
});
testWidgets('an Escape a descendant already handled never counts', (
tester,
) async {
await tester.pumpWidget(
host(
running: true,
child: Focus(
autofocus: true,
onKeyEvent: (_, event) =>
event.logicalKey == LogicalKeyboardKey.escape
? KeyEventResult.handled
: KeyEventResult.ignored,
child: const SizedBox(width: 10, height: 10),
),
),
);
await tester.pump();
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(stops, 0);
expect(find.text(chatEscapeStopHint), findsNothing);
});
testWidgets('a held Escape is one press, not a pair', (tester) async {
await tester.pumpWidget(
host(
running: true,
child: const Focus(
autofocus: true,
child: SizedBox(width: 10, height: 10),
),
),
);
await tester.pump();
await tester.sendKeyDownEvent(LogicalKeyboardKey.escape);
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.escape);
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.escape);
await tester.sendKeyUpEvent(LogicalKeyboardKey.escape);
await tester.pump();
expect(stops, 0);
});
});
}
@@ -38,6 +38,15 @@ JsonMap permission({
if (decision.isNotEmpty) 'decision': decision,
};
Future<void> expectStopInMoreMenu(WidgetTester tester) async {
await tester.tap(find.byTooltip('More actions').hitTestable().first);
await tester.pumpAndSettle();
expect(find.text('Stop'), findsOneWidget);
await tester.tapAt(const Offset(1, 1));
await tester.pumpAndSettle();
expect(find.text('Stop'), findsNothing);
}
void main() {
test('recorded action, risk and options survive the card model', () {
final card = chatPermissionCard(permission(), '')!;
@@ -331,7 +340,8 @@ void main() {
await tester.pumpAndSettle();
expect(find.text('Approve bash'), findsOneWidget);
expect(find.byTooltip('Stop'), findsOneWidget);
expect(find.byKey(const Key('chat-composer-stop')), findsNothing);
await expectStopInMoreMenu(tester);
gateway.emitRaw({
'type': 'chat_permission',
@@ -339,9 +349,10 @@ void main() {
});
await tester.pumpAndSettle();
// No filler line while the turn runs; Stop is the running signal.
// No filler line while the turn runs; the More menu keeps Stop reachable.
expect(find.byKey(const Key('chat-running')), findsNothing);
expect(find.byTooltip('Stop'), findsOneWidget);
expect(find.byKey(const Key('chat-composer-stop')), findsNothing);
await expectStopInMoreMenu(tester);
});
testWidgets('consecutive Material cards stay separate surfaces', (
@@ -0,0 +1,220 @@
import 'package:flutter/gestures.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/servers/server_catalog.dart';
import 'package:pipelines_app/core/servers/server_catalog_store.dart';
import 'package:pipelines_app/core/servers/server_context.dart';
import 'package:pipelines_app/features/chat/conversation/chat_seen_interaction.dart';
import 'package:pipelines_app/features/settings/server_connections.dart';
/// One open chat's pane: a field and a long transcript, both inside the region.
Widget _pane({
required VoidCallback onInteract,
ScrollController? scroll,
FocusNode? focus,
}) => MaterialApp(
home: Scaffold(
body: ChatSeenInteraction(
sessionId: 'ses_a',
onInteract: onInteract,
child: Column(
children: [
TextField(focusNode: focus),
Expanded(
child: ListView.builder(
controller: scroll,
itemCount: 200,
itemBuilder: (context, index) =>
SizedBox(height: 40, child: Text('row $index')),
),
),
],
),
),
),
);
void main() {
testWidgets('showing the pane reports nothing', (tester) async {
var count = 0;
await tester.pumpWidget(_pane(onInteract: () => count++));
await tester.pump();
await tester.pump(const Duration(seconds: 2));
expect(count, 0);
});
testWidgets('a programmatic scroll reports nothing', (tester) async {
var count = 0;
final scroll = ScrollController();
addTearDown(scroll.dispose);
await tester.pumpWidget(_pane(onInteract: () => count++, scroll: scroll));
scroll.jumpTo(600);
await tester.pump();
expect(count, 0);
});
testWidgets('a click or tap in the pane reports once per press', (
tester,
) async {
var count = 0;
await tester.pumpWidget(_pane(onInteract: () => count++));
await tester.tap(find.text('row 3'));
await tester.pump();
expect(count, greaterThanOrEqualTo(1));
});
testWidgets('a user drag of the transcript reports', (tester) async {
var count = 0;
await tester.pumpWidget(_pane(onInteract: () => count++));
await tester.drag(find.text('row 0'), const Offset(0, -300));
await tester.pumpAndSettle();
expect(count, greaterThanOrEqualTo(1));
});
testWidgets('a mouse-wheel scroll of the transcript reports', (tester) async {
var count = 0;
final scroll = ScrollController();
addTearDown(scroll.dispose);
await tester.pumpWidget(_pane(onInteract: () => count++, scroll: scroll));
final pointer = TestPointer(1, PointerDeviceKind.mouse);
await tester.sendEventToBinding(
pointer.hover(tester.getCenter(find.text('row 0'))),
);
await tester.sendEventToBinding(pointer.scroll(const Offset(0, 200)));
await tester.pumpAndSettle();
expect(scroll.offset, greaterThan(0));
expect(count, greaterThanOrEqualTo(1));
});
testWidgets('a key press while focus is in the pane reports, with no click', (
tester,
) async {
var count = 0;
final focus = FocusNode();
addTearDown(focus.dispose);
await tester.pumpWidget(_pane(onInteract: () => count++, focus: focus));
await tester.sendKeyEvent(LogicalKeyboardKey.keyA);
await tester.pump();
expect(count, 0, reason: 'a key with no focus in the pane is not its input');
focus.requestFocus();
await tester.pump();
await tester.sendKeyEvent(LogicalKeyboardKey.keyA);
await tester.pump();
expect(count, 1);
});
testWidgets('code-driven focus into the pane reports nothing', (tester) async {
var count = 0;
final focus = FocusNode();
addTearDown(focus.dispose);
await tester.pumpWidget(_pane(onInteract: () => count++, focus: focus));
focus.requestFocus();
await tester.pump();
await tester.pump(const Duration(seconds: 1));
expect(focus.hasFocus, isTrue);
expect(count, 0, reason: 'focus moved in code, with no key press, is passive');
});
testWidgets('Tab from outside the pane into it reports once', (tester) async {
var count = 0;
final outside = FocusNode();
final focus = FocusNode();
addTearDown(outside.dispose);
addTearDown(focus.dispose);
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: Column(
children: [
TextField(focusNode: outside),
Expanded(
child: ChatSeenInteraction(
sessionId: 'ses_a',
onInteract: () => count++,
child: Column(
children: [
TextField(focusNode: focus),
const Expanded(child: SizedBox()),
],
),
),
),
],
),
),
),
);
outside.requestFocus();
await tester.pump();
await tester.sendKeyEvent(LogicalKeyboardKey.tab);
await tester.pump();
expect(focus.hasFocus, isTrue, reason: 'Tab moved focus into the pane');
expect(count, 1);
});
testWidgets('a notification tap that opened this chat reports once', (
tester,
) async {
var count = 0;
final connections = ServerConnections(
store: MemoryServerCatalogStore(
catalog: ServerCatalog(
servers: [
SavedServer.validated(
id: 'mac',
name: 'Mac',
endpoints: const ['ws://mac.test/connect'],
),
],
selectedId: 'mac',
),
),
onSelected: (_) async {},
);
addTearDown(connections.dispose);
await connections.load();
await tester.pumpWidget(
ServerContext(
connections: connections,
serverId: 'mac',
child: _pane(onInteract: () => count++),
),
);
await tester.pump();
expect(count, 0);
// Another chat's notification is not this pane's open.
connections.requestChatOpen('ses_other');
await tester.pump();
await tester.pump();
expect(count, 0);
connections.requestChatOpen('ses_a');
await tester.pump();
await tester.pump();
expect(count, 1);
// The tap is consumed: a later rebuild does not report it again.
connections.requestChatOpen('ses_other');
await tester.pump();
await tester.pump();
expect(count, 1);
});
}
@@ -1,174 +0,0 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/conversation/chat_stop_icon.dart';
import 'package:pipelines_app/features/chat/conversation/chat_composer_bar.dart';
import 'package:pipelines_app/features/chat/conversation/chat_composer_controller.dart';
import 'package:pipelines_app/features/chat/conversation/chat_draft_store.dart';
import 'package:pipelines_app/ui/motion/motion.dart';
import 'chat_composer_bar_fixtures.dart';
class _CountPaint extends CustomPainter {
_CountPaint(this.onPaint);
final VoidCallback onPaint;
@override
void paint(Canvas canvas, Size size) => onPaint();
@override
bool shouldRepaint(_CountPaint oldDelegate) => false;
}
void main() {
setUp(() {
TestWidgetsFlutterBinding.ensureInitialized()
.platformDispatcher
.accessibilityFeaturesTestValue = const FakeAccessibilityFeatures(
disableAnimations: false,
);
});
tearDown(() {
TestWidgetsFlutterBinding.ensureInitialized()
.platformDispatcher
.accessibilityFeaturesTestValue = const FakeAccessibilityFeatures(
disableAnimations: true,
);
});
testWidgets('rotation repaints only the icon, not the surrounding chat', (
tester,
) async {
var paints = 0;
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: CustomPaint(
painter: _CountPaint(() => paints++),
child: const ChatStopIcon(child: Icon(Icons.stop)),
),
),
),
);
final before = paints;
await tester.pump(const Duration(seconds: 1));
await tester.pump(const Duration(seconds: 1));
expect(paints, before);
await tester.pumpWidget(const SizedBox.shrink());
});
testWidgets(
'Stop rotates linearly and continuously once every eight seconds',
(tester) async {
await tester.pumpWidget(
const MaterialApp(
home: Scaffold(body: ChatStopIcon(child: Icon(Icons.stop))),
),
);
RotationTransition rotation() =>
tester.widget(find.byKey(const Key('chat-stop-rotation')));
await tester.pump(const Duration(seconds: 2));
expect(rotation().turns.value, closeTo(0.25, 0.001));
await tester.pump(const Duration(seconds: 2));
expect(rotation().turns.value, closeTo(0.5, 0.001));
await tester.pump(const Duration(seconds: 8));
expect(rotation().turns.value, closeTo(0.5, 0.001));
await tester.pumpWidget(const SizedBox.shrink());
expect(tester.binding.transientCallbackCount, 0);
},
);
testWidgets('reduced motion stops/reset rotation and resumes when enabled', (
tester,
) async {
final reduce = ValueNotifier<bool>(true);
addTearDown(reduce.dispose);
await tester.pumpWidget(
MaterialApp(
home: ValueListenableBuilder<bool>(
valueListenable: reduce,
builder: (context, value, _) => MediaQuery(
data: MediaQuery.of(context).copyWith(disableAnimations: value),
child: const ChatStopIcon(child: Icon(Icons.stop)),
),
),
),
);
RotationTransition rotation() =>
tester.widget(find.byKey(const Key('chat-stop-rotation')));
await tester.pumpAndSettle();
expect(rotation().turns.value, 0);
expect(tester.binding.transientCallbackCount, 0);
reduce.value = false;
await tester.pump();
await tester.pump(const Duration(seconds: 1));
expect(rotation().turns.value, closeTo(0.125, 0.001));
reduce.value = true;
await tester.pumpAndSettle();
expect(rotation().turns.value, 0);
expect(tester.binding.transientCallbackCount, 0);
});
testWidgets('TickerMode silences hidden Stop animation', (tester) async {
await tester.pumpWidget(
const MaterialApp(
home: TickerMode(
enabled: false,
child: ChatStopIcon(child: Icon(Icons.stop)),
),
),
);
await tester.pumpAndSettle();
expect(tester.binding.transientCallbackCount, 0);
await tester.pumpWidget(const SizedBox.shrink());
});
testWidgets(
'rotating Stop keeps its target and interrupt action; Send stays available',
(tester) async {
final gateway = ComposerBarGateway();
addTearDown(gateway.close);
final composer = ChatComposerController(
gateway,
's',
drafts: MemoryChatDraftStore(),
);
addTearDown(composer.dispose);
final running = ValueNotifier<bool>(true);
addTearDown(running.dispose);
final bar = ValueListenableBuilder<bool>(
valueListenable: running,
builder: (_, value, _) =>
ChatComposerBar(composer: composer, running: value),
);
await tester.pumpWidget(
MaterialApp(
home: Scaffold(body: Center(child: bar)),
),
);
// The composer pops in first; Stop's target is measured once it has.
await tester.pump(Motion.tabEntranceDuration);
final stop = find.byKey(const Key('chat-composer-stop'));
final target = tester.getRect(stop);
await tester.pump(const Duration(seconds: 3));
expect(tester.getRect(stop), target);
expect(find.byKey(const Key('chat-composer-primary')), findsOneWidget);
expect(
tester
.widget<RotationTransition>(
find.byKey(const Key('chat-stop-rotation')),
)
.turns
.value,
greaterThan(0),
);
await tester.tap(stop);
await tester.pump();
await tester.pump();
expect(gateway.interruptBodies, [
{'session_id': 's'},
]);
running.value = false;
await tester.pumpAndSettle();
expect(find.byType(ChatStopIcon), findsNothing);
expect(tester.binding.transientCallbackCount, 0);
},
);
}
@@ -0,0 +1,122 @@
import 'dart:async';
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/conversation/chat_background_tasks.dart';
import 'package:pipelines_app/features/chat/conversation/chat_task_spinner.dart';
RotationTransition _rotation(WidgetTester tester) =>
tester.widget<RotationTransition>(
find.byKey(const Key('chat-background-tasks-spinner')),
);
Widget _spinner(bool spinning) => MaterialApp(
home: Scaffold(
body: ChatTaskSpinner(
spinning: spinning,
child: const Icon(Icons.layers_outlined, size: 16),
),
),
);
void _reducedMotion(bool reduced) =>
TestWidgetsFlutterBinding.ensureInitialized()
.platformDispatcher
.accessibilityFeaturesTestValue = FakeAccessibilityFeatures(
disableAnimations: reduced,
);
class _TasksGateway implements ApiGateway {
final _frames = StreamController<JsonMap>.broadcast();
List<JsonMap> running = const [];
@override
Stream<JsonMap> get frames => _frames.stream;
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
if (type == 'chat_shells') return {'chat_shells': running};
if (type == 'chat_automations') {
return {
'chat_automations': {'status': 'unavailable'},
};
}
return <String, dynamic>{};
}
void close() => _frames.close();
}
void main() {
tearDown(() => _reducedMotion(false));
testWidgets('turns once every period while spinning', (tester) async {
_reducedMotion(false);
await tester.pumpWidget(_spinner(true));
expect(_rotation(tester).turns.value, 0);
await tester.pump(ChatTaskSpinner.period ~/ 4);
expect(_rotation(tester).turns.value, closeTo(0.25, 0.01));
// Past one full lap the turn starts again from the top.
await tester.pump(
ChatTaskSpinner.period ~/ 4 * 3 + const Duration(milliseconds: 100),
);
expect(_rotation(tester).turns.value, closeTo(0.04, 0.01));
await tester.pumpWidget(const SizedBox.shrink());
expect(tester.binding.transientCallbackCount, 0);
});
testWidgets('stays still when not spinning, and stops when it stops', (
tester,
) async {
_reducedMotion(false);
await tester.pumpWidget(_spinner(false));
await tester.pump(const Duration(seconds: 2));
expect(_rotation(tester).turns.value, 0);
expect(tester.binding.transientCallbackCount, 0);
await tester.pumpWidget(_spinner(true));
await tester.pump(const Duration(milliseconds: 625));
expect(_rotation(tester).turns.value, greaterThan(0));
await tester.pumpWidget(_spinner(false));
await tester.pump();
expect(_rotation(tester).turns.value, 0);
await tester.pump(const Duration(seconds: 2));
expect(_rotation(tester).turns.value, 0);
expect(tester.binding.transientCallbackCount, 0);
});
testWidgets('reduced motion keeps the icon static even while spinning', (
tester,
) async {
_reducedMotion(true);
await tester.pumpWidget(_spinner(true));
await tester.pump(const Duration(seconds: 1));
expect(_rotation(tester).turns.value, 0);
expect(tester.binding.transientCallbackCount, 0);
});
testWidgets('the tasks icon rotates only while a task runs', (tester) async {
_reducedMotion(false);
final gateway = _TasksGateway();
addTearDown(gateway.close);
gateway.running = const [
{'id': 'sh1', 'status': 'running', 'command': 'go test ./...'},
];
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: ChatBackgroundTasks(gateway: gateway, sessionId: 's'),
),
),
);
// The spinning icon repeats forever, so settle by pumping, never by waiting.
await tester.pump();
await tester.pump();
expect(find.text('1 task'), findsOneWidget);
final before = _rotation(tester).turns.value;
await tester.pump(const Duration(milliseconds: 300));
expect(_rotation(tester).turns.value, greaterThan(before));
});
}
@@ -0,0 +1,46 @@
import 'package:flutter_test/flutter_test.dart';
import 'chat_composer_bar_fixtures.dart';
import 'chat_thread_fixtures.dart';
void main() {
Future<ComposerBarGateway> pumpThread(WidgetTester tester) async {
final gateway = ComposerBarGateway()..page = fixtureTurn();
addTearDown(gateway.close);
await tester.pumpWidget(
composerThread(gateway, newOperationId: () => 'op/1'),
);
await tester.pumpAndSettle();
return gateway;
}
testWidgets('the More menu offers Stop while a turn runs, for touch use', (
tester,
) async {
final gateway = await pumpThread(tester);
gateway.emitEvent(chatStepFrame('running'));
await tester.pump();
await tester.pump();
await tester.tap(find.byTooltip('More actions').hitTestable().first);
await tester.pumpAndSettle();
await tester.tap(find.text('Stop'));
await tester.pump();
await tester.pump();
expect(gateway.interruptBodies, [
{'session_id': 's'},
]);
expect(gateway.promptBodies, isEmpty);
});
testWidgets('the More menu has no Stop once the turn has ended', (
tester,
) async {
final gateway = await pumpThread(tester);
await tester.tap(find.byTooltip('More actions').hitTestable().first);
await tester.pumpAndSettle();
expect(find.text('Stop'), findsNothing);
expect(gateway.interruptBodies, isEmpty);
});
}
@@ -0,0 +1,376 @@
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/attention/runtime/attention_ack_queue.dart';
import 'package:pipelines_app/features/attention/runtime/attention_ack_sync.dart';
import 'package:pipelines_app/features/chat/data/chat_repository.dart';
import 'package:pipelines_app/features/chat/ui/sessions/chat_seen_focus.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 '../../../attention/runtime/fake_ack_server.dart';
import 'chat_test_harness.dart';
/// A chat reply in [id], as the server pushes it while the chat is live.
JsonMap _reply(String id) => {
'type': 'chat_event',
'chat_event': {'session_id': id, 'kind': 'text', 'delta': 'hello'},
};
/// One device's chat list, its shared acknowledgements and its window focus.
class _Device {
_Device(this.server, {required this.clock, bool focused = true})
: client = server.connect(),
local = MemoryChatSessionLocalStore(),
focus = ChatSeenFocus(focused: focused) {
sync = AttentionAckSync(gateway: client, queue: MemoryAttentionAckQueue());
bindAttentionAckSync(client, sync);
list = ChatSessionsController(
ChatRepository(client),
localStore: local,
nowMillis: () => clock(),
seenFocus: focus,
// Short enough to test quiet periods, long enough to settle under load.
activeAckDelay: const Duration(milliseconds: 60),
);
}
final FakeAckServer server;
final FakeAckClient client;
final MemoryChatSessionLocalStore local;
final ChatSeenFocus focus;
final int Function() clock;
late final AttentionAckSync sync;
late final ChatSessionsController list;
Future<void> start() async {
await sync.connected();
await list.refresh();
await settle();
}
JsonMap row(String id) => list.sessions.firstWhere((row) => row['id'] == id);
/// Whether [id] shows a New badge in the list (an open chat never does).
bool isNew(String id) => list.isUnseen(row(id));
/// Whether this device holds [id] as unread, whether or not it is open.
bool holdsUnread(String id) => local.state?.isUnseen(id) ?? false;
void dispose() {
list.dispose();
sync.dispose();
focus.dispose();
}
}
/// Lets a pending quiet-period acknowledgement fire (60 ms here) and settle.
Future<void> quietPeriod() async {
await Future<void>.delayed(const Duration(milliseconds: 200));
await settle();
}
void main() {
late FakeAckServer server;
var now = 5000;
setUp(() {
now = 5000;
server = FakeAckServer()
..chatSessions = [
{'id': 'ses_a', 'title': 'A', 'directory': '/w', 'updated_at': 1000},
{'id': 'ses_b', 'title': 'B', 'directory': '/w', 'updated_at': 1000},
];
});
void pushToAll(JsonMap frame) {
for (final client in server.clients) {
client.pushed.add(frame);
}
}
group('passive states never mark a chat seen', () {
test('a reply in an unfocused window stays New', () async {
final device = _Device(server, clock: () => now, focused: false);
addTearDown(device.dispose);
await device.start();
// Restored as the open chat, then the window is in the background.
device.list.activeSessionId = 'ses_a';
pushToAll(_reply('ses_a'));
await quietPeriod();
expect(server.state.chatSeen, isEmpty);
expect(device.holdsUnread('ses_a'), isTrue);
device.list.activeSessionId = null;
expect(device.isNew('ses_a'), isTrue);
});
test('a restored open chat with no interaction stays New', () async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
// A layout restored on start sets the open chat without any open.
device.list.activeSessionId = 'ses_a';
await settle();
pushToAll(_reply('ses_a'));
await quietPeriod();
expect(server.state.chatSeen, isEmpty);
expect(device.holdsUnread('ses_a'), isTrue);
});
testWidgets(
'a layout restored with a chat open, then a reply, leaves it New',
(tester) async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await tester.runAsync(device.start);
// The list screen is shown with the restored chat as its open conversation.
await tester.pumpWidget(
MaterialApp(
home: ChatSessionsScreen(
gateway: device.client,
onOpen: (_) {},
controller: device.list,
activeSessionId: 'ses_a',
localStore: device.local,
),
),
);
await tester.runAsync(
() => Future<void>.delayed(const Duration(milliseconds: 20)),
);
await tester.pump();
await tester.runAsync(() async {
pushToAll(_reply('ses_a'));
await quietPeriod();
});
await tester.pump();
expect(server.state.chatSeen, isEmpty);
expect(device.holdsUnread('ses_a'), isTrue);
},
);
test('an open chat left idle long after a reply stays New', () async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
await settle();
pushToAll(_reply('ses_a'));
now += 600000; // Ten minutes later, nothing touched it.
await quietPeriod();
expect(server.state.chatSeen, isEmpty);
expect(device.holdsUnread('ses_a'), isTrue);
});
test('a reply after backgrounding an engaged chat stays New, even '
'once the window is focused again without interaction', () async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
device.list.reportInteraction('ses_a');
await settle();
expect(server.state.chatSeen['ses_a'], 5000);
device.focus.focused = false;
now = 6000;
pushToAll(_reply('ses_a'));
await quietPeriod();
expect(server.state.chatSeen['ses_a'], 5000);
device.focus.focused = true;
now = 7000;
pushToAll(_reply('ses_a'));
await quietPeriod();
expect(server.state.chatSeen['ses_a'], 5000);
expect(device.holdsUnread('ses_a'), isTrue);
});
test('a reply in another chat while this one is open stays New', () async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
device.list.reportInteraction('ses_a');
await settle();
now = 6000;
pushToAll(_reply('ses_b'));
await quietPeriod();
expect(server.state.chatSeen.containsKey('ses_b'), isFalse);
expect(device.isNew('ses_b'), isTrue);
});
test('a reply after leaving an engaged chat stays New', () async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
device.list.reportInteraction('ses_a');
await settle();
device.list.activeSessionId = 'ses_b';
now = 6000;
pushToAll(_reply('ses_a'));
await quietPeriod();
expect(server.state.chatSeen['ses_a'], 5000);
expect(device.isNew('ses_a'), isTrue);
});
test('a reply still in its quiet period when the window loses focus '
'stays New, not seen', () async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
device.list.reportInteraction('ses_a');
await settle();
expect(server.state.chatSeen['ses_a'], 5000);
now = 6000;
pushToAll(_reply('ses_a'));
await settle(); // The reply is held in its quiet period, not yet acked.
device.focus.focused = false;
await quietPeriod();
expect(server.state.chatSeen['ses_a'], 5000);
expect(device.holdsUnread('ses_a'), isTrue);
});
test('a reply still in its quiet period when the user opens another '
'chat stays New, not seen', () async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
device.list.reportInteraction('ses_a');
await settle();
now = 6000;
pushToAll(_reply('ses_a'));
await settle();
device.list.activeSessionId = 'ses_b';
await quietPeriod();
expect(server.state.chatSeen['ses_a'], 5000);
expect(device.isNew('ses_a'), isTrue);
});
test('an interaction while the window is unfocused is ignored', () async {
final device = _Device(server, clock: () => now, focused: false);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
device.list.reportInteraction('ses_a');
await quietPeriod();
expect(server.state.chatSeen, isEmpty);
});
});
group('user interactions mark the chat seen', () {
test(
'an interaction in an unread open chat marks it seen up to now',
() async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
pushToAll(_reply('ses_a'));
await settle();
expect(device.holdsUnread('ses_a'), isTrue);
now = 6000;
device.list.reportInteraction('ses_a');
await settle();
expect(server.state.chatSeen['ses_a'], 6000);
expect(device.holdsUnread('ses_a'), isFalse);
expect(device.sync.pending.chatSeen, isEmpty);
},
);
test('opening a chat from the list marks it seen', () async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
pushToAll(_reply('ses_a'));
await settle();
now = 6000;
await device.list.markOpened(device.row('ses_a'));
await settle();
expect(server.state.chatSeen['ses_a'], 6000);
expect(device.holdsUnread('ses_a'), isFalse);
});
test(
'a reply after an interaction is marked seen once the chat is quiet',
() async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
device.list.reportInteraction('ses_a');
await settle();
now = 6000;
pushToAll(_reply('ses_a'));
await quietPeriod();
expect(server.state.chatSeen['ses_a'], 6000);
expect(device.holdsUnread('ses_a'), isFalse);
},
);
test(
'repeated interactions in an engaged, read chat send nothing more',
() async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
device.list.reportInteraction('ses_a');
await settle();
final sent = device.client.count('ack_attention');
// Scroll ticks and clicks after the first engagement.
for (var i = 0; i < 5; i++) {
device.list.reportInteraction('ses_a');
}
await settle();
expect(device.client.count('ack_attention'), sent);
},
);
test('an interaction in a visible chat that is not the open one marks it '
'seen', () async {
final device = _Device(server, clock: () => now);
addTearDown(device.dispose);
await device.start();
device.list.activeSessionId = 'ses_a';
pushToAll(_reply('ses_b'));
await settle();
expect(device.holdsUnread('ses_b'), isTrue);
now = 6000;
device.list.reportInteraction('ses_b');
await settle();
expect(server.state.chatSeen['ses_b'], 6000);
expect(device.holdsUnread('ses_b'), isFalse);
});
});
}
@@ -229,29 +229,32 @@ void main() {
expect(find.byKey(const Key('chat-row-unread')), findsOneWidget);
});
testWidgets('a tool call and reply in the open chat stay read on leaving', (
tester,
) async {
final fake = gateway();
await _pump(tester, fake, active: 's1');
fake.pushed.add(_tool('s1', 'running'));
fake.pushed.add(_tool('s1', 'completed'));
fake.pushed.add(_event('s1', delta: 'Here is the answer.'));
fake.pushed.add({
'type': 'chat_event',
'chat_event': {
'session_id': 's1',
'kind': 'step',
'step': {'status': 'ended'},
},
});
await tester.pumpAndSettle();
expect(find.byKey(const Key('chat-row-unread')), findsNothing);
testWidgets(
'a tool call and reply in the open chat stay New on leaving without interaction',
(tester) async {
final fake = gateway();
await _pump(tester, fake, active: 's1');
fake.pushed.add(_tool('s1', 'running'));
fake.pushed.add(_tool('s1', 'completed'));
fake.pushed.add(_event('s1', delta: 'Here is the answer.'));
fake.pushed.add({
'type': 'chat_event',
'chat_event': {
'session_id': 's1',
'kind': 'step',
'step': {'status': 'ended'},
},
});
await tester.pumpAndSettle();
expect(find.byKey(const Key('chat-row-unread')), findsNothing);
await _pump(tester, fake);
expect(find.byKey(const Key('chat-row-unread')), findsNothing);
expect(_store.state?.isUnseen('s1') ?? false, isFalse);
});
// The chat was open but the user never interacted with it, so the
// reply is not seen: it stays New after the chat is left.
await _pump(tester, fake);
expect(find.byKey(const Key('chat-row-unread')), findsOneWidget);
expect(_store.state?.isUnseen('s1') ?? false, isTrue);
},
);
testWidgets('only unresolved permission requests mark New', (tester) async {
final fake = gateway();
@@ -0,0 +1,211 @@
import 'dart:async';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/chat/workspace/chat_open_workspace_controller.dart';
import 'package:pipelines_app/features/chat/workspace/chat_open_workspace_gateway.dart';
/// Answers each chat_open_workspace call only when the test completes it.
class _Gateway implements ApiGateway {
final requests = <({JsonMap fields, Completer<JsonMap> reply})>[];
final _frames = StreamController<JsonMap>.broadcast();
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) {
final reply = Completer<JsonMap>();
requests.add((fields: fields, reply: reply));
return reply.future;
}
@override
Stream<JsonMap> get frames => _frames.stream;
void push(int revision, List<String> ids) => _frames.add({
'type': 'chat_open_workspace_changed',
'chat_open_workspace': _snapshot(revision, ids),
});
void answer(
int index,
int revision,
List<String> ids, {
bool rejected = false,
}) => requests[index].reply.complete({
'type': 'chat_open_workspace',
'chat_open_workspace': _snapshot(revision, ids, rejected: rejected),
});
List<String> sentIds(int index) => [
for (final entry
in (requests[index].fields['chat_open_workspace_request']
as Map)['entries']
as List)
'${entry['session_id']}',
];
int base(int index) =>
(requests[index].fields['chat_open_workspace_request']
as Map)['base_revision'];
}
JsonMap _snapshot(int revision, List<String> ids, {bool rejected = false}) => {
'revision': revision,
'entries': [
for (final id in ids) {'session_id': id},
],
if (rejected) 'rejected': true,
};
List<ChatOpenWorkspaceEntry> _entries(List<String> ids) => [
for (final id in ids) ChatOpenWorkspaceEntry(id),
];
Future<(ChatOpenWorkspaceController, _Gateway, List<List<String>>)> _started({
int revision = 1,
List<String> ids = const ['a'],
}) async {
final gateway = _Gateway();
final applied = <List<String>>[];
final controller = ChatOpenWorkspaceController(gateway: gateway)
..onChanged = (snapshot) =>
applied.add(snapshot.entries.map((e) => e.sessionId).toList());
final started = controller.start(local: _entries(ids));
await pumpEventQueue();
expect(gateway.requests.single.fields['chat_open_workspace_request'], {
'entries': [
for (final id in ids) {'session_id': id},
],
'base_revision': 0,
'seed': true,
});
gateway.answer(0, revision, ids);
await started;
return (controller, gateway, applied);
}
void main() {
test('reads instead of seeding when the device has no chats', () async {
final gateway = _Gateway();
final controller = ChatOpenWorkspaceController(gateway: gateway);
final started = controller.start();
await pumpEventQueue();
expect(gateway.requests.single.fields, isEmpty);
gateway.answer(0, 4, ['x']);
await started;
expect(controller.revision, 4);
expect(controller.ready, isTrue);
});
test(
'serializes writes and sends the latest from the replied revision',
() async {
final (controller, gateway, _) = await _started();
controller.replace(_entries(['a', 'b']));
controller.replace(_entries(['a', 'b', 'c']));
controller.replace(_entries(['c', 'a', 'b']));
await pumpEventQueue();
// One write in flight; the two later ones coalesced behind it.
expect(gateway.requests, hasLength(2));
expect(gateway.sentIds(1), ['a', 'b']);
expect(gateway.base(1), 1);
gateway.answer(1, 2, ['a', 'b']);
await pumpEventQueue();
expect(gateway.requests, hasLength(3));
expect(gateway.sentIds(2), ['c', 'a', 'b']);
expect(gateway.base(2), 2);
gateway.answer(2, 3, ['c', 'a', 'b']);
await pumpEventQueue();
expect(controller.revision, 3);
// An unchanged set is not sent again.
controller.replace(_entries(['c', 'a', 'b']));
await pumpEventQueue();
expect(gateway.requests, hasLength(3));
},
);
test('a late reply never overwrites a newer pushed revision', () async {
final (controller, gateway, applied) = await _started();
controller.replace(_entries(['a', 'b']));
await pumpEventQueue();
// Another device's change (revision 3) is pushed before this write's
// reply (revision 2) arrives.
gateway.push(3, ['z']);
await pumpEventQueue();
gateway.answer(1, 2, ['a', 'b']);
await pumpEventQueue();
expect(controller.revision, 3);
expect(applied.last, ['z']);
// Older and repeated pushes are ignored.
gateway.push(2, ['a', 'b']);
gateway.push(3, ['z']);
await pumpEventQueue();
expect(applied, [
['a'],
['z'],
]);
});
test(
'a refused stale write applies the server state and drops queued ones',
() async {
final (controller, gateway, applied) = await _started();
controller.replace(_entries(['a', 'b']));
await pumpEventQueue();
controller.replace(_entries(['a', 'b', 'c']));
gateway.answer(1, 5, ['q'], rejected: true);
await pumpEventQueue();
expect(applied.last, ['q']);
expect(controller.revision, 5);
expect(gateway.requests, hasLength(2));
// The next change is derived from the server's state.
controller.replace(_entries(['q', 'r']));
await pumpEventQueue();
expect(gateway.base(2), 5);
},
);
test('a push applied while writing replaces the queued write', () async {
final (controller, gateway, applied) = await _started();
controller.replace(_entries(['a', 'b']));
await pumpEventQueue();
controller.replace(_entries(['a', 'b', 'c']));
gateway.push(4, ['b']);
await pumpEventQueue();
expect(applied.last, ['b']);
gateway.answer(1, 4, ['b'], rejected: true);
await pumpEventQueue();
expect(gateway.requests, hasLength(2));
});
test('dispose stops pushes and writes', () async {
final (controller, gateway, applied) = await _started();
controller.dispose();
gateway.push(9, ['late']);
controller.replace(_entries(['x']));
await pumpEventQueue();
expect(applied, [
['a'],
]);
expect(gateway.requests, hasLength(1));
});
test(
'stays local-only when the server does not answer the request',
() async {
final gateway = _Gateway();
final controller = ChatOpenWorkspaceController(gateway: gateway);
final started = controller.start(local: _entries(['a']));
await pumpEventQueue();
gateway.requests.single.reply.completeError(StateError('unknown type'));
await started;
expect(controller.ready, isFalse);
controller.replace(_entries(['a', 'b']));
await pumpEventQueue();
expect(gateway.requests, hasLength(1));
// A server push (a reconnect) brings it up to date and enables writes.
gateway.push(2, ['a']);
await pumpEventQueue();
expect(controller.ready, isTrue);
},
);
}
@@ -0,0 +1,38 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/workspace/chat_open_workspace_gateway.dart';
void main() {
test('decodes bounded ordered membership and floating state', () {
final snapshot = ChatOpenWorkspaceSnapshot.fromJson({
'revision': 7,
'entries': [
{'session_id': 'ses_a', 'floating': true},
{'session_id': 'ses_b'},
],
});
expect(snapshot?.revision, 7);
expect(snapshot?.entries.map((entry) => entry.sessionId), [
'ses_a',
'ses_b',
]);
expect(snapshot?.entries.first.floating, isTrue);
});
test('rejects duplicate and oversized snapshots', () {
expect(
ChatOpenWorkspaceSnapshot.fromJson({
'entries': [
{'session_id': 'ses_a'},
{'session_id': 'ses_a'},
],
}),
isNull,
);
expect(
ChatOpenWorkspaceSnapshot.fromJson({
'entries': List.generate(65, (index) => {'session_id': 'ses_$index'}),
}),
isNull,
);
});
}
@@ -0,0 +1,56 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/workspace/chat_workspace_controller.dart';
List<String> _sessions(ChatWorkspaceController c) =>
c.panes.map((pane) => pane.sessionId).toList();
ChatWorkspaceController _three() {
final c = ChatWorkspaceController()..open('a');
c.splitActive('b', ChatSplitAxis.vertical);
c.splitActive('c', ChatSplitAxis.horizontal);
c.resize(c.root!.id, .3);
return c;
}
void main() {
test('a remote removal drops only that pane and keeps the geometry', () {
final c = _three();
final paneA = c.panes.first.id;
final paneC = c.panes.last.id;
c.reconcileSessions(['a', 'c']);
expect(_sessions(c), ['a', 'c']);
expect(c.panes.map((pane) => pane.id), [paneA, paneC]);
expect((c.root as ChatWorkspaceSplit).ratio, .3);
});
test('a reorder moves panes with their ids and keeps the splits', () {
final c = _three();
final ids = {for (final pane in c.panes) pane.sessionId: pane.id};
final splitId = c.root!.id;
c.reconcileSessions(['c', 'a', 'b']);
expect(_sessions(c), ['c', 'a', 'b']);
expect(c.panes.map((pane) => pane.id), [ids['c'], ids['a'], ids['b']]);
expect(c.root!.id, splitId);
expect((c.root as ChatWorkspaceSplit).ratio, .3);
});
test('new chats split off and an unchanged set notifies nothing', () {
final c = ChatWorkspaceController()..open('a');
c.reconcileSessions(['a', 'b']);
expect(_sessions(c), ['a', 'b']);
var notified = 0;
c.addListener(() => notified++);
c.reconcileSessions(['a', 'b']);
expect(notified, 0);
c.reconcileSessions(const []);
expect(c.panes, isEmpty);
expect(c.activePane, isNull);
});
test('the active pane moves on when its chat is removed', () {
final c = _three();
expect(c.activePane?.sessionId, 'c');
c.reconcileSessions(['b']);
expect(c.activePane?.sessionId, 'b');
});
}
@@ -0,0 +1,79 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/runs/data/runs_repository.dart';
import 'package:pipelines_app/features/runs/ui/run_detail_view.dart';
import 'package:pipelines_app/features/runs/ui/runs_controller.dart';
import 'package:pipelines_app/shell/adaptive_shell.dart';
import 'package:pipelines_app/shell/destination.dart';
import 'run_detail_graph_support.dart';
/// A pushed run detail covers the phone's bottom navigation bar, both once the
/// run has loaded and while its placeholder (loading or failed) shows.
void main() {
Future<void> pumpPhoneRunDetail(
WidgetTester tester, {
required bool loaded,
}) async {
tester.view.physicalSize = const Size(390, 844);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
final gateway = RunDetailFakeGateway(graphRunFixture());
final controller = RunsController(RunsRepository(gateway));
addTearDown(controller.dispose);
if (loaded) await controller.select(51);
await tester.pumpWidget(
MaterialApp(
home: AdaptiveShell(
destination: AppDestination.runs,
destinationBodies: {
AppDestination.runs: (_) => RunDetailView(
controller: controller,
gateway: gateway,
onBack: () {},
),
},
),
),
);
await tester.pumpAndSettle();
}
testWidgets('a loaded run detail hides the phone navigation bar', (
tester,
) async {
await pumpPhoneRunDetail(tester, loaded: true);
expect(find.byType(RunDetailView), findsOneWidget);
expect(find.byType(NavigationBar), findsNothing);
});
testWidgets('the run detail placeholder hides the phone navigation bar', (
tester,
) async {
await pumpPhoneRunDetail(tester, loaded: false);
expect(find.byType(RunDetailView), findsOneWidget);
expect(find.text('Run details unavailable.'), findsOneWidget);
expect(find.byType(NavigationBar), findsNothing);
});
testWidgets('the runs list keeps the phone navigation bar', (tester) async {
tester.view.physicalSize = const Size(390, 844);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
await tester.pumpWidget(
MaterialApp(
home: AdaptiveShell(
destination: AppDestination.runs,
destinationBodies: {
AppDestination.runs: (_) => const Text('runs list'),
},
),
),
);
await tester.pumpAndSettle();
expect(find.byType(NavigationBar), findsOneWidget);
});
}
@@ -13,7 +13,7 @@ import 'package:pipelines_app/features/runs/ui/runs_controller.dart';
import 'package:pipelines_app/features/runs/ui/runs_list.dart';
import 'package:pipelines_app/shell/adaptive_shell.dart';
import 'package:pipelines_app/shell/destination.dart';
import 'package:pipelines_app/ui/adaptive/floating_destination_bar.dart';
import 'package:pipelines_app/shell/shell_navigation_bar.dart';
import 'package:pipelines_app/ui/text/relative_time_label.dart';
class _Gateway implements ApiGateway {
@@ -198,11 +198,11 @@ void main() {
print(
'BENCH offstage activeTimers=$active labelRebuildsIn2Minutes=$tick '
'burst50: runsListRebuilds=${rebuilds.of(RunsList)} '
'shellBarRebuilds=${rebuilds.of(FloatingDestinationBar)} '
'shellBarRebuilds=${rebuilds.of(ShellNavigationBar)} '
'totalRebuilds=${rebuilds.total}',
);
expect(tick, 0);
expect(rebuilds.of(FloatingDestinationBar), 0);
expect(rebuilds.of(ShellNavigationBar), 0);
await tester.pumpWidget(const SizedBox());
expect(timers.active, 0);
});
@@ -232,7 +232,7 @@ void main() {
'BENCH visibleBurst50 controllerNotifications=$notifications '
'runsListRebuilds=${rebuilds.of(RunsList)} '
'runRowRebuilds=${rebuilds.of(RunListRow)} '
'shellBarRebuilds=${rebuilds.of(FloatingDestinationBar)} '
'shellBarRebuilds=${rebuilds.of(ShellNavigationBar)} '
'totalRebuilds=${rebuilds.total}',
);
final top = rebuilds.counts.entries.toList()
+2 -3
View File
@@ -1,7 +1,6 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/shell/adaptive_shell.dart';
import 'package:pipelines_app/ui/adaptive/floating_destination_bar.dart';
/// The Runs tab keeps running work visible without an error counter.
void main() {
@@ -23,9 +22,9 @@ void main() {
for (final width in [390.0, 1000.0]) {
final mount = width < 600 ? 'bottom bar' : 'rail';
// The rail (wide) or the floating bar (phone) carries the same counts.
// The rail (wide) or the phone's navigation bar carries the same counts.
final navigation = width < 600
? find.byType(FloatingDestinationBar)
? find.byType(NavigationBar)
: find.byType(NavigationRail);
testWidgets('$mount shows the count on the Runs tab', (tester) async {
+43 -34
View File
@@ -3,13 +3,14 @@ import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/shell/list_detail_policy.dart';
import 'package:pipelines_app/shell/adaptive_shell.dart';
import 'package:pipelines_app/shell/destination.dart';
import 'package:pipelines_app/shell/shell_navigation_bar.dart';
import 'package:pipelines_app/ui/adaptive/floating_destination_bar.dart';
import 'package:pipelines_app/ui/adaptive/floating_destination_labels.dart';
import 'package:pipelines_app/ui/adaptive/floating_bar_layout.dart';
/// Main navigation keeps visible captions and full-size targets, floating at
/// the trailing edge on a phone and the leading edge under the list on a wide
/// window.
/// Main navigation keeps visible captions and full-size targets: a full-width
/// navigation bar on a phone, and on a wide window a floating bar at the
/// leading edge under the list.
void main() {
Finder pill() => find.descendant(
of: find.byType(FloatingDestinationBar),
@@ -87,19 +88,18 @@ void main() {
return MaterialApp(home: app);
}
testWidgets('phone bar hugs its tabs at the bottom right too, and '
'taps beside it reach the content', (tester) async {
testWidgets('a phone shows a full-width navigation bar, and taps above it '
'reach the content', (tester) async {
taps = 0;
await setSize(tester, const Size(390, 844));
await tester.pumpWidget(shell());
final rect = tester.getRect(pill());
await expectLabeledTargets(tester, rect);
await expectNoSharedBackdrop(tester);
expect(rect.width, lessThanOrEqualTo(390 - 2 * 16));
expect(rect.right, 390 - 16);
expect(rect.bottom, 844 - 16);
await tester.pumpAndSettle();
final bar = tester.getRect(find.byType(NavigationBar));
expect(bar.left, 0);
expect(bar.right, 390);
expect(find.byType(FloatingDestinationBar), findsNothing);
expect(find.byType(NavigationRail), findsNothing);
await tester.tapAt(Offset(rect.left - 40, rect.center.dy));
await tester.tapAt(Offset(195, bar.top - 40));
await tester.pump();
expect(taps, 1);
await tester.tap(find.byKey(const ValueKey('shell.destination.chat')));
@@ -146,7 +146,9 @@ void main() {
await setSize(tester, size);
await tester.pumpWidget(shell());
await tester.pump();
final rect = tester.getRect(pill());
final rect = size.width < 600
? tester.getRect(find.byType(NavigationBar))
: tester.getRect(pill());
// The content's bottom padding clears the whole bar and its margin.
expect(
contentBottomPadding,
@@ -169,6 +171,7 @@ void main() {
tester.view.physicalSize = const Size(640, 800);
await tester.pump();
expect(find.byType(NavigationBar), findsNothing);
expect(
tester.getRect(pill()).left,
moreOrLessEquals(kFloatingBarMargin, epsilon: 0.5),
@@ -178,17 +181,21 @@ void main() {
tester.view.physicalSize = const Size(390, 844);
await tester.pump();
await expectLabeledTargets(tester, tester.getRect(pill()));
expect(tester.getRect(pill()).width, lessThanOrEqualTo(390 - 2 * 16));
expect(tester.getRect(pill()).right, 390 - 16);
await tester.pumpAndSettle();
expect(find.byType(FloatingDestinationBar), findsNothing);
expect(tester.getRect(find.byType(NavigationBar)).width, 390);
expect(tester.state(find.byType(StatefulBuilder)), same(state));
});
testWidgets('the bar respects the bottom safe area', (tester) async {
testWidgets('the navigation bar respects the bottom safe area', (
tester,
) async {
await setSize(tester, const Size(390, 844));
tester.view.padding = const FakeViewPadding(bottom: 34);
await tester.pumpWidget(shell());
expect(tester.getRect(pill()).bottom, 844 - 34);
await tester.pumpAndSettle();
// The bar sits above the gesture inset, its own surface ending there.
expect(tester.getRect(find.byType(NavigationBar)).bottom, 844 - 34);
});
testWidgets('the selected tab is marked selected for assistive '
@@ -218,23 +225,25 @@ void main() {
await tester.pumpWidget(shell());
await tester.pumpAndSettle();
expect(tester.takeException(), isNull);
// Large captions wrap rather than shrinking the tap targets.
final bounds = tester.getRect(pill());
await expectLabeledTargets(tester, bounds);
expect(bounds.width, lessThanOrEqualTo(320 - 2 * 16));
for (final destination in shellTabDestinations) {
final caption = find.descendant(
of: find.byType(FloatingDestinationBar),
matching: find.text(destinationDetails(destination).label),
final bar = find.byType(NavigationBar);
expect(tester.getRect(bar).width, 320);
// Every destination keeps its label and a full-size target at 2x text.
for (final destination in shellBarDestinations) {
final label = destinationDetails(destination).label;
final caption = find.descendant(of: bar, matching: find.text(label));
expect(caption, findsOneWidget);
expect(
tester.getRect(caption).overlaps(tester.getRect(bar)),
isTrue,
reason: label,
);
final text = tester.widget<Text>(caption);
final size = text.style!.fontSize!;
expect(tester.getSize(caption).height, greaterThanOrEqualTo(size * 2));
final target = tester.getSize(
find.byType(NavigationDestination).at(
shellBarDestinations.indexOf(destination),
),
);
expect(target.width, greaterThanOrEqualTo(44), reason: label);
expect(target.height, greaterThanOrEqualTo(44), reason: label);
}
expect(
bounds.height,
greaterThan(FloatingDestinationBar.selectedButtonSize()),
);
expect(tester.getRect(pill()).right, 320 - 16);
});
}
+19 -15
View File
@@ -175,23 +175,27 @@ void main() {
expect(body.left, greaterThan(list.right));
});
testWidgets('phone and narrow windows keep the floating bar and no rail', (
testWidgets('a phone shows the navigation bar with Settings and no rail', (
tester,
) async {
for (final width in [390.0, 640.0]) {
await pumpShell(tester, width: width);
expect(rail(), findsNothing, reason: '$width');
expect(
find.byKey(const ValueKey('shell.destination.settings')),
findsNothing,
reason: '$width',
);
expect(
find.byType(FloatingDestinationBar),
findsOneWidget,
reason: '$width',
);
}
await pumpShell(tester, width: 390);
expect(rail(), findsNothing);
expect(find.byType(NavigationBar), findsOneWidget);
expect(
find.byKey(const ValueKey('shell.destination.settings')),
findsOneWidget,
);
expect(find.byType(FloatingDestinationBar), findsNothing);
});
testWidgets('a narrow window below the rail keeps the floating bar, no rail '
'and no navigation bar', (tester) async {
// 640 is wide enough for the list beside its open item, which keeps the
// floating bar under the list column.
await pumpShell(tester, width: 640);
expect(rail(), findsNothing);
expect(find.byType(NavigationBar), findsNothing);
expect(find.byType(FloatingDestinationBar), findsOneWidget);
});
testWidgets('floating windows keep to the right of the rail on a wide '
+30 -35
View File
@@ -3,6 +3,7 @@ import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/shell/adaptive_shell.dart';
import 'package:pipelines_app/shell/destination.dart';
import 'package:pipelines_app/shell/shell_bar.dart';
import 'package:pipelines_app/shell/shell_navigation_bar.dart';
import 'package:pipelines_app/ui/adaptive/floating_destination_bar.dart';
Widget _app({required bool open, VoidCallback? back}) {
@@ -45,7 +46,7 @@ void main() {
expect(find.byKey(const Key('run-more')), findsNothing);
});
testWidgets('Search is the fourth tab; Settings is not a tab', (
testWidgets('Search is the fourth tab; Settings is the bar\'s last item', (
tester,
) async {
tester.view.physicalSize = const Size(390, 844);
@@ -65,50 +66,47 @@ void main() {
);
expect(
find.byKey(const ValueKey('shell.destination.settings')),
findsNothing,
findsOneWidget,
);
expect(find.byKey(const ValueKey('shell.search')), findsNothing);
expect(find.byType(FloatingDestinationBar), findsOneWidget);
expect(find.byType(NavigationBar), findsOneWidget);
expect(find.byType(FloatingDestinationBar), findsNothing);
});
testWidgets('floating tabs stay inset and select destinations', (
tester,
) async {
testWidgets('the phone bar is a full-width navigation bar that selects '
'destinations', (tester) async {
tester.view.physicalSize = const Size(390, 844);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
await tester.pumpWidget(_app(open: false));
final destinationPill = find.descendant(
of: find.byType(FloatingDestinationBar),
matching: find.byKey(FloatingDestinationBar.rowKey),
);
// Visible captions determine the width while full-size targets stay inset.
final rect = tester.getRect(destinationPill);
expect(rect.width, lessThanOrEqualTo(390 - 2 * 16));
final bar = find.byType(NavigationBar);
final rect = tester.getRect(bar);
expect(rect.left, 0);
expect(rect.right, 390);
expect(rect.bottom, 844);
expect(
tester
.widget<FloatingDestinationBar>(find.byType(FloatingDestinationBar))
.showLabels,
isTrue,
tester.widget<NavigationBar>(bar).destinations,
hasLength(shellBarDestinations.length),
);
for (final destination in shellTabDestinations) {
final caption = find.descendant(
of: find.byType(FloatingDestinationBar),
matching: find.text(destinationDetails(destination).label),
expect(tester.widget<NavigationBar>(bar).selectedIndex, 1);
for (var index = 0; index < shellBarDestinations.length; index++) {
final label = destinationDetails(shellBarDestinations[index]).label;
expect(
find.descendant(of: bar, matching: find.text(label)),
findsOneWidget,
);
expect(caption, findsOneWidget);
expect(rect.contains(tester.getRect(caption).center), isTrue);
// Each destination's whole slot is its target, not just the icon.
final target = tester.getSize(
find.byKey(ValueKey('shell.destination.${destination.name}')),
find.byType(NavigationDestination).at(index),
);
expect(target.width, greaterThanOrEqualTo(44));
expect(target.height, greaterThanOrEqualTo(44));
expect(target.width, greaterThanOrEqualTo(44), reason: label);
expect(target.height, greaterThanOrEqualTo(44), reason: label);
}
expect(tester.getRect(destinationPill).right, 390 - 16);
await tester.tap(find.byKey(const ValueKey('shell.destination.chat')));
await tester.pump();
expect(find.text('Chat — Not implemented'), findsOneWidget);
expect(tester.widget<NavigationBar>(bar).selectedIndex, 2);
});
testWidgets('tabs show the running and unread counts their screens publish', (
@@ -163,7 +161,7 @@ void main() {
),
);
await tester.pumpWidget(shell());
expect(find.byType(FloatingDestinationBar), findsOneWidget);
expect(find.byType(NavigationBar), findsOneWidget);
final navigator = tester.state<NavigatorState>(find.byType(Navigator));
navigator.push(
MaterialPageRoute<void>(
@@ -171,16 +169,13 @@ void main() {
),
);
await tester.pumpAndSettle();
expect(find.byType(FloatingDestinationBar), findsNothing);
expect(
find.byType(FloatingDestinationBar, skipOffstage: false),
findsOneWidget,
);
expect(find.byType(NavigationBar), findsNothing);
expect(find.byType(NavigationBar, skipOffstage: false), findsOneWidget);
await navigator.maybePop();
await tester.pump(const Duration(milliseconds: 16));
expect(find.byType(FloatingDestinationBar), findsOneWidget);
expect(find.byType(NavigationBar), findsOneWidget);
await tester.pumpAndSettle();
expect(find.byType(FloatingDestinationBar), findsOneWidget);
expect(find.byType(NavigationBar), findsOneWidget);
},
);
}
@@ -0,0 +1,196 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/shell/adaptive_shell.dart';
import 'package:pipelines_app/shell/destination.dart';
import 'package:pipelines_app/shell/shell_bar.dart';
/// On a phone the destinations sit in a full-width Material NavigationBar at
/// the bottom: the four tabs and Settings, each with its icon and label, the
/// current one marked, and the badges the rail shows.
void main() {
Future<void> pumpPhone(
WidgetTester tester, {
AppDestination destination = AppDestination.pipelines,
Map<AppDestination, WidgetBuilder> bodies = const {},
int runningRunCount = 0,
ValueChanged<AppDestination>? onDestinationSelected,
}) async {
tester.view.physicalSize = const Size(390, 844);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
await tester.pumpWidget(
MaterialApp(
home: AdaptiveShell(
destination: destination,
runningRunCount: runningRunCount,
onDestinationSelected: onDestinationSelected,
destinationBodies: bodies,
),
),
);
await tester.pumpAndSettle();
}
Finder bar() => find.byType(NavigationBar);
Finder inBar(Finder finder) => find.descendant(of: bar(), matching: finder);
testWidgets('the bar offers the tabs and Settings, in order, with an icon and '
'a label each', (tester) async {
await pumpPhone(tester);
expect(bar(), findsOneWidget);
final labels = tester
.widget<NavigationBar>(bar())
.destinations
.map((item) => (item as NavigationDestination).label);
expect(labels, ['Pipelines', 'Runs', 'Chat', 'Search', 'Settings']);
for (final destination in AppDestination.values) {
expect(
inBar(
find.byKey(ValueKey('shell.destination.${destination.name}')),
),
findsOneWidget,
reason: destination.name,
);
expect(
inBar(find.byIcon(destinationDetails(destination).icon)),
findsOneWidget,
reason: destination.name,
);
}
});
testWidgets('the selected indicator follows the shown destination, Settings '
'included', (tester) async {
await pumpPhone(tester, destination: AppDestination.runs);
expect(tester.widget<NavigationBar>(bar()).selectedIndex, 1);
await pumpPhone(tester, destination: AppDestination.settings);
expect(tester.widget<NavigationBar>(bar()).selectedIndex, 4);
});
testWidgets('a tap shows its destination, and a re-tap of the shown one '
'still reports it to the shell', (tester) async {
final selected = <AppDestination>[];
await pumpPhone(
tester,
destination: AppDestination.runs,
bodies: {
AppDestination.runs: (_) => const Text('runs body'),
AppDestination.pipelines: (_) => const Text('pipelines body'),
},
onDestinationSelected: selected.add,
);
await tester.tap(find.byKey(const ValueKey('shell.destination.runs')));
await tester.pumpAndSettle();
expect(selected, [AppDestination.runs]);
await tester.tap(find.byKey(const ValueKey('shell.destination.pipelines')));
await tester.pumpAndSettle();
expect(selected, [AppDestination.runs, AppDestination.pipelines]);
});
testWidgets('without a parent route a tap shows the destination itself', (
tester,
) async {
await pumpPhone(
tester,
bodies: {
AppDestination.pipelines: (_) => const Text('pipelines body'),
AppDestination.search: (_) => const Text('search body'),
},
);
expect(find.text('pipelines body'), findsOneWidget);
await tester.tap(find.byKey(const ValueKey('shell.destination.search')));
await tester.pumpAndSettle();
expect(find.text('search body'), findsOneWidget);
expect(tester.widget<NavigationBar>(bar()).selectedIndex, 3);
});
testWidgets('the running count sits on Runs and the unread count on Chat in '
'the bar', (tester) async {
await pumpPhone(
tester,
destination: AppDestination.chat,
runningRunCount: 3,
bodies: {
AppDestination.chat: (_) => const ShellBadge(
kind: ShellBadgeKind.unread,
count: 2,
child: Text('chat body'),
),
},
);
final running = find.byKey(const ValueKey('shell.badge.runs.running'));
expect(
find.descendant(of: running, matching: find.text('3')),
findsOneWidget,
);
expect(
find.descendant(
of: find.byKey(const ValueKey('shell.destination.runs')),
matching: running,
),
findsOneWidget,
);
final unread = find.byKey(const ValueKey('shell.badge.chat.unread'));
expect(
find.descendant(of: unread, matching: find.text('2')),
findsOneWidget,
);
expect(
find.descendant(
of: find.byKey(const ValueKey('shell.destination.chat')),
matching: unread,
),
findsOneWidget,
);
});
testWidgets('the bar leaves while the keyboard is open and returns after it', (
tester,
) async {
await pumpPhone(tester);
expect(bar(), findsOneWidget);
tester.view.viewInsets = const FakeViewPadding(bottom: 300);
await tester.pump();
expect(bar(), findsNothing);
tester.view.resetViewInsets();
await tester.pumpAndSettle();
expect(bar(), findsOneWidget);
});
testWidgets('a screen that hides navigation takes the bar away and gives it '
'back when it closes', (tester) async {
var open = true;
late StateSetter setOuter;
await pumpPhone(
tester,
destination: AppDestination.runs,
bodies: {
AppDestination.runs: (_) => StatefulBuilder(
builder: (context, setState) {
setOuter = setState;
return open
? const ShellBar(
hideNavigation: true,
child: Text('workspace'),
)
: const Text('list');
},
),
},
);
expect(bar(), findsNothing);
setOuter(() => open = false);
await tester.pumpAndSettle();
expect(bar(), findsOneWidget);
});
}
+11 -9
View File
@@ -258,24 +258,26 @@ void main() {
expect(pill.width, lessThan(640 * 0.6));
});
testWidgets('390: the bar hugs its tabs at the phone\'s bottom '
'right', (tester) async {
testWidgets('390: a phone shows the full-width navigation bar at the bottom, '
'with no floating pill', (tester) async {
await setSize(tester, const Size(390, 844));
await tester.pumpWidget(shell(split: false));
await tester.pump();
final pill = destinationPill(tester);
expect(pill.width, lessThanOrEqualTo(390 - 2 * kFloatingBarMargin));
final bar = find.byType(NavigationBar);
final rect = tester.getRect(bar);
expect(rect.left, 0);
expect(rect.right, 390);
expect(rect.bottom, 844);
expect(find.byType(FloatingDestinationBar), findsNothing);
for (final destination in shellTabDestinations) {
expect(
find.byKey(
ValueKey(
'destination-label-${destinationDetails(destination).label}',
),
find.descendant(
of: bar,
matching: find.text(destinationDetails(destination).label),
),
findsOneWidget,
);
}
expect(pill.right, closeTo(390 - kFloatingBarMargin, 0.5));
});
for (final width in [600.0, 640.0]) {
@@ -284,6 +284,9 @@ void main() {
"bar's entrance", (tester) async {
final size = FloatingDestinationBar.buttonSize();
animate(tester, on: true);
// A window above the list-detail split but below the rail keeps the
// floating bar; a phone (under 600 px) shows the Material NavigationBar.
tester.view.physicalSize = const Size(640, 900);
var destination = AppDestination.runs;
final shell = StatefulBuilder(
builder: (context, setState) => AdaptiveShell(
+4 -2
View File
@@ -24,8 +24,10 @@ void main() {
);
expect(find.text('Pipelines'), findsWidgets);
expect(find.text('Pipelines — Not implemented'), findsOneWidget);
// One floating tab bar at every width; no rail.
expect(find.byType(FloatingDestinationBar), findsOneWidget);
// This shell reads its width from a MediaQuery of zero size, so it lays
// out as a phone at every test width: the navigation bar, no rail.
expect(find.byType(NavigationBar), findsOneWidget);
expect(find.byType(FloatingDestinationBar), findsNothing);
expect(find.byType(NavigationRail), findsNothing);
expect(tester.takeException(), isNull);
await tester.tap(find.byKey(const ValueKey('shell.destination.runs')));
+179
View File
@@ -0,0 +1,179 @@
package pipeline
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"strings"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// ChatOpenWorkspaceLimit bounds the open-chat set.
const ChatOpenWorkspaceLimit = 64
func (s *Store) initChatOpenWorkspace() error {
_, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS chat_open_workspaces (
scope TEXT PRIMARY KEY, entries_json TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 0,
updated_at INTEGER NOT NULL DEFAULT 0
);`)
return err
}
func validateOpenWorkspace(entries []protocol.ChatOpenWorkspaceEntry) error {
if len(entries) > ChatOpenWorkspaceLimit {
return fmt.Errorf("too many open chats")
}
seen := make(map[string]struct{}, len(entries))
for _, entry := range entries {
id := strings.TrimSpace(entry.SessionID)
if id == "" || id != entry.SessionID || len(id) > 200 {
return fmt.Errorf("invalid open chat session id")
}
if _, ok := seen[id]; ok {
return fmt.Errorf("duplicate open chat session id %q", id)
}
seen[id] = struct{}{}
}
return nil
}
func decodeOpenWorkspace(raw string) ([]protocol.ChatOpenWorkspaceEntry, error) {
var entries []protocol.ChatOpenWorkspaceEntry
if err := json.Unmarshal([]byte(raw), &entries); err != nil {
return nil, err
}
if err := validateOpenWorkspace(entries); err != nil {
return nil, err
}
return entries, nil
}
func sameOpenWorkspace(a, b []protocol.ChatOpenWorkspaceEntry) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if a[i] != b[i] {
return false
}
}
return true
}
// ChatOpenWorkspace reads the stored snapshot; revision 0 means none was ever
// stored.
func (s *Store) ChatOpenWorkspace(ctx context.Context, scope string) (protocol.ChatOpenWorkspaceSnapshot, error) {
return readOpenWorkspace(ctx, s.db, scope)
}
type rowQuerier interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
}
func readOpenWorkspace(ctx context.Context, db rowQuerier, scope string) (protocol.ChatOpenWorkspaceSnapshot, error) {
var raw string
snapshot := protocol.ChatOpenWorkspaceSnapshot{Entries: []protocol.ChatOpenWorkspaceEntry{}}
err := db.QueryRowContext(ctx, `SELECT entries_json,revision FROM chat_open_workspaces WHERE scope=?`, scope).Scan(&raw, &snapshot.Revision)
if err == sql.ErrNoRows {
return snapshot, nil
}
if err != nil {
return snapshot, err
}
snapshot.Entries, err = decodeOpenWorkspace(raw)
return snapshot, err
}
func writeOpenWorkspace(ctx context.Context, tx *sql.Tx, scope string, revision int64, entries []protocol.ChatOpenWorkspaceEntry) error {
raw, err := json.Marshal(entries)
if err != nil {
return err
}
_, err = tx.ExecContext(ctx, `INSERT INTO chat_open_workspaces(scope,entries_json,revision,updated_at) VALUES(?,?,?,?)
ON CONFLICT(scope) DO UPDATE SET entries_json=excluded.entries_json,revision=excluded.revision,updated_at=excluded.updated_at`,
scope, string(raw), revision, time.Now().UnixMilli())
return err
}
// SaveChatOpenWorkspace applies a full snapshot as one compare-and-swap. A
// write whose baseRevision is not the stored revision is not applied: the
// current snapshot is returned with Rejected set. A seed applies only when no
// workspace was ever stored and otherwise returns the stored one. changed
// reports whether a new revision was stored; an identical write stores none.
func (s *Store) SaveChatOpenWorkspace(ctx context.Context, scope string, entries []protocol.ChatOpenWorkspaceEntry, seed bool, baseRevision int64) (snapshot protocol.ChatOpenWorkspaceSnapshot, changed bool, err error) {
if strings.TrimSpace(scope) == "" {
return snapshot, false, fmt.Errorf("workspace scope is required")
}
if entries == nil {
entries = []protocol.ChatOpenWorkspaceEntry{}
}
if err := validateOpenWorkspace(entries); err != nil {
return snapshot, false, err
}
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return snapshot, false, err
}
defer tx.Rollback()
current, err := readOpenWorkspace(ctx, tx, scope)
if err != nil {
return snapshot, false, err
}
if seed && current.Revision > 0 {
return current, false, nil
}
if !seed && baseRevision != current.Revision {
current.Rejected = true
return current, false, nil
}
if current.Revision > 0 && sameOpenWorkspace(current.Entries, entries) {
return current, false, nil
}
next := protocol.ChatOpenWorkspaceSnapshot{Revision: current.Revision + 1, Entries: entries}
if err := writeOpenWorkspace(ctx, tx, scope, next.Revision, entries); err != nil {
return snapshot, false, err
}
if err := tx.Commit(); err != nil {
return snapshot, false, err
}
return next, true, nil
}
// RemoveChatOpenWorkspaceSessions drops the named sessions from the stored
// snapshot in one transaction, storing a new revision only when one was
// present. The server uses it for closed and no-longer-valid chats.
func (s *Store) RemoveChatOpenWorkspaceSessions(ctx context.Context, scope string, sessionIDs []string) (snapshot protocol.ChatOpenWorkspaceSnapshot, changed bool, err error) {
drop := make(map[string]bool, len(sessionIDs))
for _, id := range sessionIDs {
drop[id] = true
}
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return snapshot, false, err
}
defer tx.Rollback()
current, err := readOpenWorkspace(ctx, tx, scope)
if err != nil || current.Revision == 0 {
return current, false, err
}
kept := make([]protocol.ChatOpenWorkspaceEntry, 0, len(current.Entries))
for _, entry := range current.Entries {
if !drop[entry.SessionID] {
kept = append(kept, entry)
}
}
if len(kept) == len(current.Entries) {
return current, false, nil
}
next := protocol.ChatOpenWorkspaceSnapshot{Revision: current.Revision + 1, Entries: kept}
if err := writeOpenWorkspace(ctx, tx, scope, next.Revision, kept); err != nil {
return snapshot, false, err
}
if err := tx.Commit(); err != nil {
return snapshot, false, err
}
return next, true, nil
}
@@ -0,0 +1,105 @@
package pipeline
import (
"context"
"fmt"
"testing"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
func openWorkspaceStore(t *testing.T, path string) *Store {
t.Helper()
store, err := Open(path)
if err != nil {
t.Fatal(err)
}
return store
}
func TestChatOpenWorkspacePersistsAndSeedsOnce(t *testing.T) {
path := t.TempDir() + "/workspace.db"
ctx := context.Background()
store := openWorkspaceStore(t, path)
first := []protocol.ChatOpenWorkspaceEntry{{SessionID: "ses_a", Floating: true}}
snapshot, changed, err := store.SaveChatOpenWorkspace(ctx, "default", first, true, 0)
if err != nil || !changed {
t.Fatalf("seed: changed=%v err=%v", changed, err)
}
if snapshot.Revision != 1 || len(snapshot.Entries) != 1 || !snapshot.Entries[0].Floating {
t.Fatalf("unexpected snapshot: %+v", snapshot)
}
second, changed, err := store.SaveChatOpenWorkspace(ctx, "default", []protocol.ChatOpenWorkspaceEntry{{SessionID: "ses_b"}}, true, 0)
if err != nil || changed || second.Rejected {
t.Fatalf("second seed: changed=%v rejected=%v err=%v", changed, second.Rejected, err)
}
if len(second.Entries) != 1 || second.Entries[0].SessionID != "ses_a" {
t.Fatalf("seed replaced existing workspace: %+v", second)
}
// An emptied workspace is still a stored workspace: an old device-local
// snapshot must not seed its chats back.
if _, _, err := store.SaveChatOpenWorkspace(ctx, "default", nil, false, 1); err != nil {
t.Fatal(err)
}
reseed, changed, err := store.SaveChatOpenWorkspace(ctx, "default", first, true, 0)
if err != nil || changed || len(reseed.Entries) != 0 || reseed.Revision != 2 {
t.Fatalf("seed restored an emptied workspace: %+v changed=%v err=%v", reseed, changed, err)
}
if err := store.Close(); err != nil {
t.Fatal(err)
}
store = openWorkspaceStore(t, path)
defer store.Close()
loaded, err := store.ChatOpenWorkspace(ctx, "default")
if err != nil {
t.Fatal(err)
}
if loaded.Revision != 2 || len(loaded.Entries) != 0 {
t.Fatalf("workspace did not survive restart: %+v", loaded)
}
}
func TestChatOpenWorkspaceRejectsStaleRevision(t *testing.T) {
store := openWorkspaceStore(t, t.TempDir()+"/workspace.db")
defer store.Close()
ctx := context.Background()
a := []protocol.ChatOpenWorkspaceEntry{{SessionID: "ses_a"}}
ab := []protocol.ChatOpenWorkspaceEntry{{SessionID: "ses_a"}, {SessionID: "ses_b"}}
if s, _, err := store.SaveChatOpenWorkspace(ctx, "default", a, false, 0); err != nil || s.Revision != 1 {
t.Fatalf("first write: %+v %v", s, err)
}
if s, _, err := store.SaveChatOpenWorkspace(ctx, "default", ab, false, 1); err != nil || s.Revision != 2 {
t.Fatalf("second write: %+v %v", s, err)
}
stale, changed, err := store.SaveChatOpenWorkspace(ctx, "default", nil, false, 1)
if err != nil || changed || !stale.Rejected || stale.Revision != 2 || len(stale.Entries) != 2 {
t.Fatalf("stale write = %+v changed=%v err=%v", stale, changed, err)
}
same, changed, err := store.SaveChatOpenWorkspace(ctx, "default", ab, false, 2)
if err != nil || changed || same.Revision != 2 {
t.Fatalf("identical write stored a revision: %+v changed=%v", same, changed)
}
removed, changed, err := store.RemoveChatOpenWorkspaceSessions(ctx, "default", []string{"ses_a", "ses_x"})
if err != nil || !changed || removed.Revision != 3 || len(removed.Entries) != 1 || removed.Entries[0].SessionID != "ses_b" {
t.Fatalf("remove = %+v changed=%v err=%v", removed, changed, err)
}
if _, changed, _ := store.RemoveChatOpenWorkspaceSessions(ctx, "default", []string{"ses_a"}); changed {
t.Fatal("removing an absent chat stored a revision")
}
}
func TestChatOpenWorkspaceRejectsDuplicatesAndBounds(t *testing.T) {
store := openWorkspaceStore(t, t.TempDir()+"/workspace.db")
defer store.Close()
entries := []protocol.ChatOpenWorkspaceEntry{{SessionID: "ses_a"}, {SessionID: "ses_a"}}
if _, _, err := store.SaveChatOpenWorkspace(context.Background(), "default", entries, false, 0); err == nil {
t.Fatal("duplicate workspace entries accepted")
}
many := make([]protocol.ChatOpenWorkspaceEntry, ChatOpenWorkspaceLimit+1)
for i := range many {
many[i].SessionID = fmt.Sprintf("ses_%d", i)
}
if _, _, err := store.SaveChatOpenWorkspace(context.Background(), "default", many, false, 0); err == nil {
t.Fatal("oversized workspace accepted")
}
}
+4
View File
@@ -85,6 +85,10 @@ CREATE TABLE IF NOT EXISTS submissions (id INTEGER PRIMARY KEY, name TEXT NOT NU
db.Close()
return nil, err
}
if err := s.initChatOpenWorkspace(); err != nil {
db.Close()
return nil, err
}
if err := s.initServerSettings(); err != nil {
db.Close()
return nil, err
+4
View File
@@ -81,6 +81,10 @@ const (
// takes a ChatQuery with SessionID and Color (a ChatColors name; null or ""
// clears it) and echoes the updated session like chat_star.
ChatColor = "chat_color"
// ChatOpenWorkspace replaces the bounded, server-authoritative ordered set
// of open operator chats. The reply and push carry the complete snapshot.
ChatOpenWorkspace = "chat_open_workspace"
ChatOpenWorkspaceChanged = "chat_open_workspace_changed"
// ChatSessionChanged is pushed to every other open connection when a chat's
// shared list metadata (colour, star, title) changes, carrying the updated
// registry row in ChatSession, so each device's list updates live.
+33
View File
@@ -0,0 +1,33 @@
package protocol
// ChatOpenWorkspaceEntry is the server-owned part of one workspace pane. Layout
// geometry and pane ids deliberately do not cross the wire.
type ChatOpenWorkspaceEntry struct {
SessionID string `json:"session_id"`
Floating bool `json:"floating,omitempty"`
}
// ChatOpenWorkspaceRequest replaces the open-chat set. A chat_open_workspace
// without a request only reads the current snapshot.
type ChatOpenWorkspaceRequest struct {
Entries []ChatOpenWorkspaceEntry `json:"entries"`
// BaseRevision is the snapshot revision the client's entries were derived
// from. A write whose base is not the current revision is refused, and the
// reply carries the current snapshot with Rejected set, so a late write
// can never overwrite a newer change.
BaseRevision int64 `json:"base_revision"`
// Seed is honored only when the server has never stored a workspace. It
// makes migration from the old device-local snapshot race-safe; otherwise
// the reply is the existing snapshot, unchanged.
Seed bool `json:"seed,omitempty"`
}
// ChatOpenWorkspaceSnapshot is the complete open-chat set. Revision grows by
// one with every stored change.
type ChatOpenWorkspaceSnapshot struct {
Revision int64 `json:"revision"`
Entries []ChatOpenWorkspaceEntry `json:"entries"`
// Rejected marks a reply to a write whose base revision was stale: the
// write was not applied and the snapshot is the current state.
Rejected bool `json:"rejected,omitempty"`
}
+13 -11
View File
@@ -200,17 +200,19 @@ type Message struct {
SearchResults *SearchResponse `json:"search_results,omitempty"`
// Chat is the brokered OpenCode chat traffic (route B). See chat.go for the
// per-type payload structs and the wire shapes they mirror.
ChatSessions []ChatSession `json:"chat_sessions,omitempty"`
ChatSession *ChatSession `json:"chat_session,omitempty"`
ChatCreate *ChatCreateRequest `json:"chat_create,omitempty"`
ChatAdopt *ChatAdoptRequest `json:"chat_adopt,omitempty"`
ChatQuery *ChatQuery `json:"chat_query,omitempty"`
ChatPrompt *ChatPromptRequest `json:"chat_prompt,omitempty"`
ChatMessages []ChatMessage `json:"chat_messages,omitempty"`
ChatHistory *ChatHistoryPage `json:"chat_history,omitempty"`
ChatEvent *ChatEventFrame `json:"chat_event,omitempty"`
ChatPermission *ChatPermissionFrame `json:"chat_permission,omitempty"`
ChatReply *ChatReplyRequest `json:"chat_reply,omitempty"`
ChatSessions []ChatSession `json:"chat_sessions,omitempty"`
ChatSession *ChatSession `json:"chat_session,omitempty"`
ChatOpenWorkspaceRequest *ChatOpenWorkspaceRequest `json:"chat_open_workspace_request,omitempty"`
ChatOpenWorkspace *ChatOpenWorkspaceSnapshot `json:"chat_open_workspace,omitempty"`
ChatCreate *ChatCreateRequest `json:"chat_create,omitempty"`
ChatAdopt *ChatAdoptRequest `json:"chat_adopt,omitempty"`
ChatQuery *ChatQuery `json:"chat_query,omitempty"`
ChatPrompt *ChatPromptRequest `json:"chat_prompt,omitempty"`
ChatMessages []ChatMessage `json:"chat_messages,omitempty"`
ChatHistory *ChatHistoryPage `json:"chat_history,omitempty"`
ChatEvent *ChatEventFrame `json:"chat_event,omitempty"`
ChatPermission *ChatPermissionFrame `json:"chat_permission,omitempty"`
ChatReply *ChatReplyRequest `json:"chat_reply,omitempty"`
// ChatClose carries the outcome of a chat_close; the close and reopen
// requests themselves ride on ChatQuery (the session id), matching
// chat_messages/chat_interrupt.
+3
View File
@@ -225,6 +225,9 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker
case protocol.ChatColor:
handleChatColor(ctx, request, registry, hub.changes(), clientID, write)
return true
case protocol.ChatOpenWorkspace:
handleChatOpenWorkspace(ctx, request, registry, hub.changes(), clientID, write)
return true
case protocol.ChatRename:
handleChatRename(ctx, request, broker, registry, hub.changes(), clientID, write)
return true
+3
View File
@@ -92,6 +92,9 @@ func handleChatClose(ctx context.Context, request protocol.Message, broker chatB
// chat_sessions without a re-list.
response.ChatSessions = []protocol.ChatSession{wire}
_ = write(response)
// A closed chat leaves every device's open-chat set, so no client can keep
// or restore it.
dropFromChatWorkspace(ctx, registry, hub.changes(), sessionID)
}
// handleChatReopen clears the closed state of an operator chat session so it
+164
View File
@@ -0,0 +1,164 @@
package server
import (
"context"
"fmt"
"log"
"strings"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// chatWorkspaceScope keys the one operator's open-chat set: the authenticated
// local server has a single operator.
const chatWorkspaceScope = "default"
// chatOpenWorkspaceStore persists the server-authoritative open-chat set (see
// pipeline.Store.SaveChatOpenWorkspace for the revision rules).
type chatOpenWorkspaceStore interface {
ChatOpenWorkspace(context.Context, string) (protocol.ChatOpenWorkspaceSnapshot, error)
SaveChatOpenWorkspace(ctx context.Context, scope string, entries []protocol.ChatOpenWorkspaceEntry, seed bool, baseRevision int64) (protocol.ChatOpenWorkspaceSnapshot, bool, error)
RemoveChatOpenWorkspaceSessions(ctx context.Context, scope string, sessionIDs []string) (protocol.ChatOpenWorkspaceSnapshot, bool, error)
}
func openWorkspaceStoreOf(registry operatorRegistry) chatOpenWorkspaceStore {
store, _ := registry.(chatOpenWorkspaceStore)
return store
}
// openOperatorChat reports whether id is a recorded operator chat that is not
// closed. Only those may be in the open-chat set, so a pipeline-owned run
// session, a closed chat or an unknown id is never kept. The registry is the
// authority; the broker is not asked, so validation never starts a harness.
func openOperatorChat(ctx context.Context, registry operatorRegistry, id string) (bool, error) {
row, found, err := registry.OperatorSession(ctx, id)
if err != nil {
return false, err
}
return found && row.ClosedAt == 0, nil
}
// pruneChatWorkspace drops every stored entry that is no longer an open
// operator chat. changed reports a new stored revision, which the caller
// broadcasts to every connection.
func pruneChatWorkspace(ctx context.Context, registry operatorRegistry, store chatOpenWorkspaceStore) (protocol.ChatOpenWorkspaceSnapshot, bool, error) {
snapshot, err := store.ChatOpenWorkspace(ctx, chatWorkspaceScope)
if err != nil || snapshot.Revision == 0 {
return snapshot, false, err
}
var stale []string
for _, entry := range snapshot.Entries {
open, err := openOperatorChat(ctx, registry, entry.SessionID)
if err != nil {
return snapshot, false, err
}
if !open {
stale = append(stale, entry.SessionID)
}
}
if len(stale) == 0 {
return snapshot, false, nil
}
return store.RemoveChatOpenWorkspaceSessions(ctx, chatWorkspaceScope, stale)
}
// announceChatWorkspace runs when a connection opens: it prunes stale entries
// and, when that stored a new revision, pushes it to every connection;
// otherwise it sends the current snapshot to the new connection alone, so a
// reconnecting client catches up with changes it missed.
func announceChatWorkspace(ctx context.Context, registry operatorRegistry, changes *chatSessionChanges, write func(protocol.Message) error) {
store := openWorkspaceStoreOf(registry)
if store == nil {
return
}
snapshot, changed, err := pruneChatWorkspace(ctx, registry, store)
if err != nil {
log.Printf("reconcile open chat workspace: %v", err)
return
}
if changed {
changes.broadcastWorkspace("", snapshot)
} else if snapshot.Revision > 0 {
_ = write(protocol.Message{Type: protocol.ChatOpenWorkspaceChanged, ChatOpenWorkspace: &snapshot})
}
}
// dropFromChatWorkspace removes a closed chat from the open-chat set and pushes
// the new revision to every connection, the closing one included.
func dropFromChatWorkspace(ctx context.Context, registry operatorRegistry, changes *chatSessionChanges, sessionID string) {
store := openWorkspaceStoreOf(registry)
if store == nil {
return
}
snapshot, changed, err := store.RemoveChatOpenWorkspaceSessions(ctx, chatWorkspaceScope, []string{sessionID})
if err != nil {
log.Printf("drop closed chat %s from open workspace: %v", sessionID, err)
return
}
if changed {
changes.broadcastWorkspace("", snapshot)
}
}
// validChatWorkspaceEntries checks a client's snapshot and keeps only its open
// operator chats. Malformed or duplicate ids are refused; closed or unknown
// chats are dropped, so a stale client can never restore them.
func validChatWorkspaceEntries(ctx context.Context, request protocol.ChatOpenWorkspaceRequest, registry operatorRegistry) ([]protocol.ChatOpenWorkspaceEntry, error) {
if len(request.Entries) > pipeline.ChatOpenWorkspaceLimit {
return nil, fmt.Errorf("too many open chats")
}
seen := map[string]bool{}
valid := make([]protocol.ChatOpenWorkspaceEntry, 0, len(request.Entries))
for _, entry := range request.Entries {
id := strings.TrimSpace(entry.SessionID)
if !validChatSessionID(id) || seen[id] {
return nil, fmt.Errorf("invalid or duplicate open chat session %q", id)
}
seen[id] = true
open, err := openOperatorChat(ctx, registry, id)
if err != nil {
return nil, err
}
if open {
valid = append(valid, protocol.ChatOpenWorkspaceEntry{SessionID: id, Floating: entry.Floating})
}
}
return valid, nil
}
// handleChatOpenWorkspace reads (no request) or replaces the open-chat set.
// The reply always carries the resulting snapshot; a stored change is pushed
// to every other connection as chat_open_workspace_changed.
func handleChatOpenWorkspace(ctx context.Context, request protocol.Message, registry operatorRegistry, changes *chatSessionChanges, clientID string, write func(protocol.Message) error) {
fail := func(err error) {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
}
store := openWorkspaceStoreOf(registry)
if registry == nil || store == nil {
fail(fmt.Errorf("chat workspace persistence unavailable"))
return
}
var (
snapshot protocol.ChatOpenWorkspaceSnapshot
changed bool
err error
)
if request.ChatOpenWorkspaceRequest == nil {
snapshot, changed, err = pruneChatWorkspace(ctx, registry, store)
} else {
var entries []protocol.ChatOpenWorkspaceEntry
entries, err = validChatWorkspaceEntries(ctx, *request.ChatOpenWorkspaceRequest, registry)
if err == nil {
snapshot, changed, err = store.SaveChatOpenWorkspace(ctx, chatWorkspaceScope, entries, request.ChatOpenWorkspaceRequest.Seed, request.ChatOpenWorkspaceRequest.BaseRevision)
}
}
if err != nil {
fail(err)
return
}
_ = write(protocol.Message{Type: protocol.ChatOpenWorkspace, ID: request.ID, ChatOpenWorkspace: &snapshot})
if changed {
changes.broadcastWorkspace(clientID, snapshot)
}
}
+147
View File
@@ -0,0 +1,147 @@
package server
import (
"context"
"testing"
"github.com/coder/websocket"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
func workspaceWrite(id string, base int64, entries ...protocol.ChatOpenWorkspaceEntry) protocol.Message {
return protocol.Message{Type: protocol.ChatOpenWorkspace, ID: id, ChatOpenWorkspaceRequest: &protocol.ChatOpenWorkspaceRequest{Entries: entries, BaseRevision: base}}
}
func workspaceIDs(snapshot *protocol.ChatOpenWorkspaceSnapshot) []string {
ids := []string{}
for _, entry := range snapshot.Entries {
id := entry.SessionID
if entry.Floating {
id += "*"
}
ids = append(ids, id)
}
return ids
}
func sameIDs(a []string, b ...string) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if a[i] != b[i] {
return false
}
}
return true
}
// readWorkspacePush reads chat_open_workspace_changed pushes until one carries
// revision; lower revisions (pushed out of order) are skipped.
func readWorkspacePush(t *testing.T, ctx context.Context, conn *websocket.Conn, revision int64) *protocol.ChatOpenWorkspaceSnapshot {
t.Helper()
for {
message := readUntil(t, ctx, conn, protocol.ChatOpenWorkspaceChanged)
got := message.ChatOpenWorkspace
if got == nil {
t.Fatal("push without a snapshot")
}
if got.Revision == revision {
return got
}
if got.Revision > revision {
t.Fatalf("push revision %d, want %d", got.Revision, revision)
}
}
}
// TestChatOpenWorkspaceSyncsEveryConnection is the fan-out evidence: a write
// from one connection is stored at the next revision and pushed to the other;
// a write from a stale base is refused with the current snapshot; closing a
// chat drops it and pushes the result to both connections; and a later write
// cannot put the closed chat back.
func TestChatOpenWorkspaceSyncsEveryConnection(t *testing.T) {
store := newOperatorStore(t)
ctx, _, conns := dialChatConns(t, Options{Chat: scriptedChat(), OperatorRegistry: store}, 2)
for _, id := range []string{"ses_a", "ses_b"} {
if err := store.RecordOperatorSession(ctx, id, "/work", id, protocol.ChatSessionTagOperator); err != nil {
t.Fatal(err)
}
}
a, b := protocol.ChatOpenWorkspaceEntry{SessionID: "ses_a"}, protocol.ChatOpenWorkspaceEntry{SessionID: "ses_b", Floating: true}
writeChat(t, ctx, conns[0], workspaceWrite("w1", 0, a, b, protocol.ChatOpenWorkspaceEntry{SessionID: "ses_unknown"}))
reply := readUntil(t, ctx, conns[0], protocol.ChatOpenWorkspace).ChatOpenWorkspace
if reply.Revision != 1 || reply.Rejected || !sameIDs(workspaceIDs(reply), "ses_a", "ses_b*") {
t.Fatalf("first write reply = %+v", reply)
}
if push := readWorkspacePush(t, ctx, conns[1], 1); !sameIDs(workspaceIDs(push), "ses_a", "ses_b*") {
t.Fatalf("second connection got %v", workspaceIDs(push))
}
writeChat(t, ctx, conns[1], protocol.Message{Type: protocol.ChatOpenWorkspace, ID: "r1"})
if read := readUntil(t, ctx, conns[1], protocol.ChatOpenWorkspace).ChatOpenWorkspace; read.Revision != 1 || !sameIDs(workspaceIDs(read), "ses_a", "ses_b*") {
t.Fatalf("read = %+v", read)
}
// A write derived from revision 0 lands after revision 1: refused.
writeChat(t, ctx, conns[1], workspaceWrite("w2", 0, b))
stale := readUntil(t, ctx, conns[1], protocol.ChatOpenWorkspace).ChatOpenWorkspace
if !stale.Rejected || stale.Revision != 1 || !sameIDs(workspaceIDs(stale), "ses_a", "ses_b*") {
t.Fatalf("stale write reply = %+v", stale)
}
// Reorder from the second connection reaches the first.
b.Floating = false
writeChat(t, ctx, conns[1], workspaceWrite("w3", 1, b, a))
if got := readUntil(t, ctx, conns[1], protocol.ChatOpenWorkspace).ChatOpenWorkspace; got.Revision != 2 {
t.Fatalf("reorder reply = %+v", got)
}
if push := readWorkspacePush(t, ctx, conns[0], 2); !sameIDs(workspaceIDs(push), "ses_b", "ses_a") {
t.Fatalf("reorder push = %v", workspaceIDs(push))
}
// Closing ses_a drops it and pushes revision 3 to both connections.
writeChat(t, ctx, conns[0], protocol.Message{Type: protocol.ChatClose, ID: "c1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_a"}})
readUntil(t, ctx, conns[0], protocol.ChatClose)
for i, conn := range conns {
if push := readWorkspacePush(t, ctx, conn, 3); !sameIDs(workspaceIDs(push), "ses_b") {
t.Fatalf("connection %d close push = %v", i, workspaceIDs(push))
}
}
// A client still showing the closed chat cannot restore it.
writeChat(t, ctx, conns[1], workspaceWrite("w4", 3, a, b))
if got := readUntil(t, ctx, conns[1], protocol.ChatOpenWorkspace).ChatOpenWorkspace; got.Revision != 3 || !sameIDs(workspaceIDs(got), "ses_b") {
t.Fatalf("closed chat restored: %+v", got)
}
}
// TestChatOpenWorkspacePrunesOnConnectForEveryone pins that a chat closed
// behind the workspace's back is pruned when a connection opens, and that the
// pruned snapshot reaches the connections already open, not only the new one.
func TestChatOpenWorkspacePrunesOnConnectForEveryone(t *testing.T) {
store := newOperatorStore(t)
ctx, _, srv, conns := dialChatServer(t, Options{Chat: scriptedChat(), OperatorRegistry: store}, 1)
for _, id := range []string{"ses_a", "ses_b"} {
if err := store.RecordOperatorSession(ctx, id, "/work", id, protocol.ChatSessionTagOperator); err != nil {
t.Fatal(err)
}
}
writeChat(t, ctx, conns[0], workspaceWrite("w1", 0, protocol.ChatOpenWorkspaceEntry{SessionID: "ses_a"}, protocol.ChatOpenWorkspaceEntry{SessionID: "ses_b"}))
readUntil(t, ctx, conns[0], protocol.ChatOpenWorkspace)
if err := store.CloseOperatorSession(ctx, "ses_a"); err != nil {
t.Fatal(err)
}
late := dialChatConn(t, ctx, srv)
for i, conn := range []*websocket.Conn{conns[0], late} {
if push := readWorkspacePush(t, ctx, conn, 2); !sameIDs(workspaceIDs(push), "ses_b") {
t.Fatalf("connection %d prune push = %v", i, workspaceIDs(push))
}
}
// With nothing to prune, a new connection alone is brought up to date.
third := dialChatConn(t, ctx, srv)
if push := readWorkspacePush(t, ctx, third, 2); !sameIDs(workspaceIDs(push), "ses_b") {
t.Fatalf("catch-up push = %v", workspaceIDs(push))
}
}
+22
View File
@@ -62,6 +62,28 @@ func (c *chatSessionChanges) broadcast(sender string, session protocol.ChatSessi
}
}
// broadcastWorkspace pushes an open-chat snapshot to every connection except
// sender ("" reaches all of them). Writes run on their own goroutines, so they
// may arrive out of order; clients keep only the highest revision.
func (c *chatSessionChanges) broadcastWorkspace(sender string, snapshot protocol.ChatOpenWorkspaceSnapshot) {
if c == nil {
return
}
c.mu.Lock()
targets := make([]func(protocol.Message) error, 0, len(c.clients))
for id, write := range c.clients {
if id != sender {
targets = append(targets, write)
}
}
c.mu.Unlock()
for _, write := range targets {
copy := snapshot
copy.Entries = append([]protocol.ChatOpenWorkspaceEntry(nil), snapshot.Entries...)
go func() { _ = write(protocol.Message{Type: protocol.ChatOpenWorkspaceChanged, ChatOpenWorkspace: &copy}) }()
}
}
// echoOperatorSession answers a metadata change with the updated registry row
// and pushes the same row to every other connection.
func echoOperatorSession(ctx context.Context, request protocol.Message, sessionID, reply string, registry operatorRegistry, changes *chatSessionChanges, clientID string, write func(protocol.Message) error) {
+3
View File
@@ -261,6 +261,9 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
// connection the same way.
hub.sessionChanges.attach(clientID, write)
defer hub.sessionChanges.detach(clientID)
// The open-chat set: prune entries that are no longer open chats and
// push the result to every connection, else bring this one up to date.
announceChatWorkspace(connCtx, registry, hub.changes(), write)
// Terminal lifecycle changes reach every connection; output only the
// connections that opened or read that terminal.
terminals.clients.attach(clientID, write)