9bbd9e0c9b
# Conflicts: # app/lib/features/chat/conversation/chat_thread_view.dart # internal/protocol/message.go
152 lines
4.7 KiB
Dart
152 lines
4.7 KiB
Dart
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<String, ChatShellTerminalSession> _sessions = {};
|
|
final Map<String, ChatShellInputPipe> _inputs = {};
|
|
final Map<String, Timer> _resizes = {};
|
|
final Map<String, (int, int)> _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);
|
|
|
|
/// [runId]'s card was dismissed: drop its emulator.
|
|
void removed(String runId) {
|
|
_resizes.remove(runId)?.cancel();
|
|
_inputs.remove(runId);
|
|
_sentSizes.remove(runId);
|
|
_sessions.remove(runId);
|
|
}
|
|
|
|
/// [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<void> 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<void> _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;
|
|
}
|
|
}
|
|
}
|