import 'dart:async'; import 'chat_shell_run.dart'; import 'chat_shell_runs_repository.dart'; import 'chat_shell_terminal_session.dart'; /// UTF-16 units of typed or pasted text one `chat_shell_input` carries: at /// most 12 KiB of UTF-8, inside the server's 16 KiB bound. const int chatShellInputChunk = 4096; /// How long a view's size settles before the process is resized. const Duration chatShellResizeDelay = Duration(milliseconds: 150); /// The terminal emulators of one chat's runs, kept outside the cards so a /// card scrolled out of the transcript (or opened full screen) draws the same /// state, and the delivery of typed input and sizes to the server. class ChatShellTerminals { ChatShellTerminals( this._repository, this._sessionId, { required this.onError, }); final ChatShellRunsRepository _repository; final String _sessionId; /// Reports a refused input or resize of a run, in the server's words. final void Function(String runId, Object error) onError; final Map _sessions = {}; final Map _inputs = {}; final Map _resizes = {}; final Map _sentSizes = {}; bool _disposed = false; /// The size a view last laid a terminal out at: new runs start at it, so /// their first output already fits the reading column. (int, int)? lastSize; /// The emulator of [run], created (and fed its held output) on first use. ChatShellTerminalSession session(ChatShellRun run) => _sessions.putIfAbsent( run.id, () => ChatShellTerminalSession( run, onInput: (data) => _input(run.id, data), onResize: (cols, rows) => _resized(run.id, cols, rows), ), ); /// The card's copy of [run] was replaced (readback, gap): redraw it. void replaced(ChatShellRun run) => _sessions[run.id]?.replay(run); /// [run] now holds one more live chunk. void appended(ChatShellRun run, String text, int offset, int end) => _sessions[run.id]?.append(run, text, offset, end); /// [run] ended: draw its final output read-only. void finished(ChatShellRun run) { _resizes.remove(run.id)?.cancel(); _inputs.remove(run.id); _sessions[run.id]?.replay(run); } void _input(String runId, String data) { if (_disposed) return; _inputs .putIfAbsent( runId, () => ChatShellInputPipe( (data) => _repository.input(_sessionId, runId, data), (error) => onError(runId, error), ), ) .add(data); } void _resized(String runId, int cols, int rows) { lastSize = (cols, rows); if (_disposed || !(_sessions[runId]?.live ?? false)) return; _resizes.remove(runId)?.cancel(); _resizes[runId] = Timer(chatShellResizeDelay, () { _resizes.remove(runId); if (_sentSizes[runId] == (cols, rows)) return; _sentSizes[runId] = (cols, rows); _repository .resize(_sessionId, runId, cols, rows) .catchError((Object error) => onError(runId, error)); }); } void dispose() { _disposed = true; for (final timer in _resizes.values) { timer.cancel(); } _resizes.clear(); _inputs.clear(); } } /// One terminal's typed input on its way to the server (a chat run's or a /// machine terminal's), in order: what arrives /// while a request is in flight goes in the next one. Nothing is kept once /// sent, and a refusal discards what was waiting rather than retyping it. class ChatShellInputPipe { ChatShellInputPipe(this._send, this._failed); final Future Function(String data) _send; final void Function(Object error) _failed; final StringBuffer _pending = StringBuffer(); bool _busy = false; void add(String data) { _pending.write(data); if (!_busy) unawaited(_pump()); } Future _pump() async { _busy = true; try { while (_pending.isNotEmpty) { var waiting = _pending.toString(); _pending.clear(); var cut = waiting.length; if (cut > chatShellInputChunk) { cut = chatShellInputChunk; // Never split a surrogate pair across two requests. final unit = waiting.codeUnitAt(cut - 1); if (unit >= 0xD800 && unit <= 0xDBFF) cut--; _pending.write(waiting.substring(cut)); } final chunk = waiting.substring(0, cut); waiting = ''; await _send(chunk); } } catch (error) { _pending.clear(); _failed(error); } finally { _busy = false; } } }