miko-code 0.1.0

package/src/server/share.ts

@@ -0,0 +1,126 @@
+import { existsSync } from 'node:fs';
+import { bin as cloudflaredBin, install as installCloudflared, Tunnel } from 'cloudflared';
+import QRCode from 'qrcode';
+
+export interface StartedShareTunnel {
+	publicUrl: string;
+	stop: () => void;
+}
+
+export interface ShareTunnelProcess {
+	once(event: 'url', listener: (url: string) => void): ShareTunnelProcess;
+	once(event: 'error', listener: (error: Error) => void): ShareTunnelProcess;
+	once(
+		event: 'exit',
+		listener: (code: number | null, signal: NodeJS.Signals | null) => void,
+	): ShareTunnelProcess;
+	off(event: 'url', listener: (url: string) => void): ShareTunnelProcess;
+	off(event: 'error', listener: (error: Error) => void): ShareTunnelProcess;
+	off(
+		event: 'exit',
+		listener: (code: number | null, signal: NodeJS.Signals | null) => void,
+	): ShareTunnelProcess;
+	stop(): boolean;
+}
+
+export interface ShareTunnelDeps {
+	cloudflaredBin?: string;
+	existsSync?: (path: string) => boolean;
+	installCloudflared?: (to: string) => Promise<string>;
+	createQuickTunnel?: (localUrl: string) => ShareTunnelProcess;
+	log?: (message: string) => void;
+}
+
+export async function renderTerminalQr(url: string) {
+	return QRCode.toString(url, {
+		type: 'terminal',
+		small: true,
+		errorCorrectionLevel: 'M',
+	});
+}
+
+export async function ensureCloudflaredInstalled(deps: ShareTunnelDeps = {}) {
+	const resolvedBin = deps.cloudflaredBin ?? cloudflaredBin;
+	const fileExists = deps.existsSync ?? existsSync;
+	const installBinary = deps.installCloudflared ?? installCloudflared;
+
+	if (fileExists(resolvedBin)) {
+		return resolvedBin;
+	}
+
+	deps.log?.('installing cloudflared binary');
+	await installBinary(resolvedBin);
+	return resolvedBin;
+}
+
+export async function startShareTunnel(
+	localUrl: string,
+	deps: ShareTunnelDeps = {},
+): Promise<StartedShareTunnel> {
+	await ensureCloudflaredInstalled(deps);
+	const tunnel = (deps.createQuickTunnel ?? ((url) => Tunnel.quick(url)))(localUrl);
+
+	const publicUrl = await new Promise<string>((resolve, reject) => {
+		let settled = false;
+
+		const cleanup = () => {
+			tunnel.off('url', handleUrl);
+			tunnel.off('error', handleError);
+			tunnel.off('exit', handleExit);
+		};
+
+		const settle = (callback: () => void) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+
+		const handleUrl = (url: string) => {
+			settle(() => resolve(url));
+		};
+
+		const handleError = (error: Error) => {
+			settle(() => reject(error));
+		};
+
+		const handleExit = (code: number | null, signal: NodeJS.Signals | null) => {
+			settle(() =>
+				reject(
+					new Error(
+						`Cloudflare tunnel exited before a public URL was ready (code: ${String(code)}, signal: ${String(signal)})`,
+					),
+				),
+			);
+		};
+
+		tunnel.once('url', handleUrl);
+		tunnel.once('error', handleError);
+		tunnel.once('exit', handleExit);
+	});
+
+	return {
+		publicUrl,
+		stop: () => {
+			tunnel.stop();
+		},
+	};
+}
+
+export async function logShareDetails(
+	log: (message: string) => void,
+	publicUrl: string,
+	localUrl: string,
+	renderShareQrImpl: (url: string) => Promise<string> = renderTerminalQr,
+) {
+	const qrCode = await renderShareQrImpl(publicUrl);
+
+	log('QR Code:');
+	log(qrCode.trimEnd());
+	log('');
+	log('Public URL:');
+	log(publicUrl);
+	log('');
+	log('Local URL:');
+	log(localUrl);
+}

