Files
pipelines/app/lib/features/chat/shell/chat_shell_terminal_session.dart
alan 2332143e5b 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.
2026-11-09 20:51:59 +00:00

152 lines
5.2 KiB
Dart

import 'package:xterm/core.dart';
import 'chat_shell_run.dart';
/// Lines of scrollback one card's terminal keeps.
const int chatShellTerminalScrollback = 5000;
/// The terminal emulator state of one run: the xterm [terminal] fed with the
/// run's output in order, and the bridge from what the operator types (or
/// the emulator answers) to the running process.
///
/// It keeps no copy of typed input: [Terminal.onOutput] hands each key or
/// paste straight to [onInput], which sends it.
class ChatShellTerminalSession {
ChatShellTerminalSession(
ChatShellRun run, {
required this.onInput,
required this.onResize,
}) : terminal = _ChatShellTerminal() {
// Drawn at the process's own size until a view lays it out at its own.
if (run.cols > 0 && run.rows > 0) terminal.resize(run.cols, run.rows);
terminal.onOutput = _output;
terminal.onResize = (cols, rows, _, _) => onResize(cols, rows);
replay(run);
}
final Terminal terminal;
/// Receives input for the process; only called while the run is live.
final void Function(String data) onInput;
/// Receives the size the view laid the terminal out at.
final void Function(int cols, int rows) onResize;
int _end = 0;
bool _live = false;
bool _replaying = false;
/// The absolute output byte this terminal has drawn up to.
int get end => _end;
/// Whether typing reaches a running process.
bool get live => _live;
/// Draws [run]'s held output from scratch: on open, after a gap and after
/// a readback replaced the card's copy. Answers the emulator gives to old
/// queries in that output are not sent: the process asked them long ago.
void replay(ChatShellRun run) {
_live = run.running && run.terminal;
_replaying = true;
try {
terminal.useMainBuffer();
terminal.buffer.clear();
terminal.buffer.setCursor(0, 0);
terminal.setCursorVisibleMode(true);
terminal.write('\x1b[0m');
if (run.truncated) {
terminal.write('\x1b[2m[earlier output was dropped]\x1b[0m\r\n');
}
var output = _drawable(run, run.output);
// A finished run's final newline would leave an empty line below it.
if (!run.running && output.endsWith('\r\n')) {
output = output.substring(0, output.length - 2);
}
terminal.write(output);
if (!run.running) terminal.setCursorVisibleMode(false);
} finally {
_replaying = false;
}
_end = run.outputEnd;
}
/// Draws one live chunk covering bytes [offset, end) of [run], which
/// already holds it. A chunk after a hole redraws the whole held copy.
void append(ChatShellRun run, String text, int offset, int end) {
if (end <= _end) return;
if (offset != _end) {
replay(run);
return;
}
terminal.write(_drawable(run, text));
_end = end;
}
/// The run ended: nothing typed reaches it any more.
void finish(ChatShellRun run) {
if (!_live) return;
_live = false;
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);
}
/// Plain-pipe output has bare newlines, which a terminal draws as a line
/// feed without a carriage return.
static String _drawable(ChatShellRun run, String text) =>
run.terminal ? text : text.replaceAll('\n', '\r\n');
}
/// The emulator with the scrollback the cards keep. It answers a cursor
/// position query (DSR 6) with the one-based row and column the protocol
/// specifies; xterm.dart 4.0.0 itself answers zero-based.
class _ChatShellTerminal extends Terminal {
_ChatShellTerminal() : super(maxLines: chatShellTerminalScrollback);
@override
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);
}
}
}