@codexhost/cli-win32-arm64 0.10.0 → 0.10.2

package/app/plugins/omp/plugin.mjs

@@ -527,6 +527,7 @@ function splitLines(text) {
 
 // dist/omp-adapter.js
 import { randomUUID as randomUUID2 } from "node:crypto";
+import { realpath as realpath2, stat } from "node:fs/promises";
 import path4 from "node:path";
 
 // ../../../node_modules/zod/v4/classic/external.js
@@ -16706,6 +16707,100 @@ function resolveOmpForkBoundary(history, checkpointId) {
   };
 }
 
+// dist/omp-session-file.js
+import { createReadStream } from "node:fs";
+import { open, realpath } from "node:fs/promises";
+import readline from "node:readline";
+var MAX_SESSION_HEADER_BYTES = 64 * 1024;
+var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function historyEntry(value) {
+  if (!isRecord5(value) || value.type === "title" || value.type === "session" || typeof value.id !== "string" || value.id.length === 0 || value.parentId !== null && typeof value.parentId !== "string" || typeof value.type !== "string") {
+    return null;
+  }
+  return value;
+}
+async function readOmpSessionHistory(sessionFile, maxBytes) {
+  const entries = [];
+  let leafId = null;
+  const lines = readline.createInterface({
+    input: createReadStream(sessionFile, {
+      encoding: "utf8",
+      ...maxBytes === void 0 ? {} : { end: maxBytes - 1 }
+    }),
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  try {
+    for await (const line of lines) {
+      if (line.length === 0)
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const entry = historyEntry(parsed);
+      if (!entry)
+        continue;
+      entries.push(entry);
+      leafId = entry.id;
+    }
+  } finally {
+    lines.close();
+  }
+  return { entries, leafId };
+}
+async function readOmpSessionHeader(sessionFile) {
+  const handle = await open(sessionFile, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(MAX_SESSION_HEADER_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const contents = buffer.subarray(0, bytesRead);
+    const newline = contents.indexOf(10);
+    if (newline < 0 && bytesRead === buffer.length) {
+      throw new Error("Omp Session header exceeds the supported size");
+    }
+    const contentsText = utf8Decoder.decode(contents);
+    for (const line of contentsText.split("\n")) {
+      if (line.length === 0)
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!isRecord5(parsed) || parsed.type !== "session")
+        continue;
+      if (typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
+        throw new Error("Omp Session header is invalid");
+      }
+      return { type: "session", id: parsed.id, cwd: parsed.cwd };
+    }
+    throw new Error("Omp Session header is invalid");
+  } finally {
+    await handle.close();
+  }
+}
+async function verifyOmpSessionCwd(input) {
+  if (!input.sessionFile)
+    throw new Error("Omp Fork Session has no persisted Session file");
+  const header = await readOmpSessionHeader(input.sessionFile);
+  if (header.id !== input.sessionId) {
+    throw new Error("Omp Fork Session header identity does not match RPC state");
+  }
+  const [actualCwd, expectedCwd] = await Promise.all([
+    realpath(header.cwd),
+    realpath(input.expectedCwd)
+  ]);
+  if (actualCwd !== expectedCwd) {
+    throw new Error("Omp Fork Session did not bind the requested cwd");
+  }
+}
+
 // dist/omp-last-turn-rollback.js
 function modelFromState(state) {
   if (state.provider === null && state.modelId === null)
@@ -17013,14 +17108,14 @@ function resolveOmpExecutable(input, dependencies = {}) {
 }
 
 // dist/omp-usage.js
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonNegativeSafeInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
 function optionalOmpCacheHitRatePercent(value) {
-  if (!isRecord5(value) || value.role !== "assistant" || !isRecord5(value.usage))
+  if (!isRecord6(value) || value.role !== "assistant" || !isRecord6(value.usage))
     return null;
   const input = nonNegativeSafeInteger(value.usage.input);
   const cacheRead = nonNegativeSafeInteger(value.usage.cacheRead);
@@ -17033,20 +17128,20 @@ function optionalOmpCacheHitRatePercent(value) {
 function latestOmpCacheHitRatePercent(history) {
   let latest = null;
   for (const entry of activeOmpEntries(history)) {
-    if (entry.type === "message" && isRecord5(entry.message) && entry.message.role === "assistant") {
+    if (entry.type === "message" && isRecord6(entry.message) && entry.message.role === "assistant") {
       latest = optionalOmpCacheHitRatePercent(entry.message);
     }
   }
   return latest;
 }
 function responseData(response, operation) {
-  if (!isRecord5(response.data)) {
+  if (!isRecord6(response.data)) {
     throw new Error(`Omp RPC ${operation} response has no data`);
   }
   return response.data;
 }
 function contextUsage(value) {
-  if (!isRecord5(value))
+  if (!isRecord6(value))
     throw new Error("Omp RPC context Usage is invalid");
   return parseHostUsage({
     contextUsedTokens: value.tokens,
@@ -17056,15 +17151,15 @@ function contextUsage(value) {
 function parseOmpSessionUsage(response) {
   const data = responseData(response, "Session stats");
   const tokens = data.tokens;
-  if (tokens !== void 0 && !isRecord5(tokens)) {
+  if (tokens !== void 0 && !isRecord6(tokens)) {
     throw new Error("Omp RPC Session stats tokens are invalid");
   }
   return parseHostUsage({
-    ...isRecord5(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
-    ...isRecord5(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
-    ...isRecord5(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
-    ...isRecord5(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
-    ...isRecord5(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
+    ...isRecord6(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
+    ...isRecord6(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
+    ...isRecord6(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
+    ...isRecord6(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
+    ...isRecord6(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
     ...data.cost !== void 0 ? { totalCostUsd: data.cost } : {},
     ...data.contextUsage !== void 0 ? contextUsage(data.contextUsage) : {}
   });
@@ -17083,97 +17178,6 @@ function optionalOmpStateContextUsage(value) {
   }
 }
 
-// dist/omp-session-file.js
-import { createReadStream } from "node:fs";
-import { open, realpath } from "node:fs/promises";
-import readline from "node:readline";
-var MAX_SESSION_HEADER_BYTES = 64 * 1024;
-var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord6(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function historyEntry(value) {
-  if (!isRecord6(value) || value.type === "title" || value.type === "session" || typeof value.id !== "string" || value.id.length === 0 || value.parentId !== null && typeof value.parentId !== "string" || typeof value.type !== "string") {
-    return null;
-  }
-  return value;
-}
-async function readOmpSessionHistory(sessionFile) {
-  const entries = [];
-  let leafId = null;
-  const lines = readline.createInterface({
-    input: createReadStream(sessionFile, { encoding: "utf8" }),
-    crlfDelay: Number.POSITIVE_INFINITY
-  });
-  try {
-    for await (const line of lines) {
-      if (line.length === 0)
-        continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      const entry = historyEntry(parsed);
-      if (!entry)
-        continue;
-      entries.push(entry);
-      leafId = entry.id;
-    }
-  } finally {
-    lines.close();
-  }
-  return { entries, leafId };
-}
-async function readOmpSessionHeader(sessionFile) {
-  const handle = await open(sessionFile, "r");
-  try {
-    const buffer = Buffer.allocUnsafe(MAX_SESSION_HEADER_BYTES);
-    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-    const contents = buffer.subarray(0, bytesRead);
-    const newline = contents.indexOf(10);
-    if (newline < 0 && bytesRead === buffer.length) {
-      throw new Error("Omp Session header exceeds the supported size");
-    }
-    const contentsText = utf8Decoder.decode(contents);
-    for (const line of contentsText.split("\n")) {
-      if (line.length === 0)
-        continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (!isRecord6(parsed) || parsed.type !== "session")
-        continue;
-      if (typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
-        throw new Error("Omp Session header is invalid");
-      }
-      return { type: "session", id: parsed.id, cwd: parsed.cwd };
-    }
-    throw new Error("Omp Session header is invalid");
-  } finally {
-    await handle.close();
-  }
-}
-async function verifyOmpSessionCwd(input) {
-  if (!input.sessionFile)
-    throw new Error("Omp Fork Session has no persisted Session file");
-  const header = await readOmpSessionHeader(input.sessionFile);
-  if (header.id !== input.sessionId) {
-    throw new Error("Omp Fork Session header identity does not match RPC state");
-  }
-  const [actualCwd, expectedCwd] = await Promise.all([
-    realpath(header.cwd),
-    realpath(input.expectedCwd)
-  ]);
-  if (actualCwd !== expectedCwd) {
-    throw new Error("Omp Fork Session did not bind the requested cwd");
-  }
-}
-
 // dist/omp-protocol.js
 var MAX_FRAME_BYTES = 1024 * 1024;
 var MAX_REASSEMBLED_BYTES = 64 * 1024 * 1024;
@@ -17568,6 +17572,9 @@ var OmpRpcSession = class {
       new Promise((_resolve, reject) => setTimeout(() => reject(new Error("Omp RPC ready signal timed out")), this.#options.commandTimeoutMs))
     ]);
     await this.#send("negotiate_protocol", { protocolVersion: 2 }).catch(() => void 0);
+    if (this.#options.subscribeSubagentEvents !== false) {
+      await this.#send("set_subagent_subscription", { level: "events" }).catch(() => void 0);
+    }
     try {
       this.#state = parseSessionState(await this.#send("get_state", {}));
     } catch (error51) {
@@ -18713,6 +18720,46 @@ function sessionFileFromRef(ref) {
   }
   return ref.locator.sessionFile;
 }
+var MAX_SUBAGENT_TRANSCRIPT_BYTES = 8 * 1024 * 1024;
+function subagentTranscriptPath(parentSessionFile, nativeSubagentId) {
+  if (nativeSubagentId.includes("/") || nativeSubagentId.includes("\\") || nativeSubagentId.includes("\0") || nativeSubagentId === "." || nativeSubagentId === "..") {
+    throw new Error("Omp Subagent ID is not a plain transcript file name");
+  }
+  if (!parentSessionFile.endsWith(".jsonl") || !path4.isAbsolute(parentSessionFile)) {
+    return null;
+  }
+  return `${parentSessionFile.slice(0, -".jsonl".length)}/${nativeSubagentId}.jsonl`;
+}
+async function readSubagentTranscriptFile(parentSessionFile, nativeSubagentId) {
+  const transcriptFile = subagentTranscriptPath(parentSessionFile, nativeSubagentId);
+  if (transcriptFile === null)
+    return { status: "missing" };
+  const parentDirectory = path4.dirname(transcriptFile);
+  let metadata;
+  try {
+    metadata = await stat(transcriptFile);
+  } catch (error51) {
+    if (error51.code === "ENOENT")
+      return { status: "missing" };
+    throw error51;
+  }
+  if (!metadata.isFile())
+    return { status: "missing" };
+  if (metadata.size > MAX_SUBAGENT_TRANSCRIPT_BYTES) {
+    throw new Error("Omp Subagent transcript exceeds the supported size");
+  }
+  const [resolvedTranscript, resolvedParentDirectory] = await Promise.all([
+    realpath2(transcriptFile),
+    realpath2(parentDirectory)
+  ]);
+  if (path4.dirname(resolvedTranscript) !== resolvedParentDirectory) {
+    throw new Error("Omp Subagent transcript resolves outside its parent Session directory");
+  }
+  return {
+    status: "read",
+    history: await readOmpSessionHistory(transcriptFile, MAX_SUBAGENT_TRANSCRIPT_BYTES)
+  };
+}
 function toolFailure(toolName) {
   return {
     code: "nativeFailure",
@@ -20316,9 +20363,18 @@ var OmpAdapter = class {
       }
       let transport;
       try {
+        const transcriptFile = await readSubagentTranscriptFile(sessionFileFromRef(input.parent), input.nativeSubagentId);
+        if (transcriptFile.status === "read") {
+          const snapshot2 = mapOmpSnapshot(transcriptFile.history, {
+            sessionId: input.parent.nativeSessionId,
+            model: null
+          });
+          return { ok: true, value: snapshot2 };
+        }
         transport = this.#createTransport({
           cwd: input.cwd,
           sessionFile: sessionFileFromRef(input.parent),
+          subscribeSubagentEvents: false,
           onFault: () => void 0
         });
         await transport.start();
@@ -20390,7 +20446,11 @@ var OmpAdapter = class {
   async #inspectCwd(cwd) {
     const startedAt = Date.now();
     let stage = "spawn";
-    const transport = this.#createTransport({ cwd, onFault: () => void 0 });
+    const transport = this.#createTransport({
+      cwd,
+      subscribeSubagentEvents: false,
+      onFault: () => void 0
+    });
     this.#inspections.add(transport);
     try {
       stage = "startup";

package/app/plugins/pi/plugin.mjs

@@ -18700,7 +18700,10 @@ var PiRpcSession = class {
     }
     this.#options = {
       commandTimeoutMs: 3e4,
-      cancelTimeoutMs: 2e3,
+      // Bounds proven stable settlement (Abort acknowledgement plus agent_settled and get_state
+      // confirmation), not the RPC write round trip; must exceed the Host's 20s external steering
+      // bound so a slow cancellation times out gracefully instead of faulting the whole Session.
+      cancelTimeoutMs: 3e4,
       closeTimeoutMs: 2e3,
       ...options
     };