@codexhost/cli-win32-arm64 0.10.2 → 0.12.0

package/app/desktop-controller.mjs

@@ -1,93 +1,71 @@
 // packages/desktop-control/src/production-controller.ts
 import { readFile } from "node:fs/promises";
-import path from "node:path";
+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 show() {
+      if (closed) return;
+      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"
+      });
+    },
     async close() {
       if (closed) return;
       closed = true;
-      for (const socket of sockets) socket.destroy();
-      await closeServer(server);
+      await post({ type: "close-browser-tab", conversationId, browserTabId });
     }
   };
 }
 
 // packages/desktop-control/src/cdp-client.ts
+function cdpExceptionMessage(details, fallback) {
+  const exception = details.exception;
+  if (isRecord(exception) && typeof exception.description === "string" && exception.description) {
+    return exception.description;
+  }
+  return typeof details.text === "string" && details.text ? details.text : fallback;
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -120,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);
@@ -148,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");
@@ -244,8 +222,7 @@ var CdpClient = class _CdpClient {
     });
     if (!isRecord(response)) throw new Error("Runtime.evaluate returned an invalid result");
     if (isRecord(response.exceptionDetails)) {
-      const text = typeof response.exceptionDetails.text === "string" ? response.exceptionDetails.text : "Renderer evaluation failed";
-      throw new Error(text);
+      throw new Error(cdpExceptionMessage(response.exceptionDetails, "Renderer evaluation failed"));
     }
     if (!isRecord(response.result) || !("value" in response.result)) {
       throw new Error("Runtime.evaluate did not return a value");
@@ -296,16 +273,282 @@ 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 = 2e4;
+  const MAX_VISITED_FIBERS = 2e5;
   const fiber = (value2) => typeof value2 === "object" && value2 !== null ? value2 : null;
+  const exhausted = () => {
+    const target = globalThis;
+    if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function")
+      target.dispatchEvent(
+        new CustomEvent("codexhost:react-fiber-walk-limit", {
+          detail: { limit: MAX_VISITED_FIBERS }
+        })
+      );
+    return [];
+  };
   const first = fiber(value);
   if (!first) return [];
   const previous = [];
   const seen = /* @__PURE__ */ new Set();
   for (let node = first; node; node = fiber(node.return)) {
-    if (seen.has(node) || seen.size >= MAX_VISITED_FIBERS) return [];
+    if (seen.has(node)) return [];
+    if (seen.size >= MAX_VISITED_FIBERS) return exhausted();
     seen.add(node);
     previous.push(node);
   }
@@ -313,8 +556,30 @@ function committedReactAncestors(value) {
   if (!rootState || !("current" in rootState)) return previous;
   const current = fiber(rootState.current);
   if (!current) return [];
-  const stack = [{ node: current, parent: null }];
   const alternate = fiber(first.alternate);
+  const path3 = [current];
+  seen.clear();
+  seen.add(current);
+  for (let index = previous.length - 2; index >= 0; index -= 1) {
+    const expected = previous[index];
+    const expectedAlternate = fiber(expected?.alternate);
+    let child = fiber(path3.at(-1)?.child);
+    let matched = false;
+    while (child && !seen.has(child) && seen.size < MAX_VISITED_FIBERS) {
+      seen.add(child);
+      if (child === expected || child === expectedAlternate) {
+        matched = true;
+        break;
+      }
+      child = fiber(child.sibling);
+    }
+    if (!matched || !child) break;
+    path3.push(child);
+  }
+  if (path3.length === previous.length && (path3.at(-1) === first || path3.at(-1) === alternate)) {
+    return path3.reverse();
+  }
+  const stack = [{ node: current, parent: null }];
   seen.clear();
   while (stack.length > 0 && seen.size < MAX_VISITED_FIBERS) {
     const entry = stack.pop();
@@ -332,7 +597,7 @@ function committedReactAncestors(value) {
     const child = fiber(entry.node.child);
     if (child) stack.push({ node: child, parent: entry });
   }
-  return [];
+  return stack.length > 0 ? exhausted() : [];
 }
 
 // packages/desktop-control/src/renderer-host-response-ownership.ts
@@ -1085,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;
     },
@@ -1151,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' };
   })()`;
 }
@@ -1167,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))
       );
@@ -1188,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));
@@ -1227,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}`);
@@ -1253,8 +1574,9 @@ async function evaluateSource(renderer, source) {
   });
   if (!isRecord2(response)) throw new Error("Renderer source evaluation returned an invalid result");
   if (isRecord2(response.exceptionDetails)) {
-    const text = typeof response.exceptionDetails.text === "string" ? response.exceptionDetails.text : "Renderer source evaluation failed";
-    throw new Error(text);
+    throw new Error(
+      cdpExceptionMessage(response.exceptionDetails, "Renderer source evaluation failed")
+    );
   }
 }
 async function readBinding(renderer) {
@@ -1382,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
 };
@@ -1395,7 +1717,9 @@ async function createRendererCdpControlSession(options) {
     options.rendererCdpEndpoint,
     operations,
     timeoutMs,
-    pollIntervalMs
+    pollIntervalMs,
+    void 0,
+    options.signal
   );
   const installed = await installTarget(
     target,
@@ -1454,6 +1778,7 @@ var defaultDependencies = {
     process.stdout.write(`${serializeDesktopControllerReadiness(readiness)}
 `);
   },
+  publishStatus: createControllerStatusPublisher(),
   sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
   monitorIntervalMs: 500
 };
@@ -1485,8 +1810,8 @@ function parseDesktopControllerArguments(arguments_) {
     if (argument === "--renderer") {
       if (rendererPath !== void 0) throw new Error("--renderer may only be provided once");
       if (!value) throw new Error("--renderer requires a value");
-      if (!path.isAbsolute(value)) throw new Error("--renderer must be an absolute path");
-      rendererPath = path.normalize(value);
+      if (!path2.isAbsolute(value)) throw new Error("--renderer must be an absolute path");
+      rendererPath = path2.normalize(value);
       index += 1;
       continue;
     }
@@ -1568,15 +1893,22 @@ async function runDesktopController(options, signal, dependencies = defaultDepen
   let session;
   let nextRecoveryAt = 0;
   let recoveryDelayMs = RECOVERY_RETRY_INITIAL_MS;
-  const recordRecoveryFailure = () => {
+  const status = createRendererStatusReporter(
+    (document) => dependencies.publishStatus?.(document),
+    now
+  );
+  const recordRecoveryFailure = (error) => {
     nextRecoveryAt = now() + recoveryDelayMs;
     recoveryDelayMs = Math.min(recoveryDelayMs * 2, RECOVERY_RETRY_MAX_MS);
+    status.failed(error);
   };
   const recordRecoverySuccess = () => {
     nextRecoveryAt = 0;
     recoveryDelayMs = RECOVERY_RETRY_INITIAL_MS;
+    status.installed();
   };
   const createSession = async () => {
+    status.installing();
     startupTrace("reading Renderer bundle");
     const rendererSource = await dependencies.readRenderer(options.rendererPath);
     if (rendererSource.trim().length === 0) throw new Error("production Renderer Bundle is empty");
@@ -1603,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
     );
@@ -1613,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();
-  }
   let operation = Promise.resolve(void 0);
   const useSession = (callback) => {
     const next = operation.then(callback, callback);
@@ -1646,7 +1972,7 @@ ${rendererSource}`,
       return current;
     } catch (error) {
       resetSession();
-      recordRecoveryFailure();
+      recordRecoveryFailure(error);
       throw error;
     }
   };
@@ -1656,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();
@@ -1668,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;