@proagentstore/cli 0.4.56 → 0.4.58

package/dist/browser-runner/coding/engine-acts.js

@@ -29,10 +29,10 @@
  *
  * ── THE HONEST GAP ──
  *
- * Only a stream-json engine (Claude Code) produces these. A raw Codex/Grok session emits nothing
- * parseable, so it records no acts — the same gap, for the same reason, as engine usage (#267). An
- * empty act list therefore means "nothing observed", never "nothing happened", and every consumer
- * has to say so rather than render it as an all-clear.
+ * Only structured engines produce these. Claude Code emits `tool_use`/`tool_result`; Codex
+ * `exec --json` emits `command_execution` events that the adapter normalizes to the same shape.
+ * A raw engine emits nothing parseable, so an empty act list means "nothing observed", never
+ * "nothing happened", and every consumer has to say so rather than render it as an all-clear.
  */
 /** Acts whose consequences reach outside the machine, or cannot be walked back locally. */
 const IRREVERSIBLE = new Set([
@@ -183,9 +183,9 @@ function wantsPrNumber(act) {
  * true costs more than it saves. The act still carries `ok: false`, so the record remains honest
  * that the command failed.
  *
- * Only reachable from the structured stream-json path. A Codex/Grok raw spawn has no
- * `tool_use`/`tool_result` framing at all, so its PRs stay unattributed — regexing its transcript
- * instead would reintroduce exactly the temporal guess this design refuses.
+ * Only reachable from structured adapter events. A raw spawn has no `tool_use`/`tool_result`
+ * framing at all, so its PRs stay unattributed — regexing its transcript instead would reintroduce
+ * exactly the temporal guess this design refuses.
  */
 export function fillTargetFromResult(acts, content) {
     if (!acts.some(wantsPrNumber))

package/dist/browser-runner/coding/engine-adapter.js

@@ -0,0 +1,186 @@
+export function engineInvocationModeFromAdapter(mode) {
+    return mode === "stream-json" ? "structured" : "raw";
+}
+export function structuredCapableEngine(clientType) {
+    return clientType === "claude" || clientType === "codex";
+}
+export function engineInvocationWarning(clientType, mode) {
+    if (mode !== "raw" || clientType !== "claude")
+        return null;
+    return `running raw — structured not available on this machine's ${clientType} CLI`;
+}
+const RESERVED_CLAUDE_FLAGS = new Set(["-p", "--print", "--input-format", "--output-format", "--verbose", "--resume"]);
+/** Structural flags PAGS owns for Claude's stream-json engine. */
+export function buildClaudeArgs(userArgs, resumeId) {
+    const args = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"];
+    for (let i = 0; i < userArgs.length; i++) {
+        const a = userArgs[i];
+        if (RESERVED_CLAUDE_FLAGS.has(a)) {
+            if (i + 1 < userArgs.length && !userArgs[i + 1].startsWith("-"))
+                i++;
+            continue;
+        }
+        args.push(a);
+    }
+    if (!args.includes("--dangerously-skip-permissions"))
+        args.push("--dangerously-skip-permissions");
+    if (resumeId)
+        args.push("--resume", resumeId);
+    return args;
+}
+function record(v) {
+    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function contentBlocks(ev) {
+    const message = record(ev.message);
+    const content = Array.isArray(message?.content) ? message.content : [];
+    return content.flatMap((block) => {
+        const r = record(block);
+        return r ? [r] : [];
+    });
+}
+function parseClaudeLine(line) {
+    let ev;
+    try {
+        const parsed = JSON.parse(line);
+        const parsedRecord = record(parsed);
+        if (!parsedRecord)
+            return [];
+        ev = parsedRecord;
+    }
+    catch {
+        return [];
+    }
+    const type = typeof ev.type === "string" ? ev.type : "";
+    switch (type) {
+        case "system": {
+            if (ev.subtype === "init" && typeof ev.session_id === "string" && ev.session_id)
+                return [{ kind: "session", sessionId: ev.session_id }];
+            return [];
+        }
+        case "assistant":
+            return contentBlocks(ev).flatMap((block) => {
+                if (block.type === "text" && typeof block.text === "string" && block.text.trim())
+                    return [{ kind: "assistant_text", text: block.text.trim() }];
+                if (block.type !== "tool_use")
+                    return [];
+                const name = String(block.name ?? "tool");
+                return [
+                    {
+                        kind: "tool_use",
+                        block,
+                        id: typeof block.id === "string" ? block.id : "",
+                        name,
+                        input: block.input,
+                    },
+                ];
+            });
+        case "user":
+            return contentBlocks(ev).flatMap((block) => {
+                if (block.type !== "tool_result")
+                    return [];
+                return [
+                    {
+                        kind: "tool_result",
+                        block,
+                        toolUseId: typeof block.tool_use_id === "string" ? block.tool_use_id : "",
+                        content: block.content,
+                    },
+                ];
+            });
+        case "result": {
+            const result = typeof ev.result === "string" ? ev.result : typeof ev.subtype === "string" ? ev.subtype : "failed";
+            return [{ kind: "turn_end", raw: ev, isError: ev.is_error === true, result }];
+        }
+        default:
+            return [];
+    }
+}
+export const claudeEngineAdapter = {
+    mode: "stream-json",
+    persistent: true,
+    buildLaunchArgs: buildClaudeArgs,
+    buildTurnArgs: (userArgs, turnText) => [...userArgs, turnText],
+    parseLine: parseClaudeLine,
+};
+function hasFlag(args, flag) {
+    return args.some((a) => a === flag || a.startsWith(`${flag}=`));
+}
+function buildCodexExecArgs(userArgs, turnText) {
+    const args = [...userArgs];
+    if (!hasFlag(args, "--json"))
+        args.splice(1, 0, "--json");
+    args.push(turnText);
+    return args;
+}
+function parseCodexLine(line) {
+    let ev;
+    try {
+        const parsed = JSON.parse(line);
+        const parsedRecord = record(parsed);
+        if (!parsedRecord)
+            return [];
+        ev = parsedRecord;
+    }
+    catch {
+        return [];
+    }
+    const type = typeof ev.type === "string" ? ev.type : "";
+    const item = record(ev.item);
+    if (type === "thread.started" && typeof ev.thread_id === "string" && ev.thread_id)
+        return [{ kind: "session", sessionId: ev.thread_id }];
+    if (type === "turn.completed" || type === "turn.failed") {
+        const result = typeof ev.error === "string" ? ev.error : typeof ev.message === "string" ? ev.message : type === "turn.failed" ? "failed" : "";
+        return [{ kind: "turn_end", raw: ev, isError: type === "turn.failed", result }];
+    }
+    if (!item)
+        return [];
+    const itemType = typeof item.type === "string" ? item.type : "";
+    if (type === "item.completed" && itemType === "agent_message" && typeof item.text === "string" && item.text.trim()) {
+        return [{ kind: "assistant_text", text: item.text.trim() }];
+    }
+    if (itemType !== "command_execution")
+        return [];
+    const id = typeof item.id === "string" ? item.id : "";
+    const command = typeof item.command === "string" ? item.command : "";
+    const block = type === "item.completed"
+        ? {
+            type: "tool_result",
+            tool_use_id: id,
+            is_error: item.status === "failed" || (typeof item.exit_code === "number" && item.exit_code !== 0),
+            content: typeof item.aggregated_output === "string" ? item.aggregated_output : "",
+        }
+        : {
+            type: "tool_use",
+            id,
+            name: "Bash",
+            input: { command },
+        };
+    if (type === "item.completed") {
+        return [{ kind: "tool_result", block, toolUseId: id, content: block.content }];
+    }
+    if (type === "item.started" && command)
+        return [{ kind: "tool_use", block, id, name: "Bash", input: { command } }];
+    return [];
+}
+export const codexEngineAdapter = {
+    mode: "stream-json",
+    persistent: false,
+    buildLaunchArgs: (userArgs) => [...userArgs],
+    buildTurnArgs: buildCodexExecArgs,
+    parseLine: parseCodexLine,
+};
+export const genericRawEngineAdapter = {
+    mode: "raw",
+    persistent: false,
+    buildLaunchArgs: (userArgs) => [...userArgs],
+    buildTurnArgs: (userArgs, turnText) => [...userArgs, turnText],
+    parseLine: () => [],
+};
+export function engineAdapterFor(clientType, userArgs = []) {
+    if (clientType === "claude")
+        return claudeEngineAdapter;
+    if (clientType === "codex" && userArgs[0] === "exec" && !["resume", "fork", "review", "help"].includes(userArgs[1] ?? ""))
+        return codexEngineAdapter;
+    return genericRawEngineAdapter;
+}

package/dist/browser-runner/coding/engine-usage.js

@@ -12,9 +12,10 @@
  * whole ledger that is NOT an estimate, so it is carried through as reported rather than being
  * re-derived from `ai-pricing.ts` list prices.
  *
- * Raw (non-Claude) engines never reach this module: `HeadlessSession` only parses JSON in
- * stream-json mode, so a Codex/Grok session produces no records at all. That is deliberate —
- * a zero row would read as "this engine is free", which is a worse lie than a gap.
+ * Raw engines never reach this module: `HeadlessSession` only parses usage from structured engine
+ * events. Codex `exec --json` reports tokens but no dollar figure on the observed 0.151.0 schema,
+ * so those rows carry provider `openai`, model `codex`, and `costUsd: 0` without pretending the CLI
+ * reported a price.
  */
 const num = (v) => {
     const n = Number(v);
@@ -55,6 +56,8 @@ export function parseEngineUsage(ev, fallbackId) {
     if (!ev || typeof ev !== "object")
         return null;
     const e = ev;
+    if (e.type === "turn.completed")
+        return parseCodexUsage(e, fallbackId);
     if (e.type !== "result")
         return null;
     const usage = (e.usage && typeof e.usage === "object" ? e.usage : {});
@@ -68,6 +71,7 @@ export function parseEngineUsage(ev, fallbackId) {
     const uuid = typeof e.uuid === "string" && e.uuid.trim() ? e.uuid.trim() : "";
     return {
         id: uuid || fallbackId,
+        provider: "anthropic",
         model: pickModel(e.modelUsage),
         inputTokens,
         outputTokens,
@@ -77,3 +81,23 @@ export function parseEngineUsage(ev, fallbackId) {
         at: new Date().toISOString(),
     };
 }
+function parseCodexUsage(e, fallbackId) {
+    const usage = (e.usage && typeof e.usage === "object" ? e.usage : {});
+    const inputTokens = num(usage.input_tokens);
+    const outputTokens = num(usage.output_tokens);
+    const cacheReadTokens = num(usage.cached_input_tokens);
+    const cacheWriteTokens = num(usage.cache_write_input_tokens);
+    if (!inputTokens && !outputTokens && !cacheReadTokens && !cacheWriteTokens)
+        return null;
+    return {
+        id: fallbackId,
+        provider: "openai",
+        model: "codex",
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        costUsd: 0,
+        at: new Date().toISOString(),
+    };
+}