@codexhost/cli-darwin-x64 0.11.0 → 0.12.0

package/app/desktop-controller.mjs

@@ -2,182 +2,61 @@
 import { readFile } from "node:fs/promises";
 import path2 from "node:path";
 
-// packages/desktop-control/src/controller-attachment-server.ts
-import { createServer } from "node:net";
-var MAX_REQUEST_BYTES = 96;
-function validPort(value) {
-  return Number.isInteger(value) && value >= 1 && value <= 65535;
-}
-function validNonce(value) {
-  return /^[0-9a-f]{32}$/.test(value);
-}
-function closeServer(server) {
-  return new Promise((resolve, reject) => {
-    server.close((error) => {
-      if (error) reject(error);
-      else resolve();
+// packages/desktop-control/src/renderer-local-page.ts
+import { randomUUID } from "node:crypto";
+async function openRendererLocalPage(execute, url, targets) {
+  const conversationId = await execute(
+    "window.__codexhostRendererBindingProbeV1?.currentThreadId?.() ?? null"
+  );
+  if (!conversationId) throw new Error("Open a Codex task before starting verification");
+  const browserTabId = `manual:${randomUUID()}`;
+  const post = (value) => execute(`window.postMessage(${JSON.stringify(value)}, '*'); null`);
+  try {
+    await post({
+      type: "toggle-browser-panel",
+      conversationId,
+      browserTabId,
+      url,
+      open: true,
+      active: false,
+      source: "browser_use",
+      initiator: "codexhost_local_page"
     });
-  });
-}
-function respond(socket, value) {
-  socket.end(`${value}
-`);
-}
-async function startControllerAttachmentServer(options) {
-  if (!validPort(options.port)) throw new Error("attachment port must be a valid TCP port");
-  if (!validNonce(options.nonce)) {
-    throw new Error("attachment nonce must be 32 lowercase hexadecimal characters");
+    const deadline = Date.now() + 5e3;
+    while (!(await targets()).some((target) => target.url === url)) {
+      if (Date.now() >= deadline)
+        throw new Error("Codex in-app browser did not load the local page");
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  } catch (error) {
+    await post({ type: "close-browser-tab", conversationId, browserTabId });
+    throw error;
   }
-  const sockets = /* @__PURE__ */ new Set();
-  let attachment;
-  const server = createServer((socket) => {
-    sockets.add(socket);
-    socket.once("close", () => sockets.delete(socket));
-    socket.setEncoding("utf8");
-    socket.setTimeout(5e3, () => socket.destroy());
-    let request = "";
-    let handled = false;
-    socket.on("data", (chunk) => {
-      if (handled) return;
-      request += chunk;
-      if (request.length > MAX_REQUEST_BYTES) {
-        handled = true;
-        respond(socket, "rejected");
-        return;
-      }
-      const newline = request.indexOf("\n");
-      if (newline < 0) return;
-      handled = true;
-      const line = request.slice(0, newline).replace(/\r$/, "");
-      if (line === `ATTACH ${options.nonce}`) {
-        if (attachment) {
-          respond(socket, "busy");
-          return;
-        }
-        socket.setTimeout(0);
-        const current = Promise.resolve().then(() => options.attach());
-        attachment = current;
-        void current.then(
-          () => respond(socket, "ready"),
-          () => respond(socket, "failed")
-        ).finally(() => {
-          if (attachment === current) attachment = void 0;
-        });
-        return;
-      }
-      respond(socket, "rejected");
-    });
-  });
-  await new Promise((resolve, reject) => {
-    const onError = (error) => reject(error);
-    server.once("error", onError);
-    server.listen(options.port, "127.0.0.1", () => {
-      server.off("error", onError);
-      resolve();
-    });
-  });
   let closed = false;
   return {
-    async close() {
+    async show() {
       if (closed) return;
-      closed = true;
-      for (const socket of sockets) socket.destroy();
-      await closeServer(server);
-    }
-  };
-}
-
-// packages/desktop-control/src/controller-status.ts
-import { randomBytes } from "node:crypto";
-import { mkdir, rename, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-var DESKTOP_CONTROLLER_STATUS_FILE = "desktop-controller-v1.json";
-var ERROR_MAX_LENGTH = 1e3;
-function defaultControllerStatusPath(environment = process.env) {
-  const dataDirectory = environment.CODEXHOST_DATA_DIR ? path.resolve(environment.CODEXHOST_DATA_DIR) : path.join(os.homedir(), ".codexhost");
-  return path.join(dataDirectory, "diagnostics", DESKTOP_CONTROLLER_STATUS_FILE);
-}
-function errorMessage(error) {
-  const parts = [];
-  let current = error;
-  for (let depth = 0; depth < 4 && current !== void 0; depth += 1) {
-    parts.push(current instanceof Error ? current.message : String(current));
-    current = current instanceof Error ? current.cause : void 0;
-  }
-  return parts.join(": ").slice(0, ERROR_MAX_LENGTH) || "Renderer installation failed";
-}
-function createRendererStatusReporter(publish, now = Date.now, pid = process.pid) {
-  const startedAt = now();
-  let current;
-  const update = (next) => {
-    if (current && current.state === next.state && current.error === next.error && current.failures === next.failures) {
-      return;
-    }
-    current = { ...next, updatedAt: now() };
-    publish({ schemaVersion: 1, pid, startedAt, renderer: current });
-  };
-  return {
-    installing() {
-      update({
-        state: "installing",
-        error: current?.error ?? null,
-        failures: current?.failures ?? 0,
-        lastError: current?.lastError ?? null,
-        lastFailedAt: current?.lastFailedAt ?? null,
-        lastInstalledAt: current?.lastInstalledAt ?? null
-      });
-    },
-    installed() {
-      if (current?.state === "installed") return;
-      update({
-        state: "installed",
-        error: null,
-        failures: current?.failures ?? 0,
-        lastError: current?.lastError ?? null,
-        lastFailedAt: current?.lastFailedAt ?? null,
-        lastInstalledAt: now()
+      const current = await execute(
+        "window.__codexhostRendererBindingProbeV1?.currentThreadId?.() ?? null"
+      );
+      if (current !== conversationId)
+        await post({ type: "navigate-to-route", path: `/local/${conversationId}` });
+      await post({
+        type: "toggle-browser-panel",
+        conversationId,
+        browserTabId,
+        open: true,
+        source: "manual",
+        initiator: "codexhost_local_page"
       });
     },
-    failed(error) {
-      const message = errorMessage(error);
-      update({
-        state: "unavailable",
-        error: message,
-        failures: (current?.failures ?? 0) + 1,
-        lastError: message,
-        lastFailedAt: now(),
-        lastInstalledAt: current?.lastInstalledAt ?? null
-      });
+    async close() {
+      if (closed) return;
+      closed = true;
+      await post({ type: "close-browser-tab", conversationId, browserTabId });
     }
   };
 }
-async function writeControllerStatusFile(filePath, document) {
-  const directory = path.dirname(filePath);
-  await mkdir(directory, { recursive: true, mode: 448 });
-  const temporaryPath = path.join(
-    directory,
-    `.${path.basename(filePath)}.${randomBytes(6).toString("hex")}.tmp`
-  );
-  try {
-    await writeFile(temporaryPath, `${JSON.stringify(document)}
-`, {
-      encoding: "utf8",
-      mode: 384,
-      flag: "wx"
-    });
-    await rename(temporaryPath, filePath);
-  } catch (error) {
-    await rm(temporaryPath, { force: true });
-    throw error;
-  }
-}
-function createControllerStatusPublisher(filePath = defaultControllerStatusPath()) {
-  let queue = Promise.resolve();
-  return (document) => {
-    queue = queue.then(() => writeControllerStatusFile(filePath, document)).catch(() => void 0);
-  };
-}
 
 // packages/desktop-control/src/cdp-client.ts
 function cdpExceptionMessage(details, fallback) {
@@ -219,8 +98,8 @@ function parseTarget(value) {
     webSocketDebuggerUrl
   };
 }
-function defaultFetch(url) {
-  return fetch(url);
+function defaultFetch(url, init) {
+  return fetch(url, init);
 }
 function defaultSocketFactory(url) {
   return new WebSocket(url);
@@ -247,10 +126,10 @@ function parseResponse(value) {
   }
   return response;
 }
-async function listCdpTargets(endpoint, fetchImpl = defaultFetch) {
+async function listCdpTargets(endpoint, fetchImpl = defaultFetch, signal) {
   const baseUrl = loopbackUrl(endpoint, ["http:", "https:"]);
   const targetsUrl = new URL("/json/list", baseUrl).toString();
-  const response = await fetchImpl(targetsUrl);
+  const response = await fetchImpl(targetsUrl, signal ? { signal } : void 0);
   if (!response.ok) throw new Error(`CDP target discovery failed with HTTP ${response.status}`);
   const value = await response.json();
   if (!Array.isArray(value)) throw new Error("CDP target discovery did not return an array");
@@ -394,6 +273,261 @@ var CdpClient = class _CdpClient {
   }
 };
 
+// packages/desktop-control/src/controller-attachment-server.ts
+import { createServer } from "node:net";
+
+// packages/desktop-control/src/local-page-control.ts
+function isLocalPageUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" && url.hostname === "127.0.0.1" && url.port !== "" && url.pathname === "/" && !url.username && !url.password && !url.hash;
+  } catch {
+    return false;
+  }
+}
+async function serveLocalPage(socket, url, open) {
+  let page;
+  let buffer = "";
+  let operation = Promise.resolve();
+  const disconnected = Promise.withResolvers();
+  socket.once("close", () => disconnected.resolve(void 0));
+  socket.setTimeout(0);
+  const receive = (chunk) => {
+    buffer += chunk;
+    if (buffer.length > 64) {
+      socket.destroy();
+      return;
+    }
+    let end;
+    while ((end = buffer.indexOf("\n")) >= 0) {
+      const command = buffer.slice(0, end);
+      buffer = buffer.slice(end + 1);
+      operation = operation.then(async () => {
+        if (socket.destroyed) return;
+        if (command === "SHOW") {
+          await page?.show();
+          socket.write("ready\n");
+        } else if (command === "CLOSE") {
+          await page?.close();
+          socket.end("closed\n");
+        } else socket.destroy();
+      }).catch(() => {
+        socket.destroy();
+      });
+    }
+  };
+  try {
+    page = await open(url);
+    if (socket.destroyed) return;
+    socket.on("data", receive);
+    socket.write("ready\n");
+    await disconnected.promise;
+    await operation;
+  } catch {
+    if (!socket.destroyed) socket.end("failed\n");
+  } finally {
+    socket.off("data", receive);
+    await page?.close();
+  }
+}
+
+// packages/desktop-control/src/controller-attachment-server.ts
+var MAX_REQUEST_BYTES = 4096;
+function validPort(value) {
+  return Number.isInteger(value) && value >= 1 && value <= 65535;
+}
+function validNonce(value) {
+  return /^[0-9a-f]{32}$/.test(value);
+}
+function closeServer(server) {
+  return new Promise((resolve, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+function respond(socket, value) {
+  socket.end(`${value}
+`);
+}
+async function startControllerAttachmentServer(options) {
+  if (!validPort(options.port)) throw new Error("attachment port must be a valid TCP port");
+  if (!validNonce(options.nonce)) {
+    throw new Error("attachment nonce must be 32 lowercase hexadecimal characters");
+  }
+  const sockets = /* @__PURE__ */ new Set();
+  const pages = /* @__PURE__ */ new Set();
+  let attachment;
+  const server = createServer((socket) => {
+    sockets.add(socket);
+    socket.on("error", () => socket.destroy());
+    socket.once("close", () => sockets.delete(socket));
+    socket.setEncoding("utf8");
+    socket.setTimeout(5e3, () => socket.destroy());
+    let request = "";
+    let handled = false;
+    const receive = (chunk) => {
+      if (handled) return;
+      request += chunk;
+      if (request.length > MAX_REQUEST_BYTES) {
+        handled = true;
+        respond(socket, "rejected");
+        return;
+      }
+      const newline = request.indexOf("\n");
+      if (newline < 0) return;
+      handled = true;
+      const line = request.slice(0, newline).replace(/\r$/, "");
+      const prefix = `PAGE ${options.nonce} `;
+      if (options.openLocalPage && line.startsWith(prefix)) {
+        const url = line.slice(prefix.length);
+        if (!isLocalPageUrl(url) || request.slice(newline + 1) !== "") {
+          respond(socket, "rejected");
+          return;
+        }
+        socket.off("data", receive);
+        const page = serveLocalPage(socket, url, options.openLocalPage).catch(
+          () => socket.destroy()
+        );
+        const completion = page.then(() => void 0);
+        pages.add(completion);
+        void completion.finally(() => pages.delete(completion));
+        return;
+      }
+      if (line === `ATTACH ${options.nonce}`) {
+        if (attachment) {
+          respond(socket, "busy");
+          return;
+        }
+        socket.setTimeout(0);
+        const current = Promise.resolve().then(() => options.attach());
+        attachment = current;
+        void current.then(
+          () => respond(socket, "ready"),
+          () => respond(socket, "failed")
+        ).finally(() => {
+          if (attachment === current) attachment = void 0;
+        });
+        return;
+      }
+      respond(socket, "rejected");
+    };
+    socket.on("data", receive);
+  });
+  await new Promise((resolve, reject) => {
+    const onError = (error) => reject(error);
+    server.once("error", onError);
+    server.listen(options.port, "127.0.0.1", () => {
+      server.off("error", onError);
+      resolve();
+    });
+  });
+  let closed = false;
+  return {
+    async close() {
+      if (closed) return;
+      closed = true;
+      const serverClosed = closeServer(server);
+      for (const socket of sockets) socket.destroy();
+      await Promise.all(pages);
+      await serverClosed;
+    }
+  };
+}
+
+// packages/desktop-control/src/controller-status.ts
+import { randomBytes } from "node:crypto";
+import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+var DESKTOP_CONTROLLER_STATUS_FILE = "desktop-controller-v1.json";
+var ERROR_MAX_LENGTH = 1e3;
+function defaultControllerStatusPath(environment = process.env) {
+  const dataDirectory = environment.CODEXHOST_DATA_DIR ? path.resolve(environment.CODEXHOST_DATA_DIR) : path.join(os.homedir(), ".codexhost");
+  return path.join(dataDirectory, "diagnostics", DESKTOP_CONTROLLER_STATUS_FILE);
+}
+function errorMessage(error) {
+  const parts = [];
+  let current = error;
+  for (let depth = 0; depth < 4 && current !== void 0; depth += 1) {
+    parts.push(current instanceof Error ? current.message : String(current));
+    current = current instanceof Error ? current.cause : void 0;
+  }
+  return parts.join(": ").slice(0, ERROR_MAX_LENGTH) || "Renderer installation failed";
+}
+function createRendererStatusReporter(publish, now = Date.now, pid = process.pid) {
+  const startedAt = now();
+  let current;
+  const update = (next) => {
+    if (current && current.state === next.state && current.error === next.error && current.failures === next.failures) {
+      return;
+    }
+    current = { ...next, updatedAt: now() };
+    publish({ schemaVersion: 1, pid, startedAt, renderer: current });
+  };
+  return {
+    installing() {
+      update({
+        state: "installing",
+        error: current?.error ?? null,
+        failures: current?.failures ?? 0,
+        lastError: current?.lastError ?? null,
+        lastFailedAt: current?.lastFailedAt ?? null,
+        lastInstalledAt: current?.lastInstalledAt ?? null
+      });
+    },
+    installed() {
+      if (current?.state === "installed") return;
+      update({
+        state: "installed",
+        error: null,
+        failures: current?.failures ?? 0,
+        lastError: current?.lastError ?? null,
+        lastFailedAt: current?.lastFailedAt ?? null,
+        lastInstalledAt: now()
+      });
+    },
+    failed(error) {
+      const message = errorMessage(error);
+      update({
+        state: "unavailable",
+        error: message,
+        failures: (current?.failures ?? 0) + 1,
+        lastError: message,
+        lastFailedAt: now(),
+        lastInstalledAt: current?.lastInstalledAt ?? null
+      });
+    }
+  };
+}
+async function writeControllerStatusFile(filePath, document) {
+  const directory = path.dirname(filePath);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const temporaryPath = path.join(
+    directory,
+    `.${path.basename(filePath)}.${randomBytes(6).toString("hex")}.tmp`
+  );
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(document)}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+    await rename(temporaryPath, filePath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true });
+    throw error;
+  }
+}
+function createControllerStatusPublisher(filePath = defaultControllerStatusPath()) {
+  let queue = Promise.resolve();
+  return (document) => {
+    queue = queue.then(() => writeControllerStatusFile(filePath, document)).catch(() => void 0);
+  };
+}
+
 // packages/desktop-control/src/renderer-react-ownership.ts
 function committedReactAncestors(value) {
   const MAX_VISITED_FIBERS = 2e5;
@@ -1216,6 +1350,14 @@ function installRendererHostRouting(root, target, discover, resolve, createPolic
     return typeof hostId === "string" && hostId ? hostId : null;
   };
   const routing = {
+    knownHostIds() {
+      if (disposed) return [];
+      try {
+        return [...read().hostIds];
+      } catch {
+        return [];
+      }
+    },
     forHost(hostId) {
       return hostId ? routeFor(hostId) : null;
     },
@@ -1282,7 +1424,12 @@ function directRendererInstaller() {
         manager, bridge, hostId, target, prewarmed, isCurrent, retainRendererHostResponses,
       ),
     );
-    if (!routing.forComposer()) throw new Error('Renderer request manager is ambiguous');
+    // Publish a default draft policy only when its Host is unambiguous. Host
+    // connections can be ready even when multiple Composers coexist.
+    const composerRoute = routing.forComposer();
+    const connected = composerRoute !== null ||
+      ['local', ...(routing.knownHostIds?.() ?? [])].some((hostId) => routing.forHost(hostId) !== null);
+    if (!connected) throw new Error('Renderer Host request manager is unavailable');
     return { state: 'ready', reason: 'owned-request-bridge' };
   })()`;
 }
@@ -1298,7 +1445,8 @@ async function waitForDraftPrewarmPolicy(evaluate, expression) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       const remaining = deadline - Date.now();
-      if (!message.includes("Renderer request manager is ambiguous") || remaining <= 0) throw error;
+      if (!message.includes("Renderer Host request manager is unavailable") || remaining <= 0)
+        throw error;
       await new Promise(
         (resolve) => setTimeout(resolve, Math.min(REQUEST_MANAGER_POLL_INTERVAL_MS, remaining))
       );
@@ -1319,6 +1467,33 @@ function isRecord2(value) {
 function sleep(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
+function discoveryTimeoutSignal(timeoutMs, signal) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([timeout, signal]) : timeout;
+}
+function abortFailure(signal, fallback) {
+  return signal.reason instanceof Error ? signal.reason : new Error(fallback);
+}
+function awaitWithSignal(promise, signal, timeoutMessage) {
+  if (signal.aborted) return Promise.reject(abortFailure(signal, timeoutMessage));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(abortFailure(signal, timeoutMessage));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
 function sameAgents(actual, expected) {
   const expectedSet = new Set(expected);
   return actual.length === expected.length && new Set(actual).size === actual.length && actual.every((agent) => expectedSet.has(agent));
@@ -1358,21 +1533,36 @@ function validateBindingStatus(value, expectedAgents) {
   }
   return value;
 }
-async function waitForPrimaryTarget(endpoint, operations, timeoutMs, pollIntervalMs, preferredTargetId) {
-  const deadline = Date.now() + timeoutMs;
+async function waitForPrimaryTarget(endpoint, operations, timeoutMs, pollIntervalMs, preferredTargetId, signal) {
+  const discovery = discoveryTimeoutSignal(timeoutMs, signal);
   let lastError;
-  while (Date.now() < deadline) {
+  while (!discovery.aborted) {
     try {
       const target = selectPrimaryRendererTarget(
-        await operations.listTargets(endpoint),
+        await awaitWithSignal(
+          operations.listTargets(endpoint, discovery),
+          discovery,
+          "Renderer CDP target discovery timed out"
+        ),
         preferredTargetId
       );
       if (target) return target;
       lastError = new Error("Renderer CDP has no primary app://-/index.html page target");
     } catch (error) {
       lastError = error;
+      if (discovery.aborted) break;
+    }
+    if (discovery.aborted) break;
+    try {
+      await awaitWithSignal(
+        sleep(pollIntervalMs),
+        discovery,
+        "Renderer CDP target discovery timed out"
+      );
+    } catch (error) {
+      lastError = error;
+      break;
     }
-    await sleep(pollIntervalMs);
   }
   const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
   throw new Error(`Primary Codex Renderer CDP target did not become ready${detail}`);
@@ -1514,7 +1704,7 @@ var InstalledRendererCdpControlSession = class {
   }
 };
 var defaultOperations = {
-  listTargets: (endpoint) => listCdpTargets(endpoint),
+  listTargets: (endpoint, signal) => listCdpTargets(endpoint, fetch, signal),
   connect: (webSocketDebuggerUrl) => CdpClient.connect(webSocketDebuggerUrl),
   installDraftPrewarmPolicy: installRendererDraftPrewarmPolicyDirect
 };
@@ -1527,7 +1717,9 @@ async function createRendererCdpControlSession(options) {
     options.rendererCdpEndpoint,
     operations,
     timeoutMs,
-    pollIntervalMs
+    pollIntervalMs,
+    void 0,
+    options.signal
   );
   const installed = await installTarget(
     target,
@@ -1743,9 +1935,11 @@ ${rendererSource}`,
           "hermes",
           "qoder",
           "qoder-cn",
-          "kimi-code"
+          "kimi-code",
+          "zcode"
         ],
-        timeoutMs: PRODUCTION_INSTALL_TIMEOUT_MS
+        timeoutMs: PRODUCTION_INSTALL_TIMEOUT_MS,
+        signal
       },
       dependencies
     );
@@ -1753,14 +1947,6 @@ ${rendererSource}`,
     return installed;
   };
   startupTrace("initialization started");
-  try {
-    session = await createSession();
-    recordRecoverySuccess();
-  } catch (error) {
-    startupTrace("initial Renderer Session unavailable", error);
-    session = void 0;
-    recordRecoveryFailure(error);
-  }
   let operation = Promise.resolve(void 0);
   const useSession = (callback) => {
     const next = operation.then(callback, callback);
@@ -1796,6 +1982,11 @@ ${rendererSource}`,
     attachmentServer = await dependencies.startAttachmentServer({
       port: options.attachmentPort,
       nonce: options.attachmentNonce,
+      openLocalPage: (url) => openRendererLocalPage(
+        (expression) => useSession(async () => (await recoverSession()).executeRenderer(expression)),
+        url,
+        () => listCdpTargets(options.rendererCdpEndpoint)
+      ),
       attach: () => useSession(async () => {
         const current = await recoverSession();
         await current.activateDesktop();
@@ -1808,6 +1999,17 @@ ${rendererSource}`,
       state: "compatible",
       issues: []
     });
+    await useSession(async () => {
+      if (session) return;
+      try {
+        session = await createSession();
+        recordRecoverySuccess();
+      } catch (error) {
+        startupTrace("initial Renderer Session unavailable", error);
+        session = void 0;
+        recordRecoveryFailure(error);
+      }
+    });
     while (!signal.aborted) {
       await dependencies.sleep(dependencies.monitorIntervalMs);
       if (signal.aborted) continue;