evalution 1.0.3 → 1.0.4

package/dist/cli/index.js

@@ -1,4 +1,4 @@
-import { a as MemoryTraceProvider, i as setupStepCommand, r as CONFIG_FILE_RELATIVE_PATH, t as VercelAISDK } from "../vercel-ai-sdk-B5BwUGKp.js";
+import { a as MemoryTraceProvider, i as setupStepCommand, r as CONFIG_FILE_RELATIVE_PATH, t as VercelAISDK } from "../vercel-ai-sdk-B8ivuOzP.js";
 import module from "node:module";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -99,7 +99,10 @@ function setupRoutes({ app, promptProviders, traceProviders, promptRegistry, hot
 		rootPath,
 		configured: hasConfig
 	}));
-	app.get("/api/setup-tasks", (c) => c.json(setupTasks ? setupTasks.resolve(rootPath) : []));
+	app.get("/api/setup-tasks", (c) => c.json(setupTasks ? setupTasks.resolve(rootPath) : {
+		agent: [],
+		sdk: []
+	}));
 	app.post("/api/setup-tasks/:taskId/steps/:stepId/execute", async (c) => {
 		if (!setupTasks) return c.json({ error: "Setup tasks are not available" }, 404);
 		const { taskId, stepId } = c.req.param();
@@ -314,6 +317,53 @@ function setupRoutes({ app, promptProviders, traceProviders, promptRegistry, hot
 	}));
 }
 //#endregion
+//#region src/agent/registry.ts
+const AGENT_SETUP_DOMAIN = "evalut.io";
+/** The prompt handed to a coding agent */
+const AGENT_SETUP_PROMPT = `Follow manual setup steps from ${`https://${AGENT_SETUP_DOMAIN}/n/docs/setup.md`}`;
+/**
+* Every coding agent offered a one-click launcher in onboarding, in display
+* order. This is the single source of truth for which agents exist and their
+* task ids — each is a {@link SetupTask} whose lone {@link SetupStep} runs the
+* agent's CLI with the setup prompt queued up in an interactive terminal.
+*
+* Mirrors {@link AI_SDK_REGISTRY} in `../sdk/registry.ts`, but agents have no
+* adapter class, so they live here as plain tasks. `icon` keys into the
+* client's `ProviderIcon`.
+*/
+const AGENT_REGISTRY = [{
+	id: "claude-code",
+	label: "Claude Code",
+	icon: "Anthropic",
+	steps: [{
+		kind: "run_command",
+		id: "launch",
+		command: `claude "${AGENT_SETUP_PROMPT}" --allowedTools "WebFetch(domain:${AGENT_SETUP_DOMAIN})"`,
+		label: "Claude Code"
+	}]
+}, {
+	id: "codex",
+	label: "Codex",
+	icon: "OpenAI",
+	steps: [{
+		kind: "run_command",
+		id: "launch",
+		command: `codex -c 'features.network_proxy.enabled=true' -c 'features.network_proxy.domains={ "${AGENT_SETUP_DOMAIN}" = "allow" }' -c 'sandbox_workspace_write.network_access=true' "${AGENT_SETUP_PROMPT}"`,
+		label: "Codex"
+	}]
+}];
+/** Look up an agent {@link SetupTask} by its id, or `undefined` if none matches. */
+function findSetupTask$1(taskId) {
+	return AGENT_REGISTRY.find((task) => task.id === taskId);
+}
+/**
+* Look up a step within an agent task by both ids, or `undefined` if either is
+* unknown.
+*/
+function findSetupStep$2(taskId, stepId) {
+	return findSetupTask$1(taskId)?.steps.find((s) => s.id === stepId);
+}
+//#endregion
 //#region src/sdk/registry.ts
 /**
 * Every AI SDK offered in manual onboarding, in display order. This is the
@@ -330,12 +380,19 @@ function findSetupTask(taskId) {
 * Look up a step within a task by both ids, or `undefined` if either is
 * unknown.
 */
