codex-toys 0.135.0

package/dist/bin/codex-toys-proxy.js

@@ -0,0 +1,825 @@
+#!/usr/bin/env node
+import http from "node:http";
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+//#region packages/codex-client/src/app-server/events.ts
+var CodexEventEmitter = class {
+	#listeners = /* @__PURE__ */ new Map();
+	on(event, listener) {
+		let listeners = this.#listeners.get(event);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			this.#listeners.set(event, listeners);
+		}
+		listeners.add(listener);
+		return this;
+	}
+	off(event, listener) {
+		this.#listeners.get(event)?.delete(listener);
+		return this;
+	}
+	once(event, listener) {
+		const wrapped = (...args) => {
+			this.off(event, wrapped);
+			listener(...args);
+		};
+		return this.on(event, wrapped);
+	}
+	emit(event, ...args) {
+		const listeners = this.#listeners.get(event);
+		if (!listeners || listeners.size === 0) return false;
+		for (const listener of [...listeners]) listener(...args);
+		return true;
+	}
+};
+//#endregion
+//#region packages/codex-client/src/toybox/protocol.ts
+const TOYBOX_INITIALIZE_METHOD = "toybox.initialize";
+const APP_CALL_METHOD = "app.call";
+//#endregion
+//#region packages/codex-client/src/app-server/rpc.ts
+var JsonRpcError = class extends Error {
+	code;
+	data;
+	constructor(error) {
+		super(error.message);
+		this.name = "JsonRpcError";
+		this.code = error.code;
+		this.data = error.data;
+	}
+};
+function isJsonRpcResponse(value) {
+	return isRecord(value) && "id" in value && ("result" in value || "error" in value);
+}
+function isJsonRpcRequest(value) {
+	return isRecord(value) && "id" in value && typeof value.method === "string" && !("result" in value) && !("error" in value);
+}
+function isJsonRpcNotification(value) {
+	return isRecord(value) && !("id" in value) && typeof value.method === "string" && !("result" in value) && !("error" in value);
+}
+function requireJsonRpcResult(response) {
+	if (response.error) throw new JsonRpcError(response.error);
+	return response.result;
+}
+function stringifyJsonRpc(message) {
+	return `${JSON.stringify(message, (_key, value) => typeof value === "bigint" ? value.toString() : value)}\n`;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region packages/codex-client/src/app-server/stdio-transport.ts
+const DEFAULT_CODEX_COMMAND = "codex";
+var CodexStdioTransport = class extends CodexEventEmitter {
+	requestTimeoutMs;
+	#codexCommand;
+	#args;
+	#cwd;
+	#env;
+	#child;
+	#nextRequestId = 1;
+	#pending = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		super();
+		const command = resolveCodexStdioCommand(options, {
+			...process.env,
+			...options.env
+		});
+		this.#codexCommand = command.command;
+		this.#args = command.args;
+		this.#cwd = options.cwd;
+		this.#env = options.env;
+		this.requestTimeoutMs = options.requestTimeoutMs ?? 6e4;
+	}
+	get running() {
+		return this.#child !== void 0 && this.#child.exitCode === null;
+	}
+	start() {
+		if (this.running) return;
+		const child = spawn(this.#codexCommand, this.#args, {
+			cwd: this.#cwd,
+			env: {
+				...process.env,
+				...this.#env
+			},
+			detached: process.platform !== "win32"
+		});
+		this.#child = child;
+		child.once("exit", (code, signal) => {
+			if (this.#child === child) this.#child = void 0;
+			const exitError = /* @__PURE__ */ new Error(`codex app-server exited with ${code ?? signal ?? "unknown"}`);
+			this.#rejectAll(exitError);
+			this.emit("close", code, signal);
+		});
+		child.once("error", (error) => {
+			if (this.#child === child) this.#child = void 0;
+			this.#rejectAll(error);
+			this.emit("error", error);
+		});
+		readLines(child.stdout, (line) => this.#handleLine(line)).catch((error) => this.emit("error", error));
+		readLines(child.stderr, (line) => this.emit("stderr", line)).catch((error) => this.emit("error", error));
+	}
+	close() {
+		const child = this.#child;
+		this.#child = void 0;
+		if (child && child.exitCode === null) {
+			killChildProcessGroup(child, "SIGTERM");
+			setTimeout(() => {
+				if (child.exitCode === null) killChildProcessGroup(child, "SIGKILL");
+			}, 1e3).unref();
+		}
+		this.#rejectAll(/* @__PURE__ */ new Error("codex app-server transport closed"));
+	}
+	async request(method, params) {
+		this.start();
+		const id = this.#nextRequestId++;
+		return requireJsonRpcResult(await new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.#pending.delete(id);
+				reject(/* @__PURE__ */ new Error(`JSON-RPC request timed out: ${method}`));
+			}, this.requestTimeoutMs);
+			this.#pending.set(id, {
+				resolve,
+				reject,
+				timer
+			});
+			this.#write({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params
+			});
+		}));
+	}
+	notify(method, params) {
+		this.start();
+		this.#write({
+			jsonrpc: "2.0",
+			method,
+			params
+		});
+	}
+	respond(id, result) {
+		this.start();
+		this.#write({
+			jsonrpc: "2.0",
+			id,
+			result
+		});
+	}
+	respondError(id, code, message, data) {
+		this.start();
+		this.#write({
+			jsonrpc: "2.0",
+			id,
+			error: {
+				code,
+				message,
+				data
+			}
+		});
+	}
+	#write(message) {
+		const child = this.#child;
+		if (!child || child.exitCode !== null) throw new Error("codex app-server transport is not running");
+		child.stdin.write(stringifyJsonRpc(message));
+	}
+	#handleLine(line) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) return;
+		let message;
+		try {
+			message = JSON.parse(trimmed);
+		} catch (error) {
+			this.emit("error", /* @__PURE__ */ new Error(`Failed to parse app-server JSON-RPC line: ${String(error)}`));
+			return;
+		}
+		if (isJsonRpcResponse(message)) {
+			const pending = this.#pending.get(message.id);
+			if (pending) {
+				clearTimeout(pending.timer);
+				this.#pending.delete(message.id);
+				pending.resolve(message);
+			}
+			return;
+		}
+		if (isJsonRpcRequest(message)) {
+			this.emit("request", message);
+			return;
+		}
+		if (isJsonRpcNotification(message)) {
+			this.emit("notification", message);
+			return;
+		}
+		this.emit("error", /* @__PURE__ */ new Error("Received malformed JSON-RPC message"));
+	}
+	#rejectAll(error) {
+		for (const pending of this.#pending.values()) {
+			clearTimeout(pending.timer);
+			pending.reject(error);
+		}
+		this.#pending.clear();
+	}
+};
+function resolveCodexStdioCommand(options = {}, env = process.env) {
+	const explicitCommand = options.codexCommand ?? env.CODEX_APP_SERVER_CODEX_COMMAND;
+	const appServerSocket = options.appServerSocket ?? env.CODEX_WORKSPACE_APP_SERVER_SOCK;
+	const args = [...envJsonStringArray$1(env.CODEX_APP_SERVER_CODEX_ARGS, "CODEX_APP_SERVER_CODEX_ARGS"), ...options.args ?? defaultCodexArgs(appServerSocket)];
+	if (explicitCommand?.trim()) return {
+		command: explicitCommand,
+		args
+	};
+	const packageName = env.CODEX_APP_SERVER_CODEX_PACKAGE?.trim();
+	if (packageName) {
+		const dlxCommand = env.CODEX_APP_SERVER_DLX_COMMAND?.trim();
+		if (!dlxCommand) return {
+			command: "vp",
+			args: [
+				"dlx",
+				packageName,
+				...args
+			]
+		};
+		return {
+			command: dlxCommand,
+			args: [packageName, ...args]
+		};
+	}
+	return {
+		command: DEFAULT_CODEX_COMMAND,
+		args
+	};
+}
+function envJsonStringArray$1(value, label) {
+	if (!value?.trim()) return [];
+	const parsed = JSON.parse(stripJsonBom$1(value));
+	if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) throw new Error(`${label} must be a JSON array of strings`);
+	return parsed;
+}
+function stripJsonBom$1(text) {
+	return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function killChildProcessGroup(child, signal) {
+	if (process.platform !== "win32" && child.pid) try {
+		process.kill(-child.pid, signal);
+		return;
+	} catch {
+		child.kill(signal);
+		return;
+	}
+	child.kill(signal);
+}
+async function readLines(stream, onLine) {
+	let buffer = "";
+	stream.setEncoding("utf8");
+	for await (const chunk of stream) {
+		buffer += String(chunk);
+		let lineEnd = buffer.indexOf("\n");
+		while (lineEnd !== -1) {
+			const line = buffer.slice(0, lineEnd).replace(/\r$/, "");
+			buffer = buffer.slice(lineEnd + 1);
+			onLine(line);
+			lineEnd = buffer.indexOf("\n");
+		}
+	}
+	if (buffer.length > 0) onLine(buffer.replace(/\r$/, ""));
+}
+function defaultCodexArgs(appServerSocket) {
+	if (appServerSocket) return [
+		"app-server",
+		"proxy",
+		"--sock",
+		appServerSocket
+	];
+	return [
+		"app-server",
+		"--listen",
+		"stdio://",
+		"--enable",
+		"apps",
+		"--enable",
+		"hooks"
+	];
+}
+//#endregion
+//#region packages/codex-client/src/cli/json.ts
+function parseJsonText(text, label = "JSON") {
+	try {
+		return JSON.parse(stripJsonBom(text));
+	} catch (error) {
+		throw new Error(`Failed to parse ${label}: ${errorMessage$2(error)}`);
+	}
+}
+function stripJsonBom(text) {
+	return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function errorMessage$2(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region packages/codex-client/src/cli/remote-provider.ts
+const removedRemoteEnvVars = [
+	"CODEX_TOYS_REMOTE_MODE",
+	"CODEX_TOYS_REMOTE_TUNNEL_PORT",
+	"CODEX_TOYS_REMOTE_BACKEND_HOST",
+	"CODEX_TOYS_REMOTE_BACKEND_PORT",
+	"CODEX_TOYS_REMOTE_TOYBOX_COMMAND",
+	"CODEX_TOYS_REMOTE_TOYBOX_ARGS"
+];
+function hasSshRemote(options) {
+	return Boolean(options.sshTarget ?? options.env?.CODEX_TOYS_REMOTE_SSH_TARGET);
+}
+function resolveSshRemoteOptions(options) {
+	const env = options.env ?? process.env;
+	rejectRemovedRemoteEnvVars(env);
+	const sshTarget = options.sshTarget ?? env.CODEX_TOYS_REMOTE_SSH_TARGET;
+	if (!sshTarget?.trim()) throw new Error("SSH remote provider requires --ssh <target> or CODEX_TOYS_REMOTE_SSH_TARGET");
+	const toyboxCommand = options.toyboxCommand ?? env.CODEX_TOYS_TOYBOX_COMMAND ?? "codex-toys";
+	const remoteCodexCommand = options.remoteCodexCommand ?? env.CODEX_TOYS_REMOTE_CODEX_COMMAND ?? "codex";
+	rejectInlineEnvCommand("CODEX_TOYS_TOYBOX_COMMAND", toyboxCommand);
+	rejectInlineEnvCommand("CODEX_TOYS_REMOTE_CODEX_COMMAND", remoteCodexCommand);
+	return {
+		sshTarget,
+		...options.cwd ?? env.CODEX_TOYS_REMOTE_CWD ? { cwd: options.cwd ?? env.CODEX_TOYS_REMOTE_CWD } : {},
+		...options.remotePathPrepend ?? env.CODEX_TOYS_REMOTE_PATH_PREPEND ? { remotePathPrepend: options.remotePathPrepend ?? env.CODEX_TOYS_REMOTE_PATH_PREPEND } : {},
+		sshCommand: env.CODEX_TOYS_SSH_COMMAND ?? "ssh",
+		toyboxCommand,
+		remoteCodexCommand,
+		remoteCodexArgs: options.remoteCodexArgs ?? envJsonStringArray(env.CODEX_TOYS_REMOTE_CODEX_ARGS, "CODEX_TOYS_REMOTE_CODEX_ARGS") ?? [],
+		timeoutMs: options.timeoutMs
+	};
+}
+function createSshToyboxPlan(options) {
+	const resolved = resolveSshRemoteOptions(options);
+	const toyboxArgs = [
+		"toybox",
+		"serve",
+		"--timeout-ms",
+		String(resolved.timeoutMs),
+		...resolved.cwd ? ["--cwd", resolved.cwd] : [],
+		"--codex-command",
+		resolved.remoteCodexCommand,
+		...resolved.remoteCodexArgs.flatMap((arg) => ["--codex-arg", arg])
+	];
+	const remoteCommand = withRemoteBootstrap(resolved, `exec ${shellCommand(resolved.toyboxCommand, toyboxArgs)}`);
+	return {
+		kind: "toybox",
+		command: [
+			resolved.sshCommand,
+			"-T",
+			resolved.sshTarget,
+			remoteCommand
+		],
+		remoteCommand
+	};
+}
+function createSshToyboxTransport(options) {
+	const plan = createSshToyboxPlan(options);
+	const stderr = [];
+	const transport = new CodexStdioTransport({
+		codexCommand: plan.command[0],
+		args: plan.command.slice(1),
+		requestTimeoutMs: options.timeoutMs
+	});
+	transport.toyboxPlan = plan;
+	transport.toyboxStderr = stderr;
+	transport.on("stderr", (line) => {
+		stderr.push(line);
+		trimBuffer(stderr);
+	});
+	return transport;
+}
+function createLocalToyboxTransport(options) {
+	const env = options.env ?? process.env;
+	const toyboxCommand = options.toyboxCommand ?? env.CODEX_TOYS_TOYBOX_COMMAND ?? "codex-toys";
+	const codexCommand = options.remoteCodexCommand ?? env.CODEX_TOYS_CODEX_COMMAND ?? env.CODEX_TOYS_REMOTE_CODEX_COMMAND ?? "codex";
+	const codexArgs = options.remoteCodexArgs ?? envJsonStringArray(env.CODEX_TOYS_CODEX_ARGS, "CODEX_TOYS_CODEX_ARGS") ?? envJsonStringArray(env.CODEX_TOYS_REMOTE_CODEX_ARGS, "CODEX_TOYS_REMOTE_CODEX_ARGS") ?? [];
+	const command = [
+		toyboxCommand,
+		"toybox",
+		"serve",
+		"--timeout-ms",
+		String(options.timeoutMs),
+		...options.cwd ? ["--cwd", options.cwd] : [],
+		"--codex-command",
+		codexCommand,
+		...codexArgs.flatMap((arg) => ["--codex-arg", arg])
+	];
+	const transport = new CodexStdioTransport({
+		codexCommand: command[0],
+		args: command.slice(1),
+		requestTimeoutMs: options.timeoutMs
+	});
+	transport.toyboxPlan = {
+		kind: "toybox",
+		command,
+		remoteCommand: shellCommand(command[0], command.slice(1))
+	};
+	transport.toyboxStderr = [];
+	transport.on("stderr", (line) => {
+		transport.toyboxStderr.push(line);
+		trimBuffer(transport.toyboxStderr);
+	});
+	return transport;
+}
+function withRemoteBootstrap(options, command) {
+	const parts = [];
+	if (options.cwd) parts.push(`cd ${shellQuote(options.cwd)}`);
+	if (options.remotePathPrepend) parts.push(`export PATH=${shellQuote(options.remotePathPrepend)}\${PATH:+":$PATH"}`);
+	parts.push(command);
+	return parts.join(" && ");
+}
+function shellCommand(command, args) {
+	return [shellQuote(command), ...args.map(shellQuote)].join(" ");
+}
+function shellQuote(value) {
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function rejectInlineEnvCommand(label, command) {
+	if (/^\s*[A-Za-z_][A-Za-z0-9_]*=.*\s+\S/.test(command)) throw new Error(`${label} must be a command name or path, not an inline environment assignment. Set CODEX_TOYS_REMOTE_PATH_PREPEND for PATH changes or use an absolute command path.`);
+}
+function rejectRemovedRemoteEnvVars(env) {
+	const present = removedRemoteEnvVars.filter((name) => env[name]?.trim());
+	if (present.length === 0) return;
+	throw new Error(`Removed SSH backend/tunnel environment variables are no longer supported: ${present.join(", ")}. Install codex-toys on the SSH target and use the SSH toybox provider instead.`);
+}
+function envJsonStringArray(value, label) {
+	if (!value?.trim()) return;
+	const parsed = parseJsonText(value, label);
+	if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) throw new Error(`${label} must be a JSON array of strings`);
+	return parsed;
+}
+function trimBuffer(chunks) {
+	while (chunks.join("\n").length > 4e3) chunks.shift();
+}
+//#endregion
+//#region packages/codex-client/src/proxy.ts
+function createCodexToysProxyHandler(options = {}) {
+	const apiBasePath = normalizeBasePath(options.apiBasePath ?? "/api");
+	let requester;
+	const getRequester = () => {
+		requester ??= createProxyRequester(options);
+		return requester;
+	};
+	return async (request, response, next) => {
+		const url = new URL(request.url ?? "/", "http://codex-toys.local");
+		const cors = corsPolicyForRequest(request);
+		if (url.pathname === apiBasePath || url.pathname.startsWith(`${apiBasePath}/`)) {
+			applyCorsHeaders(response, cors);
+			if (!cors.allowed) {
+				writeJson(response, 403, { error: "CORS origin is not allowed" });
+				return;
+			}
+			if (request.method === "OPTIONS") {
+				response.statusCode = 204;
+				response.end();
+				return;
+			}
+			try {
+				await handleApiRequest(getRequester(), apiBasePath, request, response);
+			} catch (error) {
+				writeJson(response, 500, { error: errorMessage$1(error) });
+			}
+			return;
+		}
+		if (options.staticDir) {
+			if (await serveStatic(options.staticDir, url.pathname, response)) return;
+		}
+		if (next) {
+			next();
+			return;
+		}
+		writeJson(response, 404, { error: "not found" });
+	};
+}
+function createProxyRequester(options) {
+	const timeoutMs = options.timeoutMs ?? 9e4;
+	const transport = options.transport ?? (hasSshRemote({
+		sshTarget: options.sshTarget,
+		env: options.env
+	}) ? createSshToyboxTransport({
+		...options,
+		timeoutMs
+	}) : createLocalToyboxTransport({
+		...options,
+		timeoutMs
+	}));
+	let initialized;
+	const initialize = async () => {
+		transport.start();
+		initialized ??= transport.request(TOYBOX_INITIALIZE_METHOD, {
+			clientInfo: {
+				name: "codex-toys-proxy",
+				title: "Codex Toys Proxy",
+				version: "0.1.0"
+			},
+			capabilities: { appPassThrough: true }
+		});
+		return await initialized;
+	};
+	return {
+		initialize,
+		request: async (method, params) => {
+			await initialize();
+			return await transport.request(method, params);
+		},
+		close: () => {
+			transport.close();
+			initialized = void 0;
+		}
+	};
+}
+async function handleApiRequest(requester, apiBasePath, request, response) {
+	const apiPath = new URL(request.url ?? "/", "http://codex-toys.local").pathname.slice(apiBasePath.length) || "/";
+	if (request.method === "GET" && apiPath === "/status") {
+		const initialized = await requester.initialize();
+		let toybox = null;
+		try {
+			toybox = await requester.request("toybox.status", {});
+		} catch {
+			toybox = null;
+		}
+		writeJson(response, 200, {
+			ok: true,
+			serverInfo: initialized.serverInfo,
+			capabilities: initialized.capabilities,
+			toybox
+		});
+		return;
+	}
+	if (request.method === "GET" && apiPath === "/schema") {
+		writeJson(response, 200, await requester.initialize());
+		return;
+	}
+	if (request.method === "POST" && apiPath === "/rpc") {
+		const body = record(await readJsonBody(request));
+		const method = requiredString(body.method, "method");
+		writeJson(response, 200, await requester.request(method, body.params));
+		return;
+	}
+	if (request.method === "POST" && apiPath.startsWith("/app/")) {
+		const method = decodeURIComponent(apiPath.slice(5));
+		writeJson(response, 200, await requester.request(APP_CALL_METHOD, {
+			method,
+			params: await readJsonBody(request)
+		}));
+		return;
+	}
+	if (request.method === "POST" && apiPath.startsWith("/workspace/")) {
+		const method = decodeURIComponent(apiPath.slice(11));
+		writeJson(response, 200, await requester.request(method, await readJsonBody(request)));
+		return;
+	}
+	writeJson(response, 404, { error: "Unknown Codex Toys proxy endpoint" });
+}
+async function readJsonBody(request) {
+	let body = "";
+	for await (const chunk of request) {
+		body += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+		if (body.length > 1e6) throw new Error("Request body is too large");
+	}
+	if (!body.trim()) return {};
+	return JSON.parse(body);
+}
+async function serveStatic(staticDir, urlPath, response) {
+	const root = path.resolve(staticDir);
+	const decoded = decodeURIComponent(urlPath.split("?")[0] ?? "/");
+	const candidate = path.resolve(root, `.${decoded === "/" ? "/index.html" : decoded}`);
+	if (!candidate.startsWith(`${root}${path.sep}`) && candidate !== root) return false;
+	try {
+		if (!(await stat(candidate)).isFile()) return false;
+		response.statusCode = 200;
+		response.setHeader("content-type", contentType(candidate));
+		response.end(await readFile(candidate));
+		return true;
+	} catch {
+		return false;
+	}
+}
+function writeJson(response, status, value) {
+	response.statusCode = status;
+	response.setHeader("content-type", "application/json; charset=utf-8");
+	response.end(`${JSON.stringify(value)}\n`);
+}
+function corsPolicyForRequest(request) {
+	const origin = request.headers.origin;
+	if (typeof origin !== "string" || origin.length === 0) return { allowed: true };
+	return isLoopbackOrigin(origin) ? {
+		allowed: true,
+		origin
+	} : { allowed: false };
+}
+function applyCorsHeaders(response, cors) {
+	response.setHeader("vary", "Origin");
+	if (!cors.allowed || !cors.origin) return;
+	response.setHeader("access-control-allow-origin", cors.origin);
+	response.setHeader("access-control-allow-methods", "GET, POST, OPTIONS");
+	response.setHeader("access-control-allow-headers", "content-type");
+	response.setHeader("access-control-max-age", "600");
+}
+function isLoopbackOrigin(origin) {
+	try {
+		const url = new URL(origin);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+		const hostname = url.hostname.toLowerCase();
+		return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]" || hostname.endsWith(".localhost");
+	} catch {
+		return false;
+	}
+}
+function normalizeBasePath(value) {
+	return (value.startsWith("/") ? value : `/${value}`).replace(/\/+$/, "") || "/api";
+}
+function contentType(filePath) {
+	const extension = path.extname(filePath).toLowerCase();
+	if (extension === ".html") return "text/html; charset=utf-8";
+	if (extension === ".js") return "text/javascript; charset=utf-8";
+	if (extension === ".css") return "text/css; charset=utf-8";
+	if (extension === ".json") return "application/json; charset=utf-8";
+	return "application/octet-stream";
+}
+function requiredString(value, name) {
+	if (typeof value === "string" && value.length > 0) return value;
+	throw new Error(`${name} is required`);
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function errorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region packages/codex-client/src/bin/codex-toys-proxy.ts
+const parsed = parseArgs(process.argv.slice(2));
+if (parsed.help) {
+	process.stdout.write(helpText());
+	process.exit(0);
+}
+const handler = createCodexToysProxyHandler({
+	cwd: parsed.cwd,
+	sshTarget: parsed.sshTarget,
+	staticDir: parsed.staticDir,
+	timeoutMs: parsed.timeoutMs,
+	toyboxCommand: parsed.toyboxCommand,
+	remoteCodexCommand: parsed.remoteCodexCommand,
+	remoteCodexArgs: parsed.remoteCodexArgs,
+	apiBasePath: "/api"
+});
+const server = http.createServer((request, response) => {
+	handler(request, response).catch((error) => {
+		response.statusCode = 500;
+		response.setHeader("content-type", "application/json; charset=utf-8");
+		response.end(`${JSON.stringify({ error: errorMessage(error) })}\n`);
+	});
+});
+server.listen(parsed.port, parsed.host, () => {
+	const address = server.address();
+	const port = typeof address === "object" && address ? address.port : parsed.port;
+	process.stderr.write(`codex-toys-proxy listening on http://${parsed.host}:${port}\n`);
+});
+function parseArgs(argv) {
+	const result = {
+		host: "127.0.0.1",
+		port: 3587,
+		timeoutMs: 9e4,
+		remoteCodexArgs: [],
+		help: false
+	};
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (!arg) continue;
+		if (arg === "-h" || arg === "--help") {
+			result.help = true;
+			continue;
+		}
+		if (arg === "serve") continue;
+		if (arg === "--cwd") {
+			result.cwd = required(argv, ++index, arg);
+			continue;
+		}
+		if (arg.startsWith("--cwd=")) {
+			result.cwd = arg.slice(6);
+			continue;
+		}
+		if (arg === "--ssh" || arg === "--ssh-target") {
+			result.sshTarget = required(argv, ++index, arg);
+			continue;
+		}
+		if (arg.startsWith("--ssh=")) {
+			result.sshTarget = arg.slice(6);
+			continue;
+		}
+		if (arg.startsWith("--ssh-target=")) {
+			result.sshTarget = arg.slice(13);
+			continue;
+		}
+		if (arg === "--static") {
+			result.staticDir = required(argv, ++index, arg);
+			continue;
+		}
+		if (arg.startsWith("--static=")) {
+			result.staticDir = arg.slice(9);
+			continue;
+		}
+		if (arg === "--host") {
+			result.host = required(argv, ++index, arg);
+			continue;
+		}
+		if (arg.startsWith("--host=")) {
+			result.host = arg.slice(7);
+			continue;
+		}
+		if (arg === "--port") {
+			result.port = positiveInteger(required(argv, ++index, arg), arg);
+			continue;
+		}
+		if (arg.startsWith("--port=")) {
+			result.port = positiveInteger(arg.slice(7), "--port");
+			continue;
+		}
+		if (arg === "--timeout-ms") {
+			result.timeoutMs = positiveInteger(required(argv, ++index, arg), arg);
+			continue;
+		}
+		if (arg.startsWith("--timeout-ms=")) {
+			result.timeoutMs = positiveInteger(arg.slice(13), "--timeout-ms");
+			continue;
+		}
+		if (arg === "--toybox-command") {
+			result.toyboxCommand = required(argv, ++index, arg);
+			continue;
+		}
+		if (arg.startsWith("--toybox-command=")) {
+			result.toyboxCommand = arg.slice(17);
+			continue;
+		}
+		if (arg === "--codex-command" || arg === "--remote-codex-command") {
+			result.remoteCodexCommand = required(argv, ++index, arg);
+			continue;
+		}
+		if (arg.startsWith("--codex-command=")) {
+			result.remoteCodexCommand = arg.slice(16);
+			continue;
+		}
+		if (arg.startsWith("--remote-codex-command=")) {
+			result.remoteCodexCommand = arg.slice(23);
+			continue;
+		}
+		if (arg === "--codex-arg" || arg === "--remote-codex-arg") {
+			result.remoteCodexArgs.push(required(argv, ++index, arg));
+			continue;
+		}
+		if (arg.startsWith("--codex-arg=")) {
+			result.remoteCodexArgs.push(arg.slice(12));
+			continue;
+		}
+		if (arg.startsWith("--remote-codex-arg=")) {
+			result.remoteCodexArgs.push(arg.slice(19));
+			continue;
+		}
+		throw new Error(`Unknown option: ${arg}`);
+	}
+	return result;
+}
+function helpText() {
+	return `codex-toys-proxy serves a generic HTTP edge for codex-toys toyboxes.
+
+Usage:
+  codex-toys-proxy serve --cwd <workspace> [--static <dir>]
+  codex-toys-proxy serve --ssh <target> --cwd <remote-workspace> [--static <dir>]
+
+Options:
+  --cwd <path>                 Workspace cwd for the local or SSH toybox.
+  --ssh, --ssh-target <target> SSH target for remote toybox stdio.
+  --static <dir>               Optional static dashboard directory.
+  --host <host>                HTTP host. Defaults to 127.0.0.1.
+  --port <port>                HTTP port. Defaults to 3587.
+  --timeout-ms <ms>            Toybox request timeout. Defaults to 90000.
+  --toybox-command <command>    codex-toys command/path for spawned toyboxes.
+  --codex-command <command>    Codex command used inside the toybox.
+  --codex-arg <arg>            Extra Codex argument. Repeatable.
+
+HTTP API:
+  GET  /api/status
+  GET  /api/schema
+  POST /api/rpc
+  POST /api/app/:method
+  POST /api/workspace/:method
+`;
+}
+function required(args, index, flag) {
+	const value = args[index];
+	if (!value) throw new Error(`${flag} requires a value`);
+	return value;
+}
+function positiveInteger(value, flag) {
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${flag} must be a positive integer`);
+	return parsed;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export {};