agent-worker 0.1.0

package/dist/backends-BklSbwcH.mjs

@@ -0,0 +1,381 @@
+import { i as createModelAsync, r as createModel } from "./models-FOOpWB91.mjs";
+import { generateText } from "ai";
+import { spawn } from "node:child_process";
+
+//#region src/backends/claude-cli.ts
+/**
+* Claude Code CLI backend
+* Uses `claude -p` for non-interactive mode
+*
+* @see https://code.claude.com/docs/en/headless
+*/
+var ClaudeCliBackend = class {
+	type = "claude";
+	options;
+	constructor(options = {}) {
+		this.options = options;
+	}
+	async send(message, options) {
+		const args = this.buildArgs(message, options);
+		return new Promise((resolve, reject) => {
+			const proc = spawn("claude", args, {
+				cwd: this.options.cwd,
+				env: process.env
+			});
+			let stdout = "";
+			let stderr = "";
+			proc.stdout.on("data", (data) => {
+				stdout += data.toString();
+			});
+			proc.stderr.on("data", (data) => {
+				stderr += data.toString();
+			});
+			proc.on("close", (code) => {
+				if (code !== 0) {
+					reject(/* @__PURE__ */ new Error(`claude exited with code ${code}: ${stderr}`));
+					return;
+				}
+				if (this.options.outputFormat === "json") try {
+					const parsed = JSON.parse(stdout);
+					resolve({
+						content: parsed.content || parsed.result || stdout,
+						toolCalls: parsed.toolCalls,
+						usage: parsed.usage
+					});
+				} catch {
+					resolve({ content: stdout.trim() });
+				}
+				else resolve({ content: stdout.trim() });
+			});
+			proc.on("error", (err) => {
+				reject(/* @__PURE__ */ new Error(`Failed to spawn claude: ${err.message}`));
+			});
+		});
+	}
+	async isAvailable() {
+		return new Promise((resolve) => {
+			const proc = spawn("claude", ["--version"], { stdio: "pipe" });
+			proc.on("close", (code) => resolve(code === 0));
+			proc.on("error", () => resolve(false));
+		});
+	}
+	getInfo() {
+		return {
+			name: "Claude Code CLI",
+			model: this.options.model
+		};
+	}
+	buildArgs(message, options) {
+		const args = ["-p", message];
+		if (this.options.model) args.push("--model", this.options.model);
+		if (options?.system || this.options.appendSystemPrompt) {
+			const system = options?.system || this.options.appendSystemPrompt;
+			args.push("--append-system-prompt", system);
+		}
+		if (this.options.allowedTools?.length) args.push("--allowed-tools", this.options.allowedTools.join(","));
+		if (this.options.outputFormat) args.push("--output-format", this.options.outputFormat);
+		if (this.options.continue) args.push("--continue");
+		if (this.options.resume) args.push("--resume", this.options.resume);
+		return args;
+	}
+};
+
+//#endregion
+//#region src/backends/codex-cli.ts
+/**
+* OpenAI Codex CLI backend
+* Uses `codex exec` for non-interactive mode
+*
+* @see https://developers.openai.com/codex/noninteractive/
+*/
+var CodexCliBackend = class {
+	type = "codex";
+	options;
+	constructor(options = {}) {
+		this.options = options;
+	}
+	async send(message, _options) {
+		const args = this.buildArgs(message);
+		return new Promise((resolve, reject) => {
+			const proc = spawn("codex", args, {
+				cwd: this.options.cwd,
+				env: process.env
+			});
+			let stdout = "";
+			let stderr = "";
+			proc.stdout.on("data", (data) => {
+				stdout += data.toString();
+			});
+			proc.stderr.on("data", (data) => {
+				stderr += data.toString();
+			});
+			proc.on("close", (code) => {
+				if (code !== 0) {
+					reject(/* @__PURE__ */ new Error(`codex exited with code ${code}: ${stderr}`));
+					return;
+				}
+				if (this.options.json) try {
+					const lines = stdout.trim().split("\n");
+					const lastEvent = JSON.parse(lines[lines.length - 1]);
+					resolve({
+						content: lastEvent.message || lastEvent.content || stdout,
+						toolCalls: lastEvent.toolCalls,
+						usage: lastEvent.usage
+					});
+				} catch {
+					resolve({ content: stdout.trim() });
+				}
+				else resolve({ content: stdout.trim() });
+			});
+			proc.on("error", (err) => {
+				reject(/* @__PURE__ */ new Error(`Failed to spawn codex: ${err.message}`));
+			});
+		});
+	}
+	async isAvailable() {
+		return new Promise((resolve) => {
+			const proc = spawn("codex", ["--version"], { stdio: "pipe" });
+			proc.on("close", (code) => resolve(code === 0));
+			proc.on("error", () => resolve(false));
+		});
+	}
+	getInfo() {
+		return {
+			name: "OpenAI Codex CLI",
+			model: this.options.model
+		};
+	}
+	buildArgs(message) {
+		const args = ["exec", message];
+		if (this.options.model) args.push("--model", this.options.model);
+		if (this.options.json) args.push("--json");
+		if (this.options.skipGitRepoCheck) args.push("--skip-git-repo-check");
+		if (this.options.approvalMode) args.push("--approval-mode", this.options.approvalMode);
+		if (this.options.resume) args.push("--resume", this.options.resume);
+		return args;
+	}
+};
+
+//#endregion
+//#region src/backends/cursor-cli.ts
+/**
+* Cursor CLI backend
+* Uses `cursor-agent -p` or `agent chat` for non-interactive mode
+*
+* @see https://cursor.com/docs/cli/headless
+*/
+var CursorCliBackend = class {
+	type = "cursor";
+	options;
+	constructor(options = {}) {
+		this.options = {
+			timeout: 12e4,
+			...options
+		};
+	}
+	async send(message, _options) {
+		const { command, args } = this.buildCommand(message);
+		return new Promise((resolve, reject) => {
+			const proc = spawn(command, args, {
+				cwd: this.options.cwd,
+				env: process.env
+			});
+			let stdout = "";
+			let stderr = "";
+			let timedOut = false;
+			const timer = setTimeout(() => {
+				timedOut = true;
+				proc.kill("SIGTERM");
+			}, this.options.timeout);
+			proc.stdout.on("data", (data) => {
+				stdout += data.toString();
+			});
+			proc.stderr.on("data", (data) => {
+				stderr += data.toString();
+			});
+			proc.on("close", (code) => {
+				clearTimeout(timer);
+				if (timedOut) {
+					reject(/* @__PURE__ */ new Error(`cursor-agent timed out after ${this.options.timeout}ms`));
+					return;
+				}
+				if (code !== 0 && code !== null) {
+					reject(/* @__PURE__ */ new Error(`cursor-agent exited with code ${code}: ${stderr}`));
+					return;
+				}
+				resolve({ content: stdout.trim() });
+			});
+			proc.on("error", (err) => {
+				clearTimeout(timer);
+				reject(/* @__PURE__ */ new Error(`Failed to spawn cursor-agent: ${err.message}`));
+			});
+		});
+	}
+	async isAvailable() {
+		for (const cmd of ["cursor-agent", "agent"]) if (await this.checkCommand(cmd)) return true;
+		return false;
+	}
+	async checkCommand(command) {
+		return new Promise((resolve) => {
+			const proc = spawn(command, ["--version"], { stdio: "pipe" });
+			const timer = setTimeout(() => {
+				proc.kill();
+				resolve(false);
+			}, 5e3);
+			proc.on("close", (code) => {
+				clearTimeout(timer);
+				resolve(code === 0);
+			});
+			proc.on("error", () => {
+				clearTimeout(timer);
+				resolve(false);
+			});
+		});
+	}
+	getInfo() {
+		return {
+			name: "Cursor Agent CLI",
+			model: this.options.model
+		};
+	}
+	buildCommand(message) {
+		if (this.options.useAgentCommand) return {
+			command: "agent",
+			args: ["chat", message]
+		};
+		const args = ["-p", message];
+		if (this.options.model) args.push("--model", this.options.model);
+		return {
+			command: "cursor-agent",
+			args
+		};
+	}
+};
+
+//#endregion
+//#region src/backends/sdk.ts
+/**
+* Vercel AI SDK backend
+* Uses the AI SDK for direct API access
+*/
+var SdkBackend = class {
+	type = "sdk";
+	modelId;
+	model = null;
+	maxTokens;
+	constructor(options) {
+		this.modelId = options.model;
+		this.maxTokens = options.maxTokens ?? 4096;
+		try {
+			this.model = createModel(this.modelId);
+		} catch {}
+	}
+	async send(message, options) {
+		if (!this.model) this.model = await createModelAsync(this.modelId);
+		const result = await generateText({
+			model: this.model,
+			system: options?.system,
+			prompt: message,
+			maxTokens: this.maxTokens
+		});
+		return {
+			content: result.text,
+			usage: {
+				input: result.usage.promptTokens,
+				output: result.usage.completionTokens,
+				total: result.usage.totalTokens
+			}
+		};
+	}
+	async isAvailable() {
+		try {
+			if (!this.model) this.model = await createModelAsync(this.modelId);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	getInfo() {
+		return {
+			name: "Vercel AI SDK",
+			model: this.modelId
+		};
+	}
+};
+
+//#endregion
+//#region src/backends/index.ts
+/**
+* Create a backend instance
+*/
+function createBackend(config) {
+	switch (config.type) {
+		case "sdk": return new SdkBackend({
+			model: config.model,
+			maxTokens: config.maxTokens
+		});
+		case "claude": return new ClaudeCliBackend({
+			...config.options,
+			model: config.model
+		});
+		case "codex": return new CodexCliBackend({
+			...config.options,
+			model: config.model
+		});
+		case "cursor": return new CursorCliBackend({
+			...config.options,
+			model: config.model
+		});
+		default: throw new Error(`Unknown backend type: ${config.type}`);
+	}
+}
+/**
+* Check which backends are available
+*/
+async function checkBackends() {
+	const claude = new ClaudeCliBackend();
+	const codex = new CodexCliBackend();
+	const cursor = new CursorCliBackend();
+	const [claudeAvailable, codexAvailable, cursorAvailable] = await Promise.all([
+		claude.isAvailable(),
+		codex.isAvailable(),
+		cursor.isAvailable()
+	]);
+	return {
+		sdk: true,
+		claude: claudeAvailable,
+		codex: codexAvailable,
+		cursor: cursorAvailable
+	};
+}
+/**
+* List available backends with info
+*/
+async function listBackends() {
+	const availability = await checkBackends();
+	return [
+		{
+			type: "sdk",
+			available: availability.sdk,
+			name: "Vercel AI SDK"
+		},
+		{
+			type: "claude",
+			available: availability.claude,
+			name: "Claude Code CLI"
+		},
+		{
+			type: "codex",
+			available: availability.codex,
+			name: "OpenAI Codex CLI"
+		},
+		{
+			type: "cursor",
+			available: availability.cursor,
+			name: "Cursor Agent CLI"
+		}
+	];
+}
+
+//#endregion
+export { CursorCliBackend as a, SdkBackend as i, createBackend as n, CodexCliBackend as o, listBackends as r, ClaudeCliBackend as s, checkBackends as t };

package/dist/backends-BqaAh6cC.mjs

@@ -0,0 +1,4 @@
+import "./models-FOOpWB91.mjs";
+import { a as CursorCliBackend, i as SdkBackend, n as createBackend, o as CodexCliBackend, r as listBackends, s as ClaudeCliBackend, t as checkBackends } from "./backends-BklSbwcH.mjs";
+
+export { listBackends };

package/dist/cli/index.d.mts

@@ -0,0 +1 @@
+export { };