@mikenguyen69/harness 0.1.0-beta.1

package/dist/internal/orchestration/runners/cursor/exec.js

@@ -0,0 +1,531 @@
+/**
+ * exec — the ONLY module that shells `cursor-agent`. Everything else in
+ * `src/runners/cursor/` is plain glue over the agent-neutral `Runner` contract.
+ * If the Cursor Agent CLI's flag surface shifts, this file is the blast radius.
+ *
+ * `cursor-agent -p` runs one non-interactive turn. Surface used (verify against
+ * the installed `cursor-agent` at integration time — do not guess further):
+ *   cursor-agent -p --output-format stream-json --trust --workspace <cwd>
+ *     --model <m> [--plan | --force] "<prompt>"
+ * `--plan` is read-only (verifier); `--force` auto-approves writes (implementer).
+ * `--output-format stream-json` emits NDJSON events on stdout as the turn
+ * progresses (`system`, `thinking`, `tool_call`, `assistant`, `result`). Exit 0
+ * = the turn completed. We fold as lines arrive so an optional `onActivity`
+ * sink can observe mid-turn (execFile would buffer until exit and stay blind).
+ *
+ * `execImpl` is injectable so the runner's tests never spawn `cursor-agent`.
+ * On Windows, PATH often resolves to a `.cmd` shim — bare `spawn`/`execFile`
+ * cannot run that (ENOENT); resolve via `where` and run through `cmd.exe /c`.
+ */
+import { execFile, execFileSync, spawn, } from "node:child_process";
+import { existsSync } from "node:fs";
+import { isAbsolute, posix as posixPath, resolve, win32 as win32Path } from "node:path";
+const LINE_CLAMP = 400;
+/** Board wire max is 160; watch sink keeps a longer line so stderr isn't clipped mid-thought. */
+/** Locate `bin` on PATH (or as an absolute/relative path). */
+export function locateCursorBin(bin, cwd) {
+    const candidate = isAbsolute(bin) ? bin : resolve(cwd, bin);
+    if (existsSync(candidate))
+        return candidate;
+    try {
+        const locator = process.platform === "win32" ? "where.exe" : "which";
+        const found = execFileSync(locator, [bin], { cwd, encoding: "utf8" })
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .find(Boolean);
+        if (found)
+            return found;
+    }
+    catch {
+        // fall through — let spawn report ENOENT
+    }
+    return bin;
+}
+function windowsCommandLine(command, args) {
+    const quote = (value) => `"${value.replaceAll("%", "%%").replaceAll("\"", "\"\"")}"`;
+    return `"${[command, ...args].map(quote).join(" ")}"`;
+}
+function resolveSpawn(bin, args, cwd) {
+    const resolved = locateCursorBin(bin, cwd);
+    const isWindowsShim = process.platform === "win32" && /\.(?:cmd|bat)$/i.test(resolved);
+    if (isWindowsShim) {
+        return {
+            command: process.env.ComSpec ?? "cmd.exe",
+            args: ["/d", "/s", "/c", windowsCommandLine(resolved, args)],
+            windowsVerbatimArguments: true,
+        };
+    }
+    return { command: resolved, args };
+}
+/** Buffered spawn (tests / callers that only need the final stdout). */
+export async function execCursorAgentProcess(bin, args, opts) {
+    const spawnSpec = resolveSpawn(bin, args, opts.cwd);
+    return new Promise((resolvePromise) => {
+        const child = execFile(spawnSpec.command, spawnSpec.args, {
+            cwd: opts.cwd,
+            env: opts.env,
+            encoding: "utf8",
+            maxBuffer: 32 * 1024 * 1024,
+            windowsHide: true,
+            ...(spawnSpec.windowsVerbatimArguments
+                ? { windowsVerbatimArguments: true }
+                : {}),
+            ...(opts.timeoutMs !== undefined ? { timeout: opts.timeoutMs } : {}),
+        }, (error, stdout, stderr) => resolvePromise(foldProcessExit(error, stdout, stderr, opts.timeoutMs)));
+        child.stdin?.end();
+    });
+}
+/**
+ * Live spawn: stdout is delivered line-by-line so `onLine` can fold activity
+ * before the process exits.
+ */
+export async function streamCursorAgentProcess(bin, args, opts) {
+    const spawnSpec = resolveSpawn(bin, args, opts.cwd);
+    return new Promise((resolvePromise) => {
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        let lineBuf = "";
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolvePromise(result);
+        };
+        // Stay in the parent's process group / console (no `detached`) so the
+        // facade's process-group interrupt reaches this child.
+        const child = spawn(spawnSpec.command, spawnSpec.args, {
+            cwd: opts.cwd,
+            env: opts.env,
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"],
+            ...(spawnSpec.windowsVerbatimArguments
+                ? { windowsVerbatimArguments: true }
+                : {}),
+        });
+        let killer;
+        if (opts.timeoutMs !== undefined) {
+            killer = setTimeout(() => {
+                child.kill();
+                finish({
+                    code: 1,
+                    stdout,
+                    stderr: [stderr.trim(), `cursor-agent timed out after ${opts.timeoutMs}ms`]
+                        .filter(Boolean)
+                        .join("\n"),
+                });
+            }, opts.timeoutMs);
+        }
+        const flushLines = (chunk, final = false) => {
+            lineBuf += chunk;
+            const parts = lineBuf.split(/\r?\n/);
+            lineBuf = final ? "" : (parts.pop() ?? "");
+            for (const part of parts) {
+                if (!part)
+                    continue;
+                opts.onLine?.(part);
+            }
+            if (final && lineBuf) {
+                opts.onLine?.(lineBuf);
+                lineBuf = "";
+            }
+        };
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+            flushLines(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            if (killer)
+                clearTimeout(killer);
+            finish({
+                code: 1,
+                stdout,
+                stderr: [stderr.trim(), `spawn failed: ${error.message}`]
+                    .filter(Boolean)
+                    .join("\n"),
+            });
+        });
+        child.on("close", (code) => {
+            if (killer)
+                clearTimeout(killer);
+            flushLines("", true);
+            finish({ code: code ?? 1, stdout, stderr });
+        });
+        // `close` waits for every stdio pipe to hit EOF. If cursor-agent spawned a
+        // background process that outlives it (e.g. an un-reaped `harness board
+        // serve` from a verifier smoke test), that descendant keeps the stdout
+        // handle open and `close` never fires — hanging the orchestrator on the
+        // review step. `exit` fires when the agent process itself ends: reap its
+        // process tree so the inherited pipes close and `close` can fire naturally
+        // with the *complete* buffer (a bare timeout race truncates the final
+        // stream-json `result` event and loses the verifier verdict). A long
+        // backstop timer covers the case where even that does not release them.
+        child.on("exit", (code) => {
+            if (settled || child.pid === undefined)
+                return;
+            try {
+                if (process.platform === "win32") {
+                    spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+                        windowsHide: true,
+                        stdio: "ignore",
+                    }).on("error", () => undefined);
+                }
+                else {
+                    try {
+                        process.kill(-child.pid, "SIGKILL");
+                    }
+                    catch {
+                        process.kill(child.pid, "SIGKILL");
+                    }
+                }
+            }
+            catch {
+                // best effort — the backstop below still resolves the promise
+            }
+            setTimeout(() => {
+                if (settled)
+                    return;
+                if (killer)
+                    clearTimeout(killer);
+                flushLines("", true);
+                finish({ code: code ?? 0, stdout, stderr });
+            }, 20_000).unref?.();
+        });
+        child.stdin?.on("error", () => undefined); // child may exit before draining
+        child.stdin?.end(opts.stdin ?? "");
+    });
+}
+function foldProcessExit(error, stdout, stderr, timeoutMs) {
+    if (!error)
+        return { code: 0, stdout, stderr };
+    const timedOut = timeoutMs !== undefined &&
+        (error.killed === true || error.signal != null || error.code === "ETIMEDOUT");
+    const timeoutError = timedOut ? `cursor-agent timed out after ${timeoutMs}ms` : "";
+    const spawnError = typeof error.code === "string" ? `spawn failed: ${error.code}` : "";
+    return {
+        code: typeof error.code === "number" ? error.code : 1,
+        stdout,
+        stderr: [stderr.trim(), timeoutError, spawnError].filter(Boolean).join("\n"),
+    };
+}
+export async function runCursorAgent(params) {
+    const bin = params.bin ?? process.env.CURSOR_AGENT_BIN ?? "cursor-agent";
+    // `cursor-agent -p` takes the prompt as a positional arg OR on stdin. A
+    // verifier prompt embeds the full branch diff; as an argv element that
+    // overflows the OS command-line limit (Windows: spawn ENAMETOOLONG, which
+    // crashes the orchestrator). Feed it on stdin for the real spawn; the
+    // injected `execImpl` (tests) still receives it as the last arg.
+    const baseArgs = [
+        "-p",
+        "--output-format",
+        "stream-json",
+        "--trust",
+        "--workspace",
+        params.cwd,
+        "--model",
+        params.model,
+        ...(params.resumeSessionId ? ["--resume", params.resumeSessionId] : []),
+        ...(params.posture === "read-only" ? ["--plan"] : ["--force"]),
+    ];
+    const fold = createStreamFolder(params.onActivity, params.cwd);
+    if (params.execImpl) {
+        const { code, stdout, stderr } = await params.execImpl([...baseArgs, params.prompt], {
+            cwd: params.cwd,
+            env: params.env,
+            ...(params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs } : {}),
+        });
+        for (const line of stdout.split(/\r?\n/)) {
+            if (line.trim())
+                fold.consumeLine(line);
+        }
+        return fold.finish(code, stderr);
+    }
+    const { code, stderr } = await streamCursorAgentProcess(bin, baseArgs, {
+        cwd: params.cwd,
+        env: params.env,
+        stdin: params.prompt,
+        ...(params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs } : {}),
+        onLine: (line) => fold.consumeLine(line),
+    });
+    return fold.finish(code, stderr);
+}
+/** Parse buffered stdout (legacy json or stream-json) into a flat result. */
+export function foldCursorOutput(stdout, code, stderr, onActivity, cwd) {
+    const fold = createStreamFolder(onActivity, cwd);
+    const trimmed = stdout.trim();
+    if (trimmed) {
+        try {
+            const ev = JSON.parse(trimmed);
+            fold.consumeEvent(ev);
+            return fold.finish(code, stderr);
+        }
+        catch {
+            // NDJSON / plain text below
+        }
+    }
+    for (const line of stdout.split(/\r?\n/)) {
+        if (line.trim())
+            fold.consumeLine(line);
+    }
+    return fold.finish(code, stderr);
+}
+/**
+ * A worktree-absolute path (`<cwd>\repos\...\file.ts`) is unreadable on a
+ * board that shows five of them stacked — every activity line pays the same
+ * `.harness\worktrees\<unit>-<hash>\` prefix. Show it relative to the
+ * workspace root instead; leave anything outside the workspace alone.
+ *
+ * cursor-agent emits host-native paths (Windows paths on Windows), but the
+ * board and the tests may run on Linux — so pick the path flavour from the
+ * string rather than from `process.platform`.
+ */
+function shortenPath(path, cwd) {
+    if (!path || !cwd)
+        return path;
+    const p = /^[a-zA-Z]:[\\/]|^\\\\/.test(path) ? win32Path : posixPath;
+    if (!p.isAbsolute(path))
+        return path;
+    const rel = p.relative(cwd, path);
+    if (!rel || rel.startsWith(".."))
+        return path;
+    return rel.split(/[\\/]/).join("/");
+}
+function createStreamFolder(onActivity, cwd) {
+    let resultText = "";
+    let costUsd = 0;
+    let turn = 0;
+    let sessionId = "";
+    let tokens = { in: 0, out: 0 };
+    const toolNames = new Map();
+    const emit = (line, kind, tool, target) => {
+        if (!onActivity)
+            return;
+        try {
+            onActivity({
+                line: clamp(line, LINE_CLAMP),
+                turn,
+                tokens: { ...tokens },
+                kind,
+                ...(tool ? { tool } : {}),
+                ...(target ? { target } : {}),
+            });
+        }
+        catch {
+            // broken sink must not fail the session
+        }
+    };
+    const consumeEvent = (ev) => {
+        if (!sessionId && typeof ev.session_id === "string")
+            sessionId = ev.session_id;
+        const usage = usageTokens(ev.usage);
+        if (usage)
+            tokens = usage;
+        costUsd += usageToCostUsd(ev.usage);
+        const type = typeof ev.type === "string" ? ev.type : "";
+        if (type === "tool_call") {
+            const subtype = typeof ev.subtype === "string" ? ev.subtype : "";
+            const callId = typeof ev.call_id === "string" ? ev.call_id : "";
+            const { name, target } = describeToolCall(ev.tool_call, cwd);
+            if (callId && name)
+                toolNames.set(callId, name);
+            if (subtype === "started") {
+                turn += 1;
+                emit(target ? `${name}: ${target}` : name, "tool", name, target || undefined);
+            }
+            else if (subtype === "completed") {
+                // Success completes are redundant with the started line; only surface failures.
+                if (!toolCallSucceeded(ev.tool_call)) {
+                    const detail = toolCallErrorDetail(ev.tool_call);
+                    emit(detail ? `${name} -> error: ${detail}` : `${name} -> error`, "tool-result", name, target || undefined);
+                }
+            }
+            return;
+        }
+        if (type === "assistant") {
+            turn += 1;
+            const text = assistantText(ev);
+            emit(text ? `assistant: ${text}` : "assistant", "text");
+            const fromMsg = pickResultText(ev);
+            if (fromMsg)
+                resultText = fromMsg;
+            return;
+        }
+        if (type === "result" || type === "" || type === "message") {
+            const text = pickResultText(ev);
+            if (text)
+                resultText = text;
+        }
+    };
+    return {
+        consumeLine(line) {
+            const t = line.trim();
+            if (!t)
+                return;
+            try {
+                consumeEvent(JSON.parse(t));
+            }
+            catch {
+                if (!resultText)
+                    resultText = t;
+            }
+        },
+        consumeEvent,
+        finish(code, stderr) {
+            const sid = sessionId ? { sessionId } : {};
+            return code === 0
+                ? { ok: true, resultText, costUsd, ...sid }
+                : {
+                    ok: false,
+                    resultText,
+                    costUsd,
+                    ...sid,
+                    error: stderr.trim() || resultText || `cursor-agent exit ${code}`,
+                };
+        },
+    };
+}
+function describeToolCall(toolCall, cwd) {
+    if (!toolCall || typeof toolCall !== "object") {
+        return { name: "tool", target: "" };
+    }
+    const tc = toolCall;
+    for (const [key, value] of Object.entries(tc)) {
+        if (!key.endsWith("ToolCall") || !value || typeof value !== "object")
+            continue;
+        const name = key.replace(/ToolCall$/, "") || "tool";
+        const body = value;
+        const args = (body.args ?? {});
+        const description = (typeof body.description === "string" && body.description) ||
+            (typeof args.description === "string" && args.description) ||
+            "";
+        const command = typeof args.command === "string" ? args.command : "";
+        const path = (typeof args.path === "string" && args.path) ||
+            (typeof args.targetDirectory === "string" && args.targetDirectory) ||
+            (typeof args.filePath === "string" && args.filePath) ||
+            "";
+        const target = description || command || shortenPath(path, cwd) || "";
+        return { name, target };
+    }
+    return { name: "tool", target: "" };
+}
+function toolCallSucceeded(toolCall) {
+    if (!toolCall || typeof toolCall !== "object")
+        return true;
+    for (const value of Object.values(toolCall)) {
+        if (!value || typeof value !== "object")
+            continue;
+        const result = value.result;
+        if (!result || typeof result !== "object")
+            continue;
+        if ("success" in result)
+            return true;
+        if ("error" in result || "failure" in result)
+            return false;
+    }
+    return true;
+}
+/** One-line error excerpt from a failed tool_call / completed payload. */
+function toolCallErrorDetail(toolCall) {
+    if (!toolCall || typeof toolCall !== "object")
+        return "";
+    for (const value of Object.values(toolCall)) {
+        if (!value || typeof value !== "object")
+            continue;
+        const result = value.result;
+        if (!result || typeof result !== "object")
+            continue;
+        const r = result;
+        if (typeof r.error === "string")
+            return normalizeErrorExcerpt(r.error);
+        if (r.error && typeof r.error === "object") {
+            const err = r.error;
+            const msg = (typeof err.message === "string" && err.message) ||
+                (typeof err.stderr === "string" && err.stderr) ||
+                (typeof err.stdout === "string" && err.stdout) ||
+                "";
+            if (msg)
+                return normalizeErrorExcerpt(msg);
+        }
+        if (typeof r.failure === "string")
+            return normalizeErrorExcerpt(r.failure);
+        if (r.failure && typeof r.failure === "object") {
+            const fail = r.failure;
+            if (typeof fail.message === "string")
+                return normalizeErrorExcerpt(fail.message);
+        }
+        const success = r.success;
+        if (success && typeof success === "object") {
+            const s = success;
+            if (typeof s.exitCode === "number" && s.exitCode !== 0) {
+                return `exit ${s.exitCode}`;
+            }
+        }
+    }
+    return "";
+}
+function normalizeErrorExcerpt(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function assistantText(ev) {
+    const message = ev.message;
+    if (!message || typeof message !== "object")
+        return "";
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string")
+            parts.push(b.text);
+    }
+    return parts.join(" ").trim();
+}
+function pickResultText(ev) {
+    if (typeof ev.result === "string")
+        return ev.result;
+    const fromAssistant = assistantText(ev);
+    if (fromAssistant)
+        return fromAssistant;
+    return (pickString(ev, ["message", "text", "content", "last_message"]) ??
+        (ev.type === "message" ? pickString(ev, ["data"]) : undefined));
+}
+function usageTokens(usage) {
+    if (!usage || typeof usage !== "object")
+        return undefined;
+    const u = usage;
+    const input = (typeof u.inputTokens === "number" ? u.inputTokens : undefined) ??
+        (typeof u.input_tokens === "number" ? u.input_tokens : undefined);
+    const output = (typeof u.outputTokens === "number" ? u.outputTokens : undefined) ??
+        (typeof u.output_tokens === "number" ? u.output_tokens : undefined);
+    if (input === undefined && output === undefined)
+        return undefined;
+    return { in: input ?? 0, out: output ?? 0 };
+}
+function usageToCostUsd(usage) {
+    const t = usageTokens(usage);
+    if (!t)
+        return 0;
+    return (t.in / 1e6) * 3 + (t.out / 1e6) * 15;
+}
+function pickString(o, keys) {
+    for (const k of keys)
+        if (typeof o[k] === "string")
+            return o[k];
+    return undefined;
+}
+function clamp(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, Math.max(0, max - 3)) + "...";
+}
+//# sourceMappingURL=exec.js.map