agent-worker 0.1.0

package/dist/cli/index.mjs

@@ -0,0 +1,867 @@
+#!/usr/bin/env node
+import { a as getDefaultModel, t as FRONTIER_MODELS } from "../models-FOOpWB91.mjs";
+import { t as AgentSession } from "../session-DQQAmPf-.mjs";
+import { spawn } from "node:child_process";
+import { Command } from "commander";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createConnection, createServer } from "node:net";
+import { homedir } from "node:os";
+
+//#region src/cli/server.ts
+const CONFIG_DIR = join(homedir(), ".agent-worker");
+const SESSIONS_DIR = join(CONFIG_DIR, "sessions");
+const REGISTRY_FILE = join(CONFIG_DIR, "registry.json");
+let state = null;
+const DEFAULT_IDLE_TIMEOUT = 1800 * 1e3;
+function ensureDirs() {
+	if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+	if (!existsSync(SESSIONS_DIR)) mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+function loadRegistry() {
+	ensureDirs();
+	if (!existsSync(REGISTRY_FILE)) return { sessions: {} };
+	try {
+		return JSON.parse(readFileSync(REGISTRY_FILE, "utf-8"));
+	} catch {
+		return { sessions: {} };
+	}
+}
+function saveRegistry(registry) {
+	ensureDirs();
+	writeFileSync(REGISTRY_FILE, JSON.stringify(registry, null, 2));
+}
+function resetIdleTimer() {
+	if (!state) return;
+	state.lastActivity = Date.now();
+	if (state.idleTimer) {
+		clearTimeout(state.idleTimer);
+		state.idleTimer = void 0;
+	}
+	const timeout = state.info.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
+	if (timeout > 0) state.idleTimer = setTimeout(() => {
+		if (state && state.pendingRequests === 0) {
+			console.log(`\nSession idle for ${timeout / 1e3}s, shutting down...`);
+			gracefulShutdown();
+		} else resetIdleTimer();
+	}, timeout);
+}
+async function gracefulShutdown() {
+	if (!state) {
+		process.exit(0);
+		return;
+	}
+	state.server.close();
+	const maxWait = 1e4;
+	const start = Date.now();
+	while (state.pendingRequests > 0 && Date.now() - start < maxWait) await new Promise((resolve) => setTimeout(resolve, 100));
+	cleanup();
+	process.exit(0);
+}
+function registerSession(info) {
+	const registry = loadRegistry();
+	registry.sessions[info.id] = info;
+	if (info.name) registry.sessions[info.name] = info;
+	if (Object.keys(registry.sessions).length <= 2) registry.defaultSession = info.id;
+	saveRegistry(registry);
+}
+function unregisterSession(idOrName) {
+	const registry = loadRegistry();
+	const info = registry.sessions[idOrName];
+	if (info) {
+		delete registry.sessions[info.id];
+		if (info.name) delete registry.sessions[info.name];
+		if (registry.defaultSession === info.id) registry.defaultSession = Object.values(registry.sessions).filter((s) => s.id !== info.id)[0]?.id;
+	}
+	saveRegistry(registry);
+}
+function getSessionInfo(idOrName) {
+	const registry = loadRegistry();
+	if (!idOrName) {
+		if (registry.defaultSession) return registry.sessions[registry.defaultSession] || null;
+		const uniqueSessions = Object.values(registry.sessions).filter((s, i, arr) => arr.findIndex((x) => x.id === s.id) === i);
+		if (uniqueSessions.length === 1) return uniqueSessions[0];
+		return null;
+	}
+	return registry.sessions[idOrName] || null;
+}
+function listSessions() {
+	const registry = loadRegistry();
+	const seen = /* @__PURE__ */ new Set();
+	return Object.values(registry.sessions).filter((info) => {
+		if (seen.has(info.id)) return false;
+		seen.add(info.id);
+		return true;
+	});
+}
+function setDefaultSession(idOrName) {
+	const registry = loadRegistry();
+	const info = registry.sessions[idOrName];
+	if (!info) return false;
+	registry.defaultSession = info.id;
+	saveRegistry(registry);
+	return true;
+}
+async function handleRequest(req) {
+	if (!state) return {
+		success: false,
+		error: "No active session"
+	};
+	state.pendingRequests++;
+	resetIdleTimer();
+	const { session } = state;
+	try {
+		switch (req.action) {
+			case "ping": return {
+				success: true,
+				data: {
+					id: session.id,
+					model: session.model,
+					name: state.info.name
+				}
+			};
+			case "send": {
+				const { message, options } = req.payload;
+				return {
+					success: true,
+					data: await session.send(message, options)
+				};
+			}
+			case "tool_add": {
+				const tool = req.payload;
+				session.addTool(tool);
+				return {
+					success: true,
+					data: { name: tool.name }
+				};
+			}
+			case "tool_mock": {
+				const { name, response } = req.payload;
+				session.setMockResponse(name, response);
+				return {
+					success: true,
+					data: { name }
+				};
+			}
+			case "tool_list": return {
+				success: true,
+				data: session.getTools()
+			};
+			case "tool_import": {
+				const { filePath } = req.payload;
+				if (!filePath || typeof filePath !== "string") return {
+					success: false,
+					error: "File path is required"
+				};
+				let module;
+				try {
+					module = await import(filePath);
+				} catch (importError) {
+					return {
+						success: false,
+						error: `Failed to import file: ${(importError instanceof Error ? importError.message : String(importError)).replace(filePath, "<file>")}`
+					};
+				}
+				let tools = [];
+				if (Array.isArray(module.default)) tools = module.default;
+				else if (typeof module.default === "function") try {
+					const result = await module.default();
+					tools = Array.isArray(result) ? result : [];
+				} catch (factoryError) {
+					return {
+						success: false,
+						error: `Factory function failed: ${factoryError instanceof Error ? factoryError.message : String(factoryError)}`
+					};
+				}
+				else if (Array.isArray(module.tools)) tools = module.tools;
+				else return {
+					success: false,
+					error: "No tools found. Export default array or named \"tools\" array."
+				};
+				const imported = [];
+				const skipped = [];
+				for (const tool of tools) {
+					if (!tool.name || typeof tool.name !== "string") {
+						skipped.push("(unnamed)");
+						continue;
+					}
+					if (!tool.description || !tool.parameters) {
+						skipped.push(tool.name);
+						continue;
+					}
+					session.addTool(tool);
+					imported.push(tool.name);
+				}
+				return {
+					success: true,
+					data: {
+						imported,
+						skipped: skipped.length > 0 ? skipped : void 0
+					}
+				};
+			}
+			case "history": return {
+				success: true,
+				data: session.history()
+			};
+			case "stats": return {
+				success: true,
+				data: session.stats()
+			};
+			case "export": return {
+				success: true,
+				data: session.export()
+			};
+			case "clear":
+				session.clear();
+				return { success: true };
+			case "pending": return {
+				success: true,
+				data: session.getPendingApprovals()
+			};
+			case "approve": {
+				const { id } = req.payload;
+				return {
+					success: true,
+					data: await session.approve(id)
+				};
+			}
+			case "deny": {
+				const { id, reason } = req.payload;
+				session.deny(id, reason);
+				return { success: true };
+			}
+			case "shutdown":
+				state.pendingRequests--;
+				setTimeout(() => gracefulShutdown(), 100);
+				return {
+					success: true,
+					data: "Shutting down"
+				};
+			default: return {
+				success: false,
+				error: `Unknown action: ${req.action}`
+			};
+		}
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	} finally {
+		if (state && req.action !== "shutdown") state.pendingRequests--;
+	}
+}
+function cleanup() {
+	if (state) {
+		if (state.idleTimer) clearTimeout(state.idleTimer);
+		if (existsSync(state.info.socketPath)) unlinkSync(state.info.socketPath);
+		if (existsSync(state.info.pidFile)) unlinkSync(state.info.pidFile);
+		if (existsSync(state.info.readyFile)) unlinkSync(state.info.readyFile);
+		unregisterSession(state.info.id);
+	}
+}
+function startServer(config) {
+	ensureDirs();
+	const session = new AgentSession({
+		model: config.model,
+		system: config.system
+	});
+	const socketPath = join(SESSIONS_DIR, `${session.id}.sock`);
+	const pidFile = join(SESSIONS_DIR, `${session.id}.pid`);
+	const readyFile = join(SESSIONS_DIR, `${session.id}.ready`);
+	if (existsSync(socketPath)) unlinkSync(socketPath);
+	const info = {
+		id: session.id,
+		name: config.name,
+		model: config.model,
+		socketPath,
+		pidFile,
+		readyFile,
+		pid: process.pid,
+		createdAt: session.createdAt,
+		idleTimeout: config.idleTimeout
+	};
+	const server = createServer((socket) => {
+		let buffer = "";
+		socket.on("data", async (data) => {
+			buffer += data.toString();
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const res = await handleRequest(JSON.parse(line));
+					socket.write(JSON.stringify(res) + "\n");
+				} catch (error) {
+					socket.write(JSON.stringify({
+						success: false,
+						error: error instanceof Error ? error.message : "Parse error"
+					}) + "\n");
+				}
+			}
+		});
+		socket.on("error", () => {});
+	});
+	server.listen(socketPath, () => {
+		writeFileSync(pidFile, process.pid.toString());
+		registerSession(info);
+		state = {
+			session,
+			server,
+			info,
+			lastActivity: Date.now(),
+			pendingRequests: 0
+		};
+		writeFileSync(readyFile, session.id);
+		resetIdleTimer();
+		const nameStr = config.name ? ` (${config.name})` : "";
+		console.log(`Session started: ${session.id}${nameStr}`);
+		console.log(`Model: ${session.model}`);
+	});
+	server.on("error", (error) => {
+		console.error("Server error:", error);
+		cleanup();
+		process.exit(1);
+	});
+	process.on("SIGINT", () => {
+		console.log("\nShutting down...");
+		cleanup();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		cleanup();
+		process.exit(0);
+	});
+}
+function isSessionRunning(idOrName) {
+	const info = getSessionInfo(idOrName);
+	if (!info) return false;
+	try {
+		process.kill(info.pid, 0);
+		return true;
+	} catch {
+		if (existsSync(info.socketPath)) unlinkSync(info.socketPath);
+		if (existsSync(info.pidFile)) unlinkSync(info.pidFile);
+		if (info.readyFile && existsSync(info.readyFile)) unlinkSync(info.readyFile);
+		unregisterSession(info.id);
+		return false;
+	}
+}
+/**
+* Wait for a session to be ready (ready file exists)
+* Returns session info if ready, null if timeout
+*/
+async function waitForReady(nameOrId, timeoutMs = 5e3) {
+	const start = Date.now();
+	const pollInterval = 50;
+	while (Date.now() - start < timeoutMs) {
+		const info = getSessionInfo(nameOrId);
+		if (info?.readyFile && existsSync(info.readyFile)) return info;
+		await new Promise((resolve) => setTimeout(resolve, pollInterval));
+	}
+	return null;
+}
+
+//#endregion
+//#region src/cli/client.ts
+/**
+* Send a request to a specific session
+* @param req - The request to send
+* @param target - Session ID or name (optional, uses default if not specified)
+*/
+function sendRequest(req, target) {
+	return new Promise((resolve, reject) => {
+		const info = getSessionInfo(target);
+		if (!info) {
+			if (target) resolve({
+				success: false,
+				error: `Session not found: ${target}`
+			});
+			else resolve({
+				success: false,
+				error: "No active session. Start one with: agent-worker session start -m <model>"
+			});
+			return;
+		}
+		if (!isSessionRunning(target)) {
+			resolve({
+				success: false,
+				error: `Session not running: ${target || info.id}`
+			});
+			return;
+		}
+		const socket = createConnection(info.socketPath);
+		let buffer = "";
+		socket.on("connect", () => {
+			socket.write(JSON.stringify(req) + "\n");
+		});
+		socket.on("data", (data) => {
+			buffer += data.toString();
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const res = JSON.parse(line);
+					socket.end();
+					resolve(res);
+				} catch (error) {
+					socket.end();
+					reject(error);
+				}
+			}
+		});
+		socket.on("error", (error) => {
+			reject(error);
+		});
+		socket.on("timeout", () => {
+			socket.end();
+			reject(/* @__PURE__ */ new Error("Connection timeout"));
+		});
+		socket.setTimeout(6e4);
+	});
+}
+/**
+* Check if any session is active, or a specific session
+*/
+function isSessionActive(target) {
+	return isSessionRunning(target);
+}
+
+//#endregion
+//#region src/cli/index.ts
+const program = new Command();
+program.name("agent-worker").description("CLI for creating and testing agent workers").version("0.0.1");
+const sessionCmd = program.command("session").description("Manage sessions");
+sessionCmd.command("new").description("Create a new session").option("-m, --model <model>", `Model identifier (default: ${getDefaultModel()})`).option("-s, --system <prompt>", "System prompt", "You are a helpful assistant.").option("-f, --system-file <file>", "Read system prompt from file").option("-n, --name <name>", "Session name for easy reference").option("--idle-timeout <ms>", "Idle timeout in ms (0 = no timeout)", "1800000").option("--foreground", "Run in foreground").action(async (options) => {
+	let system = options.system;
+	if (options.systemFile) system = readFileSync(options.systemFile, "utf-8");
+	const model = options.model || getDefaultModel();
+	const idleTimeout = parseInt(options.idleTimeout, 10);
+	if (options.foreground) startServer({
+		model,
+		system,
+		name: options.name,
+		idleTimeout
+	});
+	else {
+		const args = [
+			process.argv[1],
+			"session",
+			"new",
+			"-m",
+			model,
+			"-s",
+			system,
+			"--foreground"
+		];
+		if (options.name) args.push("-n", options.name);
+		args.push("--idle-timeout", String(idleTimeout));
+		spawn(process.execPath, args, {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+		const info = await waitForReady(options.name, 5e3);
+		if (info) {
+			const nameStr = options.name ? ` (${options.name})` : "";
+			console.log(`Session started: ${info.id}${nameStr}`);
+			console.log(`Model: ${info.model}`);
+		} else {
+			console.error("Failed to start session");
+			process.exit(1);
+		}
+	}
+});
+sessionCmd.command("list").description("List all sessions").action(() => {
+	const sessions = listSessions();
+	if (sessions.length === 0) {
+		console.log("No active sessions");
+		return;
+	}
+	for (const s of sessions) {
+		const status = isSessionRunning(s.id) ? "running" : "stopped";
+		const nameStr = s.name ? ` (${s.name})` : "";
+		console.log(`  ${s.id.slice(0, 8)}${nameStr} - ${s.model} [${status}]`);
+	}
+});
+sessionCmd.command("status [target]").description("Check session status").action(async (target) => {
+	if (!isSessionRunning(target)) {
+		console.log(target ? `Session not found: ${target}` : "No active session");
+		return;
+	}
+	const res = await sendRequest({ action: "ping" }, target);
+	if (res.success && res.data) {
+		const { id, model, name } = res.data;
+		const nameStr = name ? ` (${name})` : "";
+		console.log(`Session: ${id}${nameStr}`);
+		console.log(`Model: ${model}`);
+	}
+});
+sessionCmd.command("use <target>").description("Set default session").action((target) => {
+	if (setDefaultSession(target)) console.log(`Default session set to: ${target}`);
+	else {
+		console.error(`Session not found: ${target}`);
+		process.exit(1);
+	}
+});
+sessionCmd.command("end [target]").description("End a session (or all with --all)").option("--all", "End all sessions").action(async (target, options) => {
+	if (options.all) {
+		const sessions = listSessions();
+		for (const s of sessions) if (isSessionRunning(s.id)) {
+			await sendRequest({ action: "shutdown" }, s.id);
+			console.log(`Ended: ${s.name || s.id}`);
+		}
+		return;
+	}
+	if (!isSessionRunning(target)) {
+		console.log(target ? `Session not found: ${target}` : "No active session");
+		return;
+	}
+	const res = await sendRequest({ action: "shutdown" }, target);
+	if (res.success) console.log("Session ended");
+	else console.error("Error:", res.error);
+});
+program.command("send <message>").description("Send a message").option("--to <target>", "Target session (name or ID)").option("--json", "Output full JSON response").option("--auto-approve", "Auto-approve all tool calls (default)").option("--no-auto-approve", "Require manual approval").action(async (message, options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		if (target) console.error(`Session not found: ${target}`);
+		else console.error("No active session. Create one with: agent-worker session new -m <model>");
+		process.exit(1);
+	}
+	const res = await sendRequest({
+		action: "send",
+		payload: {
+			message,
+			options: { autoApprove: options.autoApprove !== false }
+		}
+	}, target);
+	if (!res.success) {
+		console.error("Error:", res.error);
+		process.exit(1);
+	}
+	const response = res.data;
+	if (options.json) console.log(JSON.stringify(response, null, 2));
+	else {
+		console.log(response.content);
+		if (response.toolCalls?.length > 0) {
+			console.log("\n--- Tool Calls ---");
+			for (const tc of response.toolCalls) console.log(`${tc.name}(${JSON.stringify(tc.arguments)}) => ${JSON.stringify(tc.result)}`);
+		}
+		if (response.pendingApprovals?.length > 0) {
+			console.log("\n--- Pending Approvals ---");
+			for (const p of response.pendingApprovals) console.log(`[${p.id.slice(0, 8)}] ${p.toolName}(${JSON.stringify(p.arguments)})`);
+		}
+	}
+});
+const toolCmd = program.command("tool").description("Manage tools");
+toolCmd.command("add <name>").description("Add a tool").option("--to <target>", "Target session").requiredOption("-d, --desc <description>", "Tool description").option("-p, --param <params...>", "Parameters (name:type:description)").option("--needs-approval", "Require approval").action(async (name, options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	const properties = {};
+	const required = [];
+	for (const param of options.param ?? []) {
+		const [paramName, type, ...descParts] = param.split(":");
+		properties[paramName] = {
+			type: type ?? "string",
+			description: descParts.join(":") ?? ""
+		};
+		required.push(paramName);
+	}
+	const res = await sendRequest({
+		action: "tool_add",
+		payload: {
+			name,
+			description: options.desc,
+			parameters: {
+				type: "object",
+				properties,
+				required
+			},
+			needsApproval: options.needsApproval ?? false
+		}
+	}, target);
+	if (res.success) {
+		const approvalNote = options.needsApproval ? " (needs approval)" : "";
+		console.log(`Tool added: ${name}${approvalNote}`);
+	} else {
+		console.error("Error:", res.error);
+		process.exit(1);
+	}
+});
+toolCmd.command("import <file>").description("Import tools from JS/TS file").option("--to <target>", "Target session").action(async (file, options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	const res = await sendRequest({
+		action: "tool_import",
+		payload: { filePath: file.startsWith("/") ? file : join(process.cwd(), file) }
+	}, target);
+	if (res.success) {
+		const data = res.data;
+		console.log(`Imported ${data.imported.length} tool(s):`);
+		for (const name of data.imported) console.log(`  ${name}`);
+		if (data.skipped && data.skipped.length > 0) {
+			console.log(`Skipped ${data.skipped.length} invalid tool(s):`);
+			for (const name of data.skipped) console.log(`  ${name}`);
+		}
+	} else {
+		console.error("Error:", res.error);
+		process.exit(1);
+	}
+});
+toolCmd.command("mock <name> <response>").description("Set mock response").option("--to <target>", "Target session").action(async (name, response, options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	try {
+		const res = await sendRequest({
+			action: "tool_mock",
+			payload: {
+				name,
+				response: JSON.parse(response)
+			}
+		}, target);
+		if (res.success) console.log(`Mock set for: ${name}`);
+		else {
+			console.error("Error:", res.error);
+			process.exit(1);
+		}
+	} catch {
+		console.error("Invalid JSON response");
+		process.exit(1);
+	}
+});
+toolCmd.command("list").description("List tools").option("--to <target>", "Target session").action(async (options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	const res = await sendRequest({ action: "tool_list" }, target);
+	if (!res.success) {
+		console.error("Error:", res.error);
+		process.exit(1);
+	}
+	const tools = res.data;
+	if (tools.length === 0) console.log("No tools");
+	else for (const t of tools) {
+		const approval = t.needsApproval ? " [needs approval]" : "";
+		const mock = t.mockResponse !== void 0 ? " [mocked]" : "";
+		console.log(`  ${t.name}${approval}${mock} - ${t.description}`);
+	}
+});
+program.command("history").description("Show conversation history").option("--to <target>", "Target session").option("--json", "Output as JSON").option("-n, --last <count>", "Show last N messages", parseInt).action(async (options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	const res = await sendRequest({ action: "history" }, target);
+	if (!res.success) {
+		console.error("Error:", res.error);
+		process.exit(1);
+	}
+	let history = res.data;
+	if (options.last && options.last > 0) history = history.slice(-options.last);
+	if (options.json) console.log(JSON.stringify(history, null, 2));
+	else {
+		if (history.length === 0) {
+			console.log("No messages");
+			return;
+		}
+		for (const msg of history) {
+			const role = msg.role === "user" ? "YOU" : msg.role.toUpperCase();
+			const status = msg.status === "responding" ? " (responding...)" : "";
+			console.log(`[${role}${status}] ${msg.content}`);
+		}
+	}
+});
+program.command("stats").description("Show session statistics").option("--to <target>", "Target session").action(async (options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	const res = await sendRequest({ action: "stats" }, target);
+	if (!res.success) {
+		console.error("Error:", res.error);
+		process.exit(1);
+	}
+	const stats = res.data;
+	console.log(`Messages: ${stats.messageCount}`);
+	console.log(`Tokens: ${stats.usage.total} (in: ${stats.usage.input}, out: ${stats.usage.output})`);
+});
+program.command("export").description("Export session transcript").option("--to <target>", "Target session").action(async (options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	const res = await sendRequest({ action: "export" }, target);
+	if (!res.success) {
+		console.error("Error:", res.error);
+		process.exit(1);
+	}
+	console.log(JSON.stringify(res.data, null, 2));
+});
+program.command("clear").description("Clear conversation history").option("--to <target>", "Target session").action(async (options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	const res = await sendRequest({ action: "clear" }, target);
+	if (res.success) console.log("History cleared");
+	else console.error("Error:", res.error);
+});
+program.command("pending").description("List pending tool approvals").option("--to <target>", "Target session").option("--json", "Output as JSON").action(async (options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	const res = await sendRequest({ action: "pending" }, target);
+	if (!res.success) {
+		console.error("Error:", res.error);
+		process.exit(1);
+	}
+	const pending = res.data;
+	if (options.json) {
+		console.log(JSON.stringify(pending, null, 2));
+		return;
+	}
+	if (pending.length === 0) {
+		console.log("No pending approvals");
+		return;
+	}
+	for (const p of pending) {
+		console.log(`[${p.id.slice(0, 8)}] ${p.toolName}`);
+		console.log(`  Arguments: ${JSON.stringify(p.arguments)}`);
+	}
+});
+program.command("approve <id>").description("Approve a pending tool call").option("--to <target>", "Target session").option("--json", "Output as JSON").action(async (id, options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	const res = await sendRequest({
+		action: "approve",
+		payload: { id }
+	}, target);
+	if (!res.success) {
+		console.error("Error:", res.error);
+		process.exit(1);
+	}
+	if (options.json) console.log(JSON.stringify({
+		approved: true,
+		result: res.data
+	}, null, 2));
+	else {
+		console.log("Approved");
+		console.log(`Result: ${JSON.stringify(res.data, null, 2)}`);
+	}
+});
+program.command("deny <id>").description("Deny a pending tool call").option("--to <target>", "Target session").option("-r, --reason <reason>", "Reason for denial").action(async (id, options) => {
+	const target = options.to;
+	if (!isSessionActive(target)) {
+		console.error(target ? `Session not found: ${target}` : "No active session");
+		process.exit(1);
+	}
+	const res = await sendRequest({
+		action: "deny",
+		payload: {
+			id,
+			reason: options.reason
+		}
+	}, target);
+	if (res.success) console.log("Denied");
+	else {
+		console.error("Error:", res.error);
+		process.exit(1);
+	}
+});
+const PROVIDER_API_KEYS = {
+	gateway: {
+		envVar: "AI_GATEWAY_API_KEY",
+		description: "Vercel AI Gateway (all providers)"
+	},
+	anthropic: {
+		envVar: "ANTHROPIC_API_KEY",
+		description: "Anthropic Claude"
+	},
+	openai: {
+		envVar: "OPENAI_API_KEY",
+		description: "OpenAI GPT"
+	},
+	deepseek: {
+		envVar: "DEEPSEEK_API_KEY",
+		description: "DeepSeek"
+	},
+	google: {
+		envVar: "GOOGLE_GENERATIVE_AI_API_KEY",
+		description: "Google Gemini"
+	},
+	groq: {
+		envVar: "GROQ_API_KEY",
+		description: "Groq"
+	},
+	mistral: {
+		envVar: "MISTRAL_API_KEY",
+		description: "Mistral"
+	},
+	xai: {
+		envVar: "XAI_API_KEY",
+		description: "xAI Grok"
+	},
+	minimax: {
+		envVar: "MINIMAX_API_KEY",
+		description: "MiniMax"
+	}
+};
+program.command("providers").description("Check provider availability").action(() => {
+	console.log("Provider Status:\n");
+	for (const [name, config] of Object.entries(PROVIDER_API_KEYS)) {
+		const isConfigured = !!process.env[config.envVar];
+		const status = isConfigured ? "✓" : "✗";
+		const statusText = isConfigured ? "" : " (not configured)";
+		const envHint = isConfigured ? "" : ` [${config.envVar}]`;
+		const defaultModel = name === "gateway" ? "" : ` → ${name}/${FRONTIER_MODELS[name]?.[0] || "?"}`;
+		console.log(`  ${status} ${name.padEnd(10)} - ${config.description}${statusText}${envHint}${defaultModel}`);
+	}
+	const defaultModel = getDefaultModel();
+	const gatewayExample = `openai/${FRONTIER_MODELS.openai[0]}`;
+	const directExample = `deepseek:${FRONTIER_MODELS.deepseek[0]}`;
+	console.log("\nUsage:");
+	console.log(`  Provider only:   provider         (e.g., openai → ${gatewayExample})`);
+	console.log(`  Gateway format:  provider/model   (e.g., ${gatewayExample})`);
+	console.log(`  Direct format:   provider:model   (e.g., ${directExample})`);
+	console.log(`\nDefault: ${defaultModel} (when no model specified)`);
+});
+program.command("backends").description("Check available backends (SDK, CLI tools)").action(async () => {
+	const { listBackends } = await import("../backends-BqaAh6cC.mjs");
+	const backends = await listBackends();
+	console.log("Backend Status:\n");
+	for (const backend of backends) {
+		const status = backend.available ? "✓" : "✗";
+		const statusText = backend.available ? "" : " (not installed)";
+		console.log(`  ${status} ${backend.type.padEnd(8)} - ${backend.name}${statusText}`);
+	}
+	console.log("\nUsage:");
+	console.log("  SDK backend:    agent-worker session new -m openai/gpt-5.2");
+	console.log("  Claude CLI:     agent-worker session new --backend claude");
+	console.log("  Codex CLI:      agent-worker session new --backend codex");
+	console.log("  Cursor CLI:     agent-worker session new --backend cursor");
+});
+program.parse();
+
+//#endregion
+export {  };