@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/shared/backends/codex.js

@@ -0,0 +1,287 @@
+import { extractThinkingText, formatToolResultDetail, isEditTool, mergeThinkingText, TOOL_RESULT_DETAIL_LIMIT, stringifyUnknown, } from "./cursor.js";
+import { codexToolIntegration } from "../toolIntegration.js";
+import { codexTurnUsage } from "./usage.js";
+/** Text of a Codex MCP result: `{ content: [{ type: "text", text }] }` or an error. */
+function mcpResultText(rec) {
+    const error = rec.error;
+    if (typeof error === "string" && error.trim())
+        return error;
+    if (error && typeof error === "object" && typeof error.message === "string") {
+        return error.message;
+    }
+    const result = rec.result;
+    if (result && Array.isArray(result.content)) {
+        const text = result.content
+            .map((part) => part && typeof part === "object" && typeof part.text === "string"
+            ? part.text
+            : "")
+            .filter(Boolean)
+            .join("\n");
+        if (text)
+            return text;
+    }
+    return result ? stringifyUnknown(result) : "";
+}
+/**
+ * OpenAI Codex CLI headless backend.
+ * Spawns: `codex exec --json --dangerously-bypass-approvals-and-sandbox …`
+ *
+ * Event stream is JSONL (`thread.*`, `item.*`, `turn.*`).
+ */
+export class CodexBackend {
+    kind = "codex";
+    available = true;
+    command = "codex";
+    buildArgs(opts) {
+        const args = ["exec", "--json"];
+        // Always pin the workspace — Blaxel process workingDir alone is not enough
+        // for Codex to discover the cloned repo (it asks the user for `ls`/`README`).
+        if (opts.cwd?.trim()) {
+            args.push("--cd", opts.cwd.trim());
+        }
+        if (opts.mode === "plan") {
+            args.push("--sandbox", "read-only");
+        }
+        else {
+            args.push("--dangerously-bypass-approvals-and-sandbox");
+        }
+        if (opts.modelId && opts.modelId !== "auto") {
+            args.push("--model", opts.modelId);
+        }
+        for (const [name, server] of Object.entries(opts.mcpServers || {})) {
+            const key = name.replace(/[^A-Za-z0-9_-]/g, "_");
+            const headers = Object.entries(server.headers)
+                .map(([h, v]) => `${JSON.stringify(h)}=${JSON.stringify(v)}`)
+                .join(", ");
+            args.push("-c", `mcp_servers.${key}.url=${JSON.stringify(server.url)}`);
+            if (headers)
+                args.push("-c", `mcp_servers.${key}.http_headers={${headers}}`);
+        }
+        if (opts.sessionId) {
+            args.push("resume", opts.sessionId);
+        }
+        args.push(opts.prompt);
+        return args;
+    }
+    parseLine(json, ctx = {
+        assistantBuf: { value: "" },
+        gotTerminalEvent: { value: false },
+    }) {
+        if (!json || typeof json !== "object")
+            return [];
+        const ev = json;
+        const type = String(ev.type ?? "");
+        const out = [];
+        if (type === "thread.started" && ev.thread_id) {
+            out.push({ kind: "session", sessionId: String(ev.thread_id) });
+            return out;
+        }
+        if (type === "error") {
+            ctx.gotTerminalEvent.value = true;
+            out.push({
+                kind: "error",
+                message: stringifyUnknown(ev.message) ||
+                    stringifyUnknown(ev.error) ||
+                    ctx.stderr ||
+                    "Codex error",
+            });
+            return out;
+        }
+        if (type === "turn.failed") {
+            ctx.gotTerminalEvent.value = true;
+            out.push({
+                kind: "error",
+                message: stringifyUnknown(ev.error) ||
+                    stringifyUnknown(ev.message) ||
+                    ctx.stderr ||
+                    "Codex turn failed",
+            });
+            return out;
+        }
+        if (type === "turn.completed") {
+            ctx.gotTerminalEvent.value = true;
+            out.push({
+                kind: "done",
+                result: ctx.assistantBuf.value || "",
+                usage: codexTurnUsage(ev),
+            });
+            return out;
+        }
+        if (type === "item.started" ||
+            type === "item.updated" ||
+            type === "item.completed") {
+            const item = ev.item;
+            if (!item || typeof item !== "object")
+                return out;
+            const rec = item;
+            const itemType = String(rec.type ?? "");
+            const callId = String(rec.id ?? `${itemType}-${type}`);
+            if (itemType === "agent_message") {
+                const text = typeof rec.text === "string" ? rec.text : "";
+                if (!text)
+                    return out;
+                if (type === "item.completed") {
+                    ctx.assistantBuf.value = text;
+                    out.push({ kind: "assistant_final", text });
+                }
+                else if (text.length >= ctx.assistantBuf.value.length) {
+                    ctx.assistantBuf.value = text;
+                    out.push({ kind: "assistant_delta", text });
+                }
+                return out;
+            }
+            if (itemType === "reasoning" ||
+                itemType === "agent_reasoning" ||
+                itemType === "reasoning_text") {
+                if (ctx.toolsOnly)
+                    return out;
+                const text = extractThinkingText(rec);
+                if (!text)
+                    return out;
+                ctx.thinkingBuf ??= { value: "" };
+                const merged = mergeThinkingText(ctx.thinkingBuf.value, text);
+                if (merged === ctx.thinkingBuf.value)
+                    return out;
+                ctx.thinkingBuf.value = merged;
+                out.push({
+                    kind: type === "item.completed" ? "thinking_final" : "thinking_delta",
+                    text: merged,
+                });
+                return out;
+            }
+            if (itemType === "command_execution") {
+                const command = typeof rec.command === "string" ? rec.command : "shell";
+                const path = firstPath(rec);
+                if (type === "item.started") {
+                    out.push({
+                        kind: "tool_start",
+                        callId,
+                        name: "Bash",
+                        detail: command,
+                        path,
+                    });
+                }
+                else if (type === "item.completed") {
+                    const output = typeof rec.aggregated_output === "string"
+                        ? rec.aggregated_output
+                        : typeof rec.output === "string"
+                            ? rec.output
+                            : command;
+                    out.push({
+                        kind: "tool_done",
+                        callId,
+                        name: "Bash",
+                        detail: formatToolResultDetail("Bash", { command }, { success: { content: output } }, output),
+                        path,
+                    });
+                }
+                return out;
+            }
+            if (itemType === "mcp_tool_call") {
+                const integration = codexToolIntegration(rec);
+                const server = typeof rec.server === "string" ? rec.server : "mcp";
+                const tool = typeof rec.tool === "string" ? rec.tool : "tool";
+                const name = `mcp__${server}__${tool}`;
+                let args = "";
+                try {
+                    args = rec.arguments == null ? "" : JSON.stringify(rec.arguments);
+                }
+                catch {
+                    args = "";
+                }
+                if (type === "item.started") {
+                    out.push({
+                        kind: "tool_start",
+                        callId,
+                        name,
+                        detail: args || tool,
+                        ...(integration ? { integration } : {}),
+                    });
+                }
+                else if (type === "item.completed") {
+                    out.push({
+                        kind: "tool_done",
+                        callId,
+                        name,
+                        detail: (mcpResultText(rec) || args || "Done").slice(0, TOOL_RESULT_DETAIL_LIMIT),
+                        ...(integration ? { integration } : {}),
+                    });
+                }
+                return out;
+            }
+            if (itemType === "file_change") {
+                const name = "Edit";
+                const path = firstPath(rec);
+                const detail = typeof rec.command === "string"
+                    ? rec.command
+                    : path || name;
+                if (type === "item.started") {
+                    out.push({
+                        kind: "tool_start",
+                        callId,
+                        name: isEditTool(name) ? name : name,
+                        detail: String(detail),
+                        path,
+                    });
+                }
+                else if (type === "item.completed") {
+                    out.push({
+                        kind: "tool_done",
+                        callId,
+                        name,
+                        detail: String(detail).slice(0, TOOL_RESULT_DETAIL_LIMIT),
+                        path,
+                    });
+                }
+                return out;
+            }
+            if (itemType === "todo_list" && Array.isArray(rec.items)) {
+                const todos = rec.items
+                    .filter((row) => Boolean(row && typeof row === "object"))
+                    .map((row, index) => {
+                    const raw = String(row.status ?? "");
+                    const status = raw === "completed" ||
+                        raw === "in_progress" ||
+                        raw === "cancelled"
+                        ? raw
+                        : "pending";
+                    return {
+                        id: String(row.id ?? `todo-${index}`),
+                        content: String(row.text ?? row.content ?? ""),
+                        status,
+                    };
+                });
+                if (todos.length) {
+                    out.push({
+                        kind: type === "item.started" ? "tool_start" : "tool_done",
+                        callId,
+                        name: "todo",
+                        detail: `${todos.length} todos`,
+                        todos,
+                    });
+                }
+                return out;
+            }
+        }
+        return out;
+    }
+}
+function firstPath(rec) {
+    for (const key of ["path", "file_path", "filePath", "target_file"]) {
+        if (typeof rec[key] === "string" && rec[key].trim()) {
+            return String(rec[key]).trim();
+        }
+    }
+    const changes = rec.changes;
+    if (Array.isArray(changes)) {
+        for (const change of changes) {
+            if (change && typeof change === "object" && "path" in change) {
+                const path = String(change.path ?? "").trim();
+                if (path)
+                    return path;
+            }
+        }
+    }
+    return undefined;
+}
+export const codexBackend = new CodexBackend();

