@anna-ai/cli 0.1.12 → 0.1.14

package/dist/runner-Bral1LFW.js

@@ -0,0 +1,279 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+
+//#region src/executa/runner.ts
+/** Spec describing where the host advertises its capabilities. */
+const HOST_INITIALIZE_PARAMS = {
+	protocolVersion: "2.0",
+	client_capabilities: {
+		sampling: {},
+		agent: {},
+		storage: {}
+	},
+	client_info: {
+		name: "anna-app-cli",
+		version: "executa-dev"
+	}
+};
+var ExecutaRunner = class {
+	proc = null;
+	nextId = 1;
+	pending = new Map();
+	exitWaiters = [];
+	closed = false;
+	/** Resolved by start() after the v2 handshake (or v1 fallback) succeeds. */
+	initialized = null;
+	constructor(opts) {
+		this.opts = opts;
+	}
+	/** Spawn the subprocess and perform the initialize handshake. */
+	async start() {
+		if (this.proc) {
+			if (!this.initialized) throw new Error("executa already starting");
+			return this.initialized;
+		}
+		const [bin, ...args] = this.opts.command;
+		if (!bin) throw new Error("ExecutaRunner: empty command");
+		const env = {
+			...process.env,
+			...this.opts.env
+		};
+		env.ANNA_EXECUTA_DEV = "1";
+		this.proc = spawn(bin, args, {
+			cwd: this.opts.cwd,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			env
+		});
+		const stderrSink = this.opts.onStderr ?? ((l) => process.stderr.write(`[executa] ${l}\n`));
+		createInterface({ input: this.proc.stderr }).on("line", stderrSink);
+		this.proc.on("exit", (code) => {
+			this.closed = true;
+			const waiters = this.exitWaiters.splice(0);
+			for (const w of waiters) w(code);
+			const err = new Error(`executa exited (code=${code ?? "null"})`);
+			for (const p of this.pending.values()) p.reject(err);
+			this.pending.clear();
+		});
+		this.proc.on("error", (e) => {
+			this.closed = true;
+			for (const p of this.pending.values()) p.reject(e);
+			this.pending.clear();
+		});
+		createInterface({ input: this.proc.stdout }).on("line", (line) => {
+			this.handleLine(line, stderrSink);
+		});
+		const initTimeout = this.opts.initTimeoutMs ?? 8e3;
+		try {
+			const raw = await this.callWithTimeout("initialize", HOST_INITIALIZE_PARAMS, initTimeout);
+			const ver = String(raw.protocolVersion ?? "1.0");
+			this.initialized = {
+				protocolVersion: ver === "2.0" ? "2.0" : "1.0",
+				raw
+			};
+		} catch (e) {
+			const rpc = e.rpc;
+			if (rpc && rpc.code === -32601) this.initialized = {
+				protocolVersion: "1.0",
+				raw: {}
+			};
+			else {
+				await this.stop();
+				throw e;
+			}
+		}
+		return this.initialized;
+	}
+	/** Send a JSON-RPC request and await the response. */
+	call(method, params = {}) {
+		if (this.closed || !this.proc) return Promise.reject(new Error("executa not running"));
+		const id = this.nextId++;
+		const env = {
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve, reject) => {
+			this.pending.set(id, {
+				resolve: (v) => resolve(v),
+				reject
+			});
+			this.proc.stdin.write(`${JSON.stringify(env)}\n`);
+		});
+	}
+	/** Convenience: `describe → MANIFEST`. */
+	describe() {
+		return this.call("describe");
+	}
+	/** Convenience: `invoke {tool, arguments}`. */
+	invoke(tool, args) {
+		return this.call("invoke", {
+			tool,
+			arguments: args
+		});
+	}
+	/** Convenience: `health → {status}`. */
+	health() {
+		return this.call("health");
+	}
+	/** Close stdin (graceful EOF shutdown) then SIGTERM after a grace period. */
+	async stop(graceMs = 1500) {
+		if (!this.proc) return;
+		this.closed = true;
+		const p = this.proc;
+		try {
+			p.stdin.end();
+		} catch {}
+		const waitExit = new Promise((resolve) => {
+			this.exitWaiters.push(resolve);
+			if (p.exitCode != null) resolve(p.exitCode);
+		});
+		const timer = new Promise((resolve) => {
+			setTimeout(() => resolve("timeout"), graceMs);
+		});
+		const winner = await Promise.race([waitExit, timer]);
+		if (winner === "timeout") try {
+			p.kill("SIGTERM");
+		} catch {}
+		this.proc = null;
+	}
+	async callWithTimeout(method, params, ms) {
+		const id = this.nextId++;
+		const env = {
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve, reject) => {
+			const to = setTimeout(() => {
+				this.pending.delete(id);
+				reject(new Error(`executa ${method} timed out after ${ms}ms`));
+			}, ms);
+			this.pending.set(id, {
+				resolve: (v) => {
+					clearTimeout(to);
+					resolve(v);
+				},
+				reject: (e) => {
+					clearTimeout(to);
+					reject(e);
+				}
+			});
+			this.proc.stdin.write(`${JSON.stringify(env)}\n`);
+		});
+	}
+	handleLine(line, stderrSink) {
+		if (!line.trim()) return;
+		let env;
+		try {
+			env = JSON.parse(line);
+		} catch {
+			stderrSink(`non-json from executa stdout: ${line}`);
+			return;
+		}
+		if (typeof env.method === "string") {
+			this.handleReverse(env);
+			return;
+		}
+		const id = env.id;
+		if (typeof id !== "number") return;
+		const pending = this.pending.get(id);
+		if (!pending) return;
+		this.pending.delete(id);
+		if (env.error) {
+			const e = env.error;
+			const err = new Error(`[${e.code}] ${e.message}`);
+			err.rpc = e;
+			pending.reject(err);
+		} else pending.resolve(env.result);
+	}
+	async handleReverse(env) {
+		const id = env.id;
+		const method = env.method;
+		const params = env.params ?? {};
+		const respond = (body) => {
+			if (id === void 0 || id === null) return;
+			if (!this.proc) return;
+			const out = {
+				jsonrpc: "2.0",
+				id,
+				...body
+			};
+			try {
+				this.proc.stdin.write(`${JSON.stringify(out)}\n`);
+			} catch {}
+		};
+		if (method === "sampling/createMessage") {
+			if (!this.opts.sampling) {
+				respond({ error: {
+					code: -32008,
+					message: "sampling not configured (use `anna-app login` and rerun without `--no-sampling`, or pass `--mock-sampling`)"
+				} });
+				return;
+			}
+			try {
+				const result = await this.opts.sampling.createMessage(params);
+				respond({ result });
+			} catch (e) {
+				const code = e.rpcCode ?? -32e3;
+				respond({ error: {
+					code,
+					message: e.message
+				} });
+			}
+			return;
+		}
+		if (method.startsWith("agent/")) {
+			if (!this.opts.agent) {
+				respond({ error: {
+					code: -32041,
+					message: "agent reverse-RPC not configured (rerun without `--no-agent`, or pass `--mock-agent <fixture>`)"
+				} });
+				return;
+			}
+			try {
+				const result = await this.opts.agent.call(method, params);
+				respond({ result });
+			} catch (e) {
+				const code = e.rpcCode ?? -32e3;
+				respond({ error: {
+					code,
+					message: e.message
+				} });
+			}
+			return;
+		}
+		if (method.startsWith("storage/") || method.startsWith("files/")) {
+			if (!this.opts.storage) {
+				respond({ error: {
+					code: -32021,
+					message: "storage not configured (rerun with `--storage memory|mock|real`)"
+				} });
+				return;
+			}
+			try {
+				const result = await this.opts.storage.call(method, params);
+				respond({ result });
+			} catch (e) {
+				const code = e.rpcCode ?? -32e3;
+				respond({ error: {
+					code,
+					message: e.message
+				} });
+			}
+			return;
+		}
+		respond({ error: {
+			code: -32601,
+			message: `unknown reverse method: ${method}`
+		} });
+	}
+};
+
+//#endregion
+export { ExecutaRunner };

