Merge branch 'worktree-agent-a7743f4217dc47a1b'
This commit is contained in:
@@ -8,3 +8,14 @@ const double kChatReadingWidth = 760;
|
||||
/// The space on each side of the centred reading column in [width].
|
||||
double chatReadingInset(double width) =>
|
||||
math.max(0, (width - kChatReadingWidth) / 2);
|
||||
|
||||
/// The strip left of the reading column that holds an answer's Copy button,
|
||||
/// outside the answer itself.
|
||||
const double kChatCopyGutterWidth = 48;
|
||||
|
||||
/// The copy gutter a transcript [width] wide gives each answer:
|
||||
/// [kChatCopyGutterWidth] when the margin left of the centred reading column
|
||||
/// fits it, else 0, and Copy stays in the answer's footer (phones, narrow
|
||||
/// panes).
|
||||
double chatCopyGutter(double width) =>
|
||||
chatReadingInset(width) >= kChatCopyGutterWidth ? kChatCopyGutterWidth : 0;
|
||||
|
||||
@@ -59,6 +59,7 @@ import '../../../ui/adaptive/segmented_bar_overlay.dart';
|
||||
import '../../../ui/layout/app_sheet_header.dart';
|
||||
import '../../../ui/layout/wheel_scroll_forwarding.dart';
|
||||
import 'chat_reading_width.dart';
|
||||
import '../ui/transcript/chat_copy_gutter.dart';
|
||||
import 'chat_pane_presentation.dart';
|
||||
import 'chat_thread_header.dart';
|
||||
import 'chat_transcript_anchor.dart';
|
||||
@@ -67,6 +68,8 @@ import '../files/files_controller.dart';
|
||||
import '../files/files_panel.dart';
|
||||
import '../files/files_preferences.dart';
|
||||
import '../shell/chat_shell_command.dart';
|
||||
import '../shell/chat_shell_history.dart';
|
||||
import '../shell/chat_shell_history_chip.dart';
|
||||
import '../shell/chat_shell_dismiss.dart';
|
||||
import '../shell/chat_shell_run.dart';
|
||||
import '../shell/chat_shell_run_card.dart';
|
||||
@@ -1053,11 +1056,15 @@ class _ChatThreadViewState extends State<ChatThreadView> {
|
||||
);
|
||||
final notices = _dismissals.visible(allNotices);
|
||||
final compactionNotice = _noticeOf(notices, ChatNoticeKind.compaction);
|
||||
// The operator's own shell commands sit among the turns by start time.
|
||||
final rows = withChatShellRunRows([
|
||||
for (final row in allRows)
|
||||
if (!_hiddenRunningCompaction(row)) row,
|
||||
], _shellRuns.runs);
|
||||
// The operator's own shell commands sit among the turns by start time;
|
||||
// dismissed ones fold into a chip under the answer that followed them.
|
||||
final rows = attachChatShellHistory(
|
||||
withChatShellRunRows([
|
||||
for (final row in allRows)
|
||||
if (!_hiddenRunningCompaction(row)) row,
|
||||
], _shellRuns.runs),
|
||||
_shellRuns.dismissedRuns,
|
||||
);
|
||||
// Older pages prepend messages and a live frame can append one, so a
|
||||
// folded assistant turn's first message id is not a stable identity.
|
||||
// ChatRowKeys carries a turn's key forward while it still holds any of
|
||||
@@ -1129,29 +1136,42 @@ class _ChatThreadViewState extends State<ChatThreadView> {
|
||||
// Rows keep to the centred reading column on a wide
|
||||
// window; the margins beside it still scroll the list.
|
||||
final side = chatReadingInset(constraints.maxWidth);
|
||||
// Answers draw Copy in a strip left of the column; every
|
||||
// other row keeps to the column by insetting past it.
|
||||
final gutter = chatCopyGutter(constraints.maxWidth);
|
||||
final media = MediaQuery.paddingOf(context);
|
||||
final transcript = [
|
||||
for (var index = 0; index < rows.length; index++)
|
||||
Padding(
|
||||
key: ValueKey<String>(keys[index]),
|
||||
padding: const EdgeInsets.symmetric(horizontal: 16),
|
||||
padding: EdgeInsets.only(
|
||||
left:
|
||||
16 +
|
||||
(rows[index]['kind'] == 'assistant' ? 0 : gutter),
|
||||
right: 16,
|
||||
),
|
||||
// Slivers mount only visible rows. Defer constructing
|
||||
// their chips and checking cached widgets until then,
|
||||
// rather than visiting the entire history per delta.
|
||||
child: Builder(
|
||||
builder: (_) => _entering(
|
||||
rows[index],
|
||||
_transcriptRow(
|
||||
child: ChatCopyGutter(
|
||||
width: rows[index]['kind'] == 'assistant'
|
||||
? gutter
|
||||
: 0,
|
||||
child: Builder(
|
||||
builder: (_) => _entering(
|
||||
rows[index],
|
||||
keys[index],
|
||||
onDismissCompaction:
|
||||
compactionNotice != null &&
|
||||
chatNoticeActivityCondition(
|
||||
rows[index],
|
||||
) ==
|
||||
compactionNotice.condition
|
||||
? () => _dismiss(compactionNotice)
|
||||
: null,
|
||||
_transcriptRow(
|
||||
rows[index],
|
||||
keys[index],
|
||||
onDismissCompaction:
|
||||
compactionNotice != null &&
|
||||
chatNoticeActivityCondition(
|
||||
rows[index],
|
||||
) ==
|
||||
compactionNotice.condition
|
||||
? () => _dismiss(compactionNotice)
|
||||
: null,
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
@@ -1177,12 +1197,12 @@ class _ChatThreadViewState extends State<ChatThreadView> {
|
||||
? null
|
||||
: ValueKey<String>(keys[split]),
|
||||
padding: EdgeInsets.fromLTRB(
|
||||
side,
|
||||
side - gutter,
|
||||
media.top + 8,
|
||||
side,
|
||||
8,
|
||||
),
|
||||
children: [
|
||||
children: chatCopyGutterInset(gutter, transcript, [
|
||||
if (initialLoad)
|
||||
Padding(
|
||||
key: const Key('chat-thread-loading'),
|
||||
@@ -1278,7 +1298,7 @@ class _ChatThreadViewState extends State<ChatThreadView> {
|
||||
notice: notice,
|
||||
onDismiss: _dismiss,
|
||||
),
|
||||
],
|
||||
]),
|
||||
),
|
||||
),
|
||||
if (showJump)
|
||||
@@ -1538,6 +1558,16 @@ class _ChatThreadViewState extends State<ChatThreadView> {
|
||||
runId: '${row['run_id']}',
|
||||
);
|
||||
}
|
||||
if (kind == chatShellHistoryRowKind) {
|
||||
// A chat with no answer yet keeps its dismissed commands on their own.
|
||||
return Align(
|
||||
alignment: AlignmentDirectional.centerStart,
|
||||
child: ChatShellHistoryChip(
|
||||
controller: _shellRuns,
|
||||
runIds: chatShellHistoryIds(row),
|
||||
),
|
||||
);
|
||||
}
|
||||
if (kind == chatShownRowKind) {
|
||||
return ChatShownCard(
|
||||
row: row,
|
||||
@@ -1563,6 +1593,8 @@ class _ChatThreadViewState extends State<ChatThreadView> {
|
||||
summary: Map<String, dynamic>.from(diff),
|
||||
load: () => _controller.turnDiff('${diff['turn_id']}'),
|
||||
),
|
||||
if (chatShellHistoryIds(row) case final ids when ids.isNotEmpty)
|
||||
ChatShellHistoryChip(controller: _shellRuns, runIds: ids),
|
||||
];
|
||||
if (kind == 'permissions') {
|
||||
return Align(
|
||||
@@ -1587,7 +1619,15 @@ class _ChatThreadViewState extends State<ChatThreadView> {
|
||||
return _rowWidgets.widgetFor(
|
||||
key,
|
||||
row,
|
||||
[delivery, cupertino, onRemove != null, _images, _controller, _composer],
|
||||
[
|
||||
delivery,
|
||||
cupertino,
|
||||
onRemove != null,
|
||||
_images,
|
||||
_controller,
|
||||
_composer,
|
||||
_shellRuns,
|
||||
],
|
||||
() => ChatMessageView(
|
||||
row: row,
|
||||
textBuilder: chatMarkdownText,
|
||||
|
||||
@@ -9,7 +9,6 @@ import 'chat_shell_runs_controller.dart';
|
||||
const String chatShellDismissLabel = 'Dismiss';
|
||||
const String chatShellDismissAllLabel = 'Dismiss all finished commands';
|
||||
|
||||
|
||||
/// The card's Dismiss button, offered once the command has finished.
|
||||
class ChatShellDismissButton extends StatelessWidget {
|
||||
const ChatShellDismissButton({
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
import '../../../core/api_gateway.dart';
|
||||
import 'chat_shell_run.dart';
|
||||
|
||||
/// The row field that carries an answer's dismissed command ids, oldest
|
||||
/// first: what its footer's "N commands" chip lists.
|
||||
const String chatShellHistoryField = 'shellHistory';
|
||||
|
||||
/// The transcript row kind of the history chip a chat with no answer shows.
|
||||
const String chatShellHistoryRowKind = 'shell_history';
|
||||
|
||||
/// Attaches each dismissed run to an answer's footer as [chatShellHistoryField]:
|
||||
/// the first assistant reply created at or after the run started, or the last
|
||||
/// reply for a run newer than every reply. A reply without a recorded time is
|
||||
/// only chosen as that last reply. With no assistant reply at all, one
|
||||
/// [chatShellHistoryRowKind] row at the end holds every run.
|
||||
List<JsonMap> attachChatShellHistory(
|
||||
List<JsonMap> rows,
|
||||
List<ChatShellRun> dismissed,
|
||||
) {
|
||||
if (dismissed.isEmpty) return rows;
|
||||
final replies = [
|
||||
for (var i = 0; i < rows.length; i++)
|
||||
if (rows[i]['kind'] == 'assistant') i,
|
||||
];
|
||||
final ordered = [...dismissed]
|
||||
..sort((a, b) => a.startedAt.compareTo(b.startedAt));
|
||||
if (replies.isEmpty) {
|
||||
return [
|
||||
...rows,
|
||||
{
|
||||
'kind': chatShellHistoryRowKind,
|
||||
'key': 'chat-shell-history',
|
||||
chatShellHistoryField: [for (final run in ordered) run.id],
|
||||
},
|
||||
];
|
||||
}
|
||||
final assigned = <int, List<String>>{};
|
||||
for (final run in ordered) {
|
||||
final index = replies.firstWhere((i) {
|
||||
final created = rows[i]['created_at'];
|
||||
return created is num && created >= run.startedAt;
|
||||
}, orElse: () => replies.last);
|
||||
(assigned[index] ??= []).add(run.id);
|
||||
}
|
||||
return [
|
||||
for (var i = 0; i < rows.length; i++)
|
||||
if (assigned[i] case final ids?)
|
||||
{...rows[i], chatShellHistoryField: ids}
|
||||
else
|
||||
rows[i],
|
||||
];
|
||||
}
|
||||
|
||||
/// The dismissed command ids [row] carries, oldest first.
|
||||
List<String> chatShellHistoryIds(JsonMap row) => [
|
||||
for (final id in row[chatShellHistoryField] as List? ?? const []) '$id',
|
||||
];
|
||||
|
||||
/// The chip's label, e.g. `2 commands`.
|
||||
String chatShellHistoryLabel(int count) =>
|
||||
count == 1 ? '1 command' : '$count commands';
|
||||
|
||||
/// The chip's accessible name.
|
||||
String chatShellHistorySemantics(int count) =>
|
||||
'${chatShellHistoryLabel(count)} dismissed, open command history';
|
||||
@@ -0,0 +1,82 @@
|
||||
import 'package:flutter/cupertino.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
|
||||
import '../../../shell/list_detail_policy.dart';
|
||||
import '../ui/sessions/chat_adaptive.dart';
|
||||
import '../ui/transcript/chat_turn_chip.dart';
|
||||
import 'chat_shell_history.dart';
|
||||
import 'chat_shell_history_view.dart';
|
||||
import 'chat_shell_runs_controller.dart';
|
||||
|
||||
/// The dismissed commands attached to an answer, as a chip in its footer
|
||||
/// beside the change and tool chips: `2 commands`. A wide window opens the
|
||||
/// list in the turn sheet; a narrow one opens it as a full-screen page.
|
||||
class ChatShellHistoryChip extends StatelessWidget {
|
||||
const ChatShellHistoryChip({
|
||||
super.key,
|
||||
required this.controller,
|
||||
required this.runIds,
|
||||
});
|
||||
|
||||
final ChatShellRunsController controller;
|
||||
|
||||
/// The dismissed runs this chip lists, oldest first.
|
||||
final List<String> runIds;
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final cupertino =
|
||||
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
|
||||
final color = cupertino
|
||||
? CupertinoColors.secondaryLabel.resolveFrom(context)
|
||||
: Theme.of(context).colorScheme.onSurfaceVariant;
|
||||
return ChatTurnChip(
|
||||
chipKey: const Key('chat-shell-history-chip'),
|
||||
leading: Icon(
|
||||
cupertino
|
||||
? CupertinoIcons.chevron_left_slash_chevron_right
|
||||
: Icons.terminal,
|
||||
size: 14,
|
||||
color: color,
|
||||
),
|
||||
label: chatShellHistoryLabel(runIds.length),
|
||||
color: color,
|
||||
semanticsLabel: chatShellHistorySemantics(runIds.length),
|
||||
ellipsizeLabel: true,
|
||||
open: _open,
|
||||
);
|
||||
}
|
||||
|
||||
Future<void> _open(BuildContext context, bool cupertino) {
|
||||
if (MediaQuery.sizeOf(context).width >= kListDetailMinWidth) {
|
||||
return showChatTurnSheet(
|
||||
context,
|
||||
cupertino,
|
||||
ChatShellHistoryView(controller: controller, runIds: runIds),
|
||||
);
|
||||
}
|
||||
final view = ChatShellHistoryView(
|
||||
controller: controller,
|
||||
runIds: runIds,
|
||||
inSheet: false,
|
||||
);
|
||||
const title = Text(chatShellHistoryTitle);
|
||||
return Navigator.of(context).push<void>(
|
||||
cupertino
|
||||
? CupertinoPageRoute<void>(
|
||||
fullscreenDialog: true,
|
||||
builder: (_) => CupertinoPageScaffold(
|
||||
navigationBar: const CupertinoNavigationBar(middle: title),
|
||||
child: SafeArea(child: view),
|
||||
),
|
||||
)
|
||||
: MaterialPageRoute<void>(
|
||||
fullscreenDialog: true,
|
||||
builder: (_) => Scaffold(
|
||||
appBar: AppBar(title: title),
|
||||
body: SafeArea(child: view),
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,277 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/cupertino.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter/services.dart';
|
||||
|
||||
import '../../../ui/text/monospace.dart';
|
||||
import '../conversation/chat_card_styles.dart';
|
||||
import 'chat_shell_card_actions.dart';
|
||||
import 'chat_shell_run.dart';
|
||||
import 'chat_shell_runs_controller.dart';
|
||||
import 'chat_shell_status.dart';
|
||||
import 'chat_shell_terminal_session.dart';
|
||||
import 'chat_shell_terminal_view.dart';
|
||||
|
||||
/// Opens a dismissed command's output read-only, full screen.
|
||||
Future<void> openChatShellHistoryOutput(
|
||||
BuildContext context, {
|
||||
required ChatShellRunsController controller,
|
||||
required String runId,
|
||||
required bool cupertino,
|
||||
}) {
|
||||
Widget page(BuildContext _) => ChatShellHistoryOutputPage(
|
||||
controller: controller,
|
||||
runId: runId,
|
||||
cupertino: cupertino,
|
||||
);
|
||||
return Navigator.of(context).push<void>(
|
||||
cupertino
|
||||
? CupertinoPageRoute<void>(builder: page)
|
||||
: MaterialPageRoute<void>(builder: page),
|
||||
);
|
||||
}
|
||||
|
||||
/// One dismissed command: everything the server kept of its output in the
|
||||
/// card's terminal view (read-only), with Copy output, Send to agent and
|
||||
/// Restore, which puts its card back in the transcript and closes the page.
|
||||
class ChatShellHistoryOutputPage extends StatefulWidget {
|
||||
const ChatShellHistoryOutputPage({
|
||||
super.key,
|
||||
required this.controller,
|
||||
required this.runId,
|
||||
required this.cupertino,
|
||||
});
|
||||
|
||||
final ChatShellRunsController controller;
|
||||
final String runId;
|
||||
final bool cupertino;
|
||||
|
||||
@override
|
||||
State<ChatShellHistoryOutputPage> createState() =>
|
||||
_ChatShellHistoryOutputPageState();
|
||||
}
|
||||
|
||||
class _ChatShellHistoryOutputPageState
|
||||
extends State<ChatShellHistoryOutputPage> {
|
||||
late final Future<ChatShellRun> _full = widget.controller.fullOutput(
|
||||
widget.runId,
|
||||
);
|
||||
ChatShellTerminalSession? _session;
|
||||
bool _copied = false;
|
||||
String? _refusal;
|
||||
Timer? _reset;
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
_reset?.cancel();
|
||||
super.dispose();
|
||||
}
|
||||
|
||||
Future<void> _copy(ChatShellRun full) async {
|
||||
final text = full.terminal || full.text.isNotEmpty
|
||||
? full.text
|
||||
: full.output;
|
||||
await Clipboard.setData(ClipboardData(text: text));
|
||||
if (!mounted) return;
|
||||
setState(() => _copied = true);
|
||||
_reset?.cancel();
|
||||
_reset = Timer(const Duration(seconds: 2), () {
|
||||
if (mounted) setState(() => _copied = false);
|
||||
});
|
||||
}
|
||||
|
||||
Future<void> _restore() async {
|
||||
final refusal = await widget.controller.restore([widget.runId]);
|
||||
if (!mounted) return;
|
||||
if (refusal == null) {
|
||||
Navigator.of(context).maybePop();
|
||||
} else {
|
||||
setState(() => _refusal = refusal);
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final cupertino = widget.cupertino;
|
||||
final held = widget.controller.dismissedRun(widget.runId);
|
||||
final title = Text(
|
||||
held == null ? 'Command' : '\$ ${held.command}',
|
||||
maxLines: 1,
|
||||
overflow: TextOverflow.ellipsis,
|
||||
style: const TextStyle(fontFamily: appMonospaceFamily),
|
||||
);
|
||||
final body = SafeArea(
|
||||
child: Padding(
|
||||
padding: const EdgeInsets.all(8),
|
||||
child: FutureBuilder<ChatShellRun>(
|
||||
future: _full,
|
||||
builder: (context, snapshot) {
|
||||
if (snapshot.hasError) {
|
||||
return Text(
|
||||
"Couldn't read the output: ${snapshot.error}",
|
||||
style: chatCardSecondaryStyle(context, cupertino),
|
||||
);
|
||||
}
|
||||
final full = snapshot.data;
|
||||
if (full == null) {
|
||||
return Center(
|
||||
child: cupertino
|
||||
? const CupertinoActivityIndicator()
|
||||
: const CircularProgressIndicator(),
|
||||
);
|
||||
}
|
||||
return _content(context, full);
|
||||
},
|
||||
),
|
||||
),
|
||||
);
|
||||
if (cupertino) {
|
||||
return CupertinoPageScaffold(
|
||||
navigationBar: CupertinoNavigationBar(middle: title),
|
||||
child: body,
|
||||
);
|
||||
}
|
||||
return Scaffold(
|
||||
appBar: AppBar(title: title),
|
||||
body: body,
|
||||
);
|
||||
}
|
||||
|
||||
Widget _content(BuildContext context, ChatShellRun full) {
|
||||
final cupertino = widget.cupertino;
|
||||
final session = _session ??= ChatShellTerminalSession(
|
||||
full,
|
||||
onInput: (_) {},
|
||||
onResize: (_, _) {},
|
||||
);
|
||||
return Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.stretch,
|
||||
children: [
|
||||
Padding(
|
||||
padding: const EdgeInsets.only(bottom: 8),
|
||||
child: Wrap(
|
||||
spacing: 8,
|
||||
runSpacing: 4,
|
||||
crossAxisAlignment: WrapCrossAlignment.center,
|
||||
children: [
|
||||
ChatShellStatus(run: full, cupertino: cupertino),
|
||||
if (full.directory.isNotEmpty)
|
||||
Text(
|
||||
full.directory,
|
||||
style: chatCardSecondaryStyle(context, cupertino),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
Expanded(
|
||||
child: full.output.isEmpty
|
||||
? Text(
|
||||
'No output.',
|
||||
key: const Key('chat-shell-output-empty'),
|
||||
style: chatCardSecondaryStyle(context, cupertino),
|
||||
)
|
||||
: ChatShellTerminalView(
|
||||
session: session,
|
||||
cupertino: cupertino,
|
||||
fill: true,
|
||||
),
|
||||
),
|
||||
const SizedBox(height: 8),
|
||||
ListenableBuilder(
|
||||
listenable: widget.controller,
|
||||
builder: (context, _) => _actions(context, full),
|
||||
),
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
Widget _actions(BuildContext context, ChatShellRun full) {
|
||||
final controller = widget.controller;
|
||||
final share = controller.shareState(widget.runId);
|
||||
final error = _refusal ?? controller.errorFor(widget.runId);
|
||||
return Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.start,
|
||||
mainAxisSize: MainAxisSize.min,
|
||||
children: [
|
||||
Wrap(
|
||||
spacing: 8,
|
||||
runSpacing: 4,
|
||||
children: [
|
||||
if (full.outputBytes > 0)
|
||||
_button(
|
||||
key: const Key('chat-shell-history-copy'),
|
||||
label: _copied ? chatShellCopiedLabel : chatShellCopyLabel,
|
||||
material: _copied ? Icons.check : Icons.copy_outlined,
|
||||
cupertino: _copied
|
||||
? CupertinoIcons.checkmark
|
||||
: CupertinoIcons.doc_on_doc,
|
||||
onPressed: () => unawaited(_copy(full)),
|
||||
),
|
||||
_button(
|
||||
key: const Key('chat-shell-history-share'),
|
||||
label: switch (share) {
|
||||
ChatShellShareState.idle => chatShellShareLabel,
|
||||
ChatShellShareState.sending => chatShellSharingLabel,
|
||||
ChatShellShareState.sent => chatShellSharedLabel,
|
||||
},
|
||||
material: share == ChatShellShareState.sent
|
||||
? Icons.check
|
||||
: Icons.send_outlined,
|
||||
cupertino: share == ChatShellShareState.sent
|
||||
? CupertinoIcons.checkmark
|
||||
: CupertinoIcons.paperplane,
|
||||
onPressed: share == ChatShellShareState.idle
|
||||
? () => unawaited(controller.share(widget.runId))
|
||||
: null,
|
||||
),
|
||||
_button(
|
||||
key: const Key('chat-shell-history-page-restore'),
|
||||
label: 'Restore',
|
||||
material: Icons.restore,
|
||||
cupertino: CupertinoIcons.arrow_counterclockwise,
|
||||
onPressed: () => unawaited(_restore()),
|
||||
),
|
||||
],
|
||||
),
|
||||
if (error != null)
|
||||
Semantics(
|
||||
liveRegion: true,
|
||||
child: Text(
|
||||
error,
|
||||
style: chatCardSecondaryStyle(
|
||||
context,
|
||||
widget.cupertino,
|
||||
)?.copyWith(color: chatCardErrorColor(context, widget.cupertino)),
|
||||
),
|
||||
),
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
Widget _button({
|
||||
required Key key,
|
||||
required String label,
|
||||
required IconData material,
|
||||
required IconData cupertino,
|
||||
required VoidCallback? onPressed,
|
||||
}) {
|
||||
if (widget.cupertino) {
|
||||
return CupertinoButton(
|
||||
key: key,
|
||||
padding: const EdgeInsets.symmetric(horizontal: 8),
|
||||
onPressed: onPressed,
|
||||
child: Row(
|
||||
mainAxisSize: MainAxisSize.min,
|
||||
children: [Icon(cupertino), const SizedBox(width: 6), Text(label)],
|
||||
),
|
||||
);
|
||||
}
|
||||
return TextButton.icon(
|
||||
key: key,
|
||||
onPressed: onPressed,
|
||||
icon: Icon(material),
|
||||
label: Text(label),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,186 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/cupertino.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
|
||||
import '../../../ui/text/monospace.dart';
|
||||
import '../conversation/chat_card_styles.dart';
|
||||
import '../ui/sessions/chat_adaptive.dart';
|
||||
import 'chat_shell_history_output_page.dart';
|
||||
import 'chat_shell_run.dart';
|
||||
import 'chat_shell_runs_controller.dart';
|
||||
import 'chat_shell_status.dart';
|
||||
|
||||
const String chatShellHistoryTitle = 'Dismissed commands';
|
||||
const String chatShellRestoreLabel = 'Restore';
|
||||
const String chatShellCommandNotKept = 'Command not kept';
|
||||
const String chatShellOutputNotKept = 'Output not kept';
|
||||
|
||||
/// The dismissed commands of one answer: each command with its exit status,
|
||||
/// how long it ran and when. Tapping one opens its output read-only; Restore
|
||||
/// puts its card back in the transcript.
|
||||
class ChatShellHistoryView extends StatefulWidget {
|
||||
const ChatShellHistoryView({
|
||||
super.key,
|
||||
required this.controller,
|
||||
required this.runIds,
|
||||
this.inSheet = true,
|
||||
});
|
||||
|
||||
final ChatShellRunsController controller;
|
||||
final List<String> runIds;
|
||||
|
||||
/// In the turn sheet (shrinks to its content) rather than a page.
|
||||
final bool inSheet;
|
||||
|
||||
@override
|
||||
State<ChatShellHistoryView> createState() => _ChatShellHistoryViewState();
|
||||
}
|
||||
|
||||
class _ChatShellHistoryViewState extends State<ChatShellHistoryView> {
|
||||
final Map<String, String> _refusals = {};
|
||||
|
||||
Future<void> _restore(String id) async {
|
||||
final refusal = await widget.controller.restore([id]);
|
||||
if (!mounted) return;
|
||||
setState(() {
|
||||
if (refusal == null) {
|
||||
_refusals.remove(id);
|
||||
} else {
|
||||
_refusals[id] = refusal;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final cupertino =
|
||||
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
|
||||
final list = ListenableBuilder(
|
||||
listenable: widget.controller.membership,
|
||||
builder: (context, _) {
|
||||
final runs = [
|
||||
for (final id in widget.runIds) ?widget.controller.dismissedRun(id),
|
||||
];
|
||||
return ListView(
|
||||
key: const Key('chat-shell-history-list'),
|
||||
shrinkWrap: widget.inSheet,
|
||||
padding: const EdgeInsets.symmetric(vertical: 8),
|
||||
children: [
|
||||
if (widget.inSheet)
|
||||
Padding(
|
||||
padding: const EdgeInsets.fromLTRB(16, 0, 16, 4),
|
||||
child: Text(
|
||||
chatShellHistoryTitle,
|
||||
style: const TextStyle(fontWeight: FontWeight.w600),
|
||||
),
|
||||
),
|
||||
if (runs.isEmpty)
|
||||
Padding(
|
||||
padding: const EdgeInsets.all(16),
|
||||
child: Text(
|
||||
'Every command here was restored to the transcript.',
|
||||
style: chatCardSecondaryStyle(context, cupertino),
|
||||
),
|
||||
),
|
||||
for (final run in runs) _entry(context, run, cupertino),
|
||||
],
|
||||
);
|
||||
},
|
||||
);
|
||||
final style = cupertino
|
||||
? CupertinoTheme.of(context).textTheme.textStyle
|
||||
: Theme.of(context).textTheme.bodyMedium;
|
||||
// Entries are Material list tiles inside a Cupertino surface too.
|
||||
final content = Material(
|
||||
type: MaterialType.transparency,
|
||||
child: DefaultTextStyle.merge(style: style, child: list),
|
||||
);
|
||||
if (!widget.inSheet) return content;
|
||||
return ConstrainedBox(
|
||||
constraints: BoxConstraints(
|
||||
maxHeight: MediaQuery.sizeOf(context).height * 0.8,
|
||||
),
|
||||
child: content,
|
||||
);
|
||||
}
|
||||
|
||||
Widget _entry(BuildContext context, ChatShellRun run, bool cupertino) {
|
||||
final secondary = chatCardSecondaryStyle(context, cupertino);
|
||||
final refusal = _refusals[run.id];
|
||||
final command = run.purged || run.command.isEmpty
|
||||
? Text(chatShellCommandNotKept, style: secondary)
|
||||
: Text(
|
||||
'\$ ${run.command}',
|
||||
maxLines: 2,
|
||||
overflow: TextOverflow.ellipsis,
|
||||
style: const TextStyle(
|
||||
fontFamily: appMonospaceFamily,
|
||||
fontWeight: FontWeight.w600,
|
||||
),
|
||||
);
|
||||
final details = Wrap(
|
||||
spacing: 8,
|
||||
runSpacing: 4,
|
||||
crossAxisAlignment: WrapCrossAlignment.center,
|
||||
children: [
|
||||
ChatShellStatus(run: run, cupertino: cupertino),
|
||||
Text(chatShellRunTime(context, run.startedAt), style: secondary),
|
||||
if (run.purged) Text(chatShellOutputNotKept, style: secondary),
|
||||
if (refusal != null)
|
||||
Text(
|
||||
refusal,
|
||||
key: const Key('chat-shell-history-refusal'),
|
||||
style: secondary?.copyWith(
|
||||
color: chatCardErrorColor(context, cupertino),
|
||||
),
|
||||
),
|
||||
],
|
||||
);
|
||||
final restore = run.purged
|
||||
? null
|
||||
: cupertino
|
||||
? CupertinoButton(
|
||||
key: ValueKey<String>('chat-shell-history-restore-${run.id}'),
|
||||
padding: const EdgeInsets.symmetric(horizontal: 8),
|
||||
onPressed: () => unawaited(_restore(run.id)),
|
||||
child: const Text(chatShellRestoreLabel),
|
||||
)
|
||||
: TextButton(
|
||||
key: ValueKey<String>('chat-shell-history-restore-${run.id}'),
|
||||
onPressed: () => unawaited(_restore(run.id)),
|
||||
child: const Text(chatShellRestoreLabel),
|
||||
);
|
||||
return ListTile(
|
||||
key: ValueKey<String>('chat-shell-history-${run.id}'),
|
||||
title: command,
|
||||
subtitle: Padding(padding: const EdgeInsets.only(top: 4), child: details),
|
||||
trailing: restore,
|
||||
enabled: !run.purged,
|
||||
onTap: run.purged
|
||||
? null
|
||||
: () => unawaited(
|
||||
openChatShellHistoryOutput(
|
||||
context,
|
||||
controller: widget.controller,
|
||||
runId: run.id,
|
||||
cupertino: cupertino,
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// When a command started, as the operator's local date and time.
|
||||
String chatShellRunTime(BuildContext context, int startedAt) {
|
||||
if (startedAt <= 0) return '';
|
||||
final instant = DateTime.fromMillisecondsSinceEpoch(startedAt).toLocal();
|
||||
final material = Localizations.of<MaterialLocalizations>(
|
||||
context,
|
||||
MaterialLocalizations,
|
||||
);
|
||||
final hour = instant.hour.toString().padLeft(2, '0');
|
||||
final minute = instant.minute.toString().padLeft(2, '0');
|
||||
if (material == null) return '${instant.day}/${instant.month} $hour:$minute';
|
||||
return '${material.formatShortMonthDay(instant)} · $hour:$minute';
|
||||
}
|
||||
@@ -31,6 +31,8 @@ class ChatShellRun {
|
||||
this.cols = 0,
|
||||
this.rows = 0,
|
||||
this.text = '',
|
||||
this.dismissedAt = 0,
|
||||
this.purged = false,
|
||||
});
|
||||
|
||||
final String id;
|
||||
@@ -68,6 +70,13 @@ class ChatShellRun {
|
||||
/// removed); only a whole-output readback carries it.
|
||||
final String text;
|
||||
|
||||
/// When the operator dismissed the run (epoch ms; 0 when not dismissed).
|
||||
final int dismissedAt;
|
||||
|
||||
/// True when an older server deleted the dismissed run's command and
|
||||
/// output: only its status and times are left, and it cannot be restored.
|
||||
final bool purged;
|
||||
|
||||
/// Whether earlier output is not shown here.
|
||||
bool get truncated => outputStart > 0 || gap;
|
||||
|
||||
@@ -111,6 +120,8 @@ class ChatShellRun {
|
||||
cols: _int(value['cols']),
|
||||
rows: _int(value['rows']),
|
||||
text: '${value['text'] ?? ''}',
|
||||
dismissedAt: _int(value['dismissed_at']),
|
||||
purged: value['purged'] == true,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -137,6 +148,8 @@ class ChatShellRun {
|
||||
cols: next.cols == 0 ? cols : next.cols,
|
||||
rows: next.rows == 0 ? rows : next.rows,
|
||||
text: text,
|
||||
dismissedAt: next.dismissedAt,
|
||||
purged: next.purged,
|
||||
);
|
||||
|
||||
/// This run with one live output chunk covering bytes [offset, end). A
|
||||
|
||||
@@ -18,7 +18,8 @@ import 'chat_shell_terminal_page.dart';
|
||||
/// One operator command in the transcript, as a terminal card in the reading
|
||||
/// column: the command and folder, its terminal (typed into while it runs),
|
||||
/// a spinner and Stop while it runs, then its exit status, Copy output and
|
||||
/// Send to agent, and Dismiss (for every client of the chat, with Undo). A
|
||||
/// Send to agent, and Dismiss (for every client of the chat; the run moves
|
||||
/// into the answer's command history chip, which can restore it). A
|
||||
/// running command has no Dismiss: Stop it first. Full screen opens the same
|
||||
/// terminal over the whole window.
|
||||
///
|
||||
|
||||
@@ -51,6 +51,10 @@ class ChatShellRunsController extends ChangeNotifier {
|
||||
/// Runs dismissed here or by another client: a readback racing the
|
||||
/// dismissal does not bring their cards back.
|
||||
final Set<String> _gone = {};
|
||||
|
||||
/// The dismissed runs this copy holds, shown collapsed in the transcript's
|
||||
/// command history rather than as cards.
|
||||
final Map<String, ChatShellRun> _dismissed = {};
|
||||
bool _disposed = false;
|
||||
int _generation = 0;
|
||||
|
||||
@@ -75,11 +79,16 @@ class ChatShellRunsController extends ChangeNotifier {
|
||||
Future<void> refresh() async {
|
||||
final token = ++_generation;
|
||||
try {
|
||||
final (:runs, :dismissed) = await _repository.runs(sessionId);
|
||||
final (:runs, :dismissed, :dismissedRuns) = await _repository.runs(
|
||||
sessionId,
|
||||
);
|
||||
if (_disposed || token != _generation) return;
|
||||
dismissed.forEach(_remove);
|
||||
_holdDismissed(dismissedRuns);
|
||||
for (final run in runs) {
|
||||
if (_gone.contains(run.id)) continue;
|
||||
// Restored by another client while this copy missed the frame.
|
||||
_dismissed.remove(run.id);
|
||||
final held = _runs[run.id];
|
||||
if (held != null &&
|
||||
held.running &&
|
||||
@@ -204,7 +213,10 @@ class ChatShellRunsController extends ChangeNotifier {
|
||||
if (frame is! Map || frame['session_id'] != sessionId) return;
|
||||
final id = '${frame['run_id'] ?? ''}';
|
||||
if (frame['dismissed'] == true) {
|
||||
final known = _runs.containsKey(id) || _dismissed.containsKey(id);
|
||||
_remove(id);
|
||||
// Another client dismissed a run this copy never held: read it.
|
||||
if (!known) unawaited(refresh());
|
||||
_changed(membership: true);
|
||||
return;
|
||||
}
|
||||
@@ -212,6 +224,7 @@ class ChatShellRunsController extends ChangeNotifier {
|
||||
if (record != null) {
|
||||
// A restored run (another client's Undo) comes back without output.
|
||||
if (_gone.remove(record.id) && !record.running) unawaited(refresh());
|
||||
_dismissed.remove(record.id);
|
||||
final held = _runs[record.id];
|
||||
final next = held == null ? record : held.withLifecycle(record);
|
||||
_runs[record.id] = next;
|
||||
|
||||
@@ -1,11 +1,21 @@
|
||||
part of 'chat_shell_runs_controller.dart';
|
||||
|
||||
/// Dismissing finished command cards for every client of the chat, and the
|
||||
/// Undo that restores them while the server still keeps them.
|
||||
/// Dismissing finished command cards for every client of the chat, the
|
||||
/// dismissed runs the server keeps (the transcript's command history), and
|
||||
/// Restore, which puts a card back.
|
||||
extension ChatShellRunsDismissal on ChatShellRunsController {
|
||||
/// The dismissed runs this copy holds, oldest first.
|
||||
List<ChatShellRun> get dismissedRuns =>
|
||||
[..._dismissed.values]
|
||||
..sort((a, b) => a.startedAt.compareTo(b.startedAt));
|
||||
|
||||
/// One dismissed run, or null once it was restored (or aged out).
|
||||
ChatShellRun? dismissedRun(String id) => _dismissed[id];
|
||||
|
||||
/// Dismisses finished runs [ids] for every client of the chat: their cards
|
||||
/// go at once and come back (with the refusal) if the server refuses.
|
||||
/// Returns the refusal, or null. A running command is never dismissed.
|
||||
/// go at once into the command history and come back (with the refusal) if
|
||||
/// the server refuses. Returns the refusal, or null. A running command is
|
||||
/// never dismissed.
|
||||
Future<String?> dismiss(List<String> ids) async {
|
||||
final removed = [
|
||||
for (final id in ids)
|
||||
@@ -24,6 +34,7 @@ extension ChatShellRunsDismissal on ChatShellRunsController {
|
||||
final reason = _reason(error);
|
||||
for (final run in removed) {
|
||||
_gone.remove(run.id);
|
||||
_dismissed.remove(run.id);
|
||||
_runs[run.id] = run;
|
||||
_errors[run.id] = reason;
|
||||
}
|
||||
@@ -32,14 +43,15 @@ extension ChatShellRunsDismissal on ChatShellRunsController {
|
||||
}
|
||||
}
|
||||
|
||||
/// Undoes the dismissal of [ids] while the server still keeps them.
|
||||
/// Returns the refusal, or null.
|
||||
/// Puts dismissed runs [ids] back in the transcript as cards, for every
|
||||
/// client. Returns the refusal, or null.
|
||||
Future<String?> restore(List<String> ids) async {
|
||||
try {
|
||||
final restored = await _repository.restore(sessionId, ids);
|
||||
if (_disposed) return null;
|
||||
for (final run in restored) {
|
||||
_gone.remove(run.id);
|
||||
_dismissed.remove(run.id);
|
||||
final held = _runs[run.id];
|
||||
final keep = held != null && held.outputEnd >= run.outputEnd;
|
||||
_runs[run.id] = keep ? held.withLifecycle(run) : run;
|
||||
@@ -52,7 +64,24 @@ extension ChatShellRunsDismissal on ChatShellRunsController {
|
||||
}
|
||||
}
|
||||
|
||||
/// The dismissed run [id] with everything the server kept of its output
|
||||
/// and its plain-text rendering, for the history's read-only output view.
|
||||
Future<ChatShellRun> fullOutput(String id) =>
|
||||
_repository.output(sessionId, id);
|
||||
|
||||
/// Folds a readback's dismissed runs into the history. Runs this copy
|
||||
/// dismissed but the readback does not list yet stay held.
|
||||
void _holdDismissed(List<ChatShellRun> runs) {
|
||||
for (final run in runs) {
|
||||
_gone.add(run.id);
|
||||
_dismissed[run.id] = run;
|
||||
}
|
||||
}
|
||||
|
||||
/// Takes [id]'s card out of the transcript; a held copy moves into the
|
||||
/// command history.
|
||||
void _remove(String id) {
|
||||
if (_runs[id] case final run?) _dismissed[id] = run;
|
||||
_gone.add(id);
|
||||
_runs.remove(id);
|
||||
_errors.remove(id);
|
||||
|
||||
@@ -57,15 +57,25 @@ class ChatShellRunsRepository {
|
||||
Future<void> stop(String sessionId, String runId) =>
|
||||
gateway.call('chat_shell_stop', _body(sessionId, runId: runId));
|
||||
|
||||
/// The session's recorded runs, oldest first, each with its output tail,
|
||||
/// and the ids of its dismissed runs (whose cards go away).
|
||||
Future<({List<ChatShellRun> runs, Set<String> dismissed})> runs(
|
||||
String sessionId,
|
||||
) async {
|
||||
/// The session's recorded runs, oldest first, each with its output tail;
|
||||
/// the ids of its dismissed runs (whose cards go away); and the dismissed
|
||||
/// runs themselves, which a server that keeps them also sends.
|
||||
Future<
|
||||
({
|
||||
List<ChatShellRun> runs,
|
||||
Set<String> dismissed,
|
||||
List<ChatShellRun> dismissedRuns,
|
||||
})
|
||||
>
|
||||
runs(String sessionId) async {
|
||||
final reply = await gateway.call('chat_shell_runs', {
|
||||
'chat_query': {'session_id': sessionId},
|
||||
});
|
||||
return (runs: _records(reply), dismissed: _ids(reply));
|
||||
return (
|
||||
runs: _records(reply),
|
||||
dismissed: _ids(reply),
|
||||
dismissedRuns: _records(reply, 'chat_shell_dismissed_runs'),
|
||||
);
|
||||
}
|
||||
|
||||
/// Dismisses finished runs for every client of the chat; the reply names
|
||||
@@ -78,8 +88,8 @@ class ChatShellRunsRepository {
|
||||
),
|
||||
);
|
||||
|
||||
/// Undoes a dismissal still inside the server's undo window; the reply is
|
||||
/// the restored runs with their output tail.
|
||||
/// Undoes a dismissal (at any time; an older server only within its undo
|
||||
/// window); the reply is the restored runs with their output tail.
|
||||
Future<List<ChatShellRun>> restore(
|
||||
String sessionId,
|
||||
List<String> runIds,
|
||||
@@ -87,8 +97,11 @@ class ChatShellRunsRepository {
|
||||
await gateway.call('chat_shell_restore', _body(sessionId, runIds: runIds)),
|
||||
);
|
||||
|
||||
List<ChatShellRun> _records(JsonMap reply) {
|
||||
final value = reply['chat_shell_runs'];
|
||||
List<ChatShellRun> _records(
|
||||
JsonMap reply, [
|
||||
String field = 'chat_shell_runs',
|
||||
]) {
|
||||
final value = reply[field];
|
||||
return [
|
||||
if (value is List)
|
||||
for (final item in value) ?ChatShellRun.fromJson(item),
|
||||
|
||||
@@ -0,0 +1,110 @@
|
||||
import 'package:flutter/material.dart';
|
||||
|
||||
import '../../../../ui/adaptive/platform.dart';
|
||||
|
||||
/// The width of the strip left of the reading column that an answer row
|
||||
/// draws its Copy button in (`chatCopyGutter`); 0 when there is no room, and
|
||||
/// Copy stays in the answer's footer.
|
||||
class ChatCopyGutter extends InheritedWidget {
|
||||
const ChatCopyGutter({super.key, required this.width, required super.child});
|
||||
|
||||
final double width;
|
||||
|
||||
static double of(BuildContext context) =>
|
||||
context.dependOnInheritedWidgetOfExactType<ChatCopyGutter>()?.width ?? 0;
|
||||
|
||||
@override
|
||||
bool updateShouldNotify(ChatCopyGutter oldWidget) => width != oldWidget.width;
|
||||
}
|
||||
|
||||
/// The transcript's [children] when the list starts [gutter] left of the
|
||||
/// reading column: every child except the transcript [rows] (which inset
|
||||
/// themselves) is inset past the gutter, so it keeps to the column.
|
||||
List<Widget> chatCopyGutterInset(
|
||||
double gutter,
|
||||
List<Widget> rows,
|
||||
List<Widget> children,
|
||||
) {
|
||||
if (gutter <= 0) return children;
|
||||
final own = Set<Widget>.identity()..addAll(rows);
|
||||
return [
|
||||
for (final child in children)
|
||||
if (own.contains(child))
|
||||
child
|
||||
else
|
||||
Padding(
|
||||
key: child.key,
|
||||
padding: EdgeInsets.only(left: gutter),
|
||||
child: child,
|
||||
),
|
||||
];
|
||||
}
|
||||
|
||||
/// An answer with its Copy button in the gutter to its left, bottom-aligned
|
||||
/// with the answer's footer row. On a desktop the button shows while the
|
||||
/// pointer is over the answer or the button has focus; it stays in the
|
||||
/// focus order and the semantics tree when hidden. Touch platforms always
|
||||
/// show it.
|
||||
class ChatCopyGutterRow extends StatefulWidget {
|
||||
const ChatCopyGutterRow({
|
||||
super.key,
|
||||
required this.width,
|
||||
required this.copy,
|
||||
required this.child,
|
||||
});
|
||||
|
||||
final double width;
|
||||
|
||||
/// The Copy button, or null when the answer has nothing to copy yet.
|
||||
final Widget? copy;
|
||||
final Widget child;
|
||||
|
||||
@override
|
||||
State<ChatCopyGutterRow> createState() => _ChatCopyGutterRowState();
|
||||
}
|
||||
|
||||
class _ChatCopyGutterRowState extends State<ChatCopyGutterRow> {
|
||||
bool _hovered = false;
|
||||
bool _focused = false;
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final hover = prefersCompactHitTargets(context);
|
||||
final copy = widget.copy;
|
||||
final row = Row(
|
||||
mainAxisSize: MainAxisSize.min,
|
||||
crossAxisAlignment: CrossAxisAlignment.end,
|
||||
children: [
|
||||
SizedBox(
|
||||
key: const Key('chat-copy-gutter'),
|
||||
width: widget.width,
|
||||
child: copy == null
|
||||
? null
|
||||
: Align(
|
||||
alignment: Alignment.bottomRight,
|
||||
child: Focus(
|
||||
canRequestFocus: false,
|
||||
skipTraversal: true,
|
||||
onFocusChange: (focused) =>
|
||||
setState(() => _focused = focused),
|
||||
child: AnimatedOpacity(
|
||||
key: const Key('chat-copy-gutter-visibility'),
|
||||
opacity: !hover || _hovered || _focused ? 1 : 0,
|
||||
duration: const Duration(milliseconds: 120),
|
||||
alwaysIncludeSemantics: true,
|
||||
child: copy,
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
Flexible(child: widget.child),
|
||||
],
|
||||
);
|
||||
if (!hover || copy == null) return row;
|
||||
return MouseRegion(
|
||||
onEnter: (_) => setState(() => _hovered = true),
|
||||
onExit: (_) => setState(() => _hovered = false),
|
||||
child: row,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ import 'chat_attachment_gallery.dart';
|
||||
import '../../domain/chat_tool_calls.dart';
|
||||
import '../../domain/chat_transcript.dart';
|
||||
import 'chat_copy_button.dart';
|
||||
import 'chat_copy_gutter.dart';
|
||||
import 'chat_link_text.dart';
|
||||
import 'chat_message_bubble.dart';
|
||||
import 'chat_turn_activity_view.dart';
|
||||
@@ -49,6 +50,9 @@ class ChatMessageView extends StatelessWidget {
|
||||
final role = user ? 'User' : 'Assistant';
|
||||
final cupertino = _isCupertino(context);
|
||||
final content = user ? _userParts(context) : _agentParts(context);
|
||||
// A wide window draws an answer's Copy in the gutter left of the reading
|
||||
// column; without room it stays at the start of the answer's footer.
|
||||
final gutter = user ? 0.0 : ChatCopyGutter.of(context);
|
||||
// No visible role label: side and surface say who spoke and the row's
|
||||
// semantics label names the role. The operator's turn is a neutral bubble
|
||||
// that shrinks to its content; the agent's answer sits on the page with no
|
||||
@@ -79,14 +83,15 @@ class ChatMessageView extends StatelessWidget {
|
||||
constraints: BoxConstraints(
|
||||
maxWidth: user
|
||||
? (constraints.maxWidth * 0.85).clamp(0, 560).toDouble()
|
||||
: 720,
|
||||
: 720 + gutter,
|
||||
),
|
||||
child: user
|
||||
? _userTurn(cupertino, content, body)
|
||||
: _agentTurn(
|
||||
: _agentRow(
|
||||
context,
|
||||
content,
|
||||
ChatAgentSurface(cupertino: cupertino, child: body),
|
||||
gutter,
|
||||
),
|
||||
),
|
||||
),
|
||||
@@ -174,9 +179,34 @@ class ChatMessageView extends StatelessWidget {
|
||||
return widgets;
|
||||
}
|
||||
|
||||
/// The answer, with its Copy button in the [gutter] to its left when there
|
||||
/// is one, or else first in its footer.
|
||||
Widget _agentRow(
|
||||
BuildContext context,
|
||||
List<Widget> content,
|
||||
Widget answer,
|
||||
double gutter,
|
||||
) {
|
||||
final copyText = row['streaming'] == true ? '' : _answerText(_partsOf(row));
|
||||
final copy = copyText.isEmpty
|
||||
? null
|
||||
: ChatCopyButton(text: copyText, cupertino: _isCupertino(context));
|
||||
if (gutter <= 0) return _agentTurn(context, content, answer, copy);
|
||||
return ChatCopyGutterRow(
|
||||
width: gutter,
|
||||
copy: copy,
|
||||
child: _agentTurn(context, content, answer, null),
|
||||
);
|
||||
}
|
||||
|
||||
/// Stable activity precedes the answer; permission summaries and recorded
|
||||
/// model remain beneath it. Pending interaction cards are rendered separately.
|
||||
Widget _agentTurn(BuildContext context, List<Widget> content, Widget answer) {
|
||||
Widget _agentTurn(
|
||||
BuildContext context,
|
||||
List<Widget> content,
|
||||
Widget answer,
|
||||
Widget? copy,
|
||||
) {
|
||||
final parts = _partsOf(row);
|
||||
final reasoning = [
|
||||
for (final part in parts)
|
||||
@@ -189,10 +219,8 @@ class ChatMessageView extends StatelessWidget {
|
||||
if (isChatToolPart(part)) part,
|
||||
];
|
||||
final model = '${row['model'] ?? ''}'.trim();
|
||||
final copyText = row['streaming'] == true ? '' : _answerText(parts);
|
||||
final footer = <Widget>[
|
||||
if (copyText.isNotEmpty)
|
||||
ChatCopyButton(text: copyText, cupertino: _isCupertino(context)),
|
||||
?copy,
|
||||
...this.footer,
|
||||
if (model.isNotEmpty)
|
||||
Text(
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
# Answer Copy button in the left gutter
|
||||
|
||||
Operator request: "Let's move the copy button from the answer to the left,
|
||||
outside the chat, to the left."
|
||||
|
||||
- On a wide conversation the answer's Copy icon button sits in a strip left
|
||||
of the reading column, outside the answer, bottom-aligned with the
|
||||
answer's footer row. The footer now starts with the chips, model and time.
|
||||
- The rule is centralized in `conversation/chat_reading_width.dart`:
|
||||
`chatCopyGutter(width)` is `kChatCopyGutterWidth` (48 px) when the margin
|
||||
beside the centred 760 px reading column is at least that wide, else 0.
|
||||
With 0 (phones, narrow panes) Copy stays first in the footer as before.
|
||||
- The transcript list starts the gutter's width further left; answer rows
|
||||
draw the gutter themselves (`ChatCopyGutterRow`, provided through the
|
||||
`ChatCopyGutter` inherited width) and every other row and notice is inset
|
||||
past it (`chatCopyGutterInset`), so the column itself does not move.
|
||||
- Visibility: touch platforms always show it. Desktops
|
||||
(`prefersCompactHitTargets`) show it while the pointer is over the answer
|
||||
or the button has keyboard focus. Hidden, it stays in the focus order and
|
||||
the semantics tree (tooltip and name "Copy").
|
||||
- Files: `lib/features/chat/ui/transcript/chat_copy_gutter.dart`,
|
||||
`chat_message_view.dart`, `conversation/chat_reading_width.dart`,
|
||||
`conversation/chat_thread_view.dart`.
|
||||
- Tests: `test/features/chat/ui/transcript/chat_copy_gutter_test.dart` (the
|
||||
rule, footer vs gutter placement, alignment with the footer, hover and
|
||||
focus on macOS, semantics while hidden, a 1400 px vs 560 px conversation).
|
||||
- Verification (2026-11-09): `tool/memwatch/full.sh test/features/chat`:
|
||||
`PASS: 1161 passed, 0 failed`; `tool/analyze.sh` clean. Real Chrome
|
||||
captures (Material light and dark): at 1400x900 the gutter Copy hidden and
|
||||
shown on hover, aligned with the footer chip; at 560x1000 Copy back in the
|
||||
footer. Touch platforms (always visible) were checked by widget tests only.
|
||||
@@ -143,28 +143,34 @@ change, and `{session_id, run_id, output, offset, end}` for output chunks.
|
||||
run has finished. It dismisses every finished run and leaves running ones.
|
||||
- Dismissal is per chat, for every client (not per device). The card goes at
|
||||
once. A refusal brings the card back with the server's reason.
|
||||
- Undo: a 5 s SnackBar (Material) or a transient notice over the
|
||||
conversation (Cupertino, `ChatUndoBar` in the root overlay) offers Undo.
|
||||
The Cupertino notice briefly covers the composer.
|
||||
- Server design: dismiss-then-restore within a window, then purge.
|
||||
- History: a dismissed card is not lost. It moves into a "N commands" chip
|
||||
in an answer's footer (see "Command history" below), which can restore it.
|
||||
There is no Undo notice.
|
||||
- Server design (since 2026-11-09): dismiss keeps the run.
|
||||
`chat_shell_dismiss {session_id, run_ids}` sets `dismissed_at` on finished
|
||||
runs and pushes `chat_shell_run_event {dismissed: true}` to every watcher.
|
||||
`chat_shell_restore {session_id, run_ids}` clears it within
|
||||
`ChatShellRunUndoWindow` (30 s, longer than the 5 s notice). The reply
|
||||
carries the runs, and watchers get lifecycle frames. A client that held no
|
||||
copy reads the list again for the output. After the window the server
|
||||
purges the run's command, output, output text and error (an `AfterFunc`,
|
||||
plus on every server start). Only a tombstone row remains.
|
||||
- Readback: `chat_shell_runs` and `chat_shell_run_output` exclude dismissed
|
||||
runs. `chat_shell_runs` lists tombstone ids in `chat_shell_dismissed`, so a
|
||||
client that missed the event drops those cards on its next refresh.
|
||||
Tombstones age out with the 50-run history prune.
|
||||
The command, folder, status, exit code, times, output tail (1 MiB) and
|
||||
plain-text rendering stay, within the usual 50-run history. Nothing is
|
||||
purged: the undo window, its `AfterFunc` and the startup purge are gone.
|
||||
`chat_shell_restore {session_id, run_ids}` clears `dismissed_at` at any
|
||||
time. The reply carries the runs, and watchers get lifecycle frames.
|
||||
- Readback: `chat_shell_runs` leaves dismissed runs out of
|
||||
`chat_shell_runs`, lists their ids in `chat_shell_dismissed` (as before)
|
||||
and the runs themselves in `chat_shell_dismissed_runs` (oldest first,
|
||||
64 KiB tail each, `dismissed: true`, `dismissed_at`).
|
||||
`chat_shell_run_output` and `chat_shell_share` work for a dismissed run.
|
||||
- Older rows: a run an older server already purged keeps `purged = 1`. It is
|
||||
listed with `purged: true` and no command or output. The app shows it as
|
||||
"Command not kept" / "Output not kept" and offers no Restore (the server
|
||||
refuses to restore it).
|
||||
- Files: `internal/protocol/chat_shell_dismiss.go`,
|
||||
`internal/pipeline/chat_shell_dismiss.go`,
|
||||
`internal/server/chat_shell_dismiss.go`,
|
||||
`lib/features/chat/shell/chat_shell_dismiss.dart` (button, menu entry,
|
||||
Undo notice) and `chat_shell_runs_dismissal.dart` (controller part).
|
||||
- Tests: `internal/pipeline/chat_shell_dismiss_test.go` covers dismiss,
|
||||
`lib/features/chat/shell/chat_shell_dismiss.dart` (button, menu entry)
|
||||
and `chat_shell_runs_dismissal.dart` (controller part).
|
||||
- Tests and verification of the first version (superseded where they
|
||||
mention Undo or purging; see "Command history" below for the current
|
||||
tests): `internal/pipeline/chat_shell_dismiss_test.go` covers dismiss,
|
||||
readback, restore, purge and tombstones.
|
||||
`internal/server/chat_shell_dismiss_test.go` covers the websocket dismiss
|
||||
to two watchers, refusing a running or empty request, readback with
|
||||
@@ -247,5 +253,56 @@ end to end. The Go websocket tests cover the server with real processes, and
|
||||
the browser captures use the fixture channel. Mobile devices were not tested.
|
||||
|
||||
**Update:** dismissing no longer shows a notice or Undo; the card simply
|
||||
goes away (operator request). The server still accepts `chat_shell_restore`
|
||||
within its 30 s window, but the app no longer offers it.
|
||||
goes away (operator request).
|
||||
|
||||
## Command history (2026-11-09)
|
||||
|
||||
Operator request: "when we dismiss a command, it should show in the bottom
|
||||
like the files changes, model, etc, so that I can expand and see the
|
||||
history."
|
||||
|
||||
- A dismissed run leaves the transcript and shows as a chip in an answer's
|
||||
footer, in the same row and chip family (`ChatTurnChip`) as
|
||||
"3 files changed +9 −2", the tool chips, the model and the time: a terminal
|
||||
icon and "2 commands".
|
||||
- Placement (`shell/chat_shell_history.dart`, `attachChatShellHistory`):
|
||||
each run goes to the first assistant reply created at or after the run
|
||||
started. A run newer than every reply goes to the last reply. A chat with
|
||||
no reply shows the chip on its own row at the end of the transcript.
|
||||
- Tapping the chip opens the turn sheet on a wide window (≥ 600 px) or a
|
||||
full-screen page on a narrow one, like the diff chip. "Dismissed commands"
|
||||
lists each command with its exit status chip and duration, its start time,
|
||||
and Restore. Tapping a command opens its whole retained output read-only
|
||||
in the card's terminal view (`chat_shell_run_output`), with Copy output,
|
||||
Send to agent and Restore. Restore puts the card back in the transcript for
|
||||
every client. A refusal shows the server's reason under the entry.
|
||||
- Multi-machine: everything goes through the chat's own gateway, as cards do.
|
||||
- Files: `lib/features/chat/shell/chat_shell_history.dart` (placement,
|
||||
labels), `chat_shell_history_chip.dart`, `chat_shell_history_view.dart`,
|
||||
`chat_shell_history_output_page.dart`; controller part
|
||||
`chat_shell_runs_dismissal.dart` (`dismissedRuns`, `restore`,
|
||||
`fullOutput`); hooks in `conversation/chat_thread_view.dart`. Server:
|
||||
`internal/{protocol,pipeline,server}/chat_shell_dismiss.go`.
|
||||
- Tests: `internal/pipeline/chat_shell_dismiss_test.go` (dismiss keeps
|
||||
output, readback, restore without a time limit, older purged tombstones,
|
||||
dismissed runs counting toward the 50-run history);
|
||||
`internal/server/chat_shell_dismiss_test.go` (websocket dismiss to two
|
||||
watchers, readback of dismissed runs with output, output read of a
|
||||
dismissed run, restore, restore a day later after a restart);
|
||||
`test/features/chat/shell/chat_shell_history_test.dart` (placement rules)
|
||||
and `chat_shell_history_view_test.dart` (chip in the right answer's
|
||||
footer, the no-reply row, dismiss moving a card into the chip, sheet,
|
||||
output, Copy, Send to agent, Restore, narrow page, purged rows, a refused
|
||||
restore).
|
||||
- Capture fixture: `?shell_dismissed=run_status,run_tests` starts with those
|
||||
runs dismissed (`tool/perf/chat_shell_fixture.dart`).
|
||||
- Verification (2026-11-09): `go test ./internal/protocol ./internal/pipeline
|
||||
./internal/server` all ok (server 74 s). `tool/memwatch/full.sh
|
||||
test/features/chat`: `PASS: 1161 passed, 0 failed`. `tool/analyze.sh`:
|
||||
clean. Real Chrome captures (`tool/capture`,
|
||||
`chats=1&msgs=4&shell=1&rich=1&shell_dismissed=run_status,run_tests`),
|
||||
Material light and dark: at 1400x900 the footer chip, the sheet and a
|
||||
command's output page; at 560x1000 the footer chip, the full-screen list
|
||||
and the list after Restore, plus (light) the restored card back in the
|
||||
transcript with "1 command". The PNGs were inspected. Cupertino, a live
|
||||
server end to end and mobile devices were not exercised.
|
||||
|
||||
@@ -16,10 +16,15 @@ class ShellGateway implements ApiGateway {
|
||||
final calls = <({String type, JsonMap fields})>[];
|
||||
final _frames = StreamController<JsonMap>.broadcast();
|
||||
List<JsonMap> runs = const [];
|
||||
|
||||
/// The chat history `chat_messages` answers with.
|
||||
List<JsonMap> messages = const [];
|
||||
String? refusal;
|
||||
|
||||
/// Tombstone ids the `chat_shell_runs` readback reports.
|
||||
/// Dismissed ids the `chat_shell_runs` readback reports, and the dismissed
|
||||
/// runs it carries (a server that keeps them).
|
||||
List<String> dismissed = const [];
|
||||
List<JsonMap> dismissedRuns = const [];
|
||||
|
||||
/// The refusal of `chat_shell_dismiss` / `chat_shell_restore`, when set.
|
||||
String? dismissRefusal;
|
||||
@@ -47,9 +52,13 @@ class ShellGateway implements ApiGateway {
|
||||
final body = fields['chat_shell_run_request'] as JsonMap? ?? const {};
|
||||
switch (type) {
|
||||
case 'chat_messages':
|
||||
return chatPage(const []);
|
||||
return chatPage(messages);
|
||||
case 'chat_shell_runs':
|
||||
return {'chat_shell_runs': runs, 'chat_shell_dismissed': dismissed};
|
||||
return {
|
||||
'chat_shell_runs': runs,
|
||||
'chat_shell_dismissed': dismissed,
|
||||
'chat_shell_dismissed_runs': dismissedRuns,
|
||||
};
|
||||
case 'chat_shell_dismiss':
|
||||
if (dismissRefusal != null) throw StateError(dismissRefusal!);
|
||||
return {'chat_shell_dismissed': body['run_ids']};
|
||||
@@ -58,7 +67,7 @@ class ShellGateway implements ApiGateway {
|
||||
final ids = (body['run_ids'] as List).toSet();
|
||||
return {
|
||||
'chat_shell_runs': [
|
||||
for (final run in runs)
|
||||
for (final run in [...runs, ...dismissedRuns])
|
||||
if (ids.contains(run['id'])) run,
|
||||
],
|
||||
};
|
||||
@@ -75,7 +84,10 @@ class ShellGateway implements ApiGateway {
|
||||
return {'chat_shell_run': resumeReply};
|
||||
}
|
||||
return {
|
||||
'chat_shell_run': runs.firstWhere((r) => r['id'] == body['run_id']),
|
||||
'chat_shell_run': [
|
||||
...runs,
|
||||
...dismissedRuns,
|
||||
].firstWhere((r) => r['id'] == body['run_id']),
|
||||
};
|
||||
}
|
||||
return <String, dynamic>{};
|
||||
@@ -123,6 +135,7 @@ JsonMap shellRecord(
|
||||
bool terminal = false,
|
||||
String text = '',
|
||||
int outputStart = 0,
|
||||
int startedAt = 1000,
|
||||
}) => {
|
||||
'id': id,
|
||||
'session_id': 's',
|
||||
@@ -130,8 +143,8 @@ JsonMap shellRecord(
|
||||
'directory': '/home/op/project',
|
||||
'status': status,
|
||||
'exit_code': ?exitCode,
|
||||
'started_at': 1000,
|
||||
'ended_at': ?(status == 'running' ? null : 1000 + durationMs),
|
||||
'started_at': startedAt,
|
||||
'ended_at': ?(status == 'running' ? null : startedAt + durationMs),
|
||||
'duration_ms': durationMs,
|
||||
'output': output,
|
||||
'output_start': outputStart,
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/core/api_gateway.dart';
|
||||
import 'package:pipelines_app/features/chat/shell/chat_shell_history.dart';
|
||||
import 'package:pipelines_app/features/chat/shell/chat_shell_run.dart';
|
||||
|
||||
ChatShellRun _run(String id, int started) => ChatShellRun(
|
||||
id: id,
|
||||
command: 'echo $id',
|
||||
directory: '/w',
|
||||
status: 'exited',
|
||||
exitCode: 0,
|
||||
startedAt: started,
|
||||
);
|
||||
|
||||
JsonMap _reply(String id, int? created) => {
|
||||
'kind': 'assistant',
|
||||
'key': id,
|
||||
'created_at': ?created,
|
||||
};
|
||||
|
||||
void main() {
|
||||
test('each run attaches to the first reply at or after its start', () {
|
||||
final rows = [
|
||||
{'kind': 'user', 'created_at': 5},
|
||||
_reply('a', 10),
|
||||
{'kind': 'user', 'created_at': 15},
|
||||
_reply('b', 20),
|
||||
_reply('c', 30),
|
||||
];
|
||||
final attached = attachChatShellHistory(rows, [
|
||||
_run('late', 31),
|
||||
_run('before', 1),
|
||||
_run('exact', 20),
|
||||
_run('between', 12),
|
||||
]);
|
||||
expect(chatShellHistoryIds(attached[1]), ['before']);
|
||||
expect(chatShellHistoryIds(attached[3]), ['between', 'exact']);
|
||||
// Newer than every reply: the last reply.
|
||||
expect(chatShellHistoryIds(attached[4]), ['late']);
|
||||
expect(attached[0].containsKey(chatShellHistoryField), isFalse);
|
||||
expect(attached[2].containsKey(chatShellHistoryField), isFalse);
|
||||
expect(attached, hasLength(rows.length));
|
||||
});
|
||||
|
||||
test('a reply without a time is only the fallback last reply', () {
|
||||
final rows = [_reply('a', 10), _reply('pending', null)];
|
||||
final attached = attachChatShellHistory(rows, [
|
||||
_run('x', 5),
|
||||
_run('y', 50),
|
||||
]);
|
||||
expect(chatShellHistoryIds(attached[0]), ['x']);
|
||||
expect(chatShellHistoryIds(attached[1]), ['y']);
|
||||
});
|
||||
|
||||
test('with no reply the runs get their own row at the end', () {
|
||||
final rows = [
|
||||
{'kind': 'user', 'created_at': 5},
|
||||
];
|
||||
final attached = attachChatShellHistory(rows, [_run('b', 9), _run('a', 1)]);
|
||||
expect(attached, hasLength(2));
|
||||
expect(attached.last['kind'], chatShellHistoryRowKind);
|
||||
expect(chatShellHistoryIds(attached.last), ['a', 'b']);
|
||||
expect(attachChatShellHistory(rows, const []), same(rows));
|
||||
});
|
||||
|
||||
test('labels count the commands', () {
|
||||
expect(chatShellHistoryLabel(1), '1 command');
|
||||
expect(chatShellHistoryLabel(2), '2 commands');
|
||||
expect(chatShellHistorySemantics(2), contains('open command history'));
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,256 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter/services.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/core/api_gateway.dart';
|
||||
import 'package:pipelines_app/features/chat/ui/transcript/chat_message_view.dart';
|
||||
|
||||
import 'chat_shell_fixtures.dart';
|
||||
|
||||
void main() {
|
||||
late ShellGateway gateway;
|
||||
|
||||
setUp(() => gateway = ShellGateway());
|
||||
tearDown(() => gateway.close());
|
||||
|
||||
Finder card() => find.bySemanticsIdentifier('chat-shell-run-card');
|
||||
final chip = find.byKey(const Key('chat-shell-history-chip'));
|
||||
|
||||
JsonMap dismissed(String id, int started, {String command = 'true'}) => {
|
||||
...shellRecord(
|
||||
id,
|
||||
command: command,
|
||||
status: 'exited',
|
||||
exitCode: 0,
|
||||
output: 'out $id\r\n',
|
||||
text: 'out $id\n',
|
||||
durationMs: 50,
|
||||
startedAt: started,
|
||||
),
|
||||
'dismissed': true,
|
||||
'dismissed_at': started + 100,
|
||||
};
|
||||
|
||||
JsonMap reply(String id, int created, String text) => {
|
||||
'id': id,
|
||||
'role': 'assistant',
|
||||
'created_at': created,
|
||||
'parts': [
|
||||
{'type': 'text', 'text': text},
|
||||
],
|
||||
};
|
||||
|
||||
void size(WidgetTester tester, Size size) {
|
||||
tester.view.physicalSize = size;
|
||||
tester.view.devicePixelRatio = 1;
|
||||
addTearDown(tester.view.resetPhysicalSize);
|
||||
addTearDown(tester.view.resetDevicePixelRatio);
|
||||
}
|
||||
|
||||
Future<void> open(WidgetTester tester) async {
|
||||
await tester.pumpWidget(shellThread(gateway));
|
||||
await tester.pump();
|
||||
await tester.pump();
|
||||
}
|
||||
|
||||
void history(List<JsonMap> runs) {
|
||||
gateway.dismissedRuns = runs;
|
||||
gateway.dismissed = [for (final run in runs) '${run['id']}'];
|
||||
}
|
||||
|
||||
testWidgets('dismissed runs sit in the footer of the reply that followed', (
|
||||
tester,
|
||||
) async {
|
||||
size(tester, const Size(1400, 900));
|
||||
gateway.messages = [
|
||||
reply('a1', 10000, 'First answer'),
|
||||
{
|
||||
'id': 'u2',
|
||||
'role': 'user',
|
||||
'created_at': 11000,
|
||||
'parts': [
|
||||
{'type': 'text', 'text': 'Next question'},
|
||||
],
|
||||
},
|
||||
reply('a2', 20000, 'Second answer'),
|
||||
];
|
||||
history([
|
||||
dismissed('run_a', 12000, command: 'ls'),
|
||||
dismissed('run_b', 15000, command: 'pwd'),
|
||||
]);
|
||||
await open(tester);
|
||||
|
||||
expect(card(), findsNothing);
|
||||
expect(chip, findsOneWidget);
|
||||
expect(find.text('2 commands'), findsOneWidget);
|
||||
// The chip is in the second answer's footer, beside its other chips.
|
||||
final footer = find.ancestor(
|
||||
of: chip,
|
||||
matching: find.byKey(const Key('chat-message-footer')),
|
||||
);
|
||||
expect(footer, findsOneWidget);
|
||||
final message = find.ancestor(
|
||||
of: chip,
|
||||
matching: find.byType(ChatMessageView),
|
||||
);
|
||||
expect(
|
||||
find.descendant(of: message, matching: find.text('Second answer')),
|
||||
findsOneWidget,
|
||||
);
|
||||
expect(
|
||||
find.descendant(of: message, matching: find.text('First answer')),
|
||||
findsNothing,
|
||||
);
|
||||
});
|
||||
|
||||
testWidgets('a chat with no answer shows the chip on its own row', (
|
||||
tester,
|
||||
) async {
|
||||
history([dismissed('run_a', 1000)]);
|
||||
await open(tester);
|
||||
expect(find.text('1 command'), findsOneWidget);
|
||||
expect(
|
||||
find.ancestor(
|
||||
of: chip,
|
||||
matching: find.byKey(const Key('chat-message-footer')),
|
||||
),
|
||||
findsNothing,
|
||||
);
|
||||
});
|
||||
|
||||
testWidgets('dismissing a card moves it into the chip', (tester) async {
|
||||
gateway.runs = [
|
||||
shellRecord('run_done', status: 'exited', exitCode: 0, durationMs: 9),
|
||||
];
|
||||
await open(tester);
|
||||
expect(chip, findsNothing);
|
||||
await tester.tap(find.byKey(const Key('chat-shell-run-dismiss')));
|
||||
await tester.pump();
|
||||
expect(card(), findsNothing);
|
||||
expect(find.text('1 command'), findsOneWidget);
|
||||
});
|
||||
|
||||
testWidgets('wide: the sheet lists commands, opens output and restores', (
|
||||
tester,
|
||||
) async {
|
||||
size(tester, const Size(1400, 900));
|
||||
final copied = <String>[];
|
||||
tester.binding.defaultBinaryMessenger.setMockMethodCallHandler(
|
||||
SystemChannels.platform,
|
||||
(call) async {
|
||||
if (call.method == 'Clipboard.setData') {
|
||||
copied.add('${(call.arguments as Map)['text']}');
|
||||
}
|
||||
return null;
|
||||
},
|
||||
);
|
||||
addTearDown(
|
||||
() => tester.binding.defaultBinaryMessenger.setMockMethodCallHandler(
|
||||
SystemChannels.platform,
|
||||
null,
|
||||
),
|
||||
);
|
||||
gateway.messages = [reply('a1', 10000, 'Answer')];
|
||||
history([dismissed('run_a', 5000, command: 'git status')]);
|
||||
await open(tester);
|
||||
|
||||
await tester.tap(chip);
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.byType(BottomSheet), findsOneWidget);
|
||||
expect(find.text('Dismissed commands'), findsOneWidget);
|
||||
expect(find.text('\$ git status'), findsOneWidget);
|
||||
expect(find.text('Exit 0 · 50 ms'), findsOneWidget);
|
||||
|
||||
// Its output, read-only, with Copy output and Send to agent.
|
||||
await tester.tap(find.byKey(const ValueKey('chat-shell-history-run_a')));
|
||||
await tester.pumpAndSettle();
|
||||
expect(gateway.bodies('chat_shell_run_output').last['run_id'], 'run_a');
|
||||
expect(terminalText(tester), 'out run_a');
|
||||
await tester.tap(find.byKey(const Key('chat-shell-history-copy')));
|
||||
await tester.pump();
|
||||
expect(copied, ['out run_a\n']);
|
||||
await tester.tap(find.byKey(const Key('chat-shell-history-share')));
|
||||
await tester.pump();
|
||||
expect(gateway.bodies('chat_shell_share').single['run_id'], 'run_a');
|
||||
await tester.pageBack();
|
||||
await tester.pumpAndSettle();
|
||||
|
||||
// Restore puts the card back and the chip goes.
|
||||
await tester.tap(
|
||||
find.byKey(const ValueKey('chat-shell-history-restore-run_a')),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
expect(gateway.bodies('chat_shell_restore').single['run_ids'], ['run_a']);
|
||||
expect(find.textContaining('restored to the transcript'), findsOneWidget);
|
||||
Navigator.of(tester.element(find.byType(BottomSheet))).pop();
|
||||
await tester.pumpAndSettle();
|
||||
expect(card(), findsOneWidget);
|
||||
expect(chip, findsNothing);
|
||||
});
|
||||
|
||||
testWidgets('narrow: the history opens as a full-screen page', (
|
||||
tester,
|
||||
) async {
|
||||
size(tester, const Size(400, 800));
|
||||
gateway.messages = [reply('a1', 10000, 'Answer')];
|
||||
history([dismissed('run_a', 5000)]);
|
||||
await open(tester);
|
||||
await tester.tap(chip);
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.byType(BottomSheet), findsNothing);
|
||||
expect(
|
||||
find.descendant(
|
||||
of: find.byType(AppBar),
|
||||
matching: find.text('Dismissed commands'),
|
||||
),
|
||||
findsOneWidget,
|
||||
);
|
||||
await tester.tap(
|
||||
find.byKey(const ValueKey('chat-shell-history-restore-run_a')),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
expect(gateway.bodies('chat_shell_restore').single['run_ids'], ['run_a']);
|
||||
});
|
||||
|
||||
testWidgets('a run an older server purged says its output was not kept', (
|
||||
tester,
|
||||
) async {
|
||||
size(tester, const Size(1400, 900));
|
||||
history([
|
||||
{
|
||||
'id': 'run_old',
|
||||
'session_id': 's',
|
||||
'command': '',
|
||||
'directory': '/w',
|
||||
'status': 'exited',
|
||||
'exit_code': 0,
|
||||
'started_at': 1000,
|
||||
'dismissed': true,
|
||||
'purged': true,
|
||||
},
|
||||
]);
|
||||
await open(tester);
|
||||
await tester.tap(chip);
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.text('Command not kept'), findsOneWidget);
|
||||
expect(find.text('Output not kept'), findsOneWidget);
|
||||
expect(
|
||||
find.byKey(const ValueKey('chat-shell-history-restore-run_old')),
|
||||
findsNothing,
|
||||
);
|
||||
});
|
||||
|
||||
testWidgets('a refused restore shows the reason in the list', (tester) async {
|
||||
size(tester, const Size(1400, 900));
|
||||
gateway.restoreRefusal = 'these commands can no longer be restored';
|
||||
history([dismissed('run_a', 1000)]);
|
||||
await open(tester);
|
||||
await tester.tap(chip);
|
||||
await tester.pumpAndSettle();
|
||||
await tester.tap(
|
||||
find.byKey(const ValueKey('chat-shell-history-restore-run_a')),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.byKey(const Key('chat-shell-history-refusal')), findsOneWidget);
|
||||
expect(find.textContaining('no longer be restored'), findsOneWidget);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
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/api_gateway.dart';
|
||||
import 'package:pipelines_app/features/chat/conversation/chat_reading_width.dart';
|
||||
import 'package:pipelines_app/features/chat/domain/chat_transcript.dart';
|
||||
import 'package:pipelines_app/features/chat/ui/transcript/chat_copy_gutter.dart';
|
||||
import 'package:pipelines_app/features/chat/ui/transcript/chat_message_view.dart';
|
||||
|
||||
import '../../shell/chat_shell_fixtures.dart';
|
||||
|
||||
JsonMap _answer() => transcriptRows([
|
||||
{
|
||||
'id': 'a1',
|
||||
'role': 'assistant',
|
||||
'model': 'gpt-test',
|
||||
'created_at': 1000,
|
||||
'parts': [
|
||||
{'type': 'text', 'text': 'The answer text'},
|
||||
],
|
||||
},
|
||||
]).single;
|
||||
|
||||
Widget _host(double gutter) => MaterialApp(
|
||||
home: Scaffold(
|
||||
body: ListView(
|
||||
children: [
|
||||
ChatCopyGutter(
|
||||
width: gutter,
|
||||
child: ChatMessageView(row: _answer()),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
);
|
||||
|
||||
final _copy = find.byKey(const Key('chat-message-copy'));
|
||||
final _footer = find.byKey(const Key('chat-message-footer'));
|
||||
final _gutter = find.byKey(const Key('chat-copy-gutter'));
|
||||
|
||||
double _opacity(WidgetTester tester) => tester
|
||||
.widget<AnimatedOpacity>(
|
||||
find.byKey(const Key('chat-copy-gutter-visibility')),
|
||||
)
|
||||
.opacity;
|
||||
|
||||
void main() {
|
||||
test('the gutter needs room left of the reading column', () {
|
||||
expect(chatCopyGutter(kChatReadingWidth + 2 * kChatCopyGutterWidth), 48);
|
||||
expect(chatCopyGutter(1400), kChatCopyGutterWidth);
|
||||
expect(chatCopyGutter(kChatReadingWidth + 90), 0);
|
||||
expect(chatCopyGutter(560), 0);
|
||||
});
|
||||
|
||||
testWidgets('without a gutter Copy starts the footer', (tester) async {
|
||||
await tester.pumpWidget(_host(0));
|
||||
expect(find.descendant(of: _footer, matching: _copy), findsOneWidget);
|
||||
expect(_gutter, findsNothing);
|
||||
});
|
||||
|
||||
testWidgets('with a gutter Copy sits left of the answer, not in it', (
|
||||
tester,
|
||||
) async {
|
||||
await tester.pumpWidget(_host(48));
|
||||
expect(find.descendant(of: _footer, matching: _copy), findsNothing);
|
||||
expect(find.descendant(of: _gutter, matching: _copy), findsOneWidget);
|
||||
expect(find.byTooltip('Copy'), findsOneWidget);
|
||||
final copy = tester.getRect(_copy);
|
||||
final text = tester.getRect(find.text('The answer text'));
|
||||
final footer = tester.getRect(_footer);
|
||||
expect(copy.right, lessThanOrEqualTo(text.left));
|
||||
// Bottom-aligned with the footer row (model and time).
|
||||
expect((copy.bottom - footer.bottom).abs(), lessThan(1));
|
||||
// Touch platforms always show it.
|
||||
expect(_opacity(tester), 1);
|
||||
});
|
||||
|
||||
testWidgets('desktop shows it on hover and focus, and keeps semantics', (
|
||||
tester,
|
||||
) async {
|
||||
final semantics = tester.ensureSemantics();
|
||||
await tester.pumpWidget(_host(48));
|
||||
expect(_opacity(tester), 0);
|
||||
// Hidden, it is still reachable by a screen reader.
|
||||
expect(
|
||||
tester.getSemantics(_copy),
|
||||
isSemantics(tooltip: 'Copy', isButton: true, isFocusable: true),
|
||||
);
|
||||
|
||||
final mouse = await tester.createGesture(kind: PointerDeviceKind.mouse);
|
||||
addTearDown(mouse.removePointer);
|
||||
await mouse.addPointer(location: Offset.zero);
|
||||
await mouse.moveTo(tester.getCenter(find.text('The answer text')));
|
||||
await tester.pumpAndSettle();
|
||||
expect(_opacity(tester), 1);
|
||||
await mouse.moveTo(const Offset(5, 590));
|
||||
await tester.pumpAndSettle();
|
||||
expect(_opacity(tester), 0);
|
||||
|
||||
// Keyboard focus reveals it too.
|
||||
await tester.sendKeyEvent(LogicalKeyboardKey.tab);
|
||||
await tester.pumpAndSettle();
|
||||
expect(_opacity(tester), 1);
|
||||
semantics.dispose();
|
||||
}, variant: TargetPlatformVariant.only(TargetPlatform.macOS));
|
||||
|
||||
for (final (width, inGutter) in [(1400.0, true), (560.0, false)]) {
|
||||
testWidgets('a ${width.toInt()} px conversation puts Copy '
|
||||
'${inGutter ? 'in the gutter' : 'in the footer'}', (tester) async {
|
||||
tester.view.physicalSize = Size(width, 900);
|
||||
tester.view.devicePixelRatio = 1;
|
||||
addTearDown(tester.view.resetPhysicalSize);
|
||||
addTearDown(tester.view.resetDevicePixelRatio);
|
||||
final gateway = ShellGateway()
|
||||
..messages = [
|
||||
{
|
||||
'id': 'a1',
|
||||
'role': 'assistant',
|
||||
'created_at': 1000,
|
||||
'parts': [
|
||||
{'type': 'text', 'text': 'The answer text'},
|
||||
],
|
||||
},
|
||||
];
|
||||
addTearDown(gateway.close);
|
||||
await tester.pumpWidget(shellThread(gateway));
|
||||
await tester.pump();
|
||||
await tester.pump();
|
||||
expect(_copy, findsOneWidget);
|
||||
expect(
|
||||
find.descendant(of: _footer, matching: _copy),
|
||||
inGutter ? findsNothing : findsOneWidget,
|
||||
);
|
||||
final copy = tester.getRect(_copy);
|
||||
final text = tester.getRect(find.text('The answer text'));
|
||||
if (inGutter) {
|
||||
expect(copy.right, lessThanOrEqualTo(text.left));
|
||||
// The answer itself did not move: it starts where the column does.
|
||||
final column = chatReadingInset(
|
||||
tester.getSize(find.byType(Scaffold)).width,
|
||||
);
|
||||
expect(text.left, greaterThanOrEqualTo(column));
|
||||
expect(copy.left, greaterThanOrEqualTo(column - kChatCopyGutterWidth));
|
||||
} else {
|
||||
expect(copy.top, greaterThanOrEqualTo(text.bottom));
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -2,8 +2,10 @@
|
||||
// `?chats=N`): every fixture chat lists four recorded terminal runs
|
||||
// (succeeded, failed, stopped and an interactive login still waiting for a
|
||||
// token), and chat_shell_run/stop/share/input answer as the server does, with
|
||||
// the frames that follow; chat_shell_dismiss/restore hide and bring back runs. The login prompt hides what is typed, as a real
|
||||
// terminal's password prompt does, and finishes on Enter.
|
||||
// the frames that follow; chat_shell_dismiss/restore move runs into and out
|
||||
// of the dismissed list the readback reports (`?shell_dismissed=a,b` starts
|
||||
// with those run ids dismissed). The login prompt hides what is typed, as a
|
||||
// real terminal's password prompt does, and finishes on Enter.
|
||||
import 'dart:convert';
|
||||
|
||||
import 'package:pipelines_app/core/api_gateway.dart';
|
||||
@@ -23,7 +25,12 @@ void configureChatShellFixture(Map<String, String> params) {
|
||||
_enabled = params['shell'] == '1';
|
||||
_base = DateTime.now().subtract(const Duration(minutes: 3));
|
||||
_loginEnd = utf8.encode(_loginPrompt).length;
|
||||
_dismissed.clear();
|
||||
_dismissed
|
||||
..clear()
|
||||
..addAll([
|
||||
for (final id in (params['shell_dismissed'] ?? '').split(','))
|
||||
if (id.trim().isNotEmpty) id.trim(),
|
||||
]);
|
||||
}
|
||||
|
||||
const String _loginPrompt =
|
||||
@@ -128,6 +135,11 @@ JsonMap? chatShellReply(JsonMap request) {
|
||||
if (!_dismissed.contains(run['id'])) run,
|
||||
],
|
||||
'chat_shell_dismissed': _dismissed.toList(),
|
||||
'chat_shell_dismissed_runs': [
|
||||
for (final run in _runs(session))
|
||||
if (_dismissed.contains(run['id']))
|
||||
{...run, 'dismissed': true, 'dismissed_at': _at(200)},
|
||||
],
|
||||
};
|
||||
case 'chat_shell_dismiss':
|
||||
final ids = _runIds(body);
|
||||
|
||||
@@ -8,10 +8,10 @@ import (
|
||||
)
|
||||
|
||||
// initChatShellDismissals adds the dismissal columns of chat_shell_runs. A
|
||||
// dismissed run (dismissed_at > 0) is left out of every readback; once its
|
||||
// undo window has passed it is purged: its command, output and error are
|
||||
// deleted and only a tombstone (id, session, status, times) remains, which
|
||||
// tells a client that missed the dismissal to drop its card.
|
||||
// dismissed run (dismissed_at > 0) leaves the transcript readback but keeps
|
||||
// its command, output and error, so the operator can still read and restore
|
||||
// it. purged marks a row an older server emptied after its undo window: only
|
||||
// a tombstone (id, session, status, times) remains of it.
|
||||
func (s *Store) initChatShellDismissals() error {
|
||||
for _, column := range [][2]string{
|
||||
{"dismissed_at", "INTEGER NOT NULL DEFAULT 0"},
|
||||
@@ -48,9 +48,9 @@ WHERE session_id = ? AND id = ? AND status != ? AND dismissed_at = 0`, at, sessi
|
||||
}
|
||||
|
||||
// RestoreChatShellRuns undoes the dismissal of the runs of sessionID among ids
|
||||
// that were dismissed at or after since and not yet purged, and returns them,
|
||||
// oldest first.
|
||||
func (s *Store) RestoreChatShellRuns(ctx context.Context, sessionID string, ids []string, since int64) ([]protocol.ChatShellRunRecord, error) {
|
||||
// that are dismissed and not purged, however long ago they were dismissed,
|
||||
// and returns them, oldest first.
|
||||
func (s *Store) RestoreChatShellRuns(ctx context.Context, sessionID string, ids []string) ([]protocol.ChatShellRunRecord, error) {
|
||||
tx, err := s.db.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@@ -59,7 +59,7 @@ func (s *Store) RestoreChatShellRuns(ctx context.Context, sessionID string, ids
|
||||
var restored []string
|
||||
for _, id := range ids {
|
||||
result, err := tx.ExecContext(ctx, `UPDATE chat_shell_runs SET dismissed_at = 0
|
||||
WHERE session_id = ? AND id = ? AND dismissed_at > 0 AND dismissed_at >= ? AND purged = 0`, sessionID, id, since)
|
||||
WHERE session_id = ? AND id = ? AND dismissed_at > 0 AND purged = 0`, sessionID, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -74,8 +74,19 @@ WHERE session_id = ? AND id = ? AND dismissed_at > 0 AND dismissed_at >= ? AND p
|
||||
for _, id := range restored {
|
||||
args = append(args, id)
|
||||
}
|
||||
rows, err := s.db.QueryContext(ctx, chatShellRunSelect+` WHERE session_id = ? AND id IN (?`+
|
||||
return s.queryChatShellRuns(ctx, ` WHERE session_id = ? AND id IN (?`+
|
||||
strings.Repeat(", ?", len(restored)-1)+`) ORDER BY started_at, id`, args...)
|
||||
}
|
||||
|
||||
// DismissedChatShellRuns lists sessionID's dismissed runs, oldest first, with
|
||||
// their whole retained output. A purged one (an older server's tombstone) has
|
||||
// no command or output.
|
||||
func (s *Store) DismissedChatShellRuns(ctx context.Context, sessionID string) ([]protocol.ChatShellRunRecord, error) {
|
||||
return s.queryChatShellRuns(ctx, ` WHERE session_id = ? AND dismissed_at > 0 ORDER BY started_at, id`, sessionID)
|
||||
}
|
||||
|
||||
func (s *Store) queryChatShellRuns(ctx context.Context, where string, args ...any) ([]protocol.ChatShellRunRecord, error) {
|
||||
rows, err := s.db.QueryContext(ctx, chatShellRunSelect+where, args...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -90,34 +101,3 @@ WHERE session_id = ? AND id = ? AND dismissed_at > 0 AND dismissed_at >= ? AND p
|
||||
}
|
||||
return runs, rows.Err()
|
||||
}
|
||||
|
||||
// PurgeDismissedChatShellRuns deletes the command, output and error of every
|
||||
// run dismissed before epoch millisecond before, leaving its tombstone.
|
||||
func (s *Store) PurgeDismissedChatShellRuns(ctx context.Context, before int64) (int64, error) {
|
||||
result, err := s.db.ExecContext(ctx, `UPDATE chat_shell_runs SET command = '', output = '', output_text = '', error = '',
|
||||
output_start = 0, output_bytes = 0, purged = 1 WHERE dismissed_at > 0 AND dismissed_at < ? AND purged = 0`, before)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return result.RowsAffected()
|
||||
}
|
||||
|
||||
// DismissedChatShellRuns lists the ids of sessionID's dismissed runs, oldest
|
||||
// first: the tombstones a readback reports so clients drop those cards.
|
||||
func (s *Store) DismissedChatShellRuns(ctx context.Context, sessionID string) ([]string, error) {
|
||||
rows, err := s.db.QueryContext(ctx, `SELECT id FROM chat_shell_runs WHERE session_id = ? AND dismissed_at > 0
|
||||
ORDER BY started_at, id`, sessionID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var ids []string
|
||||
for rows.Next() {
|
||||
var id string
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
return ids, rows.Err()
|
||||
}
|
||||
|
||||
@@ -9,7 +9,19 @@ import (
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
)
|
||||
|
||||
func TestChatShellRunsDismissRestoreAndPurge(t *testing.T) {
|
||||
func chatShellIDs(t *testing.T, runs []protocol.ChatShellRunRecord, err error) string {
|
||||
t.Helper()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var out []string
|
||||
for _, run := range runs {
|
||||
out = append(out, run.ID)
|
||||
}
|
||||
return fmt.Sprint(out)
|
||||
}
|
||||
|
||||
func TestChatShellRunsDismissKeepsOutputAndRestores(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
store, err := Open(filepath.Join(t.TempDir(), "shell.db"))
|
||||
if err != nil {
|
||||
@@ -18,8 +30,10 @@ func TestChatShellRunsDismissRestoreAndPurge(t *testing.T) {
|
||||
defer store.Close()
|
||||
save := func(id, session, status string, started int64) {
|
||||
t.Helper()
|
||||
code := 3
|
||||
run := protocol.ChatShellRunRecord{ID: id, SessionID: session, Command: "echo " + id, Directory: "/w", Status: status,
|
||||
StartedAt: started, Output: "out " + id, OutputBytes: 6, Text: "out " + id, Error: "err"}
|
||||
ExitCode: &code, StartedAt: started, EndedAt: started + 5, DurationMS: 5, Output: "out " + id, OutputBytes: 6,
|
||||
Text: "out " + id, Error: "err"}
|
||||
if err := store.SaveChatShellRun(ctx, run, 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -28,17 +42,10 @@ func TestChatShellRunsDismissRestoreAndPurge(t *testing.T) {
|
||||
save("run_b", "ses_1", protocol.ChatShellRunFailed, 2)
|
||||
save("run_live", "ses_1", protocol.ChatShellRunRunning, 3)
|
||||
save("run_other", "ses_2", protocol.ChatShellRunExited, 4)
|
||||
ids := func(session string) string {
|
||||
listed := func(session string) string {
|
||||
t.Helper()
|
||||
runs, err := store.ChatShellRuns(ctx, session)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var out []string
|
||||
for _, run := range runs {
|
||||
out = append(out, run.ID)
|
||||
}
|
||||
return fmt.Sprint(out)
|
||||
return chatShellIDs(t, runs, err)
|
||||
}
|
||||
|
||||
// Running, foreign and unknown runs are skipped.
|
||||
@@ -46,57 +53,93 @@ func TestChatShellRunsDismissRestoreAndPurge(t *testing.T) {
|
||||
if err != nil || fmt.Sprint(dismissed) != "[run_a]" {
|
||||
t.Fatalf("dismissed = %v, %v", dismissed, err)
|
||||
}
|
||||
if got := ids("ses_1"); got != "[run_b run_live]" {
|
||||
if got := listed("ses_1"); got != "[run_b run_live]" {
|
||||
t.Fatalf("readback after dismiss = %s", got)
|
||||
}
|
||||
if _, found, _ := store.ChatShellRun(ctx, "ses_1", "run_a"); found {
|
||||
t.Fatal("a dismissed run is still readable")
|
||||
}
|
||||
if again, _ := store.DismissChatShellRuns(ctx, "ses_1", []string{"run_a"}, 1001); len(again) != 0 {
|
||||
t.Fatalf("dismissed twice: %v", again)
|
||||
}
|
||||
if tombs, _ := store.DismissedChatShellRuns(ctx, "ses_1"); fmt.Sprint(tombs) != "[run_a]" {
|
||||
t.Fatalf("tombstones = %v", tombs)
|
||||
|
||||
// The dismissed run keeps its command, status, times and output.
|
||||
held, err := store.DismissedChatShellRuns(ctx, "ses_1")
|
||||
if err != nil || len(held) != 1 {
|
||||
t.Fatalf("dismissed runs = %+v, %v", held, err)
|
||||
}
|
||||
if run := held[0]; run.ID != "run_a" || !run.Dismissed || run.DismissedAt != 1000 || run.Purged ||
|
||||
run.Command != "echo run_a" || run.Output != "out run_a" || run.Text != "out run_a" ||
|
||||
run.ExitCode == nil || *run.ExitCode != 3 || run.DurationMS != 5 || run.EndedAt != 6 {
|
||||
t.Fatalf("dismissed run = %+v", run)
|
||||
}
|
||||
if run, found, err := store.ChatShellRun(ctx, "ses_1", "run_a"); err != nil || !found || !run.Dismissed || run.Output != "out run_a" {
|
||||
t.Fatalf("reading a dismissed run = %+v, %v, %v", run, found, err)
|
||||
}
|
||||
|
||||
// Undo inside the window restores the whole record.
|
||||
restored, err := store.RestoreChatShellRuns(ctx, "ses_1", []string{"run_a", "run_b"}, 900)
|
||||
if err != nil || len(restored) != 1 || restored[0].ID != "run_a" || restored[0].Output != "out run_a" || restored[0].Text != "out run_a" {
|
||||
// Restore has no time limit and brings the whole record back.
|
||||
restored, err := store.RestoreChatShellRuns(ctx, "ses_1", []string{"run_a", "run_b"})
|
||||
if err != nil || len(restored) != 1 || restored[0].ID != "run_a" || restored[0].Dismissed || restored[0].Output != "out run_a" {
|
||||
t.Fatalf("restored = %+v, %v", restored, err)
|
||||
}
|
||||
if got := ids("ses_1"); got != "[run_a run_b run_live]" {
|
||||
if got := listed("ses_1"); got != "[run_a run_b run_live]" {
|
||||
t.Fatalf("readback after restore = %s", got)
|
||||
}
|
||||
|
||||
// Past the window: no restore, and the purge keeps only a tombstone.
|
||||
if _, err := store.DismissChatShellRuns(ctx, "ses_1", []string{"run_a", "run_b"}, 2000); err != nil {
|
||||
t.Fatal(err)
|
||||
if runs, err := store.DismissedChatShellRuns(ctx, "ses_1"); chatShellIDs(t, runs, err) != "[]" {
|
||||
t.Fatalf("dismissed after restore = %+v", runs)
|
||||
}
|
||||
if late, err := store.RestoreChatShellRuns(ctx, "ses_1", []string{"run_a"}, 2001); err != nil || len(late) != 0 {
|
||||
t.Fatalf("late restore = %+v, %v", late, err)
|
||||
}
|
||||
if n, err := store.PurgeDismissedChatShellRuns(ctx, 2000); err != nil || n != 0 {
|
||||
t.Fatalf("purged inside the window: %d, %v", n, err)
|
||||
}
|
||||
if n, err := store.PurgeDismissedChatShellRuns(ctx, 2001); err != nil || n != 2 {
|
||||
t.Fatalf("purge = %d, %v", n, err)
|
||||
}
|
||||
if restoredPurged, _ := store.RestoreChatShellRuns(ctx, "ses_1", []string{"run_a"}, 0); len(restoredPurged) != 0 {
|
||||
t.Fatalf("a purged run was restored: %+v", restoredPurged)
|
||||
}
|
||||
var command, output, text, errText string
|
||||
var bytes int64
|
||||
if err := store.db.QueryRowContext(ctx, `SELECT command, output, output_text, error, output_bytes FROM chat_shell_runs WHERE id = 'run_a'`).
|
||||
Scan(&command, &output, &text, &errText, &bytes); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if command != "" || output != "" || text != "" || errText != "" || bytes != 0 {
|
||||
t.Fatalf("purged row kept %q %q %q %q %d", command, output, text, errText, bytes)
|
||||
}
|
||||
if tombs, _ := store.DismissedChatShellRuns(ctx, "ses_1"); fmt.Sprint(tombs) != "[run_a run_b]" {
|
||||
t.Fatalf("tombstones = %v", tombs)
|
||||
}
|
||||
if got := ids("ses_2"); got != "[run_other]" {
|
||||
if got := listed("ses_2"); got != "[run_other]" {
|
||||
t.Fatalf("another session changed: %s", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestChatShellRunsListOlderPurgedTombstones(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
store, err := Open(filepath.Join(t.TempDir(), "shell.db"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer store.Close()
|
||||
run := protocol.ChatShellRunRecord{ID: "run_old", SessionID: "ses_1", Directory: "/w",
|
||||
Status: protocol.ChatShellRunExited, StartedAt: 10, EndedAt: 20, DurationMS: 10}
|
||||
if err := store.SaveChatShellRun(ctx, run, 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// An older server purged this dismissed row after its undo window.
|
||||
if _, err := store.db.ExecContext(ctx, `UPDATE chat_shell_runs SET dismissed_at = 15, purged = 1 WHERE id = 'run_old'`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
held, err := store.DismissedChatShellRuns(ctx, "ses_1")
|
||||
if err != nil || len(held) != 1 || !held[0].Purged || !held[0].Dismissed || held[0].Command != "" || held[0].Output != "" {
|
||||
t.Fatalf("tombstone = %+v, %v", held, err)
|
||||
}
|
||||
if restored, err := store.RestoreChatShellRuns(ctx, "ses_1", []string{"run_old"}); err != nil || len(restored) != 0 {
|
||||
t.Fatalf("a purged run was restored: %+v, %v", restored, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestChatShellRunsDismissedCountTowardHistory(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
store, err := Open(filepath.Join(t.TempDir(), "shell.db"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer store.Close()
|
||||
for i := range 4 {
|
||||
run := protocol.ChatShellRunRecord{ID: fmt.Sprintf("run_%d", i), SessionID: "ses_1", Command: "true", Directory: "/w",
|
||||
Status: protocol.ChatShellRunExited, StartedAt: int64(i + 1)}
|
||||
if err := store.SaveChatShellRun(ctx, run, 3); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if i == 1 {
|
||||
if _, err := store.DismissChatShellRuns(ctx, "ses_1", []string{"run_0", "run_1"}, 100); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
dismissed, err := store.DismissedChatShellRuns(ctx, "ses_1")
|
||||
if got := chatShellIDs(t, dismissed, err); got != "[run_1]" {
|
||||
t.Fatalf("dismissed kept = %s", got)
|
||||
}
|
||||
kept, err := store.ChatShellRuns(ctx, "ses_1")
|
||||
if got := chatShellIDs(t, kept, err); got != "[run_2 run_3]" {
|
||||
t.Fatalf("runs kept = %s", got)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -84,26 +84,13 @@ cols = excluded.cols, rows = excluded.rows, output_text = excluded.output_text`,
|
||||
// ChatShellRuns lists one session's runs, oldest first, leaving out dismissed
|
||||
// ones.
|
||||
func (s *Store) ChatShellRuns(ctx context.Context, sessionID string) ([]protocol.ChatShellRunRecord, error) {
|
||||
rows, err := s.db.QueryContext(ctx, chatShellRunSelect+` WHERE session_id = ? AND dismissed_at = 0 ORDER BY started_at, id`, sessionID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var runs []protocol.ChatShellRunRecord
|
||||
for rows.Next() {
|
||||
run, err := scanChatShellRun(rows)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
runs = append(runs, run)
|
||||
}
|
||||
return runs, rows.Err()
|
||||
return s.queryChatShellRuns(ctx, ` WHERE session_id = ? AND dismissed_at = 0 ORDER BY started_at, id`, sessionID)
|
||||
}
|
||||
|
||||
// ChatShellRun returns one run of sessionID; found is false when that session
|
||||
// has no undismissed run with this id.
|
||||
// ChatShellRun returns one run of sessionID, dismissed or not (a dismissed
|
||||
// one is flagged); found is false when that session has no run with this id.
|
||||
func (s *Store) ChatShellRun(ctx context.Context, sessionID, id string) (protocol.ChatShellRunRecord, bool, error) {
|
||||
run, err := scanChatShellRun(s.db.QueryRowContext(ctx, chatShellRunSelect+` WHERE session_id = ? AND id = ? AND dismissed_at = 0`, sessionID, id))
|
||||
run, err := scanChatShellRun(s.db.QueryRowContext(ctx, chatShellRunSelect+` WHERE session_id = ? AND id = ?`, sessionID, id))
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return protocol.ChatShellRunRecord{}, false, nil
|
||||
}
|
||||
@@ -123,14 +110,14 @@ duration_ms = CASE WHEN ? > started_at THEN ? - started_at ELSE 0 END WHERE stat
|
||||
return result.RowsAffected()
|
||||
}
|
||||
|
||||
const chatShellRunSelect = `SELECT id, session_id, command, directory, status, exit_code, signal, error, started_at, ended_at, duration_ms, output, output_start, output_bytes, terminal, cols, rows, output_text FROM chat_shell_runs`
|
||||
const chatShellRunSelect = `SELECT id, session_id, command, directory, status, exit_code, signal, error, started_at, ended_at, duration_ms, output, output_start, output_bytes, terminal, cols, rows, output_text, dismissed_at, purged FROM chat_shell_runs`
|
||||
|
||||
func scanChatShellRun(row chatQueueScanner) (protocol.ChatShellRunRecord, error) {
|
||||
var run protocol.ChatShellRunRecord
|
||||
var exit sql.NullInt64
|
||||
err := row.Scan(&run.ID, &run.SessionID, &run.Command, &run.Directory, &run.Status, &exit, &run.Signal, &run.Error,
|
||||
&run.StartedAt, &run.EndedAt, &run.DurationMS, &run.Output, &run.OutputStart, &run.OutputBytes,
|
||||
&run.Terminal, &run.Cols, &run.Rows, &run.Text)
|
||||
&run.Terminal, &run.Cols, &run.Rows, &run.Text, &run.DismissedAt, &run.Purged)
|
||||
if err != nil {
|
||||
return protocol.ChatShellRunRecord{}, err
|
||||
}
|
||||
@@ -139,5 +126,6 @@ func scanChatShellRun(row chatQueueScanner) (protocol.ChatShellRunRecord, error)
|
||||
run.ExitCode = &code
|
||||
}
|
||||
run.Truncated = run.OutputStart > 0
|
||||
run.Dismissed = run.DismissedAt > 0
|
||||
return run, nil
|
||||
}
|
||||
|
||||
@@ -1,26 +1,26 @@
|
||||
package protocol
|
||||
|
||||
// Dismissing operator shell commands. Dismissal is per chat, for every client:
|
||||
// a dismissed run leaves every chat_shell_runs readback and every watcher
|
||||
// receives a chat_shell_run_event with Dismissed set. A running command cannot
|
||||
// be dismissed. For ChatShellRunUndoWindow after a dismissal the run can be
|
||||
// restored (chat_shell_restore); after that the server purges its command,
|
||||
// output and error, keeping only a tombstone whose id chat_shell_runs reports
|
||||
// in ChatShellDismissed so a client that missed the event drops the card.
|
||||
// a dismissed run leaves the transcript (chat_shell_runs' ChatShellRuns) and
|
||||
// every watcher receives a chat_shell_run_event with Dismissed set. A running
|
||||
// command cannot be dismissed. A dismissed run is kept, command, status, times
|
||||
// and output included, within the same history and output bounds as any other
|
||||
// run: chat_shell_runs lists it in ChatShellDismissedRuns (flagged Dismissed)
|
||||
// so clients can show it collapsed, chat_shell_run_output still reads it, and
|
||||
// chat_shell_restore puts it back at any time. Runs dismissed by an older
|
||||
// server had their command and output purged; they are listed with Purged set
|
||||
// and cannot be restored.
|
||||
const (
|
||||
// ChatShellDismiss dismisses the finished runs named in
|
||||
// ChatShellRunRequest.RunIDs; the reply lists those it dismissed in
|
||||
// ChatShellDismissed (running, unknown and already dismissed runs are
|
||||
// skipped).
|
||||
ChatShellDismiss = "chat_shell_dismiss"
|
||||
// ChatShellRestore undoes a dismissal still inside its undo window; the
|
||||
// reply carries the restored runs (with their list output tail) in
|
||||
// ChatShellRuns, and every watcher receives their lifecycle frames.
|
||||
// ChatShellRestore undoes a dismissal; the reply carries the restored runs
|
||||
// (with their list output tail) in ChatShellRuns, and every watcher
|
||||
// receives their lifecycle frames. There is no time limit; a purged run
|
||||
// cannot be restored.
|
||||
ChatShellRestore = "chat_shell_restore"
|
||||
// ChatShellRunUndoWindow is how long, in milliseconds, a dismissed run is
|
||||
// kept restorable before its output is purged. It is longer than the
|
||||
// clients' Undo notice so a late Undo still succeeds.
|
||||
ChatShellRunUndoWindow = 30_000
|
||||
// ChatShellDismissLimit bounds the run ids of one request.
|
||||
ChatShellDismissLimit = 200
|
||||
)
|
||||
|
||||
@@ -114,6 +114,12 @@ type ChatShellRunRecord struct {
|
||||
// carriage-return redraws applied): what Copy output copies and Send to
|
||||
// agent shares. Only chat_shell_run_output carries it.
|
||||
Text string `json:"text,omitempty"`
|
||||
// Dismissed is set on a run the operator dismissed (chat_shell_dismiss.go)
|
||||
// and DismissedAt is when, in epoch milliseconds. Purged is set when an
|
||||
// older server deleted its command and output: only the tombstone is left.
|
||||
Dismissed bool `json:"dismissed,omitempty"`
|
||||
DismissedAt int64 `json:"dismissed_at,omitempty"`
|
||||
Purged bool `json:"purged,omitempty"`
|
||||
}
|
||||
|
||||
// ChatShellRunEventFrame is one live change to a run. A lifecycle frame sets
|
||||
|
||||
@@ -281,8 +281,11 @@ type Message struct {
|
||||
ChatShellRuns []ChatShellRunRecord `json:"chat_shell_runs,omitempty"`
|
||||
ChatShellRunEvent *ChatShellRunEventFrame `json:"chat_shell_run_event,omitempty"`
|
||||
// ChatShellDismissed lists dismissed run ids (chat_shell_dismiss's reply
|
||||
// and chat_shell_runs' tombstones; chat_shell_dismiss.go).
|
||||
ChatShellDismissed []string `json:"chat_shell_dismissed,omitempty"`
|
||||
// and chat_shell_runs' dismissed ids; chat_shell_dismiss.go), and
|
||||
// ChatShellDismissedRuns carries chat_shell_runs' dismissed runs, oldest
|
||||
// first, with their list output tail.
|
||||
ChatShellDismissed []string `json:"chat_shell_dismissed,omitempty"`
|
||||
ChatShellDismissedRuns []ChatShellRunRecord `json:"chat_shell_dismissed_runs,omitempty"`
|
||||
// Machine terminals (terminal.go): the request body, one terminal, the
|
||||
// machine's terminals and the pushed change.
|
||||
TerminalRequest *TerminalRequest `json:"terminal_request,omitempty"`
|
||||
|
||||
@@ -4,7 +4,6 @@ import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
)
|
||||
@@ -12,9 +11,8 @@ import (
|
||||
// chatShellDismissStore persists dismissals; *pipeline.Store implements it.
|
||||
type chatShellDismissStore interface {
|
||||
DismissChatShellRuns(ctx context.Context, sessionID string, ids []string, at int64) ([]string, error)
|
||||
RestoreChatShellRuns(ctx context.Context, sessionID string, ids []string, since int64) ([]protocol.ChatShellRunRecord, error)
|
||||
PurgeDismissedChatShellRuns(ctx context.Context, before int64) (int64, error)
|
||||
DismissedChatShellRuns(ctx context.Context, sessionID string) ([]string, error)
|
||||
RestoreChatShellRuns(ctx context.Context, sessionID string, ids []string) ([]protocol.ChatShellRunRecord, error)
|
||||
DismissedChatShellRuns(ctx context.Context, sessionID string) ([]protocol.ChatShellRunRecord, error)
|
||||
}
|
||||
|
||||
func validChatShellRunIDs(ids []string) error {
|
||||
@@ -27,9 +25,9 @@ func validChatShellRunIDs(ids []string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Dismiss removes the session's finished runs among ids for every watcher and
|
||||
// returns the ids it dismissed. Their output is purged once the undo window
|
||||
// has passed.
|
||||
// Dismiss takes the session's finished runs among ids out of the transcript
|
||||
// for every watcher and returns the ids it dismissed. Their record and output
|
||||
// are kept: the readback lists them as dismissed and Restore brings them back.
|
||||
func (r *chatShellRunner) Dismiss(ctx context.Context, sessionID string, ids []string) ([]string, error) {
|
||||
if err := validChatShellRunIDs(ids); err != nil {
|
||||
return nil, err
|
||||
@@ -52,20 +50,17 @@ func (r *chatShellRunner) Dismiss(ctx context.Context, sessionID string, ids []s
|
||||
for _, id := range dismissed {
|
||||
r.publishFrame(protocol.ChatShellRunEventFrame{SessionID: sessionID, RunID: id, Dismissed: true})
|
||||
}
|
||||
if len(dismissed) > 0 {
|
||||
r.schedulePurge()
|
||||
}
|
||||
return dismissed, nil
|
||||
}
|
||||
|
||||
// Restore undoes the dismissal of the session's runs among ids that are still
|
||||
// inside the undo window and returns them with their list output tail.
|
||||
// Restore undoes the dismissal of the session's runs among ids, however long
|
||||
// ago they were dismissed, and returns them with their list output tail. A
|
||||
// purged run (an older server's tombstone) cannot be restored.
|
||||
func (r *chatShellRunner) Restore(ctx context.Context, sessionID string, ids []string) ([]protocol.ChatShellRunRecord, error) {
|
||||
if err := validChatShellRunIDs(ids); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
since := r.now().Add(-r.undo).UnixMilli()
|
||||
runs, err := r.store.RestoreChatShellRuns(ctx, sessionID, ids, since)
|
||||
runs, err := r.store.RestoreChatShellRuns(ctx, sessionID, ids)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -80,24 +75,20 @@ func (r *chatShellRunner) Restore(ctx context.Context, sessionID string, ids []s
|
||||
return runs, nil
|
||||
}
|
||||
|
||||
// Dismissed is the session's dismissed run ids (their tombstones).
|
||||
func (r *chatShellRunner) Dismissed(ctx context.Context, sessionID string) ([]string, error) {
|
||||
return r.store.DismissedChatShellRuns(ctx, sessionID)
|
||||
}
|
||||
|
||||
// purgeDismissed deletes the output of runs whose undo window has passed.
|
||||
func (r *chatShellRunner) purgeDismissed(ctx context.Context) {
|
||||
_, _ = r.store.PurgeDismissedChatShellRuns(ctx, r.now().Add(-r.undo).UnixMilli())
|
||||
}
|
||||
|
||||
// schedulePurge purges once the window of a dismissal made now has passed.
|
||||
// A server stopping before then purges on its next start (recover).
|
||||
func (r *chatShellRunner) schedulePurge() {
|
||||
time.AfterFunc(r.undo+time.Second, func() {
|
||||
if r.base.Err() == nil {
|
||||
r.purgeDismissed(r.base)
|
||||
}
|
||||
})
|
||||
// Dismissed is the session's dismissed runs, oldest first, each with at most
|
||||
// protocol.ChatShellRunListOutput bytes of its output tail, and their ids.
|
||||
func (r *chatShellRunner) Dismissed(ctx context.Context, sessionID string) ([]protocol.ChatShellRunRecord, []string, error) {
|
||||
runs, err := r.store.DismissedChatShellRuns(ctx, sessionID)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
ids := make([]string, len(runs))
|
||||
for i, run := range runs {
|
||||
runs[i] = chatShellRecordTail(run, protocol.ChatShellRunListOutput)
|
||||
runs[i].Text = ""
|
||||
ids[i] = run.ID
|
||||
}
|
||||
return runs, ids, nil
|
||||
}
|
||||
|
||||
func (r *chatShellRunner) publishFrame(frame protocol.ChatShellRunEventFrame) {
|
||||
|
||||
@@ -13,9 +13,9 @@ func dismissRequest(kind, id string, runIDs ...string) protocol.Message {
|
||||
return protocol.Message{Type: kind, ID: id, ChatShellRunRequest: &protocol.ChatShellRunRequest{SessionID: "ses_1", RunIDs: runIDs}}
|
||||
}
|
||||
|
||||
func TestChatShellDismissRemovesForEveryWatcherAndRestores(t *testing.T) {
|
||||
func TestChatShellDismissKeepsTheRunForEveryWatcherAndRestores(t *testing.T) {
|
||||
ctx, conns, _ := shellChat(t)
|
||||
done := runShell(t, ctx, conns[0], "r1", "echo kept-output")
|
||||
done := runShell(t, ctx, conns[0], "r1", "echo kept-output; exit 2")
|
||||
for _, conn := range conns {
|
||||
finishedShell(t, ctx, conn, done.ID)
|
||||
}
|
||||
@@ -44,21 +44,32 @@ func TestChatShellDismissRemovesForEveryWatcherAndRestores(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// The readback leaves it out and reports its tombstone; its output is gone.
|
||||
// The readback lists it apart, flagged, with its command, status and output.
|
||||
writeChat(t, ctx, conns[1], protocol.Message{Type: protocol.ChatShellRuns, ID: "list", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}})
|
||||
list := readShellFrame(t, ctx, conns[1], func(m protocol.Message) bool { return m.ID == "list" })
|
||||
if len(list.ChatShellRuns) != 1 || list.ChatShellRuns[0].ID != live.ID || fmt.Sprint(list.ChatShellDismissed) != fmt.Sprint([]string{done.ID}) {
|
||||
t.Fatalf("readback = %+v", list)
|
||||
}
|
||||
if len(list.ChatShellDismissedRuns) != 1 {
|
||||
t.Fatalf("dismissed runs = %+v", list.ChatShellDismissedRuns)
|
||||
}
|
||||
if run := list.ChatShellDismissedRuns[0]; run.ID != done.ID || !run.Dismissed || run.DismissedAt == 0 || run.Purged ||
|
||||
run.Command != "echo kept-output; exit 2" || run.ExitCode == nil || *run.ExitCode != 2 ||
|
||||
run.Output != "kept-output\r\n" || run.Text != "" {
|
||||
t.Fatalf("dismissed run = %+v", run)
|
||||
}
|
||||
// Its whole output stays readable (the history's output view, Copy output).
|
||||
writeChat(t, ctx, conns[1], shellRequest(protocol.ChatShellRunOutput, "out", done.ID, ""))
|
||||
if got := readShellFrame(t, ctx, conns[1], func(m protocol.Message) bool { return m.ID == "out" }); got.Type != protocol.Error {
|
||||
if got := readShellFrame(t, ctx, conns[1], func(m protocol.Message) bool { return m.ID == "out" }); got.Type != protocol.ChatShellRunOutput ||
|
||||
got.ChatShellRun == nil || !got.ChatShellRun.Dismissed || got.ChatShellRun.Text != "kept-output\n" {
|
||||
t.Fatalf("output of a dismissed run = %+v", got)
|
||||
}
|
||||
|
||||
// Undo brings the run back, output included, for every watcher.
|
||||
// Restore brings the run back, output included, for every watcher.
|
||||
writeChat(t, ctx, conns[1], dismissRequest(protocol.ChatShellRestore, "undo", done.ID))
|
||||
restored := readShellFrame(t, ctx, conns[1], func(m protocol.Message) bool { return m.ID == "undo" })
|
||||
if restored.Type != protocol.ChatShellRestore || len(restored.ChatShellRuns) != 1 || restored.ChatShellRuns[0].Output != "kept-output\r\n" {
|
||||
if restored.Type != protocol.ChatShellRestore || len(restored.ChatShellRuns) != 1 || restored.ChatShellRuns[0].Output != "kept-output\r\n" ||
|
||||
restored.ChatShellRuns[0].Dismissed {
|
||||
t.Fatalf("restore reply = %+v", restored)
|
||||
}
|
||||
for i, conn := range conns {
|
||||
@@ -77,13 +88,13 @@ func TestChatShellDismissRemovesForEveryWatcherAndRestores(t *testing.T) {
|
||||
finishedShell(t, ctx, conns[0], live.ID)
|
||||
}
|
||||
|
||||
func TestChatShellDismissPurgesAfterTheUndoWindow(t *testing.T) {
|
||||
func TestChatShellDismissedRunIsKeptAcrossRestartsAndRestoresLater(t *testing.T) {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
runner, frames := testShellRunner(t, ctx)
|
||||
now := time.UnixMilli(1_000_000)
|
||||
runner.now = func() time.Time { return now }
|
||||
run, err := runner.Start(ctx, "ses_1", t.TempDir(), "echo gone", 0, 0)
|
||||
run, err := runner.Start(ctx, "ses_1", t.TempDir(), "echo kept", 0, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -94,21 +105,21 @@ func TestChatShellDismissPurgesAfterTheUndoWindow(t *testing.T) {
|
||||
if _, err := runner.Dismiss(ctx, "ses_1", []string{run.ID}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
now = now.Add(runner.undo - time.Millisecond)
|
||||
runner.purgeDismissed(ctx)
|
||||
if restored, err := runner.Restore(ctx, "ses_1", []string{run.ID}); err != nil || len(restored) != 1 || restored[0].Output == "" {
|
||||
t.Fatalf("restore inside the window = %+v, %v", restored, err)
|
||||
}
|
||||
if _, err := runner.Dismiss(ctx, "ses_1", []string{run.ID}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
now = now.Add(runner.undo + time.Millisecond)
|
||||
// A restart purges what expired while no server ran.
|
||||
// A day later, after a restart, the run is still whole and restorable.
|
||||
now = now.Add(24 * time.Hour)
|
||||
runner.recover(ctx)
|
||||
if _, err := runner.Restore(ctx, "ses_1", []string{run.ID}); err == nil {
|
||||
t.Fatal("a run was restored after the undo window")
|
||||
held, ids, err := runner.Dismissed(ctx, "ses_1")
|
||||
if err != nil || len(held) != 1 || fmt.Sprint(ids) != fmt.Sprint([]string{run.ID}) || held[0].Command != "echo kept" ||
|
||||
held[0].Output == "" || held[0].Purged {
|
||||
t.Fatalf("dismissed = %+v, %v, %v", held, ids, err)
|
||||
}
|
||||
if tombs, err := runner.Dismissed(ctx, "ses_1"); err != nil || fmt.Sprint(tombs) != fmt.Sprint([]string{run.ID}) {
|
||||
t.Fatalf("tombstones = %v, %v", tombs, err)
|
||||
if read, err := runner.Read(ctx, "ses_1", run.ID); err != nil || read.Text != "kept\n" || !read.Dismissed {
|
||||
t.Fatalf("read = %+v, %v", read, err)
|
||||
}
|
||||
if restored, err := runner.Restore(ctx, "ses_1", []string{run.ID}); err != nil || len(restored) != 1 || restored[0].Output == "" {
|
||||
t.Fatalf("restore a day later = %+v, %v", restored, err)
|
||||
}
|
||||
if held, _, _ := runner.Dismissed(ctx, "ses_1"); len(held) != 0 {
|
||||
t.Fatalf("still dismissed: %+v", held)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -70,12 +70,13 @@ func handleChatShellRunRequest(ctx context.Context, request protocol.Message, br
|
||||
fail(err)
|
||||
return
|
||||
}
|
||||
dismissed, err := runner.Dismissed(ctx, sessionID)
|
||||
dismissedRuns, dismissed, err := runner.Dismissed(ctx, sessionID)
|
||||
if err != nil {
|
||||
fail(err)
|
||||
return
|
||||
}
|
||||
_ = write(protocol.Message{Type: protocol.ChatShellRuns, ID: request.ID, ChatShellRuns: runs, ChatShellDismissed: dismissed})
|
||||
_ = write(protocol.Message{Type: protocol.ChatShellRuns, ID: request.ID, ChatShellRuns: runs,
|
||||
ChatShellDismissed: dismissed, ChatShellDismissedRuns: dismissedRuns})
|
||||
case protocol.ChatShellDismiss:
|
||||
dismissed, err := runner.Dismiss(ctx, sessionID, body.RunIDs)
|
||||
if err != nil {
|
||||
|
||||
@@ -49,8 +49,6 @@ type chatShellRunner struct {
|
||||
grace time.Duration
|
||||
flush time.Duration
|
||||
persist time.Duration
|
||||
// undo is how long a dismissed run stays restorable before its purge.
|
||||
undo time.Duration
|
||||
|
||||
mu sync.Mutex
|
||||
active map[string]*chatShellProcess
|
||||
@@ -77,7 +75,6 @@ func newChatShellRunner(base context.Context, store chatShellRunStore, publish f
|
||||
return &chatShellRunner{
|
||||
base: base, store: store, publish: publish, now: time.Now, shell: chatShellProgram,
|
||||
grace: 3 * time.Second, flush: 100 * time.Millisecond, persist: 2 * time.Second,
|
||||
undo: protocol.ChatShellRunUndoWindow * time.Millisecond,
|
||||
active: map[string]*chatShellProcess{},
|
||||
}
|
||||
}
|
||||
@@ -93,14 +90,12 @@ func chatShellProgram() string {
|
||||
}
|
||||
|
||||
// recover marks runs a previous server process left running as interrupted:
|
||||
// their processes died with it (or are no longer owned by anyone). It also
|
||||
// purges dismissals whose undo window passed while no server was running.
|
||||
// their processes died with it (or are no longer owned by anyone).
|
||||
func (r *chatShellRunner) recover(ctx context.Context) {
|
||||
if r.store == nil {
|
||||
return
|
||||
}
|
||||
_, _ = r.store.InterruptChatShellRuns(ctx, r.now().UnixMilli(), chatShellInterruptedReason)
|
||||
r.purgeDismissed(ctx)
|
||||
}
|
||||
|
||||
// resolveChatShellDirectory requires the chat's recorded directory to still be
|
||||
|
||||
Reference in New Issue
Block a user