package/src/server/terminal-manager.ts

@@ -0,0 +1,371 @@
+import path from 'node:path';
+import process from 'node:process';
+import { SerializeAddon } from '@xterm/addon-serialize';
+import { Terminal } from '@xterm/headless';
+import defaultShell, { detectDefaultShell } from 'default-shell';
+import type { TerminalEvent, TerminalSnapshot } from '../shared/protocol';
+
+const DEFAULT_COLS = 80;
+const DEFAULT_ROWS = 24;
+const DEFAULT_SCROLLBACK = 1_000;
+const MIN_SCROLLBACK = 500;
+const MAX_SCROLLBACK = 5_000;
+const FOCUS_IN_SEQUENCE = '\x1b[I';
+const FOCUS_OUT_SEQUENCE = '\x1b[O';
+const MODE_SEQUENCE_TAIL_LENGTH = 16;
+
+interface CreateTerminalArgs {
+	workspacePath: string;
+	terminalId: string;
+	cols: number;
+	rows: number;
+	scrollback: number;
+}
+
+interface TerminalSession {
+	terminalId: string;
+	title: string;
+	cwd: string;
+	shell: string;
+	cols: number;
+	rows: number;
+	scrollback: number;
+	status: 'running' | 'exited';
+	exitCode: number | null;
+	process: Bun.Subprocess | null;
+	terminal: Bun.Terminal;
+	headless: Terminal;
+	serializeAddon: SerializeAddon;
+	focusReportingEnabled: boolean;
+	modeSequenceTail: string;
+}
+
+interface ResolveShellOptions {
+	detect?: () => string;
+	defaultShellPath?: string | null;
+	env?: Record<string, string | undefined>;
+}
+
+export function clampScrollback(value: number) {
+	if (!Number.isFinite(value)) return DEFAULT_SCROLLBACK;
+	return Math.min(MAX_SCROLLBACK, Math.max(MIN_SCROLLBACK, Math.round(value)));
+}
+
+export function normalizeTerminalDimension(value: number, fallback: number) {
+	if (!Number.isFinite(value)) return fallback;
+	return Math.max(1, Math.round(value));
+}
+
+export function resolveShell(options: ResolveShellOptions = {}) {
+	const detect = options.detect ?? detectDefaultShell;
+	const defaultShellPath =
+		options.defaultShellPath === undefined ? defaultShell : options.defaultShellPath;
+	const env = options.env ?? process.env;
+
+	try {
+		return detect();
+	} catch {
+		if (defaultShellPath) return defaultShellPath;
+		return env.SHELL || '/bin/sh';
+	}
+}
+
+export function resolveShellArgs(shellPath: string) {
+	const shellName = path.basename(shellPath);
+	if (['bash', 'zsh', 'fish', 'sh', 'ksh'].includes(shellName)) {
+		return ['-l'];
+	}
+	return [];
+}
+
+function createTerminalEnv() {
+	return {
+		...process.env,
+		TERM: 'xterm-256color',
+		COLORTERM: 'truecolor',
+	};
+}
+
+export function updateFocusReportingState(
+	session: Pick<TerminalSession, 'focusReportingEnabled' | 'modeSequenceTail'>,
+	chunk: string,
+) {
+	const combined = session.modeSequenceTail + chunk;
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC (\x1b) is required to match ANSI focus-reporting mode toggles.
+	const regex = /\x1b\[\?1004([hl])/g;
+
+	for (const match of combined.matchAll(regex)) {
+		session.focusReportingEnabled = match[1] === 'h';
+	}
+
+	session.modeSequenceTail = combined.slice(-MODE_SEQUENCE_TAIL_LENGTH);
+}
+
+function filterFocusReportInput(data: string, allowFocusReporting: boolean) {
+	if (allowFocusReporting) {
+		return data;
+	}
+
+	return data.replaceAll(FOCUS_IN_SEQUENCE, '').replaceAll(FOCUS_OUT_SEQUENCE, '');
+}
+
+function isValidProcessGroupPid(pid: number) {
+	return Number.isInteger(pid) && pid > 0;
+}
+
+export function killTerminalProcessTree(subprocess: Bun.Subprocess | null) {
+	if (!subprocess) return;
+
+	const pid = subprocess.pid;
+	if (!isValidProcessGroupPid(pid)) return;
+
+	try {
+		process.kill(-pid, 'SIGKILL');
+		return;
+	} catch {
+		// Fall back to killing only the shell process if group termination fails.
+	}
+
+	try {
+		subprocess.kill('SIGKILL');
+	} catch {
+		// Ignore subprocess shutdown errors during disposal.
+	}
+}
+
+export function signalTerminalProcessGroup(
+	subprocess: Bun.Subprocess | null,
+	signal: NodeJS.Signals,
+) {
+	if (!subprocess) return false;
+
+	const pid = subprocess.pid;
+	if (!isValidProcessGroupPid(pid)) return false;
+
+	try {
+		process.kill(-pid, signal);
+		return true;
+	} catch {
+		// Fall back to signaling only the shell if group signaling fails.
+	}
+
+	try {
+		subprocess.kill(signal);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export class TerminalManager {
+	private readonly sessions = new Map<string, TerminalSession>();
+	private readonly listeners = new Set<(event: TerminalEvent) => void>();
+
+	onEvent(listener: (event: TerminalEvent) => void) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+
+	createTerminal(args: CreateTerminalArgs) {
+		if (typeof Bun.Terminal !== 'function') {
+			throw new Error('Embedded terminal requires Bun 1.3.5+ with Bun.Terminal support.');
+		}
+
+		const existing = this.sessions.get(args.terminalId);
+		if (existing) {
+			existing.scrollback = clampScrollback(args.scrollback);
+			existing.cols = normalizeTerminalDimension(args.cols, existing.cols);
+			existing.rows = normalizeTerminalDimension(args.rows, existing.rows);
+
+			existing.headless.options.scrollback = existing.scrollback;
+			existing.headless.resize(existing.cols, existing.rows);
+			existing.terminal.resize(existing.cols, existing.rows);
+
+			signalTerminalProcessGroup(existing.process, 'SIGWINCH');
+			return this.snapshotOf(existing);
+		}
+
+		const shell = resolveShell();
+		const cols = normalizeTerminalDimension(args.cols, DEFAULT_COLS);
+		const rows = normalizeTerminalDimension(args.rows, DEFAULT_ROWS);
+		const scrollback = clampScrollback(args.scrollback);
+
+		const title = path.basename(shell) || 'shell';
+		const headless = new Terminal({ cols, rows, scrollback, allowProposedApi: true });
+		const serializeAddon = new SerializeAddon();
+		headless.loadAddon(serializeAddon);
+
+		const session: TerminalSession = {
+			terminalId: args.terminalId,
+			title,
+			cwd: args.workspacePath,
+			shell,
+			cols,
+			rows,
+			scrollback,
+			status: 'running',
+			exitCode: null,
+			process: null,
+			terminal: new Bun.Terminal({
+				cols,
+				rows,
+				name: 'xterm-256color',
+				data: (_terminal, data) => {
+					const chunk = Buffer.from(data).toString('utf8');
+					updateFocusReportingState(session, chunk);
+					headless.write(chunk);
+					this.emit({
+						type: 'terminal.output',
+						terminalId: args.terminalId,
+						data: chunk,
+					});
+				},
+			}),
+			headless,
+			serializeAddon,
+			focusReportingEnabled: false,
+			modeSequenceTail: '',
+		};
+
+		try {
+			session.process = Bun.spawn([shell, ...resolveShellArgs(shell)], {
+				cwd: args.workspacePath,
+				env: createTerminalEnv(),
+				terminal: session.terminal,
+			});
+		} catch (error) {
+			session.terminal.close();
+			session.serializeAddon.dispose();
+			session.headless.dispose();
+			throw error;
+		}
+
+		void session.process.exited
+			.then((exitCode) => {
+				const active = this.sessions.get(args.terminalId);
+				if (!active) return;
+
+				active.status = 'exited';
+				active.exitCode = exitCode;
+
+				this.emit({
+					type: 'terminal.exit',
+					terminalId: args.terminalId,
+					exitCode,
+				});
+			})
+			.catch((error) => {
+				const active = this.sessions.get(args.terminalId);
+				if (!active) return;
+
+				active.status = 'exited';
+				active.exitCode = 1;
+
+				this.emit({
+					type: 'terminal.output',
+					terminalId: args.terminalId,
+					data: `\r\n[terminal error] ${error instanceof Error ? error.message : String(error)}\r\n`,
+				});
+
+				this.emit({
+					type: 'terminal.exit',
+					terminalId: args.terminalId,
+					exitCode: 1,
+				});
+			});
+
+		this.sessions.set(args.terminalId, session);
+		return this.snapshotOf(session);
+	}
+
+	getSnapshot(terminalId: string): TerminalSnapshot | null {
+		const session = this.sessions.get(terminalId);
+		return session ? this.snapshotOf(session) : null;
+	}
+
+	write(terminalId: string, data: string) {
+		const session = this.sessions.get(terminalId);
+		if (!session || session.status === 'exited') return;
+
+		const filteredData = filterFocusReportInput(data, session.focusReportingEnabled);
+		if (!filteredData) return;
+
+		let cursor = 0;
+
+		while (cursor < filteredData.length) {
+			const ctrlCIndex = filteredData.indexOf('\x03', cursor);
+
+			if (ctrlCIndex === -1) {
+				session.terminal.write(filteredData.slice(cursor));
+				return;
+			}
+
+			if (ctrlCIndex > cursor) {
+				session.terminal.write(filteredData.slice(cursor, ctrlCIndex));
+			}
+
+			signalTerminalProcessGroup(session.process, 'SIGINT');
+			cursor = ctrlCIndex + 1;
+		}
+	}
+
+	resize(terminalId: string, cols: number, rows: number) {
+		const session = this.sessions.get(terminalId);
+		if (!session) return;
+
+		session.cols = normalizeTerminalDimension(cols, session.cols);
+		session.rows = normalizeTerminalDimension(rows, session.rows);
+
+		session.headless.resize(session.cols, session.rows);
+		session.terminal.resize(session.cols, session.rows);
+		signalTerminalProcessGroup(session.process, 'SIGWINCH');
+	}
+
+	close(terminalId: string) {
+		const session = this.sessions.get(terminalId);
+		if (!session) return;
+
+		this.sessions.delete(terminalId);
+		killTerminalProcessTree(session.process);
+
+		session.terminal.close();
+		session.serializeAddon.dispose();
+		session.headless.dispose();
+	}
+
+	closeByCwd(cwd: string) {
+		for (const [terminalId, session] of this.sessions.entries()) {
+			if (session.cwd !== cwd) continue;
+			this.close(terminalId);
+		}
+	}
+
+	closeAll() {
+		for (const terminalId of this.sessions.keys()) {
+			this.close(terminalId);
+		}
+	}
+
+	private snapshotOf(session: TerminalSession): TerminalSnapshot {
+		return {
+			terminalId: session.terminalId,
+			title: session.title,
+			cwd: session.cwd,
+			shell: session.shell,
+			cols: session.cols,
+			rows: session.rows,
+			scrollback: session.scrollback,
+			serializedState: session.serializeAddon.serialize({ scrollback: session.scrollback }),
+			status: session.status,
+			exitCode: session.exitCode,
+		};
+	}
+
+	private emit(event: TerminalEvent) {
+		for (const listener of this.listeners) {
+			listener(event);
+		}
+	}
+}