package/dist/sampling-3EfSlDHM.js

@@ -0,0 +1,155 @@
+import { canonicalHost, getAccount } from "./credentials-BTv2IfUZ.js";
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+
+//#region src/executa/sampling.ts
+var SamplingBridge = class {
+	mocks = [];
+	cachedSession = null;
+	constructor(opts) {
+		this.opts = opts;
+		if (opts.mode === "mock" && opts.mockFile) {
+			const path = resolve(opts.mockFile);
+			if (existsSync(path)) for (const line of readFileSync(path, "utf8").split(/\r?\n/)) {
+				if (!line.trim() || line.startsWith("#")) continue;
+				try {
+					this.mocks.push(JSON.parse(line));
+				} catch {}
+			}
+		}
+	}
+	async createMessage(req) {
+		if (this.opts.mode === "off") throw withCode(new Error("sampling disabled — rerun without `--no-sampling`"), -32008);
+		if (this.opts.mode === "mock") return this.mockMessage(req);
+		return this.realMessage(req);
+	}
+	mockMessage(req) {
+		const content = collectContent(req);
+		const entry = this.mocks.find((m) => m.ns === "sampling" && m.method === "createMessage" || m.ns === "llm" && m.method === "complete") ?? null;
+		const matched = entry && (!entry.match?.contentIncludes || content.includes(entry.match.contentIncludes)) ? entry : this.mocks.find((m) => m.ns === "sampling" && m.method === "createMessage" || m.ns === "llm" && m.method === "complete");
+		if (matched && matched.result) return normaliseSamplingResult(matched.result, "mock-model");
+		return {
+			role: "assistant",
+			content: {
+				type: "text",
+				text: "(mock) no fixture matched"
+			},
+			model: "mock-model",
+			stopReason: "endTurn"
+		};
+	}
+	account() {
+		const acc = getAccount(this.opts.account);
+		if (!acc) throw withCode(new Error("no PAT on disk — run `anna-app login --host <nexus-url>` first (or pass `--mock-sampling <fixture>` / `--no-sampling`)"), -32001);
+		if (acc.expires_at && acc.expires_at < Math.floor(Date.now() / 1e3)) throw withCode(new Error("PAT expired — run `anna-app login` again"), -32001);
+		return acc;
+	}
+	async mint() {
+		if (this.cachedSession && this.cachedSession.expiresAt - 30 > Math.floor(Date.now() / 1e3)) return this.cachedSession;
+		const acc = this.account();
+		if (!this.opts.appSlug) throw withCode(new Error("sampling bridge has no app_slug — pass `--app-slug <slug>` to `anna-app executa dev` so nexus can attribute the spend"), -32602);
+		const url = `${canonicalHost(acc.host)}/api/v1/anna-apps/dev/session/mint`;
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				pat: acc.pat,
+				kind: "complete",
+				app_slug: this.opts.appSlug
+			})
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw withCode(new Error(`session.mint failed: HTTP ${res.status} ${text}`), -32e3);
+		}
+		const body = await res.json();
+		this.cachedSession = {
+			appSessionToken: body.app_session_token,
+			expiresAt: Math.floor(Date.now() / 1e3) + (body.expires_in || 600)
+		};
+		return this.cachedSession;
+	}
+	async realMessage(req) {
+		const acc = this.account();
+		const session = await this.mint();
+		const body = mcpToCompleteBody(req);
+		const res = await fetch(`${canonicalHost(acc.host)}/api/v1/copilot/app/complete`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				authorization: `Bearer ${session.appSessionToken}`
+			},
+			body: JSON.stringify(body)
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw withCode(new Error(`HTTP ${res.status}: ${text}`), -32e3);
+		}
+		const out = await res.json();
+		return normaliseSamplingResult(out, out.model ?? "unknown");
+	}
+};
+function withCode(err, code) {
+	err.rpcCode = code;
+	return err;
+}
+/** Collect a single string view of a sampling request — used for mock matching. */
+function collectContent(req) {
+	const parts = [];
+	if (req.systemPrompt) parts.push(req.systemPrompt);
+	for (const m of req.messages ?? []) {
+		const c = m.content;
+		if (typeof c === "string") parts.push(c);
+		else if (c && typeof c === "object" && "text" in c) parts.push(c.text);
+	}
+	return parts.join("\n");
+}
+/**
+* Translate an MCP `sampling/createMessage` request to the nexus
+* `/api/v1/copilot/app/complete` body. Mapping is intentionally lossy —
+* we forward only the fields nexus understands.
+*/
+function mcpToCompleteBody(req) {
+	const messages = (req.messages ?? []).map((m) => ({
+		role: m.role,
+		content: typeof m.content === "string" ? m.content : m.content.text
+	}));
+	const out = { messages };
+	if (req.systemPrompt) out.system = req.systemPrompt;
+	if (req.maxTokens != null) out.max_tokens = req.maxTokens;
+	if (req.temperature != null) out.temperature = req.temperature;
+	if (req.stopSequences) out.stop = req.stopSequences;
+	const hint = req.modelPreferences?.hints?.[0]?.name;
+	if (hint) out.model_hint = hint;
+	if (req.metadata) out.metadata = req.metadata;
+	return out;
+}
+/** Coerce arbitrary nexus / fixture output into a `SamplingResult`. */
+function normaliseSamplingResult(raw, fallbackModel) {
+	if (!raw || typeof raw !== "object") return {
+		role: "assistant",
+		content: {
+			type: "text",
+			text: String(raw ?? "")
+		},
+		model: fallbackModel,
+		stopReason: "endTurn"
+	};
+	const r = raw;
+	if (r.role === "assistant" && r.content && typeof r.content === "object") return r;
+	const text = typeof r.text === "string" && r.text || (typeof r.content === "string" ? r.content : "") || (typeof r.message === "string" ? r.message : "") || "";
+	return {
+		role: "assistant",
+		content: {
+			type: "text",
+			text
+		},
+		model: r.model ?? fallbackModel,
+		stopReason: r.stop_reason ?? r.stopReason ?? "endTurn",
+		usage: r.usage ?? void 0,
+		_meta: { source: "nexus" }
+	};
+}
+
+//#endregion
+export { SamplingBridge };