@clawos-dev/clawd 0.2.596 → 0.2.598

package/dist/cli.cjs

@@ -51818,13 +51818,22 @@ function parseCodexRolloutMeta(firstLine) {
   return obj ? metaFrom(obj) : null;
 }
 function firstUserMessageText(text) {
+  let responseText;
   for (const line of text.split("\n")) {
     const obj = parseLine(line);
-    if (!obj || obj.type !== "event_msg") continue;
+    if (!obj) continue;
     const p3 = rec(obj.payload);
-    if (p3?.type === "user_message") return str(p3.message);
+    if (obj.type === "event_msg" && p3?.type === "user_message") return str(p3.message);
+    if (!responseText && obj.type === "response_item" && p3?.type === "message" && p3.role === "user" && hasContentKind(p3, "user.text")) responseText = outputText(p3.content) || void 0;
   }
-  return void 0;
+  return responseText;
+}
+function hasContentKind(payload, kind) {
+  const kinds = rec(payload.internal_chat_message_metadata_passthrough)?.content_item_kinds;
+  return Array.isArray(kinds) && kinds.includes(kind);
+}
+function messageTurnId(payload) {
+  return str(rec(payload.internal_chat_message_metadata_passthrough)?.turn_id);
 }
 function outputText(output) {
   if (typeof output === "string") return output;
@@ -51852,8 +51861,21 @@ function functionCallInput(name, rawArgs) {
 }
 function parseCodexRollout(text) {
   const out = { meta: null, messages: [], subagents: [], turns: [] };
+  const lines = text.split("\n");
   const collabCallIds = /* @__PURE__ */ new Set();
-  for (const line of text.split("\n")) {
+  const eventTexts = /* @__PURE__ */ new Set();
+  let eventTurnId;
+  for (const line of lines) {
+    const obj = parseLine(line);
+    const p3 = obj && rec(obj.payload);
+    if (!p3 || obj?.type !== "event_msg") continue;
+    if (p3.type === "task_started") eventTurnId = str(p3.turn_id);
+    if (p3.type === "user_message" || p3.type === "agent_message") {
+      const body = str(p3.message);
+      if (body) eventTexts.add(JSON.stringify([eventTurnId, p3.type === "user_message" ? "user" : "assistant", body]));
+    }
+  }
+  for (const line of lines) {
     const obj = parseLine(line);
     if (!obj) continue;
     const ts = str(obj.timestamp);
@@ -51921,6 +51943,15 @@ function parseCodexRollout(text) {
     }
     if (obj.type === "response_item") {
       switch (p3.type) {
+        case "message": {
+          const role = str(p3.role);
+          if (role !== "user" && role !== "assistant") break;
+          if (role === "user" ? !hasContentKind(p3, "user.text") : !Array.isArray(rec(p3.internal_chat_message_metadata_passthrough)?.content_item_kinds)) break;
+          const body = outputText(p3.content);
+          if (!body || eventTexts.has(JSON.stringify([messageTurnId(p3), role, body]))) break;
+          out.messages.push({ kind: role === "user" ? "user-text" : "assistant-text", text: body, raw: obj, ...ts ? { ts } : {} });
+          break;
+        }
         case "function_call": {
           const callId = str(p3.call_id);
           const name = str(p3.name);
@@ -52125,6 +52156,26 @@ function subagentSummaries(parent) {
   }
   return out;
 }
+function historyBase(text) {
+  const newline = text.indexOf("\n");
+  const firstLine = newline < 0 ? text : text.slice(0, newline);
+  let payload;
+  try {
+    const row = JSON.parse(firstLine);
+    if (row.type !== "session_meta" || !row.payload || typeof row.payload !== "object") return null;
+    payload = row.payload;
+  } catch {
+    return null;
+  }
+  const base = payload.history_base;
+  if (base == null) return null;
+  if (typeof base !== "object" || Array.isArray(base)) throw new Error("Codex fork history_base is invalid");
+  const { thread_id: threadId, end_byte_offset: endByteOffset } = base;
+  if (typeof threadId !== "string" || !threadId || typeof endByteOffset !== "number" || !Number.isSafeInteger(endByteOffset) || endByteOffset < 0) {
+    throw new Error("Codex fork history_base is invalid");
+  }
+  return { threadId, endByteOffset };
+}
 var CodexHistoryReader = class {
   deps;
   constructor(deps) {
@@ -52177,24 +52228,29 @@ var CodexHistoryReader = class {
   }
   async read(args) {
     const locate = createCodexRolloutLocator(this.deps.roots);
-    const parent = this.parseThread(locate, args.toolSessionId);
-    const messages = await withSubagentResults(
-      parent,
-      args.toolSessionId,
-      async (agentId) => {
-        const file = locate(agentId);
-        return file ? import_node_fs15.default.readFileSync(file, "utf8") : null;
-      },
-      this.deps.logger
-    );
+    const segments = this.parseThreadSegments(locate, args.toolSessionId);
+    const messages = [];
+    for (const segment of segments) {
+      messages.push(...await withSubagentResults(
+        segment.parsed,
+        segment.threadId,
+        async (agentId) => {
+          const file = locate(agentId);
+          return file ? import_node_fs15.default.readFileSync(file, "utf8") : null;
+        },
+        this.deps.logger
+      ));
+    }
     return pageMessages(messages, args);
   }
   async listSubagents(args) {
     return subagentSummaries(this.parseThread(createCodexRolloutLocator(this.deps.roots), args.toolSessionId));
   }
   async readSubagent(args) {
-    const child = this.parseThread(createCodexRolloutLocator(this.deps.roots), args.subagentId);
-    if (child.meta?.threadId !== args.subagentId || child.meta.parentThreadId !== args.toolSessionId) {
+    const locate = createCodexRolloutLocator(this.deps.roots);
+    const owner2 = this.parseThreadSegments(locate, args.toolSessionId).find((segment) => segment.parsed.subagents.some((sub) => sub.agentId === args.subagentId));
+    const child = this.parseThread(locate, args.subagentId);
+    if (!owner2 || child.meta?.threadId !== args.subagentId || child.meta.parentThreadId !== owner2.threadId) {
       throw new Error(
         `Codex subagent thread ${args.subagentId} does not belong to parent thread ${args.toolSessionId}`
       );
@@ -52208,9 +52264,37 @@ var CodexHistoryReader = class {
     return [];
   }
   parseThread(locate, threadId) {
-    const file = locate(threadId);
-    if (!file) throw new Error(`Codex rollout not found for thread ${threadId}`);
-    return parseCodexRollout(import_node_fs15.default.readFileSync(file, "utf8"));
+    const segments = this.parseThreadSegments(locate, threadId);
+    const current = segments[segments.length - 1].parsed;
+    return {
+      ...current,
+      messages: segments.flatMap((s2) => s2.parsed.messages),
+      subagents: segments.flatMap((s2) => s2.parsed.subagents),
+      turns: segments.flatMap((s2) => s2.parsed.turns)
+    };
+  }
+  parseThreadSegments(locate, threadId, endByteOffset, seen = /* @__PURE__ */ new Set()) {
+    const key = threadId.toLowerCase();
+    if (seen.has(key)) throw new Error(`Codex fork history cycle at thread ${threadId}`);
+    seen.add(key);
+    try {
+      const file = locate(threadId);
+      if (!file) throw new Error(`Codex rollout not found for thread ${threadId}`);
+      const bytes = import_node_fs15.default.readFileSync(file);
+      if (endByteOffset !== void 0 && endByteOffset > bytes.length) {
+        throw new Error(`Codex fork history_base exceeds source rollout ${threadId}`);
+      }
+      const text = (endByteOffset === void 0 ? bytes : bytes.subarray(0, endByteOffset)).toString("utf8");
+      const parsed = parseCodexRollout(text);
+      if (parsed.meta?.threadId.toLowerCase() !== key) {
+        throw new Error(`Codex rollout metadata does not match thread ${threadId}`);
+      }
+      const base = historyBase(text);
+      const inherited = base ? this.parseThreadSegments(locate, base.threadId, base.endByteOffset, seen) : [];
+      return [...inherited, { threadId, parsed }];
+    } finally {
+      seen.delete(key);
+    }
   }
 };
 
@@ -72875,7 +72959,7 @@ function computeMethodAccess(args) {
 }
 
 // src/version.ts
-var version = "0.2.596".length > 0 ? "0.2.596" : "dev";
+var version = "0.2.598".length > 0 ? "0.2.598" : "dev";
 
 // src/cli-probe/probe.ts
 var fs83 = __toESM(require("fs"), 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.596",
+  "version": "0.2.598",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",