2332143e5b
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.
152 lines
5.2 KiB
Dart
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);
|
|
}
|
|
}
|
|
}
|