loopable-cli 0.1.0

package/.output/server/_ssr/agents-Btql102J.mjs

@@ -0,0 +1,657 @@
+import { f as eq } from "../_libs/drizzle-orm.mjs";
+import { n as agentSettings, r as appSettings, s as db } from "./client-CKkOfh-s.mjs";
+import { n as isHosted } from "./secrets-Hqti-niS.mjs";
+import { accessSync, constants, createWriteStream, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+//#region node_modules/.nitro/vite/services/ssr/assets/agents-Btql102J.js
+function defineAgentManifest(manifest) {
+	return manifest;
+}
+function defineAgentRuntime(runtime) {
+	return runtime;
+}
+var codexManifest = defineAgentManifest({
+	id: "codex",
+	name: "Codex",
+	tagline: "OpenAI's coding agent, driven non-interactively through codex exec.",
+	docsUrl: "https://developers.openai.com/codex/cli",
+	icon: "Terminal",
+	accent: "bg-neutral-900 text-white",
+	binaries: ["codex"],
+	installHint: "Install with npm i -g @openai/codex, then run codex login.",
+	permissionModes: ["read_only", "workspace_write"],
+	supportsModel: true,
+	modelPlaceholder: "leave empty for the Codex default",
+	defaults: {
+		permissionMode: "read_only",
+		model: null,
+		timeoutMs: 3e5
+	}
+});
+var cursorAgentManifest = defineAgentManifest({
+	id: "cursor-agent",
+	name: "Cursor Agent",
+	tagline: "Cursor's CLI agent, driven through its print mode.",
+	docsUrl: "https://cursor.com/docs/cli",
+	icon: "MousePointerClick",
+	accent: "bg-blue-600 text-white",
+	binaries: ["cursor-agent"],
+	installHint: "Install with curl https://cursor.com/install -fsS | bash, then run cursor-agent login.",
+	permissionModes: ["read_only", "workspace_write"],
+	supportsModel: true,
+	modelPlaceholder: "e.g. gpt-5 or sonnet-4.5",
+	defaults: {
+		permissionMode: "read_only",
+		model: null,
+		timeoutMs: 3e5
+	}
+});
+/** Client-safe registry, listing only agents whose invocation we have verified. */
+var AGENT_MANIFESTS = [codexManifest, cursorAgentManifest];
+function agentManifest(id) {
+	return AGENT_MANIFESTS.find((manifest) => manifest.id === id);
+}
+var exec = promisify(execFile);
+var HOME_DIRS = [
+	".local/bin",
+	".bun/bin",
+	".cargo/bin",
+	".volta/bin",
+	".deno/bin"
+];
+var SYSTEM_DIRS = [
+	"/opt/homebrew/bin",
+	"/usr/local/bin",
+	"/usr/bin",
+	"/bin"
+];
+function unique(values) {
+	return [...new Set(values.filter(Boolean))];
+}
+function inheritedDirs() {
+	const home = homedir();
+	return unique([
+		...(process.env.PATH ?? "").split(":"),
+		...HOME_DIRS.map((dir) => join(home, dir)),
+		...SYSTEM_DIRS
+	]);
+}
+var loginDirs = null;
+/**
+* A packaged app or a launchd job inherits a minimal PATH, so agents installed
+* under a shell-managed directory would look missing. Asking the login shell is
+* the fallback, and it only happens when the usual places come up empty.
+*/
+async function loginShellDirs() {
+	if (loginDirs) return loginDirs;
+	try {
+		const { stdout } = await exec(process.env.SHELL ?? "/bin/zsh", ["-lc", "printf %s \"$PATH\""], { timeout: 5e3 });
+		loginDirs = unique(stdout.split(":"));
+	} catch {
+		loginDirs = [];
+	}
+	return loginDirs;
+}
+function executableIn(dirs, names) {
+	for (const dir of dirs) for (const name of names) {
+		const candidate = join(dir, name);
+		try {
+			accessSync(candidate, constants.X_OK);
+			return candidate;
+		} catch {}
+	}
+	return null;
+}
+async function resolveBinary(names) {
+	return executableIn(inheritedDirs(), names) ?? executableIn(await loginShellDirs(), names);
+}
+var ANSI = /\u001B\[[0-9;]*[A-Za-z]/g;
+function clean(text) {
+	return text.replace(ANSI, "").trim();
+}
+/** Runs a short informational command such as --version or a status check. */
+async function probe(bin, args, timeoutMs = 1e4) {
+	try {
+		const { stdout, stderr } = await exec(bin, args, { timeout: timeoutMs });
+		return {
+			ok: true,
+			text: clean(stdout) || clean(stderr)
+		};
+	} catch (error) {
+		const failure = error;
+		return {
+			ok: false,
+			text: clean(failure.stdout ?? "") || clean(failure.stderr ?? "") || (failure.message ?? "failed")
+		};
+	}
+}
+function firstLine(text) {
+	return clean(text).split("\n")[0]?.trim() ?? "";
+}
+/**
+* Loopable's own credentials never reach an agent process. The agent keeps its
+* own model credentials, which is why this is a denylist rather than an
+* allowlist: CURSOR_API_KEY and friends have to survive.
+*/
+var WITHHELD = [
+	/^GITHUB_/,
+	/^GH_/,
+	/^LOOPABLE_/
+];
+function agentEnvironment() {
+	const env = {};
+	for (const [key, value] of Object.entries(process.env)) {
+		if (WITHHELD.some((pattern) => pattern.test(key))) continue;
+		env[key] = value;
+	}
+	return env;
+}
+/**
+* A negative pid means the process group. Failing is normal here: the group
+* is usually already gone, which is exactly what we wanted.
+*/
+function signalGroup(pid, signal) {
+	if (pid === void 0) return;
+	try {
+		process.kill(-pid, signal);
+	} catch {
+		try {
+			process.kill(pid, signal);
+		} catch {}
+	}
+}
+/**
+* An agent that waits for input would otherwise hang a loop forever, so stdin
+* is closed immediately and the timeout is enforced by us rather than trusted
+* to the tool.
+*/
+function runProcess(input) {
+	return new Promise((resolve) => {
+		const started = Date.now();
+		if (input.signal?.aborted) {
+			resolve({
+				code: null,
+				stdout: "",
+				stderr: "",
+				timedOut: false,
+				aborted: true,
+				durationMs: 0
+			});
+			return;
+		}
+		const child = spawn(input.bin, input.args, {
+			cwd: input.cwd,
+			env: agentEnvironment(),
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			detached: true
+		});
+		let stdout = "";
+		let stderr = "";
+		let timedOut = false;
+		let aborted = false;
+		/** Ask the whole group first, insist shortly after. */
+		const halt = () => {
+			signalGroup(child.pid, "SIGTERM");
+			setTimeout(() => signalGroup(child.pid, "SIGKILL"), 3e3).unref();
+		};
+		const timer = setTimeout(() => {
+			timedOut = true;
+			halt();
+		}, input.timeoutMs);
+		const onAbort = () => {
+			aborted = true;
+			halt();
+		};
+		input.signal?.addEventListener("abort", onAbort);
+		const logFile = input.logPath ? createWriteStream(input.logPath, { flags: "a" }) : null;
+		logFile?.on("error", () => {});
+		/**
+		* A chunk is not a line, so each stream keeps its own remainder. Sharing
+		* one buffer would splice half a line of stderr into the middle of stdout.
+		*/
+		const lineWriter = () => {
+			let pending = "";
+			const emit = (line) => {
+				const text = input.logLine ? input.logLine(line) : line;
+				if (text !== null && text !== "") logFile?.write(`${text}\n`);
+			};
+			return {
+				take(chunk) {
+					if (!logFile) return;
+					pending += chunk;
+					const lines = pending.split("\n");
+					pending = lines.pop() ?? "";
+					for (const line of lines) emit(line);
+				},
+				flush() {
+					if (logFile && pending !== "") emit(pending);
+					pending = "";
+				}
+			};
+		};
+		const outLines = lineWriter();
+		const errLines = lineWriter();
+		child.stdout.on("data", (chunk) => {
+			const text = chunk.toString();
+			stdout += text;
+			outLines.take(text);
+		});
+		child.stderr.on("data", (chunk) => {
+			const text = chunk.toString();
+			stderr += text;
+			errLines.take(text);
+		});
+		const finish = (code, failure) => {
+			clearTimeout(timer);
+			input.signal?.removeEventListener("abort", onAbort);
+			outLines.flush();
+			errLines.flush();
+			if (failure) logFile?.write(`\n${failure}\n`);
+			logFile?.end();
+			resolve({
+				code,
+				stdout: clean(stdout),
+				stderr: clean(failure ? `${stderr}\n${failure}` : stderr),
+				timedOut,
+				aborted,
+				durationMs: Date.now() - started
+			});
+		};
+		child.on("error", (error) => finish(null, error.message));
+		child.on("close", (code) => finish(code));
+	});
+}
+async function binary$1() {
+	const found = await resolveBinary(codexManifest.binaries);
+	if (!found) throw new Error("The codex binary was not found on this host.");
+	return found;
+}
+function args$1(input) {
+	const list = [
+		"exec",
+		"--sandbox",
+		input.settings.permissionMode === "read_only" ? "read-only" : "workspace-write",
+		"--skip-git-repo-check",
+		"--ephemeral",
+		"--color",
+		"never",
+		"-C",
+		input.cwd
+	];
+	if (input.settings.model) list.push("-m", input.settings.model);
+	if (input.outputFile) list.push("-o", input.outputFile);
+	list.push(input.prompt);
+	return list;
+}
+var codexRuntime = defineAgentRuntime({
+	async detect() {
+		const found = await resolveBinary(codexManifest.binaries);
+		if (!found) return { installed: false };
+		return {
+			installed: true,
+			binaryPath: found,
+			version: firstLine((await probe(found, ["--version"])).text)
+		};
+	},
+	async authStatus() {
+		const found = await resolveBinary(codexManifest.binaries);
+		if (!found) return {
+			signedIn: false,
+			detail: "Not installed."
+		};
+		const result = await probe(found, ["login", "status"]);
+		return {
+			signedIn: result.ok,
+			detail: firstLine(result.text) || (result.ok ? "Signed in." : "Run codex login.")
+		};
+	},
+	invocation(input) {
+		return {
+			bin: codexManifest.binaries[0],
+			args: args$1(input)
+		};
+	},
+	async run(input) {
+		const bin = await binary$1();
+		const argv = args$1(input);
+		const command = `${bin} ${argv.join(" ")}`;
+		const outcome = await runProcess({
+			bin,
+			args: argv,
+			cwd: input.cwd,
+			timeoutMs: input.settings.timeoutMs,
+			signal: input.signal,
+			logPath: input.logFile
+		});
+		let output = "";
+		if (input.outputFile) try {
+			output = readFileSync(input.outputFile, "utf8").trim();
+			rmSync(input.outputFile, { force: true });
+		} catch {
+			output = "";
+		}
+		if (!output) output = outcome.stdout;
+		if (outcome.aborted) return {
+			ok: false,
+			aborted: true,
+			output,
+			durationMs: outcome.durationMs,
+			command
+		};
+		if (outcome.timedOut) return {
+			ok: false,
+			output,
+			detail: `Codex did not finish within ${Math.round(input.settings.timeoutMs / 1e3)}s.`,
+			durationMs: outcome.durationMs,
+			command
+		};
+		return {
+			ok: outcome.code === 0,
+			output,
+			detail: outcome.code === 0 ? void 0 : outcome.stderr || `Exited with code ${outcome.code}.`,
+			durationMs: outcome.durationMs,
+			command
+		};
+	}
+});
+function parse(line) {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("{")) return null;
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		return null;
+	}
+}
+function textOf(event) {
+	return (event.message?.content ?? []).filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+}
+/** `readToolCall` with a path becomes `read <path>`. */
+function describeTool(call, cwd) {
+	const [name, body] = Object.entries(call ?? {})[0] ?? [];
+	if (!name) return "a tool";
+	const verb = name.replace(/ToolCall$/, "").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+	const args = body?.args ?? {};
+	const subject = args.path ?? args.command ?? args.query ?? args.pattern;
+	if (typeof subject !== "string") return verb;
+	return `${verb} ${cwd && subject.startsWith(`${cwd}/`) ? subject.slice(cwd.length + 1) : subject}`;
+}
+/**
+* One readable line for the log, or nothing when the event says nothing a
+* person would want to read. Partial answer deltas are dropped: the whole
+* answer arrives at the end, and showing both would print it twice.
+*/
+function describeEvent(line, cwd) {
+	const event = parse(line);
+	if (!event) return line.trim() === "" ? null : line;
+	switch (event.type) {
+		case "system": return event.model ? `Started with ${event.model}.` : "Started.";
+		case "tool_call": return event.subtype === "started" ? `Running ${describeTool(event.tool_call, cwd)}` : null;
+		case "assistant": return null;
+		case "result": {
+			const seconds = event.duration_ms ? (event.duration_ms / 1e3).toFixed(0) : "?";
+			const tokens = event.usage?.outputTokens;
+			const spent = tokens === void 0 ? "" : `, ${tokens} tokens out`;
+			return event.is_error ? `Failed after ${seconds}s${spent}.` : `Answered after ${seconds}s${spent}.`;
+		}
+		default: return null;
+	}
+}
+/**
+* The answer, which is the agent's last message and not everything it said.
+*
+* The result event looks like the obvious source and is the wrong one: it
+* concatenates every word of the run, so an answer taken from there begins
+* "I'll start by reading the two files" and that is what gets posted. Each
+* block of speech is streamed in stamped pieces and then repeated whole and
+* unstamped, so the last unstamped one is the answer and the earlier ones are
+* the agent thinking out loud between tools.
+*/
+function answerFrom(stdout) {
+	const events = stdout.split("\n").map(parse);
+	const result = events.filter((event) => event?.type === "result").at(-1);
+	const failed = result?.is_error === true;
+	const whole = events.findLastIndex((event) => event?.type === "assistant" && event.timestamp_ms === void 0);
+	if (whole >= 0) return {
+		text: textOf(events[whole]).trim(),
+		failed
+	};
+	const lastTool = events.findLastIndex((event) => event?.type === "tool_call");
+	const partial = events.slice(lastTool + 1).filter((event) => event?.type === "assistant").map((event) => textOf(event));
+	if (partial.length > 0) return {
+		text: partial.join("").trim(),
+		failed
+	};
+	return {
+		text: (result?.result ?? "").trim(),
+		failed
+	};
+}
+async function binary() {
+	const found = await resolveBinary(cursorAgentManifest.binaries);
+	if (!found) throw new Error("The cursor-agent binary was not found on this host.");
+	return found;
+}
+function args(input) {
+	const list = [
+		"-p",
+		"--output-format",
+		"stream-json",
+		"--stream-partial-output",
+		"--workspace",
+		input.cwd,
+		"--trust"
+	];
+	if (input.settings.permissionMode === "read_only") list.push("--mode", "ask");
+	else list.push("--force");
+	if (input.settings.model) list.push("--model", input.settings.model);
+	list.push(input.prompt);
+	return list;
+}
+/** Server-only registry. Never import this from a component. */
+var RUNTIMES = {
+	codex: codexRuntime,
+	"cursor-agent": defineAgentRuntime({
+		async detect() {
+			const found = await resolveBinary(cursorAgentManifest.binaries);
+			if (!found) return { installed: false };
+			return {
+				installed: true,
+				binaryPath: found,
+				version: firstLine((await probe(found, ["--version"])).text)
+			};
+		},
+		async authStatus() {
+			const found = await resolveBinary(cursorAgentManifest.binaries);
+			if (!found) return {
+				signedIn: false,
+				detail: "Not installed."
+			};
+			const result = await probe(found, ["status"]);
+			const detail = firstLine(result.text);
+			return {
+				signedIn: result.ok && !/not logged in|logged out/i.test(detail),
+				detail: detail || (result.ok ? "Signed in." : "Run cursor-agent login.")
+			};
+		},
+		invocation(input) {
+			return {
+				bin: cursorAgentManifest.binaries[0],
+				args: args(input)
+			};
+		},
+		async run(input) {
+			const bin = await binary();
+			const argv = args(input);
+			const outcome = await runProcess({
+				bin,
+				args: argv,
+				cwd: input.cwd,
+				timeoutMs: input.settings.timeoutMs,
+				signal: input.signal,
+				logPath: input.logFile,
+				logLine: (line) => describeEvent(line, input.cwd)
+			});
+			const command = `${bin} ${argv.join(" ")}`;
+			const answer = answerFrom(outcome.stdout);
+			if (outcome.aborted) return {
+				ok: false,
+				aborted: true,
+				output: answer.text,
+				durationMs: outcome.durationMs,
+				command
+			};
+			if (outcome.timedOut) return {
+				ok: false,
+				output: answer.text,
+				detail: `Cursor Agent did not finish within ${Math.round(input.settings.timeoutMs / 1e3)}s.`,
+				durationMs: outcome.durationMs,
+				command
+			};
+			return {
+				ok: outcome.code === 0 && !answer.failed,
+				output: answer.text,
+				detail: outcome.code === 0 && !answer.failed ? void 0 : answer.failed ? answer.text || "The agent reported an error." : outcome.stderr || `Exited with code ${outcome.code}.`,
+				durationMs: outcome.durationMs,
+				command
+			};
+		}
+	})
+};
+function agentRuntime(id) {
+	const runtime = RUNTIMES[id];
+	if (!runtime) throw new Error(`Unknown agent: ${id}`);
+	return runtime;
+}
+var DEFAULT_AGENT_KEY = "defaultAgentId";
+async function storedSetting(key) {
+	const row = await db().select().from(appSettings).where(eq(appSettings.key, key)).get();
+	return typeof row?.value === "string" ? row.value : null;
+}
+async function settingsFor(agentId) {
+	const manifest = agentManifest(agentId);
+	if (!manifest) throw new Error(`Unknown agent: ${agentId}`);
+	const row = await db().select().from(agentSettings).where(eq(agentSettings.agentId, agentId)).get();
+	if (!row) return manifest.defaults;
+	return {
+		permissionMode: row.permissionMode,
+		model: row.model,
+		timeoutMs: row.timeoutMs
+	};
+}
+/**
+* Detection, authorization state and settings for every known agent. Detection
+* runs on every call because installing or removing a CLI should show up
+* without anyone pressing refresh.
+*/
+async function listAgents() {
+	const chosen = await storedSetting(DEFAULT_AGENT_KEY);
+	const hosted = isHosted();
+	return (await Promise.all(AGENT_MANIFESTS.map(async (manifest) => {
+		const runtime = agentRuntime(manifest.id);
+		const settings = await settingsFor(manifest.id);
+		const preview = runtime.invocation({
+			prompt: "<prompt>",
+			cwd: "<workspace>",
+			settings
+		});
+		if (hosted) return {
+			agentId: manifest.id,
+			installed: false,
+			binaryPath: "",
+			version: null,
+			auth: null,
+			settings,
+			isDefault: false,
+			defaultIsImplicit: false,
+			commandPreview: `${preview.bin} ${preview.args.join(" ")}`,
+			onRunners: []
+		};
+		const detection = await runtime.detect();
+		const auth = detection.installed ? await runtime.authStatus() : null;
+		return {
+			agentId: manifest.id,
+			installed: detection.installed,
+			binaryPath: detection.installed ? detection.binaryPath : null,
+			version: detection.installed ? detection.version : null,
+			auth,
+			settings,
+			isDefault: false,
+			defaultIsImplicit: false,
+			commandPreview: `${preview.bin} ${preview.args.join(" ")}`,
+			onRunners: []
+		};
+	}))).map((view) => view.agentId === chosen ? {
+		...view,
+		isDefault: true,
+		defaultIsImplicit: false
+	} : view);
+}
+async function saveAgentSettings(agentId, values) {
+	const manifest = agentManifest(agentId);
+	if (!manifest) throw new Error(`Unknown agent: ${agentId}`);
+	if (!manifest.permissionModes.includes(values.permissionMode)) throw new Error(`${manifest.name} cannot run in ${values.permissionMode} mode.`);
+	if (values.timeoutMs < 1e4 || values.timeoutMs > 36e5) throw new Error("The timeout must be between 10 seconds and one hour.");
+	const model = values.model?.trim() ? values.model.trim() : null;
+	await db().insert(agentSettings).values({
+		agentId,
+		permissionMode: values.permissionMode,
+		model,
+		timeoutMs: values.timeoutMs
+	}).onConflictDoUpdate({
+		target: agentSettings.agentId,
+		set: {
+			permissionMode: values.permissionMode,
+			model,
+			timeoutMs: values.timeoutMs,
+			updatedAt: /* @__PURE__ */ new Date()
+		}
+	}).run();
+}
+async function setDefaultAgent(agentId) {
+	if (!agentManifest(agentId)) throw new Error(`Unknown agent: ${agentId}`);
+	await db().insert(appSettings).values({
+		key: DEFAULT_AGENT_KEY,
+		value: agentId
+	}).onConflictDoUpdate({
+		target: appSettings.key,
+		set: {
+			value: agentId,
+			updatedAt: /* @__PURE__ */ new Date()
+		}
+	}).run();
+}
+var TEST_WORD = "loopable-ok";
+/**
+* A real run, because a version check cannot tell you whether the agent can
+* reach a model. It stays deliberately tiny: read one file, say one word.
+*/
+async function testAgent(agentId) {
+	if (isHosted()) throw new Error("Test an agent on a runner.");
+	const runtime = agentRuntime(agentId);
+	const settings = await settingsFor(agentId);
+	const cwd = mkdtempSync(join(tmpdir(), "loopable-agent-test-"));
+	writeFileSync(join(cwd, "NOTE.md"), `${TEST_WORD}\n`);
+	const result = await runtime.run({
+		prompt: "Read NOTE.md in your working directory and reply with only the word it contains.",
+		cwd,
+		outputFile: join(cwd, "last-message.txt"),
+		settings: {
+			...settings,
+			timeoutMs: Math.min(settings.timeoutMs, 12e4)
+		}
+	});
+	return {
+		...result,
+		passed: result.ok && result.output.includes(TEST_WORD)
+	};
+}
+//#endregion
+export { setDefaultAgent as a, saveAgentSettings as i, agentManifest as n, settingsFor as o, listAgents as r, testAgent as s, AGENT_MANIFESTS as t };