-function findSetupStep(taskId, stepId) {
+function findSetupStep$1(taskId, stepId) {
 	return findSetupTask(taskId)?.steps.find((s) => s.id === stepId);
 }
 //#endregion
 //#region src/server/setup-tasks.ts
 /**
+* Resolves a setup step across both the agent and SDK registries by its
+* `taskId`/`stepId`, or `undefined` if neither knows it.
+*/
+function findSetupStep(taskId, stepId) {
+	return findSetupStep$1(taskId, stepId) ?? findSetupStep$2(taskId, stepId);
+}
+/**
 * Thrown when a requested task or step id does not exist in the registry. The
 * route layer maps this to a 404, distinguishing it from execution failures.
 */
@@ -367,36 +424,61 @@ async function executeSetupStep(rootPath, taskId, stepId) {
 		case "create_config": return { path: await writeConfigFile(rootPath, step) };
 		case "run_command":
 		case "install_package": throw new Error(`${step.kind} steps are not yet supported`);
+		default: throw new Error();
 	}
 }
 /**
-* Returns the onboarding tasks with each step's runtime
-* {@link SetupStepBase.completed | completion status} resolved against the
-* project at `rootPath` (config file present, package installed).
+* Returns the onboarding tasks — coding agents and AI SDKs — with each step's
+* runtime {@link SetupStepBase.completed | completion status} resolved against
+* the project at `rootPath` (config file present, package installed).
 *
 * @param rootPath - Absolute path to the project root.
 */
 function resolveSetupTasks(rootPath) {
-	return AI_SDK_REGISTRY.map((cls) => ({
-		...cls.setupTask,
-		steps: cls.setupTask.steps.map((step) => resolveStepStatus(rootPath, step))
-	}));
+	const resolve = (task) => ({
+		...task,
+		steps: task.steps.map((step) => resolveStepStatus(rootPath, step))
+	});
+	return {
+		agent: AGENT_REGISTRY.map(resolve),
+		sdk: AI_SDK_REGISTRY.map((cls) => resolve(cls.setupTask))
+	};
 }
 /** Adds the runtime `completed` flag to a single step where determinable. */
 function resolveStepStatus(rootPath, step) {
 	switch (step.kind) {
-		case "install_package": return {
-			...step,
-			completed: isPackageInstalled(rootPath, step.package)
-		};
 		case "create_config": return {
 			...step,
 			completed: fs$1.existsSync(path.join(rootPath, step.path))
 		};
-		case "run_command": return step;
+		case "install_package":
+		case "run_command": {
+			const result = { ...step };
+			if (step.kind === "install_package") result.completed = isPackageInstalled(rootPath, step.package);
+			const bin = setupStepCommand(step).split(/\s+/)[0];
+			if (bin && !isBinaryOnPath(bin)) result.disabledReason = `${bin} not found in PATH`;
+			return result;
+		}
+		default: throw new Error();
 	}
 }
 /**
+* Whether an executable named `bin` is resolvable on the current `PATH`. Used
+* to disable coding-agent launchers whose CLI isn't installed. Honours
+* `PATHEXT` on Windows; elsewhere it requires the file to be executable.
+*
+* @param bin - The bare executable name to look for, e.g. `claude`.
+*/
+function isBinaryOnPath(bin) {
+	const dirs = (process.env.PATH ?? "").split(path.delimiter).filter(Boolean);
+	const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";") : [""];
+	for (const dir of dirs) for (const ext of exts) try {
+		fs$1.accessSync(path.join(dir, bin + ext), fs$1.constants.X_OK);
+		return true;
+	} catch {}
+	return false;
+}
+/**
 * Whether `pkg` is installed for the project at `rootPath`, walking up the
 * directory tree to honour hoisted/workspace `node_modules`.
 *
@@ -433,6 +515,12 @@ async function writeConfigFile(rootPath, step) {
 /** Shell used to run a resolved step command, so shell syntax in it works. */
 const SHELL = process.env.SHELL || (process.platform === "win32" ? "powershell.exe" : "bash");
 /**
+* How long a session's PTY is kept alive after its WebSocket drops, waiting for
+* the client to reconnect. Covers the brief gap while the server restarts
+* itself once a config file appears, so the coding agent isn't killed mid-task.
+*/
+const GRACE_PERIOD_MS = 1e4;
+/**
 * Arguments to run `command` in {@link SHELL}, skipping the user's startup files
 * where the shell allows it. Those rc files (e.g. nvm in `~/.zshrc`) can add
 * seconds of latency before the command even begins, and they are unnecessary
@@ -465,56 +553,184 @@ function resolveTerminalCommand(taskId, stepId) {
 	if (!step || step.kind === "create_config") return null;
 	return setupStepCommand(step);
 }
-function send(ws, message) {
-	ws.send(JSON.stringify(message));
+/** Spawns a real `node-pty` PTY running the command in {@link SHELL}. */
+function defaultSpawn(options) {
+	return pty.spawn(SHELL, shellCommandArgs(options.command), {
+		name: "xterm-color",
+		cols: options.cols || 80,
+		rows: options.rows || 24,
+		cwd: options.cwd,
+		env: options.env
+	});
+}
+/**
+* A single onboarding terminal: one PTY plus the WebSocket currently attached to
+* it. The PTY outlives any one socket so it can survive the server restart that
+* happens when a config file appears — while a client is attached, output is
+* streamed live; while it is detached, output is buffered and a grace timer
+* reaps the PTY if no client reconnects in time.
+*/
+var TerminalSession = class {
+	/** While detached: PTY output accumulated to replay on reconnect. */
+	buffer = null;
+	graceTimer;
+	socket = null;
+	exited = false;
+	child;
+	onReap;
+	gracePeriodMs;
+	/**
+	* @param child - The PTY this session owns.
+	* @param onReap - Called once the session is done (exit, grace expiry, or
+	*   intentional kill) so the registry can drop it.
+	* @param gracePeriodMs - How long to keep the PTY alive after the socket drops.
+	*/
+	constructor(child, onReap, gracePeriodMs = GRACE_PERIOD_MS) {
+		this.child = child;
+		this.onReap = onReap;
+		this.gracePeriodMs = gracePeriodMs;
+		child.onData((data) => this.handleData(data));
+		child.onExit(({ exitCode }) => this.handleExit(exitCode));
+	}
+	send(message) {
+		this.socket?.send(JSON.stringify(message));
+	}
+	handleData(data) {
+		if (this.socket) this.send({
+			type: "data",
+			data
+		});
+		else this.buffer?.push(data);
+	}
+	handleExit(code) {
+		this.exited = true;
+		this.send({
+			type: "exit",
+			code
+		});
+		this.socket?.close();
+		this.clearGrace();
+		this.onReap();
+	}
+	/**
+	* Attach a (re)connected socket. Replays any output buffered while detached,
+	* then resumes live streaming. Cancels a pending grace-period reap.
+	*/
+	attach(ws) {
+		this.clearGrace();
+		this.socket = ws;
+		if (this.buffer) {
+			for (const data of this.buffer) this.send({
+				type: "data",
+				data
+			});
+			this.buffer = null;
+		}
+	}
+	/**
+	* The attached socket dropped (e.g. the server is restarting). Start buffering
+	* output and a grace timer; if no client reattaches in time, reap the PTY.
+	*/
+	detach() {
+		if (this.exited || !this.socket) return;
+		this.socket = null;
+		this.buffer = [];
+		this.graceTimer = setTimeout(() => {
+			this.buffer = null;
+			if (!this.exited) this.child.kill();
+			this.onReap();
+		}, this.gracePeriodMs);
+	}
+	/** The client intentionally left: kill the PTY now, skipping the grace wait. */
+	kill() {
+		this.clearGrace();
+		this.socket = null;
+		this.buffer = null;
+		if (!this.exited) this.child.kill();
+		this.onReap();
+	}
+	/** Forward the user's keystrokes to the PTY. */
+	write(data) {
+		this.child.write(data);
+	}
+	/** Resize the PTY to match the client's terminal. */
+	resize(cols, rows) {
+		this.child.resize(cols || 80, rows || 24);
+	}
+	clearGrace() {
+		if (this.graceTimer) {
+			clearTimeout(this.graceTimer);
+			this.graceTimer = void 0;
+		}
+	}
+};
+/**
+* Holds the live {@link TerminalSession | terminal sessions} keyed by a
+* client-supplied session id. Owned by the CLI process (not by any one server
+* instance) so sessions — and the PTYs they wrap — survive the server restart
+* that happens when a config file appears.
+*/
+var TerminalSessionRegistry = class {
+	sessions = /* @__PURE__ */ new Map();
+	spawn;
+	gracePeriodMs;
+	/**
+	* @param spawn - PTY spawner; overridable in tests.
+	* @param gracePeriodMs - Reconnect grace window passed to each session.
+	*/
+	constructor(spawn = defaultSpawn, gracePeriodMs = GRACE_PERIOD_MS) {
+		this.spawn = spawn;
+		this.gracePeriodMs = gracePeriodMs;
+	}
+	/** The session for `id`, if one is still live. */
+	get(id) {
+		return this.sessions.get(id);
+	}
+	/** Spawn a PTY and register a new session under `id`. */
+	create(id, options) {
+		const session = new TerminalSession(this.spawn(options), () => this.sessions.delete(id), this.gracePeriodMs);
+		this.sessions.set(id, session);
+		return session;
+	}
+};
+function sendError(ws, message) {
+	ws.send(JSON.stringify({
+		type: "error",
+		message
+	}));
 }
 /**
 * Registers the interactive-terminal WebSocket route at `/api/terminal`.
 *
-* The client connects with `taskId` and `stepId` query params identifying a
-* setup step; the server resolves the actual command from its own registry
-* (never from the request body) and, once the client signals `start`, spawns it
-* in a PTY rooted at the project. Output is streamed to the client and the
-* client's keystrokes are written to the process, so prompts (e.g. npm's
-* "Ok to proceed?") work. The trust boundary mirrors the step-execute route:
-* the client can only ask to run a step that already exists server-side.
+* The client connects with `taskId`, `stepId`, and a client-generated
+* `sessionId` query param. The server resolves the actual command from its own
+* registry (never from the request body). On the first connection for a session
+* the client signals `start` and the server spawns the command in a PTY rooted
+* at the project; output is streamed to the client and the client's keystrokes
+* are written to the process, so prompts (e.g. npm's "Ok to proceed?") work.
+*
+* Sessions live in `sessions`, which outlives this server instance, so when the
+* server restarts itself after a config file appears the PTY keeps running and a
+* reconnecting client (same `sessionId`) re-attaches and replays the gap.
+*
+* The trust boundary mirrors the step-execute route: the client can only ask to
+* run a step that already exists server-side.
 */
