Fit chat terminals to their output, keep pastes and keys in the terminal

Finished terminals are sized synchronously from their rows at the view's
width (the post-frame fit made the transcript re-anchor forever); blank rows
xterm.dart keeps when rewrapping are dropped; desktop typing uses key events;
the composer leaves Cmd/Ctrl-V to a focused terminal; Ctrl-A reaches the
process. The probe fixture gains coloured terminal runs and an interactive
login. Notes record behaviour, protocol, security and verification.
This commit is contained in:
2026-11-09 20:51:59 +00:00
parent 89882d90f3
commit 2332143e5b
10 changed files with 429 additions and 52 deletions
@@ -5,14 +5,22 @@ import 'package:flutter/widgets.dart';
abstract final class ChatComposerPasteFocus {
static final Set<FocusNode> _composers = {};
static final Set<FocusNode> _inputs = {};
static void register(FocusNode focus) => _composers.add(focus);
static void unregister(FocusNode focus) => _composers.remove(focus);
/// An input that is not an [EditableText] (a shell command's terminal)
/// registers its focus here: a paste while it has focus is its own.
static void registerInput(FocusNode focus) => _inputs.add(focus);
static void unregisterInput(FocusNode focus) => _inputs.remove(focus);
static bool get anotherEditableHasFocus {
final primary = FocusManager.instance.primaryFocus;
if (primary == null || _composers.any((focus) => focus.hasFocus)) {
return false;
}
if (_inputs.any((focus) => focus.hasFocus)) return true;
final context = primary.context;
if (context == null) return false;
var editable = context.widget is EditableText;
@@ -217,10 +217,16 @@ class _ChatShellTerminalKeysState extends State<ChatShellTerminalKeys> {
);
}
if (material == null) {
return OutlinedButton(key: key, onPressed: onPressed, child: Text(label));
return OutlinedButton(
key: key,
style: OutlinedButton.styleFrom(visualDensity: VisualDensity.compact),
onPressed: onPressed,
child: Text(label),
);
}
return IconButton.outlined(
key: key,
visualDensity: VisualDensity.compact,
tooltip: label,
onPressed: onPressed,
icon: Icon(material),
@@ -89,6 +89,29 @@ class ChatShellTerminalSession {
terminal.setCursorVisibleMode(false);
}
/// The rows the drawn output takes, through the cursor's line, when the
/// terminal is [cols] wide: a finished run's box is sized by it before the
/// view lays the terminal out, so a card never changes height after it.
int rowsAt(int cols) {
final buffer = terminal.buffer;
final last = buffer.absoluteCursorY.clamp(0, buffer.height - 1);
var rows = 0;
var length = 0;
void close() => rows += length <= 0 ? 1 : (length + cols - 1) ~/ cols;
for (var y = 0; y <= last; y++) {
final line = buffer.lines[y];
if (y > 0 && !line.isWrapped) {
close();
length = 0;
}
// A row the next one continues is full to the terminal's width.
final continued = y + 1 < buffer.height && buffer.lines[y + 1].isWrapped;
length += continued ? line.length : line.getTrimmedLength();
}
close();
return rows;
}
void _output(String data) {
if (_live && !_replaying) onInput(data);
}
@@ -109,4 +132,20 @@ class _ChatShellTerminal extends Terminal {
void sendCursorPosition() {
onOutput?.call('\x1b[${buffer.cursorY + 1};${buffer.cursorX + 1}R');
}
/// Narrowing rewraps long lines, and xterm.dart 4.0.0 keeps every blank
/// row below the cursor while doing so: the extra rows push the top of
/// the output into scrollback. Blank rows below the cursor are dropped
/// instead, keeping the cursor on its line.
@override
void resize(int width, int height, [int? pixelWidth, int? pixelHeight]) {
super.resize(width, height, pixelWidth, pixelHeight);
final lines = buffer.lines;
while (buffer.height > viewHeight &&
buffer.height - 1 > buffer.absoluteCursorY &&
lines[buffer.height - 1].getText().trim().isEmpty) {
lines.pop();
buffer.setCursor(buffer.cursorX, buffer.cursorY + 1);
}
}
}
@@ -1,3 +1,5 @@
import 'dart:ui' as ui;
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:xterm/xterm.dart';
@@ -71,15 +73,16 @@ TerminalStyle chatShellTerminalStyle(BuildContext context, bool cupertino) {
);
}
/// The height of one terminal row in [style] at the context's text scale,
/// measured the way the emulator measures its cells.
double chatShellTerminalLineHeight(BuildContext context, TerminalStyle style) {
final painter = TextPainter(
text: TextSpan(text: 'mmmmmmmmmm', style: style.toTextStyle()),
textDirection: TextDirection.ltr,
textScaler: MediaQuery.textScalerOf(context),
)..layout();
final height = painter.height;
painter.dispose();
return height;
/// The size of one terminal cell in [style] at the context's text scale,
/// measured exactly as the emulator measures it.
Size chatShellTerminalCellSize(BuildContext context, TerminalStyle style) {
final text = style.toTextStyle();
final builder = ui.ParagraphBuilder(text.getParagraphStyle())
..pushStyle(text.getTextStyle(textScaler: MediaQuery.textScalerOf(context)))
..addText('mmmmmmmmmm');
final paragraph = builder.build()
..layout(const ui.ParagraphConstraints(width: double.infinity));
final size = Size(paragraph.maxIntrinsicWidth / 10, paragraph.height);
paragraph.dispose();
return size;
}
@@ -1,19 +1,48 @@
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:xterm/xterm.dart';
import '../conversation/chat_composer_paste_focus.dart';
import '../ui/transcript/chat_link_launcher.dart';
import 'chat_shell_metrics.dart';
import 'chat_shell_terminal_links.dart';
import 'chat_shell_terminal_session.dart';
import 'chat_shell_terminal_theme.dart';
/// Whether the soft keyboard is the main way to type here, so the terminal
/// takes typing from the key toolbar's field rather than its own hidden one.
/// Whether the soft keyboard is the main way to type here, so the key
/// toolbar offers a text field: the terminal itself takes hardware keys only.
bool chatShellTouchFirst() =>
defaultTargetPlatform == TargetPlatform.android ||
defaultTargetPlatform == TargetPlatform.iOS;
/// The terminal's own key shortcuts. Cmd-C, Cmd-V and Cmd-A on Apple
/// platforms; elsewhere Ctrl-V (and the terminal convention Ctrl-Shift-V)
/// paste and Ctrl-Shift-C copies, so every other Ctrl key, Ctrl-A and Ctrl-C
/// included, reaches the process.
Map<ShortcutActivator, Intent> chatShellTerminalShortcuts() {
const paste = PasteTextIntent(SelectionChangedCause.keyboard);
final apple =
defaultTargetPlatform == TargetPlatform.macOS ||
defaultTargetPlatform == TargetPlatform.iOS;
if (apple) {
return const {
SingleActivator(LogicalKeyboardKey.keyC, meta: true):
CopySelectionTextIntent.copy,
SingleActivator(LogicalKeyboardKey.keyV, meta: true): paste,
SingleActivator(LogicalKeyboardKey.keyA, meta: true): SelectAllTextIntent(
SelectionChangedCause.keyboard,
),
};
}
return const {
SingleActivator(LogicalKeyboardKey.keyC, control: true, shift: true):
CopySelectionTextIntent.copy,
SingleActivator(LogicalKeyboardKey.keyV, control: true): paste,
SingleActivator(LogicalKeyboardKey.keyV, control: true, shift: true): paste,
};
}
/// One run's terminal emulator view. In a card it is bounded to
/// [kChatShellOutputCollapsedLines] rows (a finished run shrinks to its
/// output); with [fill] it takes the space its parent gives (full screen).
@@ -44,10 +73,18 @@ class ChatShellTerminalView extends StatefulWidget {
class _ChatShellTerminalViewState extends State<ChatShellTerminalView> {
final TerminalController _controller = TerminalController();
final FocusNode _focus = FocusNode(debugLabel: 'chat-shell-terminal');
int? _fitRows;
@override
void initState() {
super.initState();
// A paste while the terminal has focus goes to the process, not to the
// chat composer.
ChatComposerPasteFocus.registerInput(_focus);
}
@override
void dispose() {
ChatComposerPasteFocus.unregisterInput(_focus);
_controller.dispose();
_focus.dispose();
super.dispose();
@@ -58,14 +95,6 @@ class _ChatShellTerminalViewState extends State<ChatShellTerminalView> {
if (uri != null) openChatLink(context, uri);
}
/// A finished run's box shrinks to the rows its output uses.
void _fit() {
if (!mounted || widget.fill || widget.session.live) return;
final used = widget.session.terminal.buffer.absoluteCursorY + 1;
final rows = used.clamp(1, kChatShellOutputCollapsedLines);
if (rows != _fitRows) setState(() => _fitRows = rows);
}
@override
Widget build(BuildContext context) {
final session = widget.session;
@@ -85,8 +114,11 @@ class _ChatShellTerminalViewState extends State<ChatShellTerminalView> {
textStyle: style,
padding: padding,
readOnly: !live,
hardwareKeyboardOnly: !live || chatShellTouchFirst(),
keyboardType: TextInputType.visiblePassword,
// Keys go straight to the process as key events (a focused text
// input would stay closed on the web); touch typing goes through the
// key toolbar's field instead.
hardwareKeyboardOnly: true,
shortcuts: chatShellTerminalShortcuts(),
cursorType: TerminalCursorType.block,
onTapUp: _tapped,
),
@@ -102,12 +134,22 @@ class _ChatShellTerminalViewState extends State<ChatShellTerminalView> {
);
view = ClipRRect(borderRadius: BorderRadius.circular(8), child: view);
if (widget.fill) return view;
if (!live) WidgetsBinding.instance.addPostFrameCallback((_) => _fit());
final rows = live
? kChatShellOutputCollapsedLines
: (_fitRows ?? kChatShellOutputCollapsedLines);
final line = chatShellTerminalLineHeight(context, style);
// A pixel of slack keeps rounding from losing the last row.
return SizedBox(height: rows * line + padding.vertical + 1, child: view);
final cell = chatShellTerminalCellSize(context, style);
return LayoutBuilder(
builder: (context, constraints) {
// A finished run's box fits the rows its output takes at this width.
final cols = ((constraints.maxWidth - padding.horizontal) / cell.width)
.floor()
.clamp(1, 1000);
final rows = live
? kChatShellOutputCollapsedLines
: session.rowsAt(cols).clamp(1, kChatShellOutputCollapsedLines);
// A pixel of slack keeps rounding from losing the last row.
return SizedBox(
height: rows * cell.height + padding.vertical + 1,
child: view,
);
},
);
}
}
+170
View File
@@ -0,0 +1,170 @@
# Interactive chat shell commands (terminal)
Operator shell commands (`!cmd`, Run command…; see `chat-shell-commands.md`)
now run in a real pseudo-terminal and the card draws them with a terminal
emulator. Auth flows that print a link, wait for a pasted token and continue
(`gh auth login`, `claude login`, `npm login`, ssh prompts) work in the chat.
## Behaviour
- **Server (macOS, Linux):** every `chat_shell_run` starts `$SHELL -lc <cmd>`
inside a PTY (`github.com/creack/pty` v1.1.24) as the leader of a new
session with the PTY as controlling terminal (`Setsid`, `Setctty`), so the
session id is the process group Stop signals (SIGINT, then SIGKILL after the
grace period). `TERM=xterm-256color`; cwd and the rest of the environment are
unchanged. Size comes from the request (`cols`, `rows`), clamped to
20–500 x 4–200, default 100x30. The PTY controller is closed when the command
ends. Other platforms keep the previous pipe mode; input and resize answer
"interactive terminals are not supported on this server".
- **Card:** the output area is an `xterm` 4.0.0 (xterm.dart) `TerminalView`
fed the raw stream in order. One emulator per run lives in the controller
(`ChatShellTerminals`), so scrolling a card away or opening Full screen keeps
the same state.
- Running: 12 rows in the reading column; click/tap to focus and type
(hardware keys, Ctrl-C, arrows, Tab, Esc go to the process). Paste:
Cmd-V on Apple platforms, Ctrl-V or Ctrl-Shift-V elsewhere, plus the
toolbar's Paste button. Ctrl-A and other Ctrl keys reach the process. A key
toolbar under the terminal: Paste, Enter, Ctrl-C, Tab, Esc, arrows. On
Android/iOS the toolbar also has a text field ("Type input, then Enter")
for the soft keyboard, with a Hide typing toggle; it is emptied when sent.
- The terminal is resized to its layout (debounced 150 ms); the process gets
SIGWINCH. New runs start at the last laid-out size.
- Printed `http(s)` links open in the browser on tap (wrapped links are
joined). Other schemes are ignored.
- Finished runs are drawn read-only, shrunk to the rows their output takes
(at most 12), cursor hidden. Full screen opens the same terminal in a page.
- Colours: background/foreground/cursor/selection from the host theme; the
16 ANSI colours are xterm.dart's palette, darkened on light surfaces.
- Copy output copies the server's plain-text rendering; Send to agent shares
a bounded plain-text tail (no escape codes).
- Pipe-mode and older runs (no `terminal`) are drawn in the same emulator with
`\n` drawn as a new line, read-only.
## Protocol
- `chat_shell_run` request adds optional `cols`, `rows`; records add
`terminal`, `cols`, `rows` (current size) and, only in
`chat_shell_run_output`, `text` (plain-text rendering).
- `chat_shell_input {session_id, run_id, data}`: `data` is UTF-8 text written
byte-for-byte (its UTF-8 encoding). Control characters are JSON escapes:
Ctrl-C `\u0003`, Enter `\r`, arrows `\u001b[A`… Paste is text (bracketed when
the program asked). At most 16 KiB per request (clients split longer pastes
at 4096 UTF-16 units); invalid UTF-8 is refused. Requests from one
connection are applied in order through a 64-entry queue; a full queue is
refused ("the command is not reading its input"). Reply has no body.
- `chat_shell_resize {session_id, run_id, cols, rows}`: reply echoes the run.
The last resize from any client wins.
- Output frames are unchanged: raw terminal bytes (UTF-8, partial characters
held back) with absolute byte offsets `[offset, end)`, which are the stream
sequence numbers. `chat_shell_run_output` takes `after`: the reply's
`output_start` is `max(after, retained start)`, so a reconnecting client
fetches only what it missed and sees a gap if it fell out of the 1 MiB tail.
The app does this on reconnect for runs it holds.
- Persistence: `chat_shell_runs` gains `terminal`, `cols`, `rows`,
`output_text` (additive columns). `output` is the raw stream tail (1 MiB),
`output_text` its rendering (bounded to 1 MiB). Rows recorded before this
change get a rendering computed on read.
## Security
- Any authenticated client watching the chat may type into or resize a
running command, not only the one that started it (the same authority that
can already start and stop commands in that chat). Input is checked against
the chat's operator session like every other shell request.
- Input is never persisted or logged: the server does not log
`chat_shell_input`/`chat_shell_resize` request lines at all (keystrokes
would otherwise be one log line each), and only what the terminal echoes
becomes output. Password prompts disable echo, so hidden input never
appears in output, frames, `output` or `output_text`.
- The client keeps no copy of typed input: keys go from the emulator straight
into a send queue that is cleared as each request is sent (and discarded on
a refusal); the mobile field is cleared on send and can hide its text.
- When the terminal has focus, the chat composer leaves Cmd/Ctrl-V alone
(`ChatComposerPasteFocus.registerInput`), so a pasted token goes only to the
process.
## Limits and known gaps
- Plain-text rendering is not an emulator: it strips CSI/OSC/DCS sequences,
applies `\r`, backspace and line erase; full-screen programs render as their
last lines. The card's emulator draws them properly.
- Every watching client's emulator answers terminal queries (e.g. cursor
position) for a live run, so two open clients send two answers.
xterm.dart 4.0.0 answers DSR 6 zero-based; the app overrides it to the
correct one-based answer.
- xterm.dart 4.0.0 keeps blank rows when it rewraps; the app drops blank rows
below the cursor after a resize so the top of the output stays in view.
- Desktop typing uses key events (no IME composition for CJK input). Touch
platforms use the field.
- A descendant that keeps the PTY open after the command exits is read for
1 s; on macOS the PTY has no read deadline, so its reader goroutine ends
only when that descendant closes it (the run itself is finished and the
group killed).
- Mobile behaviour (soft keyboard field) is verified by widget tests only; no
device test ran. Android/Linux builds were not run (web and macOS were).
## Files
- Server: `internal/protocol/chat_shell_terminal.go`, `chat_shell_run.go`;
`internal/server/chat_shell_terminal{,_unix,_other}.go`,
`chat_shell_plain.go`, `chat_shell_runner.go`, `chat_shell_supervise.go`,
`chat_shell_run_handlers.go`, `chat_shell_share.go`, `chat.go`,
`websocket.go`; `internal/pipeline/chat_shell_runs.go`; `go.mod`, `go.sum`.
- App: `lib/features/chat/shell/chat_shell_terminal_{session,view,keys,theme,links,page}.dart`,
`chat_shell_terminals.dart`, `chat_shell_output_view.dart`,
`chat_shell_run{,_card}.dart`, `chat_shell_card_actions.dart`,
`chat_shell_runs_{controller,repository}.dart`, `chat_shell_metrics.dart`;
`lib/features/chat/conversation/chat_composer_paste_focus.dart`;
`pubspec.yaml`/`pubspec.lock` (`xterm: ^4.0.0`, pure Dart; pub.dev lists
Android, iOS, Linux, macOS, web, Windows); probe fixture
`tool/perf/chat_shell_fixture.dart` (`?shell=1`: coloured runs and an
interactive `gh auth login` that hides the token and finishes on Enter).
## Verification
Flutter 3.44.6 / Dart 3.12.2; macOS host.
- `go test ./internal/protocol ./internal/pipeline ./internal/server -count=1`:
`ok …/protocol 0.205s`, `ok …/pipeline 15.838s`, `ok …/server 140.086s`.
Real-PTY tests (`chat_shell_terminal_test.go`, `_ws_test.go`): a typed line
reaches `read`; `stty -echo` input is in no frame, output or text; `\x03`
interrupts; `stty size` sees the start size and a resize; resume by offset
over the websocket from a second client; raw + plain text persisted;
input bounds (16 KiB, empty, invalid UTF-8, full queue); size clamping.
`go test -run ChatShell -count=5`: ok. `GOOS=freebsd go build
./internal/server` (pipe fallback) and `GOOS=linux GOARCH=amd64 go test -c`
compile. (`-race` shows an existing data race in
`internal/opencode` `nativeRequest`, unrelated to this change.)
- `tool/memwatch/full.sh test/features/chat`: `PASS: 1124 passed, 0 failed`.
New: `test/features/chat/shell/chat_shell_terminal_test.dart` (desktop keys,
Cmd-V paste not taken by the composer, Paste button, touch toolbar and
hidden field cleared on send, resize sent, finished run read-only, colours,
reconnect resume), `chat_shell_terminal_session_test.dart` (links incl.
wrapped and non-http, query answers not resent on replay, one-based DSR,
gap redraw, rewrap keeps first line, row fitting).
- `tool/analyze.sh`: clean. `flutter build web`: built.
`FLUTTER_XCODE_ARCHS=arm64 flutter build macos`: built (34.9MB).
- Real Chrome (`tool/capture`, probe `?chats=2&shell=1`, 880x1000, Material and
Cupertino, light and dark): `/tmp/chat-interactive-terminal/<platform>-<theme>/`
`01-login-prompt.png` (coloured output, underlined link, prompt and cursor),
`02-login-focused.png` (focused cursor), `03-login-done.png` (5 typed keys
and Enter reached the fixture: "received a 5-character token", nothing
echoed; the card shrank to its output, read-only), `04-full-screen.png`.
- Scratch server end to end (`go build ./cmd/pipelines-server`, `env -i`
with HOME/XDG_DATA_HOME/DB under `/tmp/pty-e2e`, OS-chosen loopback port,
operator session inserted with sqlite3, Node websocket driver
`/tmp/pty-e2e/drive.mjs`; server stopped afterwards, no processes left):
```
started run_45be206dedb0454409c537b6 terminal=true size=90x20
resize reply: chat_shell_resize 120x40
input reply: chat_shell_input
final: status=exited exit=0 bytes=145
"tty: xterm-256color\r\n20 90\r\n\u001b[1;32mOpen https://example.com/login\u001b[0m\r\nPaste token: \r\n40 120\r\ngot 13 characters\r\nName: operator\r\nhello operator\r\n"
secret in stream: false
resume after 119: output_start=119 output="operator\r\nhello operator\r\n"
secret in text: false
late input: error this command is not running
run_…|exited|0|1|120|40|145|125|0 (sqlite: terminal, cols, rows, raw, text, SECRET offset)
```
The server log has no `chat_shell_input` or `chat_shell_resize` lines.
@@ -84,4 +84,31 @@ void main() {
contains('earlier output was dropped'),
);
});
test('narrowing rewraps without pushing the first line out of view', () {
final session = ChatShellTerminalSession(
_run('first\r\n${'u' * 30}\r\nprompt: '),
onInput: (_) {},
onResize: (_, _) {},
);
session.terminal.resize(20, 6);
final buffer = session.terminal.buffer;
expect(buffer.height, 6);
expect(buffer.lines[0].getText().trim(), 'first');
expect(buffer.lines[3].getText().trim(), 'prompt:');
expect(buffer.absoluteCursorY, 3);
expect(buffer.cursorX, 8);
});
test('a finished run counts the rows its output takes at a width', () {
final session = ChatShellTerminalSession(
_run('a\r\n${'x' * 50}\r\nend\r\n', status: 'exited'),
onInput: (_) {},
onResize: (_, _) {},
);
// The 50-character line wraps at the terminal's 40 columns.
expect(session.rowsAt(40), 4);
expect(session.rowsAt(20), 5);
expect(session.rowsAt(100), 3);
});
}
@@ -39,12 +39,36 @@ void main() {
expect(find.byKey(const Key('chat-shell-terminal-field')), findsNothing);
await tester.tap(find.byType(TerminalView));
await tester.pump();
await tester.sendKeyEvent(LogicalKeyboardKey.keyG);
await tester.sendKeyEvent(LogicalKeyboardKey.digit7);
await tester.sendKeyEvent(LogicalKeyboardKey.arrowUp);
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
await tester.sendKeyEvent(LogicalKeyboardKey.keyC);
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
await tester.pump();
expect(typed(), '\x1b[A\x03');
expect(typed(), 'g7\x1b[A\x03');
// Cmd-V pastes the clipboard into the process.
tester.binding.defaultBinaryMessenger.setMockMethodCallHandler(
SystemChannels.platform,
(call) async =>
call.method == 'Clipboard.getData' ? {'text': 'tok'} : null,
);
addTearDown(
() => tester.binding.defaultBinaryMessenger.setMockMethodCallHandler(
SystemChannels.platform,
null,
),
);
await tester.sendKeyDownEvent(LogicalKeyboardKey.metaLeft);
await tester.sendKeyEvent(LogicalKeyboardKey.keyV);
await tester.sendKeyUpEvent(LogicalKeyboardKey.metaLeft);
for (var i = 0; i < 5; i++) {
await tester.pump(const Duration(milliseconds: 20));
}
expect(typed(), 'g7\x1b[A\x03tok');
// The chat composer leaves a paste into the terminal alone.
expect(find.text('tok'), findsNothing);
expect(find.byType(EditableText), findsWidgets);
await tester.pump(const Duration(milliseconds: 400));
expect(gateway.bodies('chat_shell_input').first['run_id'], 'run_t');
},
+67 -18
View File
@@ -1,17 +1,30 @@
// Operator shell commands for the full-app probe (`?shell=1`, with
// `?chats=N`): every fixture chat lists four recorded runs (succeeded, failed,
// stopped and one still running), and chat_shell_run/stop/share answer as the
// server does, with the frames that follow.
// `?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. 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';
bool _enabled = false;
DateTime _base = DateTime.now();
int _loginEnd = utf8.encode(_loginPrompt).length;
int _tokenLength = 0;
void configureChatShellFixture(Map<String, String> params) {
_enabled = params['shell'] == '1';
_base = DateTime.now().subtract(const Duration(minutes: 3));
_loginEnd = utf8.encode(_loginPrompt).length;
}
const String _loginPrompt =
'\x1b[1m!\x1b[0m First copy your one-time code: \x1b[1;33mA1B2-C3D4\x1b[0m\r\n'
'Open this URL to continue in your web browser: '
'\x1b[4mhttps://github.com/login/device\x1b[0m\r\n'
'\x1b[32m?\x1b[0m \x1b[1mPaste an authentication token\x1b[0m: ';
int _at(int seconds) =>
_base.add(Duration(seconds: seconds)).millisecondsSinceEpoch;
@@ -30,6 +43,9 @@ JsonMap _run(
int duration = 0,
String output = '',
}) => {
'terminal': true,
'cols': 100,
'rows': 30,
'id': id,
'session_id': session,
'command': command,
@@ -40,7 +56,7 @@ JsonMap _run(
if (status != 'running') 'ended_at': _at(started) + duration,
'duration_ms': duration,
'output': output,
'output_bytes': output.length,
'output_bytes': utf8.encode(output).length,
};
List<JsonMap> _runs(String session) => [
@@ -52,8 +68,8 @@ List<JsonMap> _runs(String session) => [
exitCode: 0,
duration: 84,
output:
' M app/lib/features/chat/shell/chat_shell_run_card.dart\n'
'?? app/notes/chat-shell-commands.md\n',
' \x1b[31mM\x1b[0m app/lib/features/chat/shell/chat_shell_run_card.dart\r\n'
'\x1b[31m??\x1b[0m app/notes/chat-shell-commands.md\r\n',
),
_run(
session,
@@ -63,12 +79,12 @@ List<JsonMap> _runs(String session) => [
exitCode: 1,
duration: 4210,
output:
'${[for (final name in _tests) '=== RUN TestChatShell$name\n--- PASS: TestChatShell$name (0.0${name.length % 9}s)\n'].join()}'
'--- FAIL: TestChatShellStopInterruptsTheGroup (0.21s)\n'
' chat_shell_run_test.go:112: stopped record = {Status:exited}\n'
'FAIL\n'
'FAIL\tgit.a-wan.net/alan/pipelines/internal/server\t0.611s\n'
'FAIL\n',
'${[for (final name in _tests) '=== RUN TestChatShell$name\r\n\x1b[32m--- PASS\x1b[0m: TestChatShell$name (0.0${name.length % 9}s)\r\n'].join()}'
'\x1b[1;31m--- FAIL\x1b[0m: TestChatShellStopInterruptsTheGroup (0.21s)\r\n'
' chat_shell_run_test.go:112: stopped record = {Status:exited}\r\n'
'\x1b[31mFAIL\x1b[0m\r\n'
'\x1b[31mFAIL\x1b[0m\tgit.a-wan.net/alan/pipelines/internal/server\t0.611s\r\n'
'\x1b[31mFAIL\x1b[0m\r\n',
),
_run(
session,
@@ -77,17 +93,15 @@ List<JsonMap> _runs(String session) => [
40,
status: 'stopped',
duration: 15200,
output: 'Nov 9 15:58:01 host kernel[0]: wake reason: EC.LidOpen\n',
output: 'Nov 9 15:58:01 host kernel[0]: wake reason: EC.LidOpen\r\n^C',
),
_run(
session,
'run_build',
'flutter build web --target tool/search_selection_probe_entry.dart',
'run_login',
'gh auth login --hostname github.com',
60,
status: 'running',
output:
'Compiling lib/main.dart for the Web...\n'
'Font asset "CupertinoIcons.ttf" was tree-shaken.\n',
output: _loginPrompt,
),
];
@@ -129,6 +143,10 @@ JsonMap? chatShellReply(JsonMap request) {
};
case 'chat_shell_share':
return {'id': id, 'type': 'chat_prompt'};
case 'chat_shell_input':
return {'id': id, 'type': 'chat_shell_input'};
case 'chat_shell_resize':
return {'id': id, 'type': 'chat_shell_resize'};
}
return null;
}
@@ -171,6 +189,37 @@ List<JsonMap> chatShellFollowUps(JsonMap request) {
return [
frame({'run_id': run['id'], 'run': run}),
];
case 'chat_shell_input':
// The token prompt does not echo; Enter completes the login.
final body = request['chat_shell_run_request'];
final data = body is Map ? '${body['data'] ?? ''}' : '';
_tokenLength += data.replaceAll('\r', '').length;
if (!data.contains('\r')) return const [];
final done =
'\r\n\x1b[2m(received a $_tokenLength-character token)\x1b[0m\r\n'
'\x1b[32m\u2713\x1b[0m Configured git protocol\r\n'
'\x1b[32m\u2713\x1b[0m Logged in as \x1b[1moperator\x1b[0m\r\n';
final start = _loginEnd;
_loginEnd += utf8.encode(done).length;
return [
frame({
'run_id': 'run_login',
'output': done,
'offset': start,
'end': _loginEnd,
}),
frame({
'run_id': 'run_login',
'run': _run(
session,
'run_login',
'gh auth login --hostname github.com',
60,
exitCode: 0,
duration: 48200,
)..['output_bytes'] = _loginEnd,
}),
];
}
return const [];
}
+10 -1
View File
@@ -48,7 +48,16 @@ func TestChatShellStopKillsAfterGrace(t *testing.T) {
if err != nil {
t.Fatal(err)
}
time.Sleep(150 * time.Millisecond)
// The trap must be in place before the stop: wait for the command's
// output rather than a fixed delay (a login shell can be slow to start).
for deadline := time.Now().Add(10 * time.Second); ; time.Sleep(10 * time.Millisecond) {
if record, err := runner.Read(context.Background(), "ses_1", run.ID); err == nil && strings.Contains(record.Output, "ready") {
break
}
if time.Now().After(deadline) {
t.Fatal("the command never printed ready")
}
}
if _, err := runner.Stop("ses_2", run.ID); err == nil {
t.Fatal("another session stopped this run")
}