@getforgeai/cli 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/orchestrator/codex-jsonl-extractor.js

@@ -0,0 +1,210 @@
+import { vmLog } from "../vm/log.js";
+import { extractResetTimestampFromTexts, matchesBillingPatterns, } from "./billing-detect.js";
+import { TOOL_DETAIL_EXTRACTORS } from "./stream-json-extractor.js";
+/**
+ * Extracts normalized events from Codex CLI's `codex exec --json` output.
+ *
+ * Codex emits newline-delimited JSON "thread events":
+ *   {"type":"thread.started","thread_id":"..."}
+ *   {"type":"turn.started"}
+ *   {"type":"item.started"|"item.updated"|"item.completed","item":{...}}
+ *   {"type":"turn.completed","usage":{"input_tokens":N,"cached_input_tokens":N,"output_tokens":N}}
+ *   {"type":"turn.failed","error":{...}} / {"type":"error","message":"..."}
+ *
+ * Item types: agent_message (text), reasoning, command_execution,
+ * file_change, mcp_tool_call, web_search, todo_list.
+ *
+ * Exposes the same callback surface as StreamJsonExtractor so the spawn
+ * pipeline (StreamBatcher → Socket.io) is unchanged. Codex has no equivalent
+ * of Claude's AskUserQuestion tool — structured questions reach the Cloud via
+ * the forge_ask_human MCP tool instead, so onQuestion is never called here.
+ */
+export class CodexJsonlExtractor {
+    onText;
+    lineBuf = "";
+    /** Emitted text length per agent_message item id (suffix dedup). */
+    emittedTextLengths = new Map();
+    /** Item ids already reported as tool activity. */
+    emittedActivityIds = new Set();
+    /** Whether any text was emitted (to separate consecutive messages). */
+    hasEmittedText = false;
+    turnIndex = 0;
+    lastError = null;
+    /** Codex thread id from thread.started — usable with `codex exec resume`. */
+    threadId = null;
+    inputTokens = 0;
+    outputTokens = 0;
+    onToolActivity;
+    onTokenUsage;
+    sessionId;
+    constructor(onText, _onQuestion, onToolActivity, onTokenUsage, sessionId) {
+        this.onText = onText;
+        this.onToolActivity = onToolActivity;
+        this.onTokenUsage = onTokenUsage;
+        this.sessionId = sessionId;
+    }
+    write(data) {
+        this.lineBuf += data;
+        let newlineIdx;
+        while ((newlineIdx = this.lineBuf.indexOf("\n")) !== -1) {
+            const line = this.lineBuf.slice(0, newlineIdx).trim();
+            this.lineBuf = this.lineBuf.slice(newlineIdx + 1);
+            if (line)
+                this.parseLine(line);
+        }
+    }
+    flush() {
+        const line = this.lineBuf.trim();
+        this.lineBuf = "";
+        if (line)
+            this.parseLine(line);
+    }
+    parseLine(line) {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            vmLog.dim("codex-jsonl", "Non-JSON line skipped", this.sessionId);
+            return;
+        }
+        switch (obj.type) {
+            case "thread.started":
+                if (typeof obj.thread_id === "string")
+                    this.threadId = obj.thread_id;
+                break;
+            case "turn.started":
+                this.turnIndex++;
+                break;
+            case "turn.completed":
+                this.handleUsage(obj.usage);
+                break;
+            case "turn.failed":
+                this.captureError(obj.error ?? obj);
+                break;
+            case "error":
+                this.captureError(obj);
+                break;
+            case "item.started":
+            case "item.updated":
+            case "item.completed":
+                this.handleItem(obj.item);
+                break;
+        }
+    }
+    handleUsage(usage) {
+        if (!usage || !this.onTokenUsage)
+            return;
+        // Codex's input_tokens already includes cached_input_tokens — don't
+        // double-count the cache portion.
+        const input = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+        const output = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+        if (input === 0 && output === 0)
+            return;
+        this.inputTokens += input;
+        this.outputTokens += output;
+        this.onTokenUsage({
+            inputTokens: this.inputTokens,
+            outputTokens: this.outputTokens,
+        });
+    }
+    captureError(error) {
+        if (typeof error === "string") {
+            this.lastError = error;
+            return;
+        }
+        if (error && typeof error === "object") {
+            const rec = error;
+            if (typeof rec.message === "string") {
+                this.lastError = rec.message;
+                return;
+            }
+            this.lastError = JSON.stringify(rec).slice(0, 1000);
+        }
+    }
+    handleItem(item) {
+        if (!item || typeof item.id !== "string")
+            return;
+        switch (item.type) {
+            case "agent_message":
+                if (typeof item.text === "string") {
+                    this.emitTextDelta(item.id, item.text);
+                }
+                break;
+            case "command_execution":
+                this.emitActivityOnce(item.id, "Bash", firstLine(item.command, 80));
+                break;
+            case "file_change":
+                this.emitActivityOnce(item.id, "Edit", describeFileChanges(item));
+                break;
+            case "mcp_tool_call":
+                this.emitMcpToolCall(item);
+                break;
+            case "web_search":
+                this.emitActivityOnce(item.id, "WebSearch", truncate(item.query, 60));
+                break;
+            // reasoning / todo_list: not surfaced
+        }
+    }
+    /** Emit only the not-yet-emitted suffix of an item's text. */
+    emitTextDelta(itemId, fullText) {
+        const emitted = this.emittedTextLengths.get(itemId) ?? 0;
+        if (fullText.length <= emitted)
+            return;
+        const delta = fullText.slice(emitted);
+        this.emittedTextLengths.set(itemId, fullText.length);
+        // Separate consecutive agent messages with a blank line
+        const prefix = emitted === 0 && this.hasEmittedText ? "\n\n" : "";
+        this.hasEmittedText = true;
+        this.onText(prefix + delta);
+    }
+    emitActivityOnce(itemId, toolName, detail) {
+        if (!this.onToolActivity)
+            return;
+        if (this.emittedActivityIds.has(itemId))
+            return;
+        this.emittedActivityIds.add(itemId);
+        this.onToolActivity({ toolName, toolDetail: detail ?? toolName });
+    }
+    emitMcpToolCall(item) {
+        const tool = typeof item.tool === "string" ? item.tool : "mcp";
+        let detail = null;
+        const extractor = TOOL_DETAIL_EXTRACTORS[tool];
+        const args = item.arguments;
+        if (extractor && args && typeof args === "object") {
+            detail = extractor(args);
+        }
+        this.emitActivityOnce(item.id, tool, detail);
+    }
+    isBillingError(extraText) {
+        return matchesBillingPatterns([this.lastError, extraText]);
+    }
+    extractResetTimestamp(extraText) {
+        return extractResetTimestampFromTexts([this.lastError, extraText]);
+    }
+}
+function truncate(value, maxLen) {
+    if (typeof value !== "string" || !value)
+        return null;
+    return value.length > maxLen ? value.slice(0, maxLen - 3) + "..." : value;
+}
+function firstLine(value, maxLen) {
+    if (typeof value !== "string" || !value)
+        return null;
+    const line = value.split("\n")[0] ?? value;
+    return line.length > maxLen ? line.slice(0, maxLen - 3) + "..." : line;
+}
+function describeFileChanges(item) {
+    const changes = item.changes;
+    if (!Array.isArray(changes) || changes.length === 0)
+        return null;
+    const first = changes[0];
+    const path = typeof first.path === "string" ? first.path : null;
+    if (!path)
+        return null;
+    const shortPath = path.length > 60 ? "..." + path.slice(-(60 - 3)) : path;
+    return changes.length > 1
+        ? `${shortPath} (+${changes.length - 1} more)`
+        : shortPath;
+}
+//# sourceMappingURL=codex-jsonl-extractor.js.map

package/dist/orchestrator/connectors/connector.d.ts

@@ -25,6 +25,8 @@ export type SpawnParams = {
     skillName: string;
     /** Custom prompt override — used for workflow step agents */
     prompt?: string;
+    /** Agent engine to run (AGENT_TYPE) — defaults to CLAUDE_CODE. */
+    agentType?: string;
 };
 /**
  * Extended spawn params for VM connector — includes repo/branch/skill context