@basou/core 0.34.0 → 0.35.1

package/dist/index.d.ts

@@ -857,11 +857,20 @@ type CodexRolloutToPayloadOptions = {
  * provenance-level events from the rollout's message-level records:
  *
  * - `session_started` / `session_ended` from the first / last timestamped record.
- * - `command_executed` from each `exec_command` function call, recorded as
- *   `bash -c "<cmd>"`. The shell line and working directory come from the
- *   call's JSON `arguments` (`{ cmd, workdir }`); the exit code and duration
- *   are parsed from the paired `function_call_output` (matched by `call_id`),
- *   whose text carries `Process exited with code N` and `Wall time: X seconds`.
+ * - `command_executed` from each shell execution, recorded as `bash -c "<cmd>"`.
+ *   Codex has written these two different ways, and BOTH are read (an operator's
+ *   `~/.codex/sessions` holds a mix across a CLI upgrade):
+ *     - one `function_call` named `exec_command` per command, with JSON
+ *       `arguments` (`{ cmd, workdir }`) and a `function_call_output` whose text
+ *       carries `Process exited with code N` / `Wall time: X seconds`;
+ *     - a scripted `custom_tool_call` (see
+ *       {@link readExecCommandsFromScript}) whose `input` is a JS program that
+ *       calls `tools.exec_command({ cmd, workdir })` — possibly several times in
+ *       one call — and whose output reports only `Wall time X seconds` for the
+ *       whole script, with no per-command exit code.
+ *   Reading only the first shape made every session recorded by a CLI that had
+ *   moved to the second derive ZERO commands, so the whole session was dropped
+ *   as "no actions" — capture went silently blind rather than degrading.
  *
  * Per-session `metrics` are also derived: token totals from the cumulative
  * `token_count` events; active time from the real `task_started` ->

package/dist/index.js

@@ -701,6 +701,32 @@ function codexRolloutToImportPayload(records, options) {
       continue;
     }
     if (readString4(record.type) !== "response_item") continue;
+    if (readString4(payload2.type) === "custom_tool_call") {
+      if (readString4(payload2.name) !== SCRIPT_TOOL_NAME) continue;
+      const scan = scanScript(readString4(payload2.input));
+      if (scan.commands.length === 0) continue;
+      const output2 = readCallId(payload2.call_id, outputsByCallId);
+      const durationMs = scan.toolCallCount === 1 ? parseWallTimeMs(output2) : 0;
+      const scriptTsMs = Date.parse(ts);
+      if (Number.isFinite(scriptTsMs)) engagementTsMs.push(scriptTsMs);
+      for (const command2 of scan.commands) {
+        derived.push(
+          // The per-command exit code is absent from this format (the script
+          // would have to print it), so it stays null — "unknown", not "0".
+          commandExecutedEvent2(
+            ts,
+            placeholderSessionId,
+            command2.cmd,
+            command2.workdir ?? workingDir ?? ".",
+            {
+              exitCode: null,
+              durationMs
+            }
+          )
+        );
+      }
+      continue;
+    }
     if (readString4(payload2.type) !== "function_call") continue;
     if (readString4(payload2.name) !== "exec_command") continue;
     const command = readExecCommand(payload2.arguments);
@@ -840,6 +866,250 @@ function readCallId(value, outputs) {
   const callId = readString4(value);
   return callId !== void 0 ? outputs.get(callId) : void 0;
 }
+var SCRIPT_TOOL_NAME = "exec";
+var TOOL_CALL_PREFIX = "tools.";
+var EXEC_TOOL = "exec_command";
+function scanScript(script) {
+  const scan = { commands: [], toolCallCount: 0 };
+  if (script === void 0) return scan;
+  try {
+    collectScriptCalls(script, scan);
+  } catch {
+  }
+  return scan;
+}
+function collectScriptCalls(script, scan) {
+  let i = 0;
+  while (i < script.length) {
+    const skipped = skipNonCode(script, i);
+    if (skipped !== i) {
+      if (skipped === -1) return;
+      i = skipped;
+      continue;
+    }
+    if (!script.startsWith(TOOL_CALL_PREFIX, i) || isIdentifierChar(script[i - 1])) {
+      i++;
+      continue;
+    }
+    const nameStart = i + TOOL_CALL_PREFIX.length;
+    const nameEnd = readIdentifierEnd(script, nameStart);
+    const open = skipWhitespaceAndComments(script, nameEnd);
+    if (nameEnd === nameStart || open === -1 || script[open] !== "(") {
+      i = nameStart;
+      continue;
+    }
+    scan.toolCallCount++;
+    const argsStart = skipWhitespaceAndComments(script, open + 1);
+    i = open + 1;
+    if (argsStart === -1 || script[argsStart] !== "{") continue;
+    const argsEnd = findObjectEnd(script, argsStart);
+    if (argsEnd === -1) return;
+    i = argsStart + 1;
+    if (script.slice(nameStart, nameEnd) !== EXEC_TOOL) continue;
+    const command = readExecArguments(script.slice(argsStart, argsEnd + 1));
+    if (command !== void 0) scan.commands.push(command);
+  }
+}
+function isIdentifierChar(ch) {
+  return ch !== void 0 && /[A-Za-z0-9_$]/.test(ch);
+}
+function skipNonCode(script, at) {
+  const ch = script[at];
+  if (ch === '"' || ch === "'" || ch === "`") return skipStringLiteral(script, at);
+  if (ch !== "/") return at;
+  const next = script[at + 1];
+  if (next === "/") {
+    const eol = script.indexOf("\n", at + 2);
+    return eol === -1 ? script.length : eol + 1;
+  }
+  if (next === "*") {
+    const end = script.indexOf("*/", at + 2);
+    return end === -1 ? -1 : end + 2;
+  }
+  return at;
+}
+function skipStringLiteral(script, at) {
+  const quote = script[at];
+  for (let i = at + 1; i < script.length; i++) {
+    const ch = script[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === quote) return i + 1;
+    if (quote === "`" && ch === "$" && script[i + 1] === "{") {
+      const end = findObjectEnd(script, i + 1);
+      if (end === -1) return -1;
+      i = end;
+    }
+  }
+  return -1;
+}
+function skipWhitespaceAndComments(script, at) {
+  let i = at;
+  while (i < script.length) {
+    if (/\s/.test(script[i] ?? "")) {
+      i++;
+      continue;
+    }
+    if (script[i] !== "/") return i;
+    const skipped = skipNonCode(script, i);
+    if (skipped === -1) return -1;
+    if (skipped === i) return i;
+    i = skipped;
+  }
+  return i;
+}
+function readIdentifierEnd(script, start) {
+  let i = start;
+  while (i < script.length && /[A-Za-z0-9_$]/.test(script[i] ?? "")) i++;
+  return i;
+}
+function findObjectEnd(script, start) {
+  const closers = { "{": "}", "(": ")", "[": "]" };
+  const stack = [];
+  let i = start;
+  while (i < script.length) {
+    const skipped = skipNonCode(script, i);
+    if (skipped === -1) return -1;
+    if (skipped !== i) {
+      i = skipped;
+      continue;
+    }
+    const ch = script[i] ?? "";
+    const closer = closers[ch];
+    if (closer !== void 0) {
+      stack.push(closer);
+    } else if (ch === "}" || ch === ")" || ch === "]") {
+      if (stack.pop() !== ch) return -1;
+      if (stack.length === 0) return i;
+    }
+    i++;
+  }
+  return -1;
+}
+function readExecArguments(literal) {
+  const values = /* @__PURE__ */ new Map();
+  let i = 1;
+  while (i < literal.length) {
+    const at = skipWhitespaceAndComments(literal, i);
+    if (at === -1) return void 0;
+    const ch = literal[at];
+    if (ch === "}" || ch === void 0) break;
+    if (ch === ",") {
+      i = at + 1;
+      continue;
+    }
+    if (literal.startsWith("...", at)) return void 0;
+    let key;
+    let afterKey;
+    if (ch === '"' || ch === "'") {
+      const end = skipStringLiteral(literal, at);
+      if (end === -1) return void 0;
+      key = literal.slice(at + 1, end - 1);
+      afterKey = end;
+    } else {
+      afterKey = readIdentifierEnd(literal, at);
+      if (afterKey === at) return void 0;
+      key = literal.slice(at, afterKey);
+    }
+    const colon = skipWhitespaceAndComments(literal, afterKey);
+    if (colon === -1) return void 0;
+    if (literal[colon] !== ":") {
+      if (key === "cmd" || key === "workdir") return void 0;
+      i = colon;
+      const next2 = skipToPropertyEnd(literal, colon);
+      if (next2 === -1) return void 0;
+      i = next2;
+      continue;
+    }
+    const valueAt = skipWhitespaceAndComments(literal, colon + 1);
+    if (valueAt === -1) return void 0;
+    const valueChar = literal[valueAt];
+    let value;
+    let afterValue = valueAt;
+    if (valueChar === '"' || valueChar === "'" || valueChar === "`") {
+      const end = skipStringLiteral(literal, valueAt);
+      if (end === -1) return void 0;
+      const decoded = unescapeScriptString(literal.slice(valueAt, end));
+      afterValue = end;
+      const after = skipWhitespaceAndComments(literal, end);
+      if (after === -1) return void 0;
+      const terminator = literal[after];
+      if (terminator === "," || terminator === "}") {
+        value = decoded.length > 0 ? decoded : void 0;
+        afterValue = after;
+      } else if (key === "cmd" || key === "workdir") {
+        return void 0;
+      }
+    } else if (key === "cmd" || key === "workdir") {
+      return void 0;
+    }
+    if (key === "cmd" || key === "workdir") {
+      if (values.has(key)) return void 0;
+      values.set(key, value);
+    }
+    const next = skipToPropertyEnd(literal, afterValue);
+    if (next === -1) return void 0;
+    i = next;
+  }
+  const cmd = values.get("cmd");
+  if (cmd === void 0) return void 0;
+  return { cmd, workdir: values.get("workdir") };
+}
+function skipToPropertyEnd(literal, at) {
+  let i = at;
+  while (i < literal.length) {
+    const skipped = skipNonCode(literal, i);
+    if (skipped === -1) return -1;
+    if (skipped !== i) {
+      i = skipped;
+      continue;
+    }
+    const ch = literal[i];
+    if (ch === "," || ch === "}") return i;
+    if (ch === "{" || ch === "(" || ch === "[") {
+      const end = findObjectEnd(literal, i);
+      if (end === -1) return -1;
+      i = end + 1;
+      continue;
+    }
+    i++;
+  }
+  return -1;
+}
+var SCRIPT_STRING_ESCAPES = {
+  n: "\n",
+  r: "\r",
+  t: "	",
+  b: "\b",
+  f: "\f",
+  v: "\v",
+  "0": "\0"
+};
+function unescapeScriptString(quoted) {
+  return quoted.slice(1, -1).replace(
+    /\\(u\{[0-9a-fA-F]{1,6}\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|\r\n|[\s\S])/g,
+    (match, sequence) => {
+      if (sequence.length <= 2) {
+        if (sequence === "\n" || sequence === "\r" || sequence === "\r\n") return "";
+        if (sequence === "u" || sequence === "x") return match;
+        return SCRIPT_STRING_ESCAPES[sequence] ?? sequence;
+      }
+      const hex = sequence.startsWith("u{") ? sequence.slice(2, -1) : sequence.slice(1);
+      return codePointOrLiteral(hex, match);
+    }
+  );
+}
+function codePointOrLiteral(hex, literal) {
+  const code = Number.parseInt(hex, 16);
+  if (!Number.isInteger(code) || code < 0 || code > 1114111) return literal;
+  try {
+    return String.fromCodePoint(code);
+  } catch {
+    return literal;
+  }
+}
 function turnIntervalFromComplete(endTs, payload, startMsByTurnId) {
   const endMs = Date.parse(endTs);
   if (!Number.isFinite(endMs)) return void 0;
@@ -871,7 +1141,7 @@ function parseExitCode(output) {
 }
 function parseWallTimeMs(output) {
   if (output === void 0) return 0;
-  const match = output.match(/Wall time:\s*([\d.]+)\s*seconds/);
+  const match = output.match(/Wall time:?\s*([\d.]+)\s*seconds/);
   if (match?.[1] === void 0) return 0;
   const seconds = Number.parseFloat(match[1]);
   return Number.isFinite(seconds) ? Math.round(seconds * 1e3) : 0;
@@ -882,13 +1152,20 @@ function indexOutputs(records) {
     if (readString4(record.type) !== "response_item") continue;
     const payload = isObject4(record.payload) ? record.payload : void 0;
     if (payload === void 0) continue;
-    if (readString4(payload.type) !== "function_call_output") continue;
+    const payloadType = readString4(payload.type);
+    const output = payloadType === "function_call_output" ? readString4(payload.output) : payloadType === "custom_tool_call_output" ? readOutputParts(payload.output) : void 0;
     const callId = readString4(payload.call_id);
-    const output = readString4(payload.output);
     if (callId !== void 0 && output !== void 0) byId.set(callId, output);
   }
   return byId;
 }
+function readOutputParts(value) {
+  const asString = readString4(value);
+  if (asString !== void 0) return asString;
+  if (!Array.isArray(value)) return void 0;
+  const texts = value.map((part) => isObject4(part) ? readString4(part.text) : void 0).filter((text) => text !== void 0);
+  return texts.length > 0 ? texts.join("\n") : void 0;
+}
 
 // src/approval/approval-store.ts
 import { readdir } from "fs/promises";