Files
streamline/bin/claude-cursor.ts
T
2026-11-16 17:26:44 -08:00

685 lines
28 KiB
TypeScript

#!/usr/bin/env bun
/**
* claude-cursor — drop-in replacement for
* `claude -p <prompt> --output-format stream-json --verbose \
* --dangerously-skip-permissions [--add-dir X] [--session-id|--resume U]`
* that runs Cursor's `cursor-agent` instead of Claude Code, while emitting the
* SAME Claude stream-json line shape on stdout. Every downstream consumer in the
* satellite (session.log tailer, the STATUS/ASSESSMENT sentinel parser in the
* runners/evaluators, the client-side LogPanel, asking's event normaliser) reads
* that shape, so swapping the engine here keeps log-return and per-task
* association fully compatible.
*
* Why a translator is needed: cursor-agent's `--output-format stream-json` is
* close to Claude's but not identical. Notably it emits tool calls and thinking
* as their OWN top-level frames:
* {"type":"tool_call","subtype":"started","call_id","tool_call":{…}}
* {"type":"tool_call","subtype":"completed","call_id","tool_call":{…}}
* {"type":"thinking","subtype":"delta"|"completed","text"}
* whereas Claude (and thus our consumers) expect those FOLDED INTO message
* content: a `tool_use` block inside an `assistant` frame, a `tool_result` block
* inside a `user` frame, and a `thinking` block inside an `assistant` frame.
* This wrapper performs that folding. Text + result frames are already
* Claude-shaped and pass through (with session_id normalised).
*
* Arg mapping (claude → cursor):
* -p <prompt> positional prompt (cursor's -p is a bare
* --print boolean, so the prompt moves to a
* positional and --print is added)
* --output-format stream-json --output-format stream-json (kept)
* --verbose / --remote-control X dropped (no cursor equivalent)
* --dangerously-skip-permissions --force --trust --approve-mcps
* --add-dir X --add-dir X (same flag)
* --session-id U (first turn) create-chat → chatId, persist U→chatId,
* run --resume chatId
* --resume U (later turns) look up U→chatId, run --resume chatId
*
* The U→chatId map is a per-uuid sidecar file so the resumable asking session
* survives across the fresh process each turn spawns.
*
* Env knobs:
* CURSOR_BIN cursor-agent binary (default "cursor-agent")
* STREAMLINE_CURSOR_MODEL --model to pass (e.g. "claude-opus-4-8[context=1m]")
* CURSOR_BRIDGE_DIR where U→chatId sidecars live
* (default ~/.cursor-agent-bridge)
* CLAUDE_CURSOR_DEBUG=1 mirror raw cursor-agent stdout/stderr to stderr
*/
import { spawn, spawnSync, type Subprocess } from "bun";
import {
existsSync, mkdirSync, readFileSync, writeFileSync,
} from "node:fs";
import { homedir } from "node:os";
import path from "node:path";
import { randomUUID } from "node:crypto";
import { CursorCliDiagnosticBuffer, redactCursorCliDiagnostic } from "../satellite/src/security_telemetry/cursor_cli_diagnostics";
import { isCursorApiKeyMode } from "../satellite/src/security_telemetry/agent_account_gate";
import {
AGENT_SESSION_FILE_ENV,
AGENT_SESSION_KIND_ENV,
mappedAgentSessionIdFromEnv,
recordAgentSessionIdFromEnv,
} from "../shared/src/agent_session";
const CURSOR_BIN = process.env.CURSOR_BIN || "cursor-agent";
const CURSOR_MODEL = process.env.STREAMLINE_CURSOR_MODEL || "";
const BRIDGE_DIR = process.env.CURSOR_BRIDGE_DIR || path.join(homedir(), ".cursor-agent-bridge");
const DEBUG = process.env.CLAUDE_CURSOR_DEBUG === "1";
function dbg(msg: string) {
if (DEBUG) console.error(`[claude-cursor] ${msg}`);
}
// Same automation instruction the PTY wrapper injects, but prepended to the
// prompt (cursor-agent has no --append-system-prompt). Only used for headless
// runs; the human-in-the-loop asking session must NOT be told "nobody is
// watching", so we skip it there (see `isAsking`).
const AUTOMODE_SYSPROMPT = [
"本会话运行在无人值守的自动化流水线中,没有任何人类在观看或会作出回应。",
"绝对禁止以提问等待用户回复的方式中断任务;",
"如必须在多个方案中取舍,直接采用你推荐的(或第一个可行的)方案并继续执行,事后在输出中说明即可。",
"任务必须自主推进到完成。",
].join("");
// ── arg parsing ────────────────────────────────────────────────────────────
interface ParsedArgs {
prompt: string;
addDirs: string[];
sessionUuid: string | null; // --session-id (first turn of a resumable session)
resumeUuid: string | null; // --resume (later turns)
appendSys: string | null; // --append-system-prompt (folded into prompt)
model: string | null; // --model override from caller
}
function parseArgs(argv: string[]): ParsedArgs {
const addDirs: string[] = [];
let prompt: string | null = null;
let sessionUuid: string | null = null;
let resumeUuid: string | null = null;
let appendSys: string | null = null;
let model: string | null = null;
// claude flags whose VALUE we must consume but otherwise ignore for cursor.
const DROP_WITH_VALUE = new Set([
"--output-format", "--input-format", "--fallback-model",
"--max-budget-usd", "--json-schema", "--settings",
]);
const DROP_BARE = new Set([
"--verbose", "--print", "--include-partial-messages",
"--replay-user-messages", "--no-session-persistence",
"--dangerously-skip-permissions",
]);
for (let i = 0; i < argv.length; i++) {
const a = argv[i];
if (a === "-p" || a === "--print") {
const next = argv[i + 1];
if (next !== undefined && !next.startsWith("-")) { prompt = next; i++; }
continue;
}
if (a === "--add-dir") { const v = argv[++i]; if (v) addDirs.push(v); continue; }
if (a === "--session-id") { sessionUuid = argv[++i] ?? null; continue; }
if (a === "--resume") { resumeUuid = argv[++i] ?? null; continue; }
if (a === "--append-system-prompt") { appendSys = argv[++i] ?? null; continue; }
if (a === "--model") { model = argv[++i] ?? null; continue; }
if (a === "--remote-control") { i++; continue; }
if (DROP_BARE.has(a)) continue;
if (DROP_WITH_VALUE.has(a)) { i++; continue; }
if (DROP_WITH_VALUE.has(a.split("=")[0])) continue;
if (!a.startsWith("-") && prompt === null) { prompt = a; continue; }
// Anything else is an unknown flag: drop it rather than forward — cursor's
// commander aborts hard on unrecognised options.
dbg(`dropping unrecognised arg: ${a}`);
}
if (prompt === null) {
console.error("claude-cursor: no prompt found in args");
process.exit(2);
}
return { prompt, addDirs, sessionUuid, resumeUuid, appendSys, model };
}
// ── U→chatId session bridge ─────────────────────────────────────────────────
function sidecarPath(uuid: string): string {
return path.join(BRIDGE_DIR, `${uuid}.chat`);
}
function readChatId(uuid: string): string | null {
const managed = mappedAgentSessionIdFromEnv("cursor", uuid);
if (managed) return managed;
try {
const p = sidecarPath(uuid);
if (existsSync(p)) { const s = readFileSync(p, "utf8").trim(); if (s) return s; }
} catch { /* fall through */ }
return null;
}
function writeChatId(uuid: string, chatId: string): void {
recordAgentSessionIdFromEnv("cursor", chatId);
try {
mkdirSync(BRIDGE_DIR, { recursive: true });
writeFileSync(sidecarPath(uuid), chatId, "utf8");
} catch (e) { dbg(`could not persist chat id: ${(e as Error).message}`); }
}
/** `cursor-agent create-chat` prints a new empty chat's id. Parse it out. */
function createChat(): string | null {
try {
const p = spawnSync({ cmd: [CURSOR_BIN, "create-chat"], stdout: "pipe", stderr: "pipe" });
const out = (p.stdout?.toString() || "").trim();
if (!out) { dbg(`create-chat produced no output (stderr: ${p.stderr?.toString().trim()})`); return null; }
// Prefer a JSON payload if cursor ever wraps it; else take the last id-ish token.
try {
const j = JSON.parse(out) as Record<string, unknown>;
const id = (j.chatId || j.id || j.chat_id) as string | undefined;
if (id) return id;
} catch { /* not json */ }
const tokens = out.split(/\s+/).filter((t) => /^[\w-]{6,}$/.test(t));
return tokens.length ? tokens[tokens.length - 1] : out;
} catch (e) {
dbg(`create-chat failed: ${(e as Error).message}`);
return null;
}
}
/** Security must not wait indefinitely for a CLI that has already printed its ID. */
async function createSecurityChat(): Promise<string> {
const proc = spawn({ cmd: [CURSOR_BIN, "create-chat"], stdin: "ignore", stdout: "pipe", stderr: "pipe" });
const diagnostics = new CursorCliDiagnosticBuffer();
const stderrDone = (async () => {
const decoder = new TextDecoder();
for await (const chunk of proc.stderr) diagnostics.append(decoder.decode(chunk, { stream: true }));
diagnostics.append(decoder.decode());
})().catch(() => {});
let timedOut = false;
let timer: ReturnType<typeof setTimeout>;
const deadline = new Promise<never>((_, reject) => {
timer = setTimeout(() => {
timedOut = true;
try { proc.kill(); } catch { /* already exited */ }
reject(new Error("Cursor create-chat did not return a session ID within 30s"));
}, 30_000);
});
const reader = proc.stdout.getReader();
let id: string | null = null;
let output = "";
const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
const parseId = (line: string): string | null => {
const text = line.trim();
if (uuid.test(text)) return text;
try {
const value = JSON.parse(text) as Record<string, unknown>;
const candidate = value.chatId ?? value.id ?? value.chat_id;
return typeof candidate === "string" && uuid.test(candidate) ? candidate : null;
} catch { return null; }
};
try {
const decoder = new TextDecoder();
while (!id) {
const { value, done } = await Promise.race([reader.read(), deadline]);
output += decoder.decode(value, { stream: !done });
if (output.length > 16_384) throw new Error("Cursor create-chat output exceeded the expected size");
let end: number;
while ((end = output.indexOf("\n")) >= 0) {
id = parseId(output.slice(0, end));
output = output.slice(end + 1);
if (id) break;
}
if (done) { id ||= parseId(output); break; }
}
if (id) {
// The CLI writes the ID before its cleanup. Give cleanup a moment, but
// don't let a retained Node handle block this task for an hour.
const code = await Promise.race([proc.exited, Bun.sleep(1_000).then(() => null)]);
if (code !== null && code !== 0) {
await Promise.race([stderrDone, Bun.sleep(1_000)]);
throw new Error(diagnostics.text() || `Cursor create-chat exited with code ${code}`);
}
if (code === null) { try { proc.kill(); } catch { /* already exited */ } }
}
const exitCode = await Promise.race([proc.exited, Bun.sleep(1_000).then(() => null)]);
if (exitCode === null) { try { proc.kill("SIGKILL"); } catch { /* already exited */ } await proc.exited; }
await Promise.race([stderrDone, Bun.sleep(1_000)]);
if (!id) throw new Error(diagnostics.text() || (timedOut
? "Cursor create-chat did not return a session ID within 30s"
: `Cursor create-chat did not return a valid session ID (exit ${exitCode ?? "unknown"})`));
return id;
} finally {
clearTimeout(timer!);
try { reader.releaseLock(); } catch { /* a timed-out read may still be pending */ }
if (proc.exitCode === null && proc.signalCode === null) {
try { proc.kill("SIGKILL"); } catch { /* already exited */ }
}
}
}
/** Resolve the cursor chat id to --resume for this run, honouring the asking
* session's own uuid. Returns null for a plain headless one-shot (fresh chat). */
async function resolveChatId(a: ParsedArgs): Promise<string | null> {
const create = () => isSecurityTask ? createSecurityChat() : Promise.resolve(createChat());
if (a.resumeUuid) {
const existing = readChatId(a.resumeUuid);
if (existing) return existing;
// Asked to resume a session we have no mapping for (e.g. bridge dir wiped):
// start a fresh chat and remember it so subsequent turns stay coherent.
dbg(`no chat id mapped for resume uuid ${a.resumeUuid}; creating a fresh chat`);
const created = await create();
if (created) writeChatId(a.resumeUuid, created);
return created;
}
if (a.sessionUuid) {
const created = await create();
if (created) writeChatId(a.sessionUuid, created);
return created;
}
// Headless runner calls have no stable outer uuid, but we still want an
// actual chat id so an idle-timeout restart can `--resume` the same session.
return create();
}
// ── Claude stream-json emission ─────────────────────────────────────────────
const t0 = Date.now();
function emit(obj: Record<string, unknown>) {
process.stdout.write(JSON.stringify(obj) + "\n");
}
const parsed = parseArgs(process.argv.slice(2));
const isManagedRun = Boolean(process.env[AGENT_SESSION_FILE_ENV]?.trim());
const isSecurityTask = process.env[AGENT_SESSION_KIND_ENV] === "security";
const isAsking = !isManagedRun && !!(parsed.sessionUuid || parsed.resumeUuid);
// Stable session id for every emitted frame: the caller's uuid when it has one
// (keeps a task's logs coherent across turns), else filled from cursor's init.
let outSid = parsed.resumeUuid || parsed.sessionUuid || "";
let emittedInit = false;
// ── cursor → claude frame translation ───────────────────────────────────────
// Cursor streams assistant text and thinking as deltas; buffer them and flush a
// single consolidated block so a STATUS sentinel can't be split across frames
// and the LogPanel shows whole messages (parity with `claude -p`).
let pendingText = "";
let pendingTextCall = "";
let pendingThink = "";
let numTurns = 0;
let finalized = false;
let sawResult = false;
let lastError = "";
function emitAssistantText(text: string) {
if (!text.trim()) return;
numTurns++;
emit({
type: "assistant",
message: { role: "assistant", content: [{ type: "text", text }] },
session_id: outSid,
parent_tool_use_id: null,
uuid: randomUUID(),
});
}
function flushText() {
if (!pendingText.trim()) { pendingText = ""; pendingTextCall = ""; return; }
emitAssistantText(pendingText);
pendingText = "";
pendingTextCall = "";
}
function flushThink() {
if (!pendingThink.trim()) { pendingThink = ""; return; }
emit({
type: "assistant",
message: { role: "assistant", content: [{ type: "thinking", thinking: pendingThink }] },
session_id: outSid,
parent_tool_use_id: null,
uuid: randomUUID(),
});
pendingThink = "";
}
// Cursor nests the real payload under a single kind-specific key, e.g.
// tool_call: { readToolCall: { args:{…}, result:{ success|error:{…} } },
// toolCallId, startedAtMs, completedAtMs }
// So we locate the `<kind>ToolCall` sub-object and read args/result from it.
const KIND_NAME: Record<string, string> = {
read: "Read", write: "Write", edit: "Edit", searchReplace: "Edit",
multiEdit: "MultiEdit", ls: "LS", list: "LS", grep: "Grep", glob: "Glob",
shell: "Bash", terminal: "Bash", runTerminalCommand: "Bash",
delete: "Delete", todoWrite: "TodoWrite", webSearch: "WebSearch",
fetch: "WebFetch", codebaseSearch: "Search",
};
function findKind(tc: Record<string, any>): { kind: string; inner: Record<string, any> } {
for (const [k, v] of Object.entries(tc)) {
if (k.endsWith("ToolCall") && v && typeof v === "object") {
return { kind: k.slice(0, -"ToolCall".length), inner: v as Record<string, any> };
}
}
return { kind: "", inner: {} };
}
function toolName(kind: string): string {
if (!kind) return "tool";
return KIND_NAME[kind] || (kind[0].toUpperCase() + kind.slice(1));
}
/** Map cursor's nested tool_call → Claude's {name, input}. LogPanel renders the
* name plus the input entries; the fix runner never parses these. */
function deriveToolUse(ev: any): { id: string; name: string; input: Record<string, unknown> } {
const tc = (ev.tool_call || {}) as Record<string, any>;
const id = String(ev.call_id ?? tc.toolCallId ?? randomUUID());
const { kind, inner } = findKind(tc);
const input = (inner.args && typeof inner.args === "object") ? inner.args
: (inner.rawArgs && typeof inner.rawArgs === "object") ? inner.rawArgs
: {};
return { id, name: toolName(kind), input };
}
/** Flatten cursor's tool result (result.success.* / result.error) into a
* readable string and derive the error flag from which branch is present. */
function deriveToolResult(ev: any): { id: string; content: string; isError: boolean } {
const tc = (ev.tool_call || {}) as Record<string, any>;
const id = String(ev.call_id ?? tc.toolCallId ?? "");
const { kind, inner } = findKind(tc);
const res = inner.result as Record<string, any> | undefined;
let isError = false;
let content = "";
if (res && typeof res === "object") {
if (res.error !== undefined || res.failure !== undefined) {
isError = true;
const e = res.error ?? res.failure;
content = typeof e === "string" ? e : (e?.message ?? JSON.stringify(e));
} else {
const ok = res.success ?? res;
content = typeof ok === "string" ? ok
: (ok?.content ?? ok?.output ?? ok?.stdout ?? ok?.text ?? "");
if (!content) content = JSON.stringify(ok);
}
}
if (content.length > 8000) content = content.slice(0, 8000) + "\n…(truncated)";
if (!content) content = `[${kind || "tool"} done]`;
return { id, content, isError };
}
type NormalizedUsage = {
input_tokens: number;
output_tokens: number;
cache_read_input_tokens: number;
cache_creation_input_tokens: number;
thinking_tokens: number;
};
/** cursor result.usage is camelCase; map to Claude's usage field names. */
function mapUsage(u: any): NormalizedUsage {
const g = (k: string) => (typeof u?.[k] === "number" ? u[k] : 0);
const tokenDetail = (...values: unknown[]) => {
const value = values.find((entry) => typeof entry === "number" && Number.isFinite(entry));
return typeof value === "number" ? value : 0;
};
return {
input_tokens: g("inputTokens"),
output_tokens: g("outputTokens"),
cache_read_input_tokens: g("cacheReadTokens"),
cache_creation_input_tokens: g("cacheWriteTokens"),
thinking_tokens: tokenDetail(
u?.thinkingTokens,
u?.thinking_tokens,
u?.reasoningTokens,
u?.reasoning_tokens,
u?.reasoningOutputTokens,
),
};
}
function onCursorEvent(ev: any) {
const type = ev?.type as string | undefined;
switch (type) {
case "system": {
if (ev.subtype === "init") {
if (!outSid) outSid = String(ev.session_id || randomUUID());
if (emittedInit) return;
emittedInit = true;
emit({
type: "system", subtype: "init",
cwd: ev.cwd ?? process.cwd(),
session_id: outSid,
tools: [], model: ev.model ?? parsed.model ?? CURSOR_MODEL ?? "",
permissionMode: "bypassPermissions",
apiKeySource: ev.apiKeySource ?? "none",
mcp_servers: [], slash_commands: [],
cursor_cli: true,
});
}
return;
}
case "user":
// Cursor echoes the initial prompt as a user frame; `claude -p` does not.
// Drop it for parity (the runners never want the prompt echoed back).
return;
case "assistant": {
const content = (ev.message?.content ?? []) as Array<Record<string, any>>;
const text = content.map((c) => (typeof c?.text === "string" ? c.text : "")).join("");
if (!text) return;
const call = String(ev.model_call_id ?? "");
if (pendingText && call && call !== pendingTextCall) flushText();
pendingTextCall = call;
pendingText += text;
return;
}
case "thinking": {
if (ev.subtype === "completed") { flushThink(); return; }
if (typeof ev.text === "string") pendingThink += ev.text;
return;
}
case "tool_call": {
// A tool call means the current text turn is over — flush it first so the
// assistant text and the tool_use land in transcript order.
flushText();
flushThink();
if (ev.subtype === "started") {
const { id, name, input } = deriveToolUse(ev);
emit({
type: "assistant",
message: { role: "assistant", content: [{ type: "tool_use", id, name, input }] },
session_id: outSid,
parent_tool_use_id: null,
uuid: randomUUID(),
});
} else if (ev.subtype === "completed") {
const { id, content, isError } = deriveToolResult(ev);
emit({
type: "user",
message: { role: "user", content: [{ type: "tool_result", tool_use_id: id, content, is_error: isError }] },
session_id: outSid,
parent_tool_use_id: null,
uuid: randomUUID(),
});
}
return;
}
case "result": {
flushText();
flushThink();
sawResult = true;
const isError = ev.is_error === true;
const rawResult = ev.result ?? "";
const resultText = isError && isSecurityTask && isCursorApiKeyMode("cursor") && (typeof rawResult === "object" || (ev.error && typeof ev.error === "object"))
? redactCursorCliDiagnostic(JSON.stringify({ result: rawResult, error: ev.error ?? null }) || "") : String(rawResult);
finalize(isError ? "error_during_execution" : "success", isError, resultText, Number(ev.duration_ms ?? (Date.now() - t0)), mapUsage(ev.usage));
return;
}
case "error": {
// Surface cursor's own error so upstream infra-error detection can see it.
const raw = ev.message ?? ev.error ?? ev.text ?? "unknown error";
const msg = isSecurityTask && isCursorApiKeyMode("cursor") && ev.error && typeof ev.error === "object"
? redactCursorCliDiagnostic(JSON.stringify({ message: ev.message ?? ev.text ?? null, error: ev.error }) || "") : String(raw);
lastError = msg;
flushText();
emit({
type: "assistant",
message: { role: "assistant", content: [{ type: "text", text: `API Error: ${msg}` }] },
session_id: outSid,
parent_tool_use_id: null,
uuid: randomUUID(),
});
return;
}
case "turn_ended": {
// Current Cursor CLI reports account exhaustion as a terminal
// `turn_ended/status:error` frame rather than `type:error` or `result`.
// Keep this compatibility change security-only so feature/bug retain the
// wrapper behaviour they had before security gained runner-owned retries.
if (!isSecurityTask || ev.status !== "error") return;
const raw = ev.error ?? ev.message ?? ev.text ?? "Cursor turn ended with an error";
const msg = typeof raw === "string" ? raw : JSON.stringify(raw);
lastError = msg;
flushText();
emit({
type: "assistant",
message: { role: "assistant", model: "<synthetic>", content: [{ type: "text", text: `API Error: ${msg}` }] },
session_id: outSid,
parent_tool_use_id: null,
uuid: randomUUID(),
});
return;
}
default:
dbg(`unhandled cursor frame type: ${type}`);
}
}
const ZERO_USAGE: NormalizedUsage = {
input_tokens: 0,
output_tokens: 0,
cache_creation_input_tokens: 0,
cache_read_input_tokens: 0,
thinking_tokens: 0,
};
function finalize(subtype: string, isError: boolean, result: string, durMs: number, usage: NormalizedUsage = ZERO_USAGE) {
if (finalized) return;
finalized = true;
emit({
type: "result",
subtype,
is_error: isError,
duration_ms: durMs,
duration_api_ms: durMs,
num_turns: numTurns,
result,
stop_reason: isError ? null : "end_turn",
session_id: outSid,
uuid: randomUUID(),
total_cost_usd: 0,
usage,
});
}
// ── spawn cursor-agent ──────────────────────────────────────────────────────
let chatId: string | null;
try {
chatId = await resolveChatId(parsed);
} catch (err) {
finalize("error_during_execution", true, redactCursorCliDiagnostic((err as Error).message), Date.now() - t0);
process.exit(1);
}
function buildInitialPrompt(): string {
const parts: string[] = [];
if (!isAsking) parts.push(AUTOMODE_SYSPROMPT);
if (parsed.appendSys) parts.push(parsed.appendSys);
parts.push(parsed.prompt);
return parts.join("\n\n");
}
function buildCursorArgs(promptText: string, resumeChatId: string | null): string[] {
const cursorArgs = [
"--print",
"--output-format", "stream-json",
"--force", "--trust", "--approve-mcps",
];
// Security's host already applies isolation; avoid nesting Cursor's sandbox.
if (isSecurityTask) cursorArgs.push("--sandbox", "disabled");
for (const d of parsed.addDirs) cursorArgs.push("--add-dir", d);
const model = parsed.model || CURSOR_MODEL;
if (model) cursorArgs.push("--model", model);
if (resumeChatId) cursorArgs.push("--resume", resumeChatId);
cursorArgs.push(promptText);
return cursorArgs;
}
let currentChild: Subprocess<"ignore", "pipe", "pipe"> | null = null;
function killTree() {
try { currentChild?.kill(); } catch { /* ignore */ }
}
for (const sig of ["SIGINT", "SIGTERM"] as const) {
process.on(sig, () => {
dbg(`got ${sig}; killing cursor-agent`);
finalize("error_during_execution", true, lastError || "", Date.now() - t0);
killTree();
process.exit(143);
});
}
async function runCursorChild(promptText: string, resumeChatId: string | null): Promise<number> {
const cursorArgs = buildCursorArgs(promptText, resumeChatId);
dbg(`spawning ${CURSOR_BIN} (chat=${resumeChatId ?? "fresh"}, asking=${isAsking}, prompt=${JSON.stringify(promptText)}) cwd=${process.cwd()}`);
const child: Subprocess<"ignore", "pipe", "pipe"> = spawn({
cmd: [CURSOR_BIN, ...cursorArgs],
cwd: process.cwd(),
stdin: "ignore",
stdout: "pipe",
stderr: "pipe",
});
currentChild = child;
// Security evaluate/run opt in explicitly. Feature, bugfix and asking retain
// their previous stderr/terminal behaviour, including DEBUG output.
const diagnostic = isSecurityTask ? new CursorCliDiagnosticBuffer() : null;
const handle = (line: string) => {
const s = line.trim();
if (!s) return;
if (s[0] !== "{") {
diagnostic?.append(`${s}\n`);
return;
}
if (DEBUG) process.stderr.write(`[cursor-raw] ${s}\n`);
let ev: any;
try { ev = JSON.parse(s); } catch { return; }
try { onCursorEvent(ev); } catch (e) { dbg(`translate error: ${(e as Error).message}`); }
};
const stderrTask = (async () => {
const dec = new TextDecoder();
for await (const chunk of child.stderr) {
if (diagnostic) diagnostic.append(dec.decode(chunk, { stream: true }));
else if (DEBUG) process.stderr.write(dec.decode(chunk));
}
if (diagnostic) diagnostic.append(dec.decode());
})().catch(() => {});
const stdoutTask = (async () => {
const dec = new TextDecoder();
let buf = "";
for await (const chunk of child.stdout) {
buf += dec.decode(chunk, { stream: true });
let nl: number;
while ((nl = buf.indexOf("\n")) >= 0) {
handle(buf.slice(0, nl));
buf = buf.slice(nl + 1);
}
}
if (buf.trim()) handle(buf);
})().catch((e) => dbg(`stdout reader error: ${(e as Error).message}`));
const code = await child.exited;
await Promise.allSettled([stderrTask, stdoutTask]);
if (diagnostic && !sawResult && (code !== 0 || (numTurns === 0 && !pendingText.trim())) && !lastError) {
lastError = diagnostic.text() || `Cursor CLI exited with code ${code} without a usable result`;
}
if (currentChild === child) currentChild = null;
return code;
}
const code = await runCursorChild(buildInitialPrompt(), chatId);
// Flush anything the stream reader left buffered, then guarantee a result frame
// so the caller's parser never hangs waiting for a terminal frame cursor didn't
// emit (crash / auth failure / empty run).
flushText();
flushThink();
if (!sawResult) {
const ok = !lastError && (numTurns > 0) && code === 0;
finalize(ok ? "success" : "error_during_execution", !ok, lastError || "", Date.now() - t0);
}
process.exit(sawResult ? 0 : (code || 1));