-function registerTerminalRoute(app, upgradeWebSocket, rootPath) {
+function registerTerminalRoute(app, upgradeWebSocket, rootPath, sessions) {
 	app.get("/api/terminal", upgradeWebSocket((c) => {
 		const taskId = c.req.query("taskId");
 		const stepId = c.req.query("stepId");
-		let child;
-		const start = (ws, cols, rows) => {
-			if (child) return;
-			const command = taskId && stepId ? resolveTerminalCommand(taskId, stepId) : null;
-			if (!command) {
-				send(ws, {
-					type: "error",
-					message: "Unknown or non-runnable setup step."
-				});
-				ws.close();
-				return;
-			}
-			child = pty.spawn(SHELL, shellCommandArgs(command), {
-				name: "xterm-color",
-				cols: cols || 80,
-				rows: rows || 24,
-				cwd: rootPath,
-				env: process.env
-			});
-			child.onData((data) => send(ws, {
-				type: "data",
-				data
-			}));
-			child.onExit(({ exitCode }) => {
-				send(ws, {
-					type: "exit",
-					code: exitCode
-				});
-				ws.close();
-			});
-		};
+		const sessionId = c.req.query("sessionId") ?? `${taskId}:${stepId}`;
+		let session;
+		let leaving = false;
 		return {
+			onOpen(_evt, ws) {
+				const existing = sessions.get(sessionId);
+				if (existing) {
+					session = existing;
+					existing.attach(ws);
+				}
+			},
 			onMessage(evt, ws) {
 				let msg;
 				try {
@@ -523,20 +739,38 @@ function registerTerminalRoute(app, upgradeWebSocket, rootPath) {
 					return;
 				}
 				switch (msg.type) {
-					case "start":
-						start(ws, msg.cols, msg.rows);
+					case "start": {
+						if (session) return;
+						const command = taskId && stepId ? resolveTerminalCommand(taskId, stepId) : null;
+						if (!command) {
+							sendError(ws, "Unknown or non-runnable setup step.");
+							ws.close();
+							return;
+						}
+						session = sessions.create(sessionId, {
+							command,
+							cols: msg.cols,
+							rows: msg.rows,
+							cwd: rootPath,
+							env: process.env
+						});
+						session.attach(ws);
 						break;
+					}
 					case "input":
-						child?.write(msg.data);
+						session?.write(msg.data);
 						break;
 					case "resize":
-						child?.resize(msg.cols || 80, msg.rows || 24);
+						session?.resize(msg.cols || 80, msg.rows || 24);
+						break;
+					case "detach":
+						leaving = true;
+						session?.kill();
 						break;
 				}
 			},
 			onClose() {
-				child?.kill();
-				child = void 0;
+				if (!leaving) session?.detach();
 			}
 		};
 	}));
@@ -544,7 +778,7 @@ function registerTerminalRoute(app, upgradeWebSocket, rootPath) {
 //#endregion
 //#region src/server/index.ts
 async function startServer(options) {
-	const { promptProviders, traceProviders, port, rootPath, hasConfig } = options;
+	const { promptProviders, traceProviders, port, rootPath, hasConfig, terminalSessions } = options;
 	const promptProviderMap = new Map(promptProviders.map((p) => [p.id, p]));
 	const traceProviderMap = new Map(traceProviders.map((p) => [p.id, p]));
 	const promptRegistry = new PromptRegistry();
@@ -577,7 +811,7 @@ async function startServer(options) {
 			executeStep: executeSetupStep
 		}
 	});
-	registerTerminalRoute(app, upgradeWebSocket, rootPath);
+	registerTerminalRoute(app, upgradeWebSocket, rootPath, terminalSessions);
 	const clientRoot = fileURLToPath(new URL("../client/", import.meta.url));
 	app.get("*", serveStatic({ root: clientRoot }));
 	for (const [providerId, provider] of promptProviderMap) if (provider.watch) provider.watch(async (event) => {
@@ -613,6 +847,7 @@ async function startServer(options) {
 		});
 	});
 	const close = () => new Promise((resolve, reject) => {
+		for (const ws of wss.clients) ws.close();
 		if ("closeAllConnections" in server) server.closeAllConnections();
 		server.close((err) => err ? reject(err) : resolve());
 	});
@@ -836,14 +1071,15 @@ function applyDotenv(rootDir) {
 		if (err?.code !== "ENOENT") console.warn(`Warning: failed to load .env from ${envPath}:`, err.message);
 	}
 }
-function startConfiguredServer(rootDir, config, hasConfig, port) {
+function startConfiguredServer(rootDir, config, hasConfig, port, terminalSessions) {
 	if (config.useDotenv !== false) applyDotenv(rootDir);
 	return startServer({
 		promptProviders: config.promptProviders ?? [],
 		traceProviders: config.traceProviders ?? [new MemoryTraceProvider()],
 		port,
 		rootPath: rootDir,
-		hasConfig
+		hasConfig,
+		terminalSessions
 	});
 }
 async function main() {
@@ -861,11 +1097,12 @@ async function main() {
 	const maybeOpen = (url) => {
 		if (!process.env.EVALUTION_NO_OPEN) openBrowser(url);
 	};
+	const terminalSessions = new TerminalSessionRegistry();
 	if (hasConfig) {
-		maybeOpen((await startConfiguredServer(rootDir, await loadConfig(rootDir), true, port)).url);
+		maybeOpen((await startConfiguredServer(rootDir, await loadConfig(rootDir), true, port, terminalSessions)).url);
 		return;
 	}
-	let server = await startConfiguredServer(rootDir, {}, false, port);
+	let server = await startConfiguredServer(rootDir, {}, false, port, terminalSessions);
 	maybeOpen(server.url);
 	console.log(`👀 No config found; watching ${path.join(rootDir, ".evalution", "config.ts")} for creation...`);
 	const stopWatching = watchForConfigCreation(rootDir, async () => {
@@ -873,7 +1110,7 @@ async function main() {
 		console.log("⚙️ Config loaded; restarting server...");
 		stopWatching();
 		await server.close();
-		server = await startConfiguredServer(rootDir, config, true, port);
+		server = await startConfiguredServer(rootDir, config, true, port, terminalSessions);
 	});
 }
 main().catch((error) => {