@aitty/server 0.1.0

package/dist/runtime/output-buffer.js

@@ -0,0 +1,202 @@
+//#region src/runtime/output-buffer.ts
+const DEFAULT_OUTPUT_BUFFER_LIMIT_BYTES = 256 * 1024;
+const MIN_OUTPUT_BUFFER_LIMIT_BYTES = 1024;
+const MAX_OUTPUT_BUFFER_LIMIT_BYTES = 16 * 1024 * 1024;
+const ESCAPE_BYTE = 27;
+const OSC_TERMINATOR_BYTE = 7;
+const STRING_TERMINATOR_BYTE = 92;
+const INITIAL_REPLAY_BOUNDARY_STATE = {
+	ansiMode: "ground",
+	utf8Remaining: 0
+};
+function createOutputBuffer(limitBytes = DEFAULT_OUTPUT_BUFFER_LIMIT_BYTES) {
+	const chunks = [];
+	let byteLength = 0;
+	let leadingState = cloneReplayBoundaryState(INITIAL_REPLAY_BOUNDARY_STATE);
+	return {
+		append(chunk) {
+			const normalizedChunk = Buffer.from(chunk);
+			chunks.push(normalizedChunk);
+			byteLength += normalizedChunk.length;
+			while (byteLength > limitBytes && chunks.length > 0) {
+				const oldestChunk = chunks[0];
+				if (!oldestChunk) break;
+				const overflow = byteLength - limitBytes;
+				if (oldestChunk.length <= overflow) {
+					leadingState = advanceReplayBoundaryState(leadingState, oldestChunk);
+					chunks.shift();
+					byteLength -= oldestChunk.length;
+					continue;
+				}
+				leadingState = advanceReplayBoundaryState(leadingState, oldestChunk.subarray(0, overflow));
+				chunks[0] = oldestChunk.subarray(overflow);
+				byteLength -= overflow;
+			}
+		},
+		snapshot() {
+			if (chunks.length === 0) return null;
+			return sanitizeWrappedSnapshot(chunks.length === 1 ? chunks[0] : Buffer.concat(chunks), leadingState);
+		}
+	};
+}
+function sanitizeWrappedSnapshot(snapshot, leadingState) {
+	const safeOffset = findSafeSnapshotOffset(snapshot, leadingState);
+	if (safeOffset >= snapshot.length) return null;
+	return safeOffset === 0 ? snapshot : snapshot.subarray(safeOffset);
+}
+function findSafeSnapshotOffset(snapshot, leadingState) {
+	const state = cloneReplayBoundaryState(leadingState);
+	if (isSafeReplayBoundary(state)) return 0;
+	for (let offset = 0; offset < snapshot.length; offset += 1) {
+		const byte = snapshot[offset];
+		if (canResynchronizeBeforeByte(state, byte)) return offset;
+		advanceReplayBoundaryStateByte(state, byte);
+		if (isSafeReplayBoundary(state)) return offset + 1;
+	}
+	return snapshot.length;
+}
+function advanceReplayBoundaryState(state, chunk) {
+	const nextState = cloneReplayBoundaryState(state);
+	for (let index = 0; index < chunk.length; index += 1) advanceReplayBoundaryStateByte(nextState, chunk[index]);
+	return nextState;
+}
+function advanceReplayBoundaryStateByte(state, byte) {
+	switch (state.ansiMode) {
+		case "ground":
+			advanceGroundReplayBoundaryState(state, byte);
+			return;
+		case "escape":
+			advanceEscapeReplayBoundaryState(state, byte);
+			return;
+		case "escape-intermediate":
+			if (byte === ESCAPE_BYTE) {
+				state.ansiMode = "escape";
+				return;
+			}
+			if (byte >= 32 && byte <= 47) return;
+			state.ansiMode = "ground";
+			return;
+		case "csi":
+			if (byte === ESCAPE_BYTE) {
+				state.ansiMode = "escape";
+				return;
+			}
+			if (byte >= 64 && byte <= 126) state.ansiMode = "ground";
+			return;
+		case "osc":
+			if (byte === OSC_TERMINATOR_BYTE) {
+				state.ansiMode = "ground";
+				return;
+			}
+			if (byte === ESCAPE_BYTE) state.ansiMode = "osc-escape";
+			return;
+		case "osc-escape":
+			if (byte === STRING_TERMINATOR_BYTE) {
+				state.ansiMode = "ground";
+				return;
+			}
+			state.ansiMode = byte === ESCAPE_BYTE ? "osc-escape" : "osc";
+			return;
+		case "dcs":
+			if (byte === ESCAPE_BYTE) state.ansiMode = "dcs-escape";
+			return;
+		case "dcs-escape":
+			if (byte === STRING_TERMINATOR_BYTE) {
+				state.ansiMode = "ground";
+				return;
+			}
+			state.ansiMode = byte === ESCAPE_BYTE ? "dcs-escape" : "dcs";
+			return;
+		case "control-string":
+			if (byte === ESCAPE_BYTE) state.ansiMode = "control-string-escape";
+			return;
+		case "control-string-escape":
+			if (byte === STRING_TERMINATOR_BYTE) {
+				state.ansiMode = "ground";
+				return;
+			}
+			state.ansiMode = byte === ESCAPE_BYTE ? "control-string-escape" : "control-string";
+			return;
+	}
+}
+function advanceGroundReplayBoundaryState(state, byte) {
+	if (state.utf8Remaining > 0) {
+		if (isUtf8ContinuationByte(byte)) {
+			state.utf8Remaining -= 1;
+			return;
+		}
+		state.utf8Remaining = 0;
+	}
+	if (byte === ESCAPE_BYTE) {
+		state.ansiMode = "escape";
+		return;
+	}
+	if (byte === 155) {
+		state.ansiMode = "csi";
+		return;
+	}
+	if (byte === 157) {
+		state.ansiMode = "osc";
+		return;
+	}
+	if (byte === 144) {
+		state.ansiMode = "dcs";
+		return;
+	}
+	if (byte === 152 || byte === 158 || byte === 159) {
+		state.ansiMode = "control-string";
+		return;
+	}
+	state.utf8Remaining = getUtf8ContinuationCount(byte);
+}
+function advanceEscapeReplayBoundaryState(state, byte) {
+	if (byte === ESCAPE_BYTE) return;
+	if (byte === 91) {
+		state.ansiMode = "csi";
+		return;
+	}
+	if (byte === 93) {
+		state.ansiMode = "osc";
+		return;
+	}
+	if (byte === 80) {
+		state.ansiMode = "dcs";
+		return;
+	}
+	if (byte === 88 || byte === 94 || byte === 95) {
+		state.ansiMode = "control-string";
+		return;
+	}
+	if (byte >= 32 && byte <= 47) {
+		state.ansiMode = "escape-intermediate";
+		return;
+	}
+	state.ansiMode = "ground";
+}
+function cloneReplayBoundaryState(state) {
+	return {
+		ansiMode: state.ansiMode,
+		utf8Remaining: state.utf8Remaining
+	};
+}
+function isSafeReplayBoundary(state) {
+	return state.ansiMode === "ground" && state.utf8Remaining === 0;
+}
+function canResynchronizeBeforeByte(state, byte) {
+	if (state.ansiMode === "ground") return state.utf8Remaining > 0 && !isUtf8ContinuationByte(byte);
+	return (state.ansiMode === "escape" || state.ansiMode === "escape-intermediate" || state.ansiMode === "csi") && isAnsiSequenceStartByte(byte);
+}
+function isAnsiSequenceStartByte(byte) {
+	return byte === ESCAPE_BYTE || byte === 144 || byte === 152 || byte === 155 || byte === 157 || byte === 158 || byte === 159;
+}
+function isUtf8ContinuationByte(byte) {
+	return byte >= 128 && byte <= 191;
+}
+function getUtf8ContinuationCount(byte) {
+	if (byte >= 194 && byte <= 223) return 1;
+	if (byte >= 224 && byte <= 239) return 2;
+	if (byte >= 240 && byte <= 244) return 3;
+	return 0;
+}
+//#endregion
+export { DEFAULT_OUTPUT_BUFFER_LIMIT_BYTES, MAX_OUTPUT_BUFFER_LIMIT_BYTES, MIN_OUTPUT_BUFFER_LIMIT_BYTES, createOutputBuffer };

