@onkernel/cua-cli 0.1.0

package/dist/main-Bphx_zOj.js

@@ -0,0 +1,899 @@
+import { i as captureScreenshot, r as resolveCuaModelRef } from "./harness-models-GT8Ke1vt.js";
+import { stderr } from "node:process";
+import { estimateContextTokens, formatSkillInvocation } from "@onkernel/cua-agent";
+import { listCuaModels } from "@onkernel/cua-ai";
+import os from "node:os";
+import path from "node:path";
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { CombinedAutocompleteProvider, Container, Editor, Image, KeybindingsManager, Markdown, ProcessTerminal, Spacer, TUI, TUI_KEYBINDINGS, Text, allocateImageId, detectCapabilities, hyperlink, matchesKey, setCapabilities, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+//#region src/tui/debug-log.ts
+const PI_RENDER_DIR = "/tmp/tui";
+const PI_REDRAW_LOG = path.join(os.homedir(), ".pi", "agent", "pi-debug.log");
+function openTuiDebugLog() {
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
+	const dir = path.join(os.tmpdir(), `cua-tui-debug-${stamp}-${process.pid}`);
+	const piRendersDir = path.join(dir, "pi-renders");
+	const terminalWriteLog = path.join(dir, "terminal-output.log");
+	const eventsPath = path.join(dir, "events.jsonl");
+	mkdirSync(piRendersDir, { recursive: true });
+	writeFileSync(path.join(dir, "README.txt"), [
+		"cua --debug-tui artifacts",
+		"",
+		"events.jsonl         app-level event timeline",
+		"terminal-output.log  raw terminal bytes written by pi-tui",
+		"pi-debug-redraw.log  full redraw reasons from PI_DEBUG_REDRAW",
+		"pi-renders/          per-render pi-tui debug snapshots",
+		"",
+		"These artifacts are meant to be captured during a manual TUI repro."
+	].join("\n"));
+	const previousEnv = {
+		PI_TUI_DEBUG: process.env.PI_TUI_DEBUG,
+		PI_DEBUG_REDRAW: process.env.PI_DEBUG_REDRAW,
+		PI_TUI_WRITE_LOG: process.env.PI_TUI_WRITE_LOG
+	};
+	const initialPiRenderFiles = snapshotFiles(PI_RENDER_DIR);
+	const redrawLogSize = fileSize(PI_REDRAW_LOG);
+	process.env.PI_TUI_DEBUG = "1";
+	process.env.PI_DEBUG_REDRAW = "1";
+	process.env.PI_TUI_WRITE_LOG = terminalWriteLog;
+	stderr.write(`[cua] TUI debug logs: ${dir}\n`);
+	const writeEvent = (event, data = {}) => {
+		appendFileSync(eventsPath, JSON.stringify({
+			ts: (/* @__PURE__ */ new Date()).toISOString(),
+			pid: process.pid,
+			event,
+			...data
+		}) + "\n");
+	};
+	writeEvent("debug_open", { dir });
+	let closed = false;
+	return {
+		dir,
+		log(event, data = {}) {
+			writeEvent(event, data);
+		},
+		close(data = {}) {
+			if (closed) return;
+			closed = true;
+			writeEvent("debug_close", data);
+			copyNewFiles(PI_RENDER_DIR, initialPiRenderFiles, piRendersDir);
+			copyRedrawLogDelta(PI_REDRAW_LOG, redrawLogSize, path.join(dir, "pi-debug-redraw.log"));
+			restoreEnv(previousEnv);
+		}
+	};
+}
+function snapshotFiles(dir) {
+	if (!existsSync(dir)) return /* @__PURE__ */ new Set();
+	return new Set(readdirSync(dir));
+}
+function fileSize(file) {
+	if (!existsSync(file)) return 0;
+	return statSync(file).size;
+}
+function copyNewFiles(sourceDir, before, targetDir) {
+	if (!existsSync(sourceDir)) return;
+	for (const entry of readdirSync(sourceDir)) {
+		if (before.has(entry)) continue;
+		copyFileSync(path.join(sourceDir, entry), path.join(targetDir, entry));
+	}
+}
+function copyRedrawLogDelta(sourceFile, startSize, targetFile) {
+	if (!existsSync(sourceFile)) return;
+	const content = readFileSync(sourceFile);
+	const start = Math.min(startSize, content.length);
+	if (start >= content.length) return;
+	writeFileSync(targetFile, content.subarray(start));
+}
+function restoreEnv(previous) {
+	restoreVar("PI_TUI_DEBUG", previous.PI_TUI_DEBUG);
+	restoreVar("PI_DEBUG_REDRAW", previous.PI_DEBUG_REDRAW);
+	restoreVar("PI_TUI_WRITE_LOG", previous.PI_TUI_WRITE_LOG);
+}
+function restoreVar(name, value) {
+	if (value === void 0) {
+		delete process.env[name];
+		return;
+	}
+	process.env[name] = value;
+}
+//#endregion
+//#region src/tui/diagnostics.ts
+/**
+* Resolve image protocol with explicit override > env var > pi-tui detection.
+* Mutates pi-tui's cached capabilities so the {@link Image} component uses
+* our resolved value on render.
+*/
+function resolveImageProtocol(flag) {
+	const override = normalize(flag) ?? normalize(process.env.CUA_IMAGE_PROTOCOL);
+	const detected = detectCapabilities();
+	let images;
+	if (override === "auto" || override === void 0) images = detected.images;
+	else if (override === "none") images = null;
+	else images = override;
+	const caps = {
+		images,
+		trueColor: detected.trueColor,
+		hyperlinks: detected.hyperlinks
+	};
+	setCapabilities(caps);
+	return caps;
+}
+function normalize(value) {
+	if (!value) return void 0;
+	const v = value.trim().toLowerCase();
+	if (v === "kitty" || v === "iterm2" || v === "none" || v === "auto") return v;
+}
+/**
+* One-line summary of the resolved terminal capabilities, suitable for
+* the TUI header so users can see at a glance whether inline images will
+* work and how to override.
+*/
+function summarizeCapabilities(applied, source) {
+	const parts = [];
+	const tag = source === "override" ? " (override)" : "";
+	parts.push(`images=${applied.images ?? "none"}${tag}`);
+	if (applied.trueColor) parts.push("trueColor");
+	if (applied.hyperlinks) parts.push("hyperlinks");
+	return parts.join(" · ");
+}
+function applyAndSummarizeImageProtocol(flag) {
+	const overridden = !!normalize(flag) || !!normalize(process.env.CUA_IMAGE_PROTOCOL);
+	const caps = resolveImageProtocol(flag);
+	return {
+		caps,
+		summary: summarizeCapabilities(caps, overridden ? "override" : "auto"),
+		overridden
+	};
+}
+//#endregion
+//#region src/tui/themes.ts
+const RESET = "\x1B[0m";
+const ansi = {
+	dim: (text) => `\x1b[2m${text}${RESET}`,
+	bold: (text) => `\x1b[1m${text}${RESET}`,
+	italic: (text) => `\x1b[3m${text}${RESET}`,
+	underline: (text) => `\x1b[4m${text}${RESET}`,
+	strikethrough: (text) => `\x1b[9m${text}${RESET}`,
+	cyan: (text) => `\x1b[36m${text}${RESET}`,
+	green: (text) => `\x1b[32m${text}${RESET}`,
+	yellow: (text) => `\x1b[33m${text}${RESET}`,
+	red: (text) => `\x1b[31m${text}${RESET}`,
+	gray: (text) => `\x1b[90m${text}${RESET}`,
+	blue: (text) => `\x1b[34m${text}${RESET}`,
+	lightBlue: (text) => `\x1b[38;2;129;162;190m${text}${RESET}`,
+	magenta: (text) => `\x1b[35m${text}${RESET}`
+};
+const colors = ansi;
+const editorTheme = {
+	borderColor: (text) => ansi.lightBlue(text),
+	selectList: {
+		selectedPrefix: (text) => ansi.cyan(text),
+		selectedText: (text) => ansi.cyan(text),
+		description: (text) => ansi.dim(text),
+		scrollInfo: (text) => ansi.dim(text),
+		noMatch: (text) => ansi.dim(text)
+	}
+};
+const imageTheme = { fallbackColor: (text) => ansi.dim(text) };
+const markdownTheme = {
+	heading: (text) => ansi.bold(text),
+	link: (text) => ansi.cyan(text),
+	linkUrl: (text) => ansi.dim(text),
+	code: (text) => ansi.magenta(text),
+	codeBlock: (text) => text,
+	codeBlockBorder: (text) => ansi.dim(text),
+	quote: (text) => ansi.dim(text),
+	quoteBorder: (text) => ansi.dim(text),
+	hr: (text) => ansi.dim(text),
+	listBullet: (text) => ansi.cyan(text),
+	bold: (text) => ansi.bold(text),
+	italic: (text) => ansi.italic(text),
+	strikethrough: (text) => ansi.strikethrough(text),
+	underline: (text) => ansi.underline(text)
+};
+//#endregion
+//#region src/tui/message-list.ts
+/**
+* Append-only chat log of user prompts, assistant text, tool-call summaries,
+* and inline error notes. Assistant blocks render through pi-tui's
+* {@link Markdown}; everything else uses plain styled {@link Text}.
+*/
+var MessageList = class extends Container {
+	addUser(text) {
+		this.appendBlock([colors.bold("you ") + colors.dim("›") + " " + text]);
+	}
+	addAssistantStart() {
+		const buffer = new AssistantBuffer();
+		this.addChild(buffer);
+		this.invalidate();
+		return buffer;
+	}
+	addToolCall(name, args) {
+		const summary = formatToolCall(name, args);
+		this.appendBlock([colors.cyan("· ") + colors.dim(name) + " " + summary]);
+	}
+	addToolResult(name, ok, summary) {
+		const icon = ok ? colors.green("✓") : colors.red("✗");
+		this.appendBlock([`  ${icon} ${colors.dim(name)} ${summary}`]);
+	}
+	addNotice(text) {
+		this.appendBlock([colors.yellow("· ") + colors.dim(text)]);
+	}
+	addError(text) {
+		this.appendBlock([colors.red("error ") + text]);
+	}
+	appendBlock(lines) {
+		for (const line of lines) this.addChild(new Text(line, 0, 0));
+		this.invalidate();
+	}
+};
+/** Live-updating buffer for the in-flight assistant message. */
+var AssistantBuffer = class extends Container {
+	text = "";
+	body;
+	constructor() {
+		super();
+		this.addChild(new Text(colors.green("assistant"), 0, 0));
+		this.body = new Markdown("", 0, 0, markdownTheme);
+		this.addChild(this.body);
+	}
+	append(delta) {
+		this.text += delta;
+		this.body.setText(this.text);
+		this.invalidate();
+	}
+	end() {
+		if (!this.text.trim()) this.children = [];
+		this.invalidate();
+	}
+};
+function formatToolCall(name, args) {
+	if (!args || typeof args !== "object") return "";
+	const obj = args;
+	switch (name) {
+		case "computer_batch": {
+			const actions = Array.isArray(obj.actions) ? obj.actions : [];
+			if (actions.length === 0) return "(empty)";
+			const parts = actions.slice(0, 4).map(describeAction);
+			const more = actions.length > 4 ? colors.dim(` +${actions.length - 4} more`) : "";
+			return parts.join(colors.dim(" → ")) + more;
+		}
+		case "computer_use_extra": {
+			const action = typeof obj.action === "string" ? obj.action : "?";
+			if (action === "goto" && typeof obj.url === "string") return `goto(${obj.url})`;
+			return action;
+		}
+		case "bash": return colors.dim(typeof obj.command === "string" ? truncate$1(obj.command, 80) : "");
+		case "read":
+		case "write":
+		case "edit": return colors.dim(typeof obj.path === "string" ? obj.path : "");
+		default: return describeAction(obj);
+	}
+}
+function truncate$1(text, max) {
+	if (text.length <= max) return text;
+	return text.slice(0, max - 1) + "…";
+}
+function describeAction(action) {
+	const t = typeof action.type === "string" ? action.type : "";
+	const num = (v) => typeof v === "number" ? Math.trunc(v) : 0;
+	switch (t) {
+		case "click": return `click(${num(action.x)},${num(action.y)})`;
+		case "double_click": return `dblclick(${num(action.x)},${num(action.y)})`;
+		case "triple_click": return `triple(${num(action.x)},${num(action.y)})`;
+		case "type": return `type(${truncate$1(JSON.stringify(action.text ?? ""), 24)})`;
+		case "keypress": return `key(${action.keys?.join("+") ?? ""})`;
+		case "scroll": return `scroll(${num(action.x)},${num(action.y)})`;
+		case "move": return `move(${num(action.x)},${num(action.y)})`;
+		case "drag": return `drag(...)`;
+		case "wait": return `wait(${typeof action.ms === "number" ? action.ms : 1e3}ms)`;
+		case "goto": return `goto(${typeof action.url === "string" ? action.url : ""})`;
+		case "back": return "back";
+		case "forward": return "forward";
+		case "url": return "url";
+		case "screenshot": return "screenshot";
+		default: return t || colors.dim(truncate$1(JSON.stringify(action), 80));
+	}
+}
+//#endregion
+//#region src/tui/screenshot-widget.ts
+const MAX_WIDTH_CELLS = 60;
+/**
+* Sticky screenshot widget that re-renders the latest tool screenshot
+* inline using pi-tui's terminal-image (Kitty / iTerm2). Falls back to
+* a compact text card on terminals without inline image support.
+*/
+var ScreenshotWidget = class extends Container {
+	imageId = allocateImageId();
+	clear() {
+		this.children = [];
+		this.invalidate();
+	}
+	update(pngBase64, mimeType = "image/png") {
+		const image = new Image(pngBase64, mimeType, imageTheme, {
+			maxWidthCells: MAX_WIDTH_CELLS,
+			imageId: this.imageId
+		});
+		this.children = [image];
+		this.invalidate();
+	}
+};
+//#endregion
+//#region src/tui/slash-commands.ts
+/**
+* Build an autocomplete provider for the TUI editor with the slash commands
+* the interactive app supports: `/model`, `/thinking`, `/compact`, plus a
+* `/skill:<name>` entry per loaded skill.
+*
+* Model and thinking values are exposed as `getArgumentCompletions` so
+* users can tab through CUA refs and reasoning levels.
+*/
+function buildAutocompleteProvider(cwd, skills) {
+	const commands = [];
+	commands.push({
+		name: "model",
+		description: "Switch the active CUA model",
+		argumentHint: "<provider:model>",
+		getArgumentCompletions: (prefix) => modelCompletions(prefix)
+	});
+	commands.push({
+		name: "thinking",
+		description: "Set the reasoning level for future turns",
+		argumentHint: "<off|minimal|low|medium|high|xhigh>",
+		getArgumentCompletions: (prefix) => thinkingCompletions(prefix)
+	});
+	commands.push({
+		name: "compact",
+		description: "Summarize older turns to free context budget"
+	});
+	for (const skill of skills) commands.push({
+		name: `skill:${skill.name}`,
+		description: skill.description
+	});
+	return new CombinedAutocompleteProvider(commands, cwd);
+}
+function modelCompletions(prefix) {
+	const all = listCuaModels();
+	const trimmed = prefix.trim().toLowerCase();
+	return (trimmed ? all.filter((m) => m.ref.toLowerCase().includes(trimmed) || m.model.toLowerCase().includes(trimmed)) : all).map((m) => ({
+		value: m.ref,
+		label: m.ref,
+		description: m.name
+	}));
+}
+const THINKING_LEVELS = [
+	{
+		value: "off",
+		description: "Disable reasoning"
+	},
+	{
+		value: "minimal",
+		description: "Minimal reasoning"
+	},
+	{
+		value: "low",
+		description: "Low reasoning (default)"
+	},
+	{
+		value: "medium",
+		description: "Medium reasoning"
+	},
+	{
+		value: "high",
+		description: "High reasoning"
+	},
+	{
+		value: "xhigh",
+		description: "Maximum reasoning (selected models only)"
+	}
+];
+function thinkingCompletions(prefix) {
+	const trimmed = prefix.trim().toLowerCase();
+	return (trimmed ? THINKING_LEVELS.filter((t) => t.value.startsWith(trimmed)) : THINKING_LEVELS).map((t) => ({
+		value: t.value,
+		label: t.value,
+		description: t.description
+	}));
+}
+/**
+* Recognize the supported slash-command forms. Returns undefined when the
+* text is a regular user prompt.
+*/
+function parseSlashCommand(text) {
+	const trimmed = text.trim();
+	if (!trimmed.startsWith("/")) return void 0;
+	const skillMatch = trimmed.match(/^\/skill:([A-Za-z0-9_\-.]+)\s*(.*)$/);
+	if (skillMatch) {
+		const [, name, rest] = skillMatch;
+		return {
+			command: "skill",
+			name: name ?? "",
+			remainder: (rest ?? "").trim()
+		};
+	}
+	const builtinMatch = trimmed.match(/^\/(model|thinking|compact)\s*(.*)$/);
+	if (builtinMatch) {
+		const [, name, rest] = builtinMatch;
+		return {
+			command: name,
+			argument: (rest ?? "").trim()
+		};
+	}
+}
+//#endregion
+//#region src/tui/status-line.ts
+var StatusLine = class extends Text {
+	state;
+	constructor(initial) {
+		super("", 0, 0);
+		this.state = initial;
+		this.refresh();
+	}
+	update(patch) {
+		this.state = {
+			...this.state,
+			...patch
+		};
+		this.refresh();
+	}
+	refresh() {
+		const sep = colors.dim(" · ");
+		const parts = [colors.bold("cua")];
+		if (this.state.liveUrl) parts.push(colors.dim("browser ") + hyperlink(this.state.liveUrl, this.state.liveUrl));
+		else if (this.state.browserSession) parts.push(colors.dim("browser ") + this.state.browserSession.slice(0, 6) + "…");
+		if (this.state.currentUrl) parts.push(colors.dim("url ") + truncate(this.state.currentUrl, 50));
+		if (this.state.tokens !== void 0) parts.push(colors.dim("tokens ") + this.state.tokens.toLocaleString());
+		if (this.state.cost !== void 0) parts.push(colors.dim("$") + this.state.cost.toFixed(3));
+		if (this.state.working) parts.push(colors.yellow(`⏳ ${this.state.working}`));
+		this.setText(parts.join(sep));
+	}
+};
+function truncate(text, max) {
+	if (text.length <= max) return text;
+	return text.slice(0, max - 1) + "…";
+}
+//#endregion
+//#region src/tui/telemetry-footer.ts
+var TelemetryFooter = class {
+	state;
+	constructor(initial) {
+		this.state = initial;
+	}
+	update(patch) {
+		this.state = {
+			...this.state,
+			...patch
+		};
+	}
+	invalidate() {}
+	render(width) {
+		const left = this.renderContextUsage();
+		const right = this.renderModelInfo();
+		if (!left && !right) return [" ".repeat(width)];
+		if (!left) return [padToWidth(truncateToWidth(right, width), width)];
+		if (!right) return [padToWidth(truncateToWidth(left, width), width)];
+		const rightWidth = visibleWidth(right);
+		if (rightWidth >= width) return [padToWidth(truncateToWidth(right, width), width)];
+		const gap = 1;
+		const leftText = truncateToWidth(left, Math.max(1, width - rightWidth - gap));
+		return [padToWidth(leftText + " ".repeat(Math.max(gap, width - visibleWidth(leftText) - rightWidth)) + right, width)];
+	}
+	renderContextUsage() {
+		if (!this.state.contextWindow || this.state.contextWindow <= 0) return "";
+		const used = Math.max(0, this.state.contextTokens ?? 0);
+		const percent = this.state.contextWindow > 0 ? (used / this.state.contextWindow * 100).toFixed(1) : "?";
+		return colors.dim(`${percent}%/${formatTokens(this.state.contextWindow)}`);
+	}
+	renderModelInfo() {
+		const modelLabel = this.state.provider && this.state.model ? `${this.state.provider}/${this.state.model}` : this.state.model ?? "";
+		if (!modelLabel) return "";
+		const thinking = this.state.thinkingLevel && this.state.thinkingLevel.length > 0 ? this.state.thinkingLevel === "off" ? "thinking off" : this.state.thinkingLevel : "";
+		if (!thinking) return colors.dim(modelLabel);
+		return colors.dim(modelLabel) + colors.dim(" • ") + colors.dim(thinking);
+	}
+};
+function formatTokens(tokens) {
+	if (tokens >= 1e6) return `${trimFraction(tokens / 1e6)}M`;
+	if (tokens >= 1e3) return `${trimFraction(tokens / 1e3)}K`;
+	return Math.round(tokens).toString();
+}
+function trimFraction(value) {
+	const rounded = value >= 10 ? value.toFixed(0) : value.toFixed(1);
+	return rounded.endsWith(".0") ? rounded.slice(0, -2) : rounded;
+}
+function padToWidth(text, width) {
+	const pad = Math.max(0, width - visibleWidth(text));
+	return text + " ".repeat(pad);
+}
+//#endregion
+//#region src/tui/main.ts
+/**
+* Run the interactive cua TUI: pi-tui differential renderer with header,
+* message list, sticky screenshot widget, editor (autocomplete-backed slash
+* commands), status line, and telemetry footer. Drives a {@link CuaAgentHarness}
+* directly via `harness.subscribe()`.
+*/
+async function runInteractive(opts) {
+	const { summary: capsSummary, overridden } = applyAndSummarizeImageProtocol(opts.imageProtocol);
+	const debug = opts.debugTui ? openTuiDebugLog() : void 0;
+	const initialModel = opts.harness.getModel();
+	const initialThinking = opts.harness.getThinkingLevel();
+	const initialContextWindow = initialModel.contextWindow ?? void 0;
+	debug?.log("interactive_init", {
+		model: opts.modelRef,
+		browserSession: opts.browserHandle.browser.session_id,
+		liveUrl: opts.browserHandle.browser.browser_live_view_url,
+		capsSummary,
+		imageProtocol: opts.imageProtocol ?? "auto",
+		overridden
+	});
+	const terminal = new ProcessTerminal();
+	const tui = new TUI(terminal);
+	const requestRender = (reason, force = false, data = {}) => {
+		debug?.log("request_render", {
+			reason,
+			force,
+			columns: terminal.columns,
+			rows: terminal.rows,
+			fullRedraws: tui.fullRedraws,
+			...data
+		});
+		tui.requestRender(force);
+	};
+	new KeybindingsManager(TUI_KEYBINDINGS);
+	const editor = new Editor(tui, editorTheme);
+	editor.setAutocompleteProvider(buildAutocompleteProvider(opts.cwd, opts.skills ?? []));
+	const messages = new MessageList();
+	const screenshot = new ScreenshotWidget();
+	const liveUrl = opts.browserHandle.browser.browser_live_view_url;
+	const status = new StatusLine({
+		model: modelLabel(initialModel),
+		browserSession: opts.browserHandle.browser.session_id,
+		liveUrl
+	});
+	const footer = new TelemetryFooter({
+		provider: opts.provider,
+		model: modelLabel(initialModel),
+		thinkingLevel: initialThinking,
+		contextWindow: initialContextWindow,
+		contextTokens: 0
+	});
+	const header = new Container();
+	header.addChild(new Text(colors.bold("cua") + colors.dim(" — kernel-cloud-browser computer-use agent"), 0, 0));
+	const capsHint = overridden ? colors.dim(capsSummary) : colors.dim(capsSummary + " · set CUA_IMAGE_PROTOCOL=kitty|iterm2 to force inline images");
+	header.addChild(new Text(capsHint, 0, 0));
+	if (liveUrl) header.addChild(new Text(colors.dim("live ") + hyperlink(liveUrl, liveUrl), 0, 0));
+	header.addChild(new Text("", 0, 0));
+	const skillSection = buildSkillSection(opts.skills ?? []);
+	tui.addChild(header);
+	if (skillSection) {
+		tui.addChild(skillSection);
+		tui.addChild(new Spacer(1));
+	}
+	tui.addChild(messages);
+	tui.addChild(new Spacer(1));
+	tui.addChild(screenshot);
+	tui.addChild(new Spacer(1));
+	tui.addChild(editor);
+	tui.addChild(status);
+	tui.addChild(footer);
+	tui.setFocus(editor);
+	tui.onDebug = () => {
+		debug?.log("pi_tui_debug_key", {
+			columns: terminal.columns,
+			rows: terminal.rows,
+			fullRedraws: tui.fullRedraws
+		});
+	};
+	if (opts.resumed) {
+		const transcript = opts.transcriptPath ? ` ${opts.transcriptPath}` : "";
+		messages.addNotice(`resumed${transcript} · fresh browser`);
+	}
+	let assistantBuffer;
+	let inflight = 0;
+	let firstPromptSent = false;
+	let lastDisplayedError;
+	const displayAgentError = (error, reason) => {
+		if (typeof error !== "string" || error.trim().length === 0) return;
+		if (error === lastDisplayedError) return;
+		lastDisplayedError = error;
+		messages.addError(error);
+		status.update({ working: void 0 });
+		debug?.log("agent_error", {
+			reason,
+			message: error
+		});
+		requestRender("agent_error", false, { reason });
+	};
+	const unsubscribe = opts.harness.subscribe((event) => {
+		switch (event.type) {
+			case "agent_start":
+				inflight += 1;
+				status.update({ working: "thinking…" });
+				debug?.log("agent_start", { inflight });
+				requestRender("agent_start", false, { inflight });
+				return;
+			case "agent_end":
+				inflight -= 1;
+				if (inflight <= 0) status.update({ working: void 0 });
+				displayAgentError(lastErrorMessage(event.messages), "agent_end");
+				debug?.log("agent_end", { inflight });
+				requestRender("agent_end", false, { inflight });
+				return;
+			case "message_start":
+				if (event.message.role === "assistant") {
+					assistantBuffer = messages.addAssistantStart();
+					debug?.log("assistant_message_start");
+					requestRender("assistant_message_start");
+				}
+				return;
+			case "message_update":
+				if (event.assistantMessageEvent.type === "text_delta") {
+					assistantBuffer?.append(event.assistantMessageEvent.delta);
+					requestRender("assistant_text_delta", false, { deltaLength: event.assistantMessageEvent.delta.length });
+				}
+				return;
+			case "message_end":
+				if (event.message.role === "assistant") {
+					if (event.message.usage) footer.update({ contextTokens: event.message.usage.input });
+					assistantBuffer?.end();
+					assistantBuffer = void 0;
+					displayAgentError(event.message.errorMessage, "assistant_message_end");
+					debug?.log("assistant_message_end");
+					requestRender("assistant_message_end");
+				}
+				return;
+			case "tool_execution_start":
+				messages.addToolCall(event.toolName, event.args);
+				status.update({ working: event.toolName });
+				debug?.log("tool_execution_start", { toolName: event.toolName });
+				requestRender("tool_execution_start", false, { toolName: event.toolName });
+				return;
+			case "tool_execution_end": {
+				const result = event.result;
+				const isError = !!event.isError;
+				let summary = isError ? colors.red("error") : colors.green("ok");
+				if (!isError && result?.content) {
+					const imgs = result.content.filter((c) => c?.type === "image");
+					if (imgs.length > 0) summary += colors.dim(` · ${imgs.length} screenshot${imgs.length > 1 ? "s" : ""}`);
+					const lastImg = imgs[imgs.length - 1];
+					if (lastImg?.data) screenshot.update(lastImg.data, lastImg.mimeType ?? "image/png");
+				}
+				if (isError && result?.details?.error) summary = colors.red(result.details.error);
+				messages.addToolResult(event.toolName, !isError, summary);
+				debug?.log("tool_execution_end", {
+					toolName: event.toolName,
+					isError,
+					hasImage: !!result?.content?.some((c) => c?.type === "image")
+				});
+				requestRender("tool_execution_end", false, {
+					toolName: event.toolName,
+					isError
+				});
+				return;
+			}
+			case "model_update":
+				footer.update({
+					provider: event.model.provider,
+					model: modelLabel(event.model),
+					contextWindow: event.model.contextWindow
+				});
+				status.update({ model: modelLabel(event.model) });
+				requestRender("model_update");
+				return;
+			case "thinking_level_update":
+				footer.update({ thinkingLevel: event.level });
+				requestRender("thinking_level_update");
+				return;
+			case "session_compact":
+				messages.addNotice(`compacted ${event.compactionEntry.tokensBefore} tokens`);
+				refreshContextTokens(opts.session).then((tokens) => {
+					footer.update({ contextTokens: tokens });
+					requestRender("session_compact");
+				});
+				return;
+			default: return;
+		}
+	});
+	const pendingPrompt = opts.initialPrompt?.trim() || "";
+	let exitRequested = false;
+	const runPrompt = async (text) => {
+		debug?.log("run_prompt_start", { length: text.length });
+		try {
+			const parsed = parseSlashCommand(text);
+			if (parsed?.command === "model") {
+				await applyModelCommand(opts, footer, status, messages, parsed.argument);
+				return;
+			}
+			if (parsed?.command === "thinking") {
+				await applyThinkingCommand(opts, footer, messages, parsed.argument);
+				return;
+			}
+			if (parsed?.command === "compact") {
+				await applyCompactCommand(opts, messages);
+				return;
+			}
+			if (parsed?.command === "skill") {
+				const skill = (opts.skills ?? []).find((s) => s.name === parsed.name);
+				if (!skill) {
+					messages.addError(`unknown skill "${parsed.name}"`);
+					requestRender("skill_unknown");
+					return;
+				}
+				messages.addNotice(`invoking /skill:${skill.name}`);
+				requestRender("skill_invocation");
+				const skillRemainder = parsed.remainder || void 0;
+				const skillImages = await maybeInitialScreenshot(opts, firstPromptSent);
+				firstPromptSent = true;
+				if (skillImages) await opts.harness.prompt(formatSkillInvocation(skill, skillRemainder), { images: skillImages });
+				else await opts.harness.skill(skill.name, skillRemainder);
+				return;
+			}
+			const images = await maybeInitialScreenshot(opts, firstPromptSent);
+			firstPromptSent = true;
+			await opts.harness.prompt(text, images ? { images } : void 0);
+		} catch (err) {
+			messages.addError(err.message);
+			debug?.log("run_prompt_error", { message: err.message });
+			requestRender("run_prompt_error", false, { message: err.message });
+			return;
+		}
+		debug?.log("run_prompt_end");
+	};
+	editor.onSubmit = (text) => {
+		const trimmed = text.trim();
+		if (!trimmed) return;
+		editor.setText("");
+		editor.addToHistory(trimmed);
+		messages.addUser(trimmed);
+		debug?.log("editor_submit", { length: trimmed.length });
+		runPrompt(trimmed);
+	};
+	const removeListener = tui.addInputListener((data) => {
+		if (matchesKey(data, "ctrl+c")) {
+			if (inflight > 0) {
+				opts.harness.abort();
+				messages.addNotice("aborted");
+				debug?.log("input_abort_stream", { key: "ctrl+c" });
+				requestRender("input_abort_stream", false, { key: "ctrl+c" });
+				return { consume: true };
+			}
+			exitRequested = true;
+			debug?.log("input_exit_request", { key: "ctrl+c" });
+			requestRender("input_exit_request", false, { key: "ctrl+c" });
+			return { consume: true };
+		}
+		if (matchesKey(data, "ctrl+d")) {
+			exitRequested = true;
+			debug?.log("input_exit_request", { key: "ctrl+d" });
+			return { consume: true };
+		}
+		if (matchesKey(data, "escape") && inflight > 0) {
+			opts.harness.abort();
+			messages.addNotice("turn aborted");
+			debug?.log("input_abort_stream", { key: "escape" });
+			requestRender("input_abort_stream", false, { key: "escape" });
+			return { consume: true };
+		}
+	});
+	tui.start();
+	debug?.log("tui_started", {
+		columns: terminal.columns,
+		rows: terminal.rows,
+		fullRedraws: tui.fullRedraws
+	});
+	try {
+		if (pendingPrompt) {
+			messages.addUser(pendingPrompt);
+			runPrompt(pendingPrompt);
+		}
+		await waitForExit(() => exitRequested, () => inflight > 0);
+		return 0;
+	} finally {
+		removeListener();
+		unsubscribe();
+		tui.stop();
+		debug?.close({
+			fullRedraws: tui.fullRedraws,
+			columns: terminal.columns,
+			rows: terminal.rows
+		});
+	}
+}
+async function waitForExit(shouldExit, isBusy) {
+	while (true) {
+		if (shouldExit() && !isBusy()) return;
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+}
+function modelLabel(model) {
+	if (!model) return "";
+	return model.id;
+}
+function lastErrorMessage(messages) {
+	for (let i = messages.length - 1; i >= 0; i -= 1) {
+		const m = messages[i];
+		if (m && m.role === "assistant" && typeof m.errorMessage === "string") return m.errorMessage;
+	}
+}
+async function maybeInitialScreenshot(opts, firstPromptSent) {
+	if (firstPromptSent) return void 0;
+	if (opts.skipInitialScreenshot) return void 0;
+	if (await sessionHasPriorTurn(opts.session)) return void 0;
+	const png = await captureScreenshot(opts.browserHandle.client, opts.browserHandle.browser.session_id);
+	if (!png) return void 0;
+	return [{
+		type: "image",
+		data: png.toString("base64"),
+		mimeType: "image/png"
+	}];
+}
+async function sessionHasPriorTurn(session) {
+	const entries = await session.getBranch();
+	for (const entry of entries) if (entry.type === "message" && (entry.message.role === "user" || entry.message.role === "assistant")) return true;
+	return false;
+}
+async function applyModelCommand(opts, footer, status, messages, argument) {
+	const ref = argument.trim();
+	if (!ref) {
+		messages.addError("usage: /model <provider:model>");
+		return;
+	}
+	try {
+		const resolved = resolveCuaModelRef(ref);
+		await opts.harness.setModel(resolved);
+		const model = opts.harness.getModel();
+		footer.update({
+			provider: model.provider,
+			model: modelLabel(model),
+			contextWindow: model.contextWindow
+		});
+		status.update({ model: modelLabel(model) });
+		messages.addNotice(`model → ${resolved}`);
+	} catch (err) {
+		messages.addError(err.message);
+	}
+}
+async function applyThinkingCommand(opts, footer, messages, argument) {
+	const value = argument.trim().toLowerCase();
+	if (!isThinkingLevel(value)) {
+		messages.addError("usage: /thinking <off|minimal|low|medium|high|xhigh>");
+		return;
+	}
+	try {
+		await opts.harness.setThinkingLevel(value);
+		footer.update({ thinkingLevel: value });
+		messages.addNotice(`thinking → ${value}`);
+	} catch (err) {
+		messages.addError(err.message);
+	}
+}
+function isThinkingLevel(value) {
+	return [
+		"off",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	].includes(value);
+}
+async function applyCompactCommand(opts, messages) {
+	messages.addNotice("compacting…");
+	try {
+		await opts.harness.compact();
+	} catch (err) {
+		messages.addError(err.message);
+	}
+}
+async function refreshContextTokens(session) {
+	return estimateContextTokens((await session.buildContext()).messages).tokens;
+}
+function buildSkillSection(skills) {
+	if (skills.length === 0) return void 0;
+	const container = new Container();
+	container.addChild(new Text(colors.blue("[Skills]") + "\n" + skills.map((s) => s.name).join(", "), 0, 0));
+	return container;
+}
+//#endregion
+export { runInteractive };