package/dist/shared/backends/cursor.d.ts

@@ -0,0 +1,111 @@
+import type { AgentTodoItem, ClarifyingQuestion } from "../events.js";
+import type { BuildArgsOptions, NormalizedAgentEvent, ParseLineContext, WorkerBackend } from "./types.js";
+/**
+ * Turn unknown thrown values / CLI payloads into a user-visible string.
+ * Never returns "[object Object]". Lives here so Next (extensionless) and
+ * Node ESM (`*.js`) both resolve it without a new shared module.
+ */
+export declare function stringifyUnknown(value: unknown, fallback?: string, depth?: number): string;
+export declare function errorMessage(err: unknown, fallback?: string): string;
+/** Whether a tool name represents an agent asking the user clarifying questions. */
+export declare function isQuestionTool(name: string): boolean;
+/** Parse structured clarifying questions from a tool's args (Claude AskUserQuestion, etc). */
+export declare function parseQuestionToolArgs(args: Record<string, unknown> | unknown): ClarifyingQuestion[];
+/**
+ * Merge a new assistant payload into the accumulated stream.
+ * Cursor `--stream-partial-output` may send either token deltas or a growing
+ * snapshot of the same message. Blind concatenation duplicates the paragraph;
+ * blindly replacing with a shorter payload truncates it.
+ */
+export declare function mergeAssistantText(prev: string, incoming: string): string;
+/** Collapse hard wraps so thinking reads as prose, not one phrase per line. */
+export declare function normalizeThinkingText(text: string): string;
+/** Merge streamed thinking: snapshots replace, deltas append with a space. */
+export declare function mergeThinkingText(prev: string, incoming: string): string;
+/**
+ * Cursor CLI streams thinking as phrase-sized JSON lines that are not prefixes
+ * of each other. Always concatenate; a new thought starts only after tools
+ * (`afterTools` in RoomManager).
+ */
+export declare function advanceThinking(prev: string, incoming: string): {
+    finalize?: string;
+    current: string;
+};
+/** Pull visible model thinking / reasoning out of a CLI or SDK payload. */
+export declare function extractThinkingText(source: unknown): string;
+/**
+ * Failure message for a finished tool call, or null when it succeeded.
+ * Covers SDK `{status:"error", error}` results / call status, CLI
+ * `{failure}` / `{error}` / `{rejected}` results and MCP `isError` replies.
+ */
+export declare function toolResultError(result: unknown, callStatus?: string): string | null;
+/** Readable start-of-call detail for tools whose args aren't a path/command. */
+export declare function structuredToolDetail(name: string, args: Record<string, unknown>): string | undefined;
+/** Max chars of tool result text we persist into chat content. */
+export declare const TOOL_RESULT_DETAIL_LIMIT = 100000;
+/** `$ command` plus its full stdout/stderr for the tool-call card. */
+export declare function formatToolTranscript(command: string | undefined, output: string | undefined): string;
+/**
+ * Keep the start-time command/args when a tool_done only has the result,
+ * so the chat card can show input and output together.
+ */
+export declare function mergeToolStartAndResult(name: string, start: string | undefined, result: string): string;
+/** Unwrap CLI `{success:{…}}` / SDK `{status,value}` / bare object result shapes. */
+export declare function unwrapToolResultPayload(result: unknown): Record<string, unknown> | null;
+/**
+ * Human-readable tool output for chat. Prefers completed `result` payloads
+ * (stdout, file content, diff summary) over the start-time args summary.
+ */
+export declare function formatToolResultDetail(name: string, args: Record<string, unknown> | undefined, result: unknown, fallback?: string): string;
+/**
+ * Pull a unified diff out of a completed tool `result` payload.
+ * Cursor editToolCall puts the real patch in `result.success.diffString`.
+ */
+export declare function diffFromToolResult(result: unknown, pathHint?: string): string;
+export declare function diffFromToolArgs(toolName: string, args?: Record<string, unknown>): string;
+/** Prefer result.diffString, then synthesize from args. */
+export declare function diffFromToolEvent(toolName: string, args?: Record<string, unknown>, result?: unknown): string;
+export declare function isEditTool(name: string): boolean;
+export declare function isTodoTool(name: string): boolean;
+export declare function todosFromToolArgs(args?: unknown): AgentTodoItem[];
+/**
+ * Recover structured todos from a chat message — prefers `message.todos`,
+ * then parses JSON tool args that older servers stored as `content`.
+ */
+export declare function resolveMessageTodos(message: {
+    todos?: AgentTodoItem[];
+    content?: string;
+    toolName?: string;
+}): AgentTodoItem[];
+/** Whether a chat tool message should render as the Todos card. */
+export declare function messageHasTodos(message: {
+    role?: string;
+    todos?: AgentTodoItem[];
+    content?: string;
+    toolName?: string;
+}): boolean;
+/**
+ * Keep only the latest todos card per agent so successive TodoWrite updates
+ * (2 → 3 → 4 items) don't stack as separate groups in the timeline.
+ */
+export declare function coalesceTodoMessages<T extends {
+    id: string;
+    role: string;
+    agentId?: string;
+    todos?: AgentTodoItem[];
+    content?: string;
+    toolName?: string;
+}>(messages: T[]): T[];
+export declare function todoStatusSummary(todos: AgentTodoItem[]): string;
+/**
+ * Cursor CLI headless agent backend.
+ * Spawns: `cursor agent --print --output-format stream-json ...`
+ */
+export declare class CursorAgentBackend implements WorkerBackend {
+    readonly kind: "cursor";
+    readonly available = true;
+    readonly command = "cursor";
+    buildArgs(opts: BuildArgsOptions): string[];
+    parseLine(json: unknown, ctx?: ParseLineContext): NormalizedAgentEvent[];
+}
+export declare const cursorAgentBackend: CursorAgentBackend;