package/dist/runtime/pty-session.d.ts

@@ -0,0 +1,59 @@
+//#region src/runtime/pty-session.d.ts
+declare const DEFAULT_TERM = "xterm-256color";
+declare const DEFAULT_COLUMNS = 80;
+declare const DEFAULT_ROWS = 24;
+interface Disposable {
+  dispose(): void;
+}
+interface PtyExitEvent {
+  exitCode: number;
+  signal?: number;
+}
+interface PtyProcess {
+  pid: number;
+  kill(signal?: string): void;
+  onData(listener: (data: Buffer | string) => void): Disposable;
+  onExit(listener: (event: PtyExitEvent) => void): Disposable;
+  resize(columns: number, rows: number): void;
+  write(data: string | Buffer): void;
+}
+interface PtyModule {
+  spawn(file: string, args: string[], options: PtySpawnOptions): PtyProcess;
+}
+interface PtySessionOptions {
+  args?: string[];
+  bufferSize?: number;
+  cols?: number;
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+  file: string;
+  rows?: number;
+  term?: string;
+}
+interface PtySpawnOptions {
+  cols: number;
+  cwd: string;
+  encoding: null;
+  env: Record<string, string>;
+  name: string;
+  rows: number;
+}
+interface PtySession {
+  readonly closed: Promise<PtyExitEvent>;
+  readonly cols: number;
+  readonly cwd: string;
+  readonly file: string;
+  readonly pid: number;
+  readonly rows: number;
+  readonly term: string;
+  close(signal?: NodeJS.Signals): Promise<PtyExitEvent>;
+  getBufferedOutput(): Buffer | null;
+  kill(signal?: string): void;
+  onData(listener: (data: Buffer) => void): Disposable;
+  onExit(listener: (event: PtyExitEvent) => void): Disposable;
+  resize(columns: number, rows: number): void;
+  write(data: string | Buffer): void | Promise<void>;
+}
+declare function createPtySession(options: PtySessionOptions, nodePty: PtyModule): PtySession;
+//#endregion
+export { DEFAULT_COLUMNS, DEFAULT_ROWS, DEFAULT_TERM, Disposable, PtyExitEvent, PtyModule, PtyProcess, PtySession, PtySessionOptions, PtySpawnOptions, createPtySession };

package/dist/runtime/pty-session.js

@@ -0,0 +1,247 @@
+import { createOutputBuffer } from "./output-buffer.js";
+import { spawn } from "node:child_process";
+//#region src/runtime/pty-session.ts
+const DEFAULT_CLOSE_TIMEOUT_MS = 1e3;
+const BULK_PASTE_THRESHOLD_BYTES = 1024;
+const BULK_PASTE_SETTLE_MS = 75;
+const LARGE_WRITE_CHUNK_BYTES = 512;
+const DEFAULT_TERM = "xterm-256color";
+const DEFAULT_COLUMNS = 80;
+const DEFAULT_ROWS = 24;
+function createPtySession(options, nodePty) {
+	const cols = options.cols ?? 80;
+	const rows = options.rows ?? 24;
+	const term = resolveTerm(options.term, options.env?.TERM);
+	const ptyProcess = nodePty.spawn(options.file, options.args ?? [], {
+		cols,
+		cwd: options.cwd,
+		encoding: null,
+		env: toPtyEnvironment(options.env, term),
+		name: term,
+		rows
+	});
+	const ttyPath = resolvePtyPath(ptyProcess);
+	let currentCols = cols;
+	let currentRows = rows;
+	const dataListeners = /* @__PURE__ */ new Set();
+	const outputBuffer = createOutputBuffer(options.bufferSize);
+	let settled = false;
+	let resolvedExit;
+	let resolveClosed;
+	const closed = new Promise((resolve) => {
+		resolveClosed = resolve;
+	});
+	const settleExit = (event) => {
+		if (settled) return resolvedExit ?? event;
+		settled = true;
+		resolvedExit = event;
+		resolveClosed(resolvedExit);
+		return resolvedExit;
+	};
+	const exitSubscription = ptyProcess.onExit((event) => {
+		settleExit({
+			exitCode: event.exitCode,
+			signal: event.signal
+		});
+	});
+	const dataSubscription = ptyProcess.onData((data) => {
+		const chunk = normalizeChunk(data);
+		outputBuffer.append(chunk);
+		for (const listener of dataListeners) listener(chunk);
+	});
+	closed.finally(() => {
+		dataSubscription.dispose();
+		exitSubscription.dispose();
+	});
+	return {
+		closed,
+		get cols() {
+			return currentCols;
+		},
+		cwd: options.cwd,
+		file: options.file,
+		getBufferedOutput() {
+			return outputBuffer.snapshot();
+		},
+		pid: ptyProcess.pid,
+		get rows() {
+			return currentRows;
+		},
+		term,
+		async close(signal = "SIGTERM") {
+			if (settled && resolvedExit) return resolvedExit;
+			sendSignal(ptyProcess, signal);
+			const gracefulExit = await waitForClosed(closed, DEFAULT_CLOSE_TIMEOUT_MS, resolvedExit);
+			if (gracefulExit) return gracefulExit;
+			if (!isProcessRunning(ptyProcess.pid)) return settleExit({ exitCode: 0 });
+			sendSignal(ptyProcess, "SIGKILL");
+			const forcedExit = await waitForClosed(closed, DEFAULT_CLOSE_TIMEOUT_MS, resolvedExit);
+			if (forcedExit) return forcedExit;
+			if (!isProcessRunning(ptyProcess.pid)) return settleExit({ exitCode: 0 });
+			throw new Error("PTY process did not exit after SIGKILL");
+		},
+		kill(signal) {
+			sendSignal(ptyProcess, signal);
+		},
+		onData(listener) {
+			dataListeners.add(listener);
+			return { dispose() {
+				dataListeners.delete(listener);
+			} };
+		},
+		onExit(listener) {
+			return ptyProcess.onExit(listener);
+		},
+		resize(columns, nextRows) {
+			if (!isValidResizeDimension(columns) || !isValidResizeDimension(nextRows)) return;
+			if (columns === currentCols && nextRows === currentRows) return;
+			currentCols = columns;
+			currentRows = nextRows;
+			ptyProcess.resize(columns, nextRows);
+		},
+		async write(data) {
+			const chunk = normalizeChunk(data);
+			if (!ttyPath || !shouldUseBulkPasteMode(chunk)) {
+				await writeChunked(ptyProcess, chunk);
+				return;
+			}
+			const ttyState = await captureBulkPasteTtyState(ttyPath);
+			if (!ttyState?.canonical) {
+				await writeChunked(ptyProcess, chunk);
+				return;
+			}
+			try {
+				await runSttyCommand(ttyPath, [
+					"-icanon",
+					"min",
+					"1",
+					"time",
+					"0"
+				]);
+				await writeChunked(ptyProcess, chunk);
+				await delay(BULK_PASTE_SETTLE_MS);
+			} finally {
+				await runSttyCommand(ttyPath, [ttyState.serialized]).catch(() => {});
+			}
+		}
+	};
+}
+function resolveTerm(explicitTerm, environmentTerm) {
+	const candidate = explicitTerm?.trim() || environmentTerm?.trim();
+	if (!candidate || candidate.toLowerCase() === "dumb") return DEFAULT_TERM;
+	return candidate;
+}
+function toPtyEnvironment(environment, term) {
+	const normalizedEnvironment = Object.fromEntries(Object.entries(environment ?? process.env).filter((entry) => typeof entry[1] === "string"));
+	normalizedEnvironment.TERM = term;
+	return normalizedEnvironment;
+}
+function sendSignal(ptyProcess, signal) {
+	try {
+		ptyProcess.kill(signal);
+	} catch (error) {
+		if (!isMissingProcessError(error)) throw error;
+	}
+	if (!signal) return;
+	try {
+		process.kill(ptyProcess.pid, signal);
+	} catch (error) {
+		if (!isMissingProcessError(error)) throw error;
+	}
+}
+async function waitForClosed(closed, timeout, resolvedExit) {
+	if (resolvedExit) return resolvedExit;
+	const result = await Promise.race([closed, delay(timeout).then(() => void 0)]);
+	if (result) return result;
+}
+function delay(milliseconds) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, milliseconds);
+	});
+}
+function waitForImmediate() {
+	return new Promise((resolve) => {
+		setImmediate(resolve);
+	});
+}
+function isMissingProcessError(error) {
+	return error instanceof Error && "code" in error && error.code === "ESRCH";
+}
+function isProcessRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		if (isMissingProcessError(error)) return false;
+		throw error;
+	}
+}
+function normalizeChunk(data) {
+	if (Buffer.isBuffer(data)) return data;
+	return Buffer.from(data, "utf8");
+}
+async function writeChunked(ptyProcess, chunk) {
+	if (chunk.length <= LARGE_WRITE_CHUNK_BYTES) {
+		ptyProcess.write(chunk);
+		return;
+	}
+	for (let offset = 0; offset < chunk.length; offset += LARGE_WRITE_CHUNK_BYTES) {
+		ptyProcess.write(chunk.subarray(offset, offset + LARGE_WRITE_CHUNK_BYTES));
+		if (offset + LARGE_WRITE_CHUNK_BYTES < chunk.length) await waitForImmediate();
+	}
+}
+function isValidResizeDimension(value) {
+	return Number.isInteger(value) && value > 0;
+}
+function resolvePtyPath(ptyProcess) {
+	const ttyPath = ptyProcess._pty;
+	return typeof ttyPath === "string" && ttyPath.length > 0 ? ttyPath : null;
+}
+function shouldUseBulkPasteMode(chunk) {
+	return chunk.length >= BULK_PASTE_THRESHOLD_BYTES;
+}
+async function captureBulkPasteTtyState(ttyPath) {
+	try {
+		const [serialized, modes] = await Promise.all([runSttyCommand(ttyPath, ["-g"]), runSttyCommand(ttyPath, ["-a"])]);
+		return {
+			canonical: /(^|[\s;])(-?icanon)(?=[\s;]|$)/.exec(modes)?.[2] === "icanon",
+			serialized
+		};
+	} catch {
+		return null;
+	}
+}
+function runSttyCommand(ttyPath, args) {
+	return new Promise((resolve, reject) => {
+		const child = spawn("stty", [
+			getSttyPathFlag(),
+			ttyPath,
+			...args
+		], { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString("utf8");
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString("utf8");
+		});
+		child.once("error", reject);
+		child.once("close", (code) => {
+			if (code === 0) {
+				resolve(stdout.trim());
+				return;
+			}
+			reject(new Error(stderr.trim() || `stty exited with code ${code ?? "unknown"}`));
+		});
+	});
+}
+function getSttyPathFlag() {
+	return process.platform === "linux" ? "-F" : "-f";
+}
+//#endregion
+export { DEFAULT_COLUMNS, DEFAULT_ROWS, DEFAULT_TERM, createPtySession };

package/dist/runtime/websocket-transport.d.ts

@@ -0,0 +1,32 @@
+import { NetworkPolicy } from "../network-policy.js";
+import { PtyExitEvent, PtySession } from "./pty-session.js";
+import { Server } from "node:http";
+import { AittyThemeSource } from "@aitty/protocol";
+import * as _$ws from "ws";
+
+//#region src/runtime/websocket-transport.d.ts
+interface TransportLogWriter {
+  write(chunk: string): boolean;
+}
+interface WebSocketTransportOptions {
+  WebSocketServer: typeof _$ws.WebSocketServer;
+  networkPolicy?: NetworkPolicy;
+  server: Server;
+  session: PtySession;
+  stderr: TransportLogWriter;
+  themeSource?: AittyThemeSource;
+  token: string;
+  maxBufferedAmountBytes?: number;
+  maxQueuedBytes?: number;
+  drainWaitMs?: number;
+  keepaliveInitialDelayMs?: number;
+  keepaliveIntervalMs?: number;
+  verbose?: boolean;
+}
+interface WebSocketTransport {
+  close(): Promise<void>;
+  notifyExit(event: PtyExitEvent): Promise<void>;
+}
+declare function createWebSocketTransport(options: WebSocketTransportOptions): WebSocketTransport;
+//#endregion
+export { TransportLogWriter, WebSocketTransport, WebSocketTransportOptions, createWebSocketTransport };