@chinhae/codex-connect-linux-arm64 0.11.0

package/app/desktop-controller.mjs

@@ -0,0 +1,1704 @@
+// packages/desktop-control/src/production-controller.ts
+import { readFile } from "node:fs/promises";
+import path 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();
+    });
+  });
+}
+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();
+  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() {
+      if (closed) return;
+      closed = true;
+      for (const socket of sockets) socket.destroy();
+      await closeServer(server);
+    }
+  };
+}
+
+// packages/desktop-control/src/cdp-client.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function loopbackUrl(value, protocols) {
+  const url = new URL(value);
+  if (!protocols.includes(url.protocol)) {
+    throw new Error(`CDP endpoint must use ${protocols.join(" or ")}`);
+  }
+  if (!["127.0.0.1", "localhost", "[::1]"].includes(url.hostname)) {
+    throw new Error("CDP endpoint must use a loopback host");
+  }
+  return url;
+}
+function optionalText(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function parseTarget(value) {
+  if (!isRecord(value)) throw new Error("CDP target must be an object");
+  const id = optionalText(value.id);
+  const type = optionalText(value.type);
+  const url = optionalText(value.url);
+  const webSocketDebuggerUrl = optionalText(value.webSocketDebuggerUrl);
+  if (webSocketDebuggerUrl) loopbackUrl(webSocketDebuggerUrl, ["ws:", "wss:"]);
+  if (!id || !type || !url || !webSocketDebuggerUrl) return null;
+  return {
+    id,
+    type,
+    title: typeof value.title === "string" ? value.title : "",
+    url,
+    webSocketDebuggerUrl
+  };
+}
+function defaultFetch(url) {
+  return fetch(url);
+}
+function defaultSocketFactory(url) {
+  return new WebSocket(url);
+}
+function messageText(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof ArrayBuffer) return new TextDecoder().decode(value);
+  if (ArrayBuffer.isView(value)) {
+    return new TextDecoder().decode(
+      new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+    );
+  }
+  throw new Error("CDP WebSocket returned a non-text message");
+}
+function parseResponse(value) {
+  if (!isRecord(value) || typeof value.id !== "number") return null;
+  const response = { id: value.id };
+  if ("result" in value) response.result = value.result;
+  if (isRecord(value.error)) {
+    response.error = {
+      ...typeof value.error.code === "number" ? { code: value.error.code } : {},
+      ...typeof value.error.message === "string" ? { message: value.error.message } : {}
+    };
+  }
+  return response;
+}
+async function listCdpTargets(endpoint, fetchImpl = defaultFetch) {
+  const baseUrl = loopbackUrl(endpoint, ["http:", "https:"]);
+  const targetsUrl = new URL("/json/list", baseUrl).toString();
+  const response = await fetchImpl(targetsUrl);
+  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");
+  return value.map(parseTarget).filter((target) => target !== null);
+}
+var CdpClient = class _CdpClient {
+  #commandTimeoutMs;
+  #socket;
+  #closed = false;
+  #nextId = 1;
+  #pending = /* @__PURE__ */ new Map();
+  #listeners = /* @__PURE__ */ new Map();
+  constructor(socket, commandTimeoutMs) {
+    this.#socket = socket;
+    this.#commandTimeoutMs = commandTimeoutMs;
+    socket.addEventListener("message", (event) => this.#onMessage(event));
+    socket.addEventListener("error", () => this.#fail(new Error("CDP WebSocket failed")));
+    socket.addEventListener("close", () => this.#fail(new Error("CDP WebSocket closed")));
+  }
+  static async connect(url, options = {}) {
+    loopbackUrl(url, ["ws:", "wss:"]);
+    const socketFactory = options.socketFactory ?? defaultSocketFactory;
+    const socket = socketFactory(url);
+    const connectTimeoutMs = options.connectTimeoutMs ?? 1e4;
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        socket.close();
+        reject(new Error("CDP WebSocket connection timed out"));
+      }, connectTimeoutMs);
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = () => {
+        cleanup();
+        reject(new Error("CDP WebSocket connection failed"));
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        socket.removeEventListener("open", onOpen);
+        socket.removeEventListener("error", onError);
+      };
+      socket.addEventListener("open", onOpen);
+      socket.addEventListener("error", onError);
+    });
+    return new _CdpClient(socket, options.commandTimeoutMs ?? 1e4);
+  }
+  command(method, params = {}) {
+    return this.#send(method, params);
+  }
+  sessionCommand(sessionId, method, params = {}) {
+    if (sessionId.length === 0) return Promise.reject(new Error("CDP session ID is required"));
+    return this.#send(method, params, sessionId);
+  }
+  on(method, listener) {
+    const listeners = this.#listeners.get(method) ?? /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.#listeners.set(method, listeners);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) this.#listeners.delete(method);
+    };
+  }
+  #send(method, params, sessionId) {
+    if (this.#closed) return Promise.reject(new Error("CDP client is closed"));
+    const id = this.#nextId++;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.#pending.delete(id);
+        reject(new Error(`CDP command '${method}' timed out`));
+      }, this.#commandTimeoutMs);
+      this.#pending.set(id, { resolve, reject, timeout });
+      try {
+        this.#socket.send(
+          JSON.stringify({ id, method, params, ...sessionId ? { sessionId } : {} })
+        );
+      } catch (error) {
+        clearTimeout(timeout);
+        this.#pending.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  async evaluate(expression) {
+    const response = await this.command("Runtime.evaluate", {
+      expression,
+      awaitPromise: true,
+      returnByValue: true
+    });
+    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);
+    }
+    if (!isRecord(response.result) || !("value" in response.result)) {
+      throw new Error("Runtime.evaluate did not return a value");
+    }
+    return response.result.value;
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#fail(new Error("CDP client closed"));
+    this.#listeners.clear();
+    this.#socket.close();
+  }
+  #onMessage(event) {
+    try {
+      const value = JSON.parse(messageText(event.data));
+      const response = parseResponse(value);
+      if (!response) {
+        if (!isRecord(value) || typeof value.method !== "string") return;
+        const sessionId = typeof value.sessionId === "string" ? value.sessionId : void 0;
+        for (const listener of this.#listeners.get(value.method) ?? []) {
+          listener(value.params, sessionId);
+        }
+        return;
+      }
+      const pending = this.#pending.get(response.id);
+      if (!pending) return;
+      clearTimeout(pending.timeout);
+      this.#pending.delete(response.id);
+      if (response.error) {
+        const code = response.error.code === void 0 ? "unknown" : String(response.error.code);
+        pending.reject(
+          new Error(response.error.message ?? `CDP command failed with error ${code}`)
+        );
+      } else {
+        pending.resolve(response.result);
+      }
+    } catch (error) {
+      this.#fail(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  #fail(error) {
+    for (const pending of this.#pending.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
+    this.#pending.clear();
+  }
+};
+
+// packages/desktop-control/src/renderer-react-ownership.ts
+function committedReactAncestors(value) {
+  const MAX_VISITED_FIBERS = 2e4;
+  const fiber = (value2) => typeof value2 === "object" && value2 !== null ? value2 : null;
+  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 [];
+    seen.add(node);
+    previous.push(node);
+  }
+  const rootState = fiber(previous.at(-1)?.stateNode);
+  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);
+  seen.clear();
+  while (stack.length > 0 && seen.size < MAX_VISITED_FIBERS) {
+    const entry = stack.pop();
+    if (!entry) break;
+    if (seen.has(entry.node)) return [];
+    seen.add(entry.node);
+    if (entry.node === first || entry.node === alternate) {
+      const ancestors = [];
+      for (let cursor = entry; cursor; cursor = cursor.parent)
+        ancestors.push(cursor.node);
+      return ancestors;
+    }
+    const sibling = entry.parent && fiber(entry.node.sibling);
+    if (sibling) stack.push({ node: sibling, parent: entry.parent });
+    const child = fiber(entry.node.child);
+    if (child) stack.push({ node: child, parent: entry });
+  }
+  return [];
+}
+
+// packages/desktop-control/src/renderer-host-response-ownership.ts
+function retainRendererHostResponses(client, hostId, target) {
+  if (typeof client.addRequestLifecycleListener !== "function" || typeof target.addEventListener !== "function" || typeof target.removeEventListener !== "function")
+    return () => {
+    };
+  const isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const pending = /* @__PURE__ */ new Set();
+  let retired = false;
+  let unsubscribe = () => {
+  };
+  const detach = () => {
+    target.removeEventListener?.("message", receive);
+    unsubscribe();
+  };
+  const receive = (event) => {
+    const { source, origin, data } = event;
+    if (source != null && source !== target) return;
+    const ownOrigin = target.location?.origin;
+    if (source === target && ownOrigin && ownOrigin !== "null" && origin !== ownOrigin) return;
+    if (!isRecord3(data) || data.type !== "mcp-response" || data.hostId !== hostId) return;
+    const message = data.message;
+    if (!isRecord3(message)) return;
+    const id = message.id;
+    if (typeof id !== "string" && typeof id !== "number" || !pending.has(id)) return;
+    const hasError = isRecord3(message.error);
+    if (!hasError && !Object.prototype.hasOwnProperty.call(message, "result")) return;
+    queueMicrotask(() => {
+      if (!pending.has(id)) return;
+      if (hasError) client.onError(id, message.error, data.hostMetrics);
+      else client.onResult(id, message.result, data.hostMetrics);
+    });
+  };
+  target.addEventListener("message", receive);
+  unsubscribe = client.addRequestLifecycleListener((event) => {
+    if (!isRecord3(event) || event.hostId !== hostId) return;
+    const id = event.id;
+    if (typeof id !== "string" && typeof id !== "number") return;
+    if (!retired && event.type === "started" && typeof event.method === "string" && event.method.startsWith("codexhost/"))
+      pending.add(id);
+    else if (event.type === "completed" || event.type === "failed") {
+      pending.delete(id);
+      if (retired && pending.size === 0) detach();
+    }
+  });
+  return () => {
+    retired = true;
+    if (pending.size === 0) detach();
+  };
+}
+
+// packages/desktop-control/src/renderer-draft-prewarm-runtime.ts
+function createDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses) {
+  let disposed = false;
+  const originalSend = bridge.sendRequest;
+  const originalPrewarm = bridge.prewarmThreadStart;
+  const originalOnNotification = manager.onNotification;
+  const originalDispatchAppServerResponse = manager.dispatchAppServerResponse;
+  let selectedModel = null;
+  let prewarmGeneration = 0;
+  const isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const isUnsupportedPosixBridgeSpawn = (value) => {
+    const marker = "AbsolutePathBuf deserialized without a base path";
+    if (typeof value === "string") {
+      return value.startsWith("Invalid request:") && value.includes(marker);
+    }
+    if (!isRecord3(value)) return false;
+    if (typeof value.message === "string" && value.message.includes(marker)) {
+      if (value.code === -32600 || value.message.startsWith("Invalid request:")) return true;
+    }
+    return value.cause !== value && isUnsupportedPosixBridgeSpawn(value.cause);
+  };
+  const isRemoteControlHost = hostId.startsWith("remote-control:");
+  const retireResponses = isRemoteControlHost ? () => {
+  } : retainResponses(bridge, hostId, target);
+  const knownExternalThreadIds = /* @__PURE__ */ new Set();
+  const knownOfficialThreadIds = /* @__PURE__ */ new Set();
+  const threadOwnershipResolutions = /* @__PURE__ */ new Map();
+  const createBridgeProcessHandle = () => `codexhost-${typeof crypto?.randomUUID === "function" ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(16).slice(2)}`}`;
+  let bridgeProcessHandle = createBridgeProcessHandle();
+  const bridgeReadyMethod = "codexhost/remote-control-bridge/ready";
+  const bridgeRequests = /* @__PURE__ */ new Map();
+  const bridgeServerRequestIdPrefix = "codexhost/remote-control-bridge/server-request/";
+  const bridgeServerRequests = /* @__PURE__ */ new Map();
+  let nextBridgeServerRequestOrdinal = 1;
+  let outputDecoders = {
+    stdout: new TextDecoder(),
+    stderr: new TextDecoder()
+  };
+  const outputBuffers = { stdout: "", stderr: "" };
+  let bridgeState = "idle";
+  let bridgeReadyPromise = null;
+  let bridgeReadyResolve = null;
+  let bridgeReadyReject = null;
+  let bridgeReadyTimeout = null;
+  let bridgeInitialization = null;
+  let writeTail = Promise.resolve();
+  const transportError = (message, cause) => {
+    const error = new Error(`codexhost Remote Control bridge: ${message}`);
+    if (cause !== void 0) Object.assign(error, { cause });
+    return error;
+  };
+  const utf8Base64 = (value) => {
+    const bytes = new TextEncoder().encode(value);
+    let binary = "";
+    for (let index = 0; index < bytes.length; index += 32768) {
+      binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
+    }
+    return btoa(binary);
+  };
+  const utf16LeBase64 = (value) => {
+    let binary = "";
+    for (let index = 0; index < value.length; index += 1) {
+      const codeUnit = value.charCodeAt(index);
+      binary += String.fromCharCode(codeUnit & 255, codeUnit >>> 8);
+    }
+    return btoa(binary);
+  };
+  const failBridge = (cause, terminateProcess = true) => {
+    if (bridgeState === "failed" || bridgeState === "disposed") return;
+    const failedProcessHandle = bridgeProcessHandle;
+    const terminate = terminateProcess && (bridgeState === "starting" || bridgeState === "ready");
+    bridgeState = "failed";
+    if (bridgeReadyTimeout !== null) globalThis.clearTimeout(bridgeReadyTimeout);
+    bridgeReadyTimeout = null;
+    const stderr = outputBuffers.stderr.trim().slice(-1e3);
+    const error = transportError(
+      `${cause instanceof Error ? cause.message : String(cause)}${stderr ? `; ${stderr}` : ""}`,
+      cause
+    );
+    bridgeReadyReject?.(error);
+    bridgeReadyReject = null;
+    bridgeReadyResolve = null;
+    for (const requestId of bridgeRequests.keys()) bridge.onError(requestId, error);
+    bridgeRequests.clear();
+    if (isRemoteControlHost && terminate) {
+      void Promise.resolve(
+        originalSend.call(bridge, "process/kill", { processHandle: failedProcessHandle })
+      ).catch(() => void 0);
+    }
+  };
+  const resetFailedBridge = () => {
+    if (bridgeState !== "failed") return;
+    bridgeProcessHandle = createBridgeProcessHandle();
+    outputDecoders = { stdout: new TextDecoder(), stderr: new TextDecoder() };
+    outputBuffers.stdout = "";
+    outputBuffers.stderr = "";
+    bridgeReadyPromise = null;
+    bridgeReadyResolve = null;
+    bridgeReadyReject = null;
+    bridgeInitialization = null;
+    writeTail = Promise.resolve();
+    bridgeServerRequests.clear();
+    nextBridgeServerRequestOrdinal = 1;
+    bridgeState = "idle";
+  };
+  const rememberExternalThread = (value) => {
+    if (!isRecord3(value) || typeof value.id !== "string") return;
+    if (value.modelProvider === "codexhost" || value.cliVersion === "codexhost") {
+      knownExternalThreadIds.add(value.id);
+      knownOfficialThreadIds.delete(value.id);
+    }
+  };
+  const observeBridgeResult = (request, result) => {
+    if (!request || !isRecord3(result)) return;
+    if (request.method === "thread/list" && Array.isArray(result.data)) {
+      for (const thread of result.data) rememberExternalThread(thread);
+      return;
+    }
+    if (request.method === "thread/start" || request.method === "thread/read" || request.method === "thread/resume") {
+      rememberExternalThread(result.thread);
+      return;
+    }
+    if (request.method === "codexhost/thread/inspect" && isRecord3(request.parameters) && typeof request.parameters.threadId === "string") {
+      if (result.owner === "external") {
+        knownExternalThreadIds.add(request.parameters.threadId);
+        knownOfficialThreadIds.delete(request.parameters.threadId);
+      } else if (result.owner === "codex") {
+        knownOfficialThreadIds.add(request.parameters.threadId);
+        knownExternalThreadIds.delete(request.parameters.threadId);
+      }
+      return;
+    }
+    if (request.method === "thread/delete" && isRecord3(request.parameters) && typeof request.parameters.threadId === "string") {
+      knownExternalThreadIds.delete(request.parameters.threadId);
+      knownOfficialThreadIds.delete(request.parameters.threadId);
+    }
+  };
+  const handleBridgeFrame = (value) => {
+    if (!isRecord3(value)) {
+      failBridge("received a non-object app-server frame");
+      return;
+    }
+    if (value.method === bridgeReadyMethod && value.id === void 0) {
+      if (isRecord3(value.params) && value.params.protocolVersion === 1) {
+        bridgeState = "ready";
+        if (bridgeReadyTimeout !== null) globalThis.clearTimeout(bridgeReadyTimeout);
+        bridgeReadyTimeout = null;
+        bridgeReadyResolve?.();
+        bridgeReadyResolve = null;
+        bridgeReadyReject = null;
+      } else {
+        failBridge("reported an unsupported protocol version");
+      }
+      return;
+    }
+    if (typeof value.method === "string" && value.id === void 0) {
+      if (value.method === "thread/started" && isRecord3(value.params)) {
+        rememberExternalThread(value.params.thread);
+      }
+      originalOnNotification.call(manager, value.method, value.params);
+      return;
+    }
+    if (typeof value.method === "string" && value.id !== void 0) {
+      const outerRequestId = `${bridgeServerRequestIdPrefix}${bridgeProcessHandle}/${nextBridgeServerRequestOrdinal}`;
+      nextBridgeServerRequestOrdinal += 1;
+      bridgeServerRequests.set(outerRequestId, value.id);
+      manager.onRequest({ ...value, id: outerRequestId });
+      return;
+    }
+    if (value.id === void 0) {
+      failBridge("received an app-server response without an id");
+      return;
+    }
+    const request = bridgeRequests.get(value.id);
+    bridgeRequests.delete(value.id);
+    if ("error" in value) {
+      bridge.onError(value.id, value.error, value.metrics);
+      return;
+    }
+    observeBridgeResult(request, value.result);
+    bridge.onResult(value.id, value.result, value.metrics);
+  };
+  const consumeBridgeOutput = (stream, base64) => {
+    const binary = atob(base64);
+    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    outputBuffers[stream] += outputDecoders[stream].decode(bytes, { stream: true });
+    if (stream === "stderr") {
+      outputBuffers.stderr = outputBuffers.stderr.slice(-4e3);
+      return;
+    }
+    while (true) {
+      const newline = outputBuffers.stdout.indexOf("\n");
+      if (newline < 0) break;
+      const line = outputBuffers.stdout.slice(0, newline).trim();
+      outputBuffers.stdout = outputBuffers.stdout.slice(newline + 1);
+      if (!line) continue;
+      try {
+        handleBridgeFrame(JSON.parse(line));
+      } catch (error) {
+        failBridge(
+          `emitted invalid JSON: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return;
+      }
+    }
+  };
+  const handleOuterNotification = (method, parameters) => {
+    if (method === "process/exited" && isRecord3(parameters) && parameters.processHandle === bridgeProcessHandle) {
+      const exitCode = typeof parameters.exitCode === "number" ? parameters.exitCode : "unknown";
+      const stderr = typeof parameters.stderr === "string" ? parameters.stderr.trim() : "";
+      failBridge(
+        `process exited unexpectedly with code ${exitCode}${stderr ? `: ${stderr}` : ""}`,
+        false
+      );
+      return true;
+    }
+    if (method !== "process/outputDelta" || !isRecord3(parameters) || parameters.processHandle !== bridgeProcessHandle || parameters.stream !== "stdout" && parameters.stream !== "stderr" || typeof parameters.deltaBase64 !== "string") {
+      return false;
+    }
+    if (parameters.capReached === true) {
+      failBridge(`${parameters.stream} was truncated`);
+      return true;
+    }
+    consumeBridgeOutput(parameters.stream, parameters.deltaBase64);
+    return true;
+  };
+  const startBridge = () => {
+    if (!isRemoteControlHost) return Promise.resolve();
+    if (bridgeReadyPromise) return bridgeReadyPromise;
+    bridgeState = "starting";
+    bridgeReadyPromise = new Promise((resolve, reject) => {
+      bridgeReadyResolve = resolve;
+      bridgeReadyReject = reject;
+    });
+    bridgeReadyTimeout = globalThis.setTimeout(
+      () => failBridge("startup timed out after 15000ms"),
+      15e3
+    );
+    const powershellScript = "$ErrorActionPreference = 'Stop'; $descriptorPath = Join-Path $env:LOCALAPPDATA 'codexhost\\remote-control-bridge-v1.json'; $descriptor = Get-Content -LiteralPath $descriptorPath -Raw | ConvertFrom-Json; if ($descriptor.schemaVersion -ne 1) { throw 'Unsupported codexhost Remote Control descriptor' }; $nodePath = [string]$descriptor.nodePath; $runtimePath = [string]$descriptor.runtimePath; if (-not [System.IO.Path]::IsPathRooted($nodePath) -or -not [System.IO.Path]::IsPathRooted($runtimePath)) { throw 'Invalid codexhost Remote Control runtime path' }; $owner = Get-Process -Id ([int]$descriptor.ownerPid) -ErrorAction SilentlyContinue; if ($null -eq $owner) { throw 'CodexHost Remote Control runtime is not running' }; $env:CODEXHOST_REMOTE_CONTROL_BRIDGE_PIPE = [string]$descriptor.pipePath; & $nodePath $runtimePath '--codexhost-remote-control-bridge'; exit $LASTEXITCODE";
+    const command = [
+      "powershell.exe",
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-EncodedCommand",
+      utf16LeBase64(powershellScript)
+    ];
+    const startedProcessHandle = bridgeProcessHandle;
+    try {
+      const started = originalSend.call(bridge, "process/spawn", {
+        command,
+        processHandle: startedProcessHandle,
+        cwd: "C:\\",
+        streamStdin: true,
+        streamStdoutStderr: true,
+        outputBytesCap: null,
+        timeoutMs: null
+      });
+      void Promise.resolve(started).catch((error) => {
+        if (bridgeProcessHandle === startedProcessHandle) failBridge(error, false);
+      });
+    } catch (error) {
+      failBridge(error);
+    }
+    return bridgeReadyPromise;
+  };
+  const writeBridgeFrame = (value) => {
+    const operation = async () => {
+      await startBridge();
+      if (bridgeState !== "ready") throw transportError("is not ready");
+      await originalSend.call(bridge, "process/writeStdin", {
+        processHandle: bridgeProcessHandle,
+        deltaBase64: utf8Base64(`${JSON.stringify(value)}
+`)
+      });
+    };
+    const next = writeTail.then(operation, operation);
+    writeTail = next.catch(() => void 0);
+    return next;
+  };
+  const enqueueBridgeRequest = (method, parameters, options) => bridge.enqueueRequest(method, parameters, options, (request) => {
+    bridgeRequests.set(request.id, { method, parameters });
+    void writeBridgeFrame(request).catch((error) => failBridge(error));
+  });
+  const initializeBridgeProtocol = () => {
+    const initialization = enqueueBridgeRequest("initialize", {
+      clientInfo: {
+        name: "codexhost_remote_control_bridge",
+        title: "codexhost Remote Control bridge",
+        version: "1"
+      },
+      capabilities: {
+        experimentalApi: true,
+        mcpServerOpenaiFormElicitation: true
+      }
+    });
+    return new Promise((resolve, reject) => {
+      const timeout = globalThis.setTimeout(() => {
+        const message = "initialization timed out after 15000ms";
+        failBridge(message);
+        reject(transportError(message));
+      }, 15e3);
+      void Promise.resolve(initialization).then(
+        (value) => {
+          globalThis.clearTimeout(timeout);
+          resolve(value);
+        },
+        (error) => {
+          globalThis.clearTimeout(timeout);
+          reject(error);
+        }
+      );
+    });
+  };
+  const initializeBridge = () => {
+    resetFailedBridge();
+    if (bridgeInitialization) return bridgeInitialization;
+    bridgeInitialization = startBridge().then(() => initializeBridgeProtocol()).then(() => writeBridgeFrame({ method: "initialized", params: {} }));
+    return bridgeInitialization;
+  };
+  const threadIdFromParameters = (parameters) => {
+    if (!isRecord3(parameters)) return null;
+    const value = parameters.threadId ?? parameters.conversationId;
+    return typeof value === "string" ? value : null;
+  };
+  const isThreadScopedMethod = (method) => method.startsWith("thread/") || method.startsWith("turn/") || method.startsWith("review/");
+  const resolveThreadOwnership = (threadId) => {
+    if (knownExternalThreadIds.has(threadId)) return Promise.resolve("external");
+    if (knownOfficialThreadIds.has(threadId)) return Promise.resolve("codex");
+    const pending = threadOwnershipResolutions.get(threadId);
+    if (pending) return pending;
+    const resolution = initializeBridge().then(
+      () => enqueueBridgeRequest("codexhost/thread/ownership/list", {
+        threadIds: [threadId]
+      })
+    ).then((value) => {
+      const ownerships = isRecord3(value) && Array.isArray(value.threads) ? value.threads : null;
+      const ownership = ownerships?.[0];
+      if (!ownerships || !isRecord3(ownership) || ownerships.length !== 1 || ownership.threadId !== threadId || ownership.owner !== "external" && ownership.owner !== "codex") {
+        throw transportError("Thread ownership lookup returned an invalid result");
+      }
+      if (ownership.owner === "external") {
+        knownExternalThreadIds.add(threadId);
+        knownOfficialThreadIds.delete(threadId);
+        return "external";
+      }
+      knownOfficialThreadIds.add(threadId);
+      knownExternalThreadIds.delete(threadId);
+      return "codex";
+    });
+    threadOwnershipResolutions.set(threadId, resolution);
+    const clearResolution = () => {
+      if (threadOwnershipResolutions.get(threadId) === resolution) {
+        threadOwnershipResolutions.delete(threadId);
+      }
+    };
+    void resolution.then(clearResolution, clearResolution);
+    return resolution;
+  };
+  const shouldResolveThreadOwnership = (method, parameters) => {
+    if (!isRemoteControlHost || method.startsWith("codexhost/") || !isThreadScopedMethod(method)) {
+      return null;
+    }
+    const threadId = threadIdFromParameters(parameters);
+    if (!threadId || knownExternalThreadIds.has(threadId) || knownOfficialThreadIds.has(threadId)) {
+      return null;
+    }
+    return threadId;
+  };
+  const shouldUseBridge = (method, parameters) => {
+    if (!isRemoteControlHost) return false;
+    if (method.startsWith("codexhost/")) return true;
+    if (method === "thread/list") return true;
+    if (method === "thread/start") {
+      return isRecord3(parameters) && typeof parameters.model === "string" && parameters.model.startsWith("codexhost/");
+    }
+    const threadId = threadIdFromParameters(parameters);
+    if (threadId && knownExternalThreadIds.has(threadId)) return true;
+    if (threadId && knownOfficialThreadIds.has(threadId)) return false;
+    return selectedModel !== null && (method.startsWith("thread/") || method.startsWith("turn/") || method.startsWith("review/"));
+  };
+  const routeThreadStart = (parameters) => {
+    if (!isRecord3(parameters) || parameters.ephemeral === true) {
+      return parameters;
+    }
+    return {
+      ...parameters,
+      ...selectedModel === null ? {} : { model: selectedModel }
+    };
+  };
+  const routedSend = (method, parameters, options) => {
+    const routedParameters = method === "thread/start" ? routeThreadStart(parameters) : parameters;
+    const sendBridged = () => initializeBridge().then(
+      () => enqueueBridgeRequest(method, routedParameters, options)
+    );
+    const sendDirect = () => options === void 0 ? originalSend.call(bridge, method, routedParameters) : originalSend.call(bridge, method, routedParameters, options);
+    const unresolvedThreadId = shouldResolveThreadOwnership(method, routedParameters);
+    if (unresolvedThreadId) {
+      return resolveThreadOwnership(unresolvedThreadId).then(
+        (owner) => owner === "external" ? sendBridged() : sendDirect(),
+        (error) => {
+          if ((method === "thread/read" || method === "thread/resume") && isUnsupportedPosixBridgeSpawn(error)) {
+            return Promise.resolve(sendDirect()).then((result) => {
+              knownOfficialThreadIds.add(unresolvedThreadId);
+              knownExternalThreadIds.delete(unresolvedThreadId);
+              return result;
+            });
+          }
+          throw error;
+        }
+      );
+    }
+    return shouldUseBridge(method, routedParameters) ? sendBridged() : sendDirect();
+  };
+  const publishDraftWorkspace = (parameters) => {
+    if (!isRecord3(parameters) || parameters.ephemeral === true) return;
+    const cwd = parameters.cwd;
+    if (typeof cwd !== "string" || cwd.length === 0) return;
+    const drafts = isRecord3(target.__codexhostDraftWorkspacesV1) ? target.__codexhostDraftWorkspacesV1 : {};
+    drafts[hostId] = cwd;
+    Object.defineProperty(target, "__codexhostDraftWorkspacesV1", {
+      configurable: true,
+      value: drafts
+    });
+    if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function") {
+      target.dispatchEvent(
+        new CustomEvent("codexhost:draft-workspace", { detail: { hostId, cwd } })
+      );
+    }
+  };
+  const routedPrewarm = (parameters, options) => {
+    const routedParameters = routeThreadStart(parameters);
+    const generation = prewarmGeneration;
+    publishDraftWorkspace(routedParameters);
+    const pending = shouldUseBridge("thread/start", routedParameters) ? routedSend("thread/start", routedParameters, options) : options === void 0 ? originalPrewarm.call(bridge, routedParameters) : originalPrewarm.call(bridge, routedParameters, options);
+    if (isRecord3(parameters) && parameters.ephemeral === true || typeof pending !== "object" && typeof pending !== "function" || pending === null || typeof Reflect.get(pending, "then") !== "function") {
+      return pending;
+    }
+    return Promise.resolve(pending).then((result) => {
+      if (disposed || generation !== prewarmGeneration) {
+        throw new Error("Renderer draft prewarm was invalidated by a configuration change");
+      }
+      publishDraftWorkspace(routedParameters);
+      return result;
+    });
+  };
+  bridge.sendRequest = routedSend;
+  bridge.prewarmThreadStart = routedPrewarm;
+  const routedWindowMessage = (event) => {
+    const message = event.data;
+    if (!isRecord3(message) || message.type !== "mcp-notification" || message.hostId !== hostId || typeof message.method !== "string") {
+      return;
+    }
+    handleOuterNotification(message.method, message.params);
+  };
+  const observesWindowNotifications = isRemoteControlHost && typeof target.addEventListener === "function" && typeof target.removeEventListener === "function";
+  if (observesWindowNotifications) target.addEventListener?.("message", routedWindowMessage);
+  const routedOnNotification = (method, parameters) => {
+    if (!handleOuterNotification(method, parameters)) {
+      originalOnNotification.call(manager, method, parameters);
+    }
+  };
+  const routedDispatchAppServerResponse = (method, response) => {
+    if (isRemoteControlHost && typeof response.id === "string") {
+      const innerRequestId = bridgeServerRequests.get(response.id);
+      if (innerRequestId !== void 0 || bridgeServerRequests.has(response.id)) {
+        bridgeServerRequests.delete(response.id);
+        void writeBridgeFrame({ ...response, id: innerRequestId }).catch(
+          (error) => failBridge(error)
+        );
+        return void 0;
+      }
+      if (response.id.startsWith(bridgeServerRequestIdPrefix)) return void 0;
+    }
+    return originalDispatchAppServerResponse.call(manager, method, response);
+  };
+  if (!observesWindowNotifications) manager.onNotification = routedOnNotification;
+  manager.dispatchAppServerResponse = routedDispatchAppServerResponse;
+  const policy = Object.freeze({
+    state: "ready",
+    hostId,
+    owns(candidateManager, candidate, candidateHostId, candidatePrewarmedThreadManager, requiresCurrentManager) {
+      return !disposed && candidateManager === manager && candidate === bridge && candidateHostId === hostId && candidatePrewarmedThreadManager === prewarmedThreadManager && requiresCurrentManager === !!isCurrentManager;
+    },
+    requestTarget() {
+      if (disposed || isCurrentManager && !isCurrentManager())
+        throw new Error("Renderer request manager is retired");
+      return manager;
+    },
+    select(model) {
+      if (disposed || isCurrentManager && !isCurrentManager())
+        throw new Error("Renderer request manager is retired");
+      if (model !== null && (typeof model !== "string" || !model.startsWith("codexhost/"))) {
+        throw new Error("Draft route Model must be a codexhost transport carrier");
+      }
+      if (selectedModel === model) return false;
+      selectedModel = model;
+      prewarmGeneration += 1;
+      return true;
+    },
+    clear() {
+      if (disposed || isCurrentManager && !isCurrentManager())
+        return Promise.reject(new Error("Renderer request manager is retired"));
+      prewarmGeneration += 1;
+      prewarmedThreadManager.discardAllPrewarmedThreads();
+      return Promise.resolve();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      prewarmGeneration += 1;
+      retireResponses();
+      if (bridge.sendRequest === routedSend) bridge.sendRequest = originalSend;
+      if (bridge.prewarmThreadStart === routedPrewarm) {
+        bridge.prewarmThreadStart = originalPrewarm;
+      }
+      if (observesWindowNotifications) {
+        target.removeEventListener?.("message", routedWindowMessage);
+      } else if (manager.onNotification === routedOnNotification) {
+        manager.onNotification = originalOnNotification;
+      }
+      if (manager.dispatchAppServerResponse === routedDispatchAppServerResponse) {
+        manager.dispatchAppServerResponse = originalDispatchAppServerResponse;
+      }
+      if (bridgeReadyTimeout !== null) globalThis.clearTimeout(bridgeReadyTimeout);
+      bridgeReadyTimeout = null;
+      if (isRemoteControlHost && (bridgeState === "starting" || bridgeState === "ready")) {
+        void Promise.resolve(
+          originalSend.call(bridge, "process/kill", { processHandle: bridgeProcessHandle })
+        ).catch(() => void 0);
+      }
+      bridgeState = "disposed";
+      const disposedError = transportError("was disposed");
+      bridgeReadyReject?.(disposedError);
+      for (const requestId of bridgeRequests.keys()) bridge.onError(requestId, disposedError);
+      bridgeRequests.clear();
+      bridgeServerRequests.clear();
+      knownExternalThreadIds.clear();
+      knownOfficialThreadIds.clear();
+      threadOwnershipResolutions.clear();
+      selectedModel = null;
+    }
+  });
+  return policy;
+}
+
+// packages/desktop-control/src/renderer-host-discovery.ts
+function requestManagerFromHookState(value, hostId) {
+  const record = (candidate) => typeof candidate === "object" && candidate !== null;
+  const manager = (candidate) => {
+    if (!record(candidate) || !record(candidate.requestClient) || !record(candidate.prewarmedThreadManager))
+      return null;
+    const bridge = candidate.requestClient;
+    return typeof candidate.sendRequest === "function" && typeof bridge.sendRequest === "function" && typeof bridge.prewarmThreadStart === "function" && typeof bridge.enqueueRequest === "function" && typeof candidate.prewarmedThreadManager.discardAllPrewarmedThreads === "function" ? candidate : null;
+  };
+  if (!record(value)) return null;
+  const direct = manager(value) ?? manager(value.manager);
+  if (direct) return direct;
+  if (!hostId || typeof value.addManager !== "function" || typeof value.getForHostId !== "function" || typeof value.waitForManagerForHostId !== "function")
+    return null;
+  return manager(value.getForHostId(hostId));
+}
+function discoverRendererHosts(root, ancestors = committedReactAncestors, managerFrom = requestManagerFromHookState) {
+  const editors = [
+    ...root.querySelectorAll('[data-codex-composer], [contenteditable="true"][role="textbox"]')
+  ];
+  const hostIds = /* @__PURE__ */ new Set();
+  const managers = /* @__PURE__ */ new Set();
+  const registries = /* @__PURE__ */ new Set();
+  const fibers = /* @__PURE__ */ new Set();
+  for (const editor of editors) {
+    let element = editor;
+    let fiber;
+    while (element && !fiber) {
+      const key = Object.getOwnPropertyNames(element).find(
+        (name) => name.startsWith("__reactFiber$")
+      );
+      if (key) fiber = Object.getOwnPropertyDescriptor(element, key)?.value;
+      element = element.parentElement ?? null;
+    }
+    for (const current of ancestors(fiber)) {
+      fibers.add(current);
+      const props = current.memoizedProps;
+      for (const key of ["executionTargetHostId", "permissionsHostId"]) {
+        const hostId = props?.[key];
+        if (typeof hostId === "string" && hostId) hostIds.add(hostId);
+      }
+    }
+  }
+  for (const fiber of fibers) {
+    let hook = fiber.memoizedState;
+    for (let index = 0; hook && index < 120; index += 1) {
+      const value = hook.memoizedState;
+      const manager = managerFrom(value);
+      if (manager) managers.add(manager);
+      if (value && typeof value === "object" && "addManager" in value && typeof value.addManager === "function" && "getForHostId" in value && typeof value.getForHostId === "function" && "waitForManagerForHostId" in value && typeof value.waitForManagerForHostId === "function") {
+        registries.add(value);
+      }
+      hook = hook.next && typeof hook.next === "object" ? hook.next : null;
+    }
+  }
+  return {
+    editorCount: editors.length,
+    hostIds: [...hostIds],
+    managers: [...managers],
+    registries: [...registries]
+  };
+}
+function resolveRendererHostManager(discovery, hostId, managerFrom = requestManagerFromHookState) {
+  if (!hostId) return null;
+  const candidates = discovery.registries.length ? discovery.registries.map((registry) => managerFrom(registry.getForHostId(hostId))) : discovery.managers;
+  const matching = new Set(
+    candidates.filter(
+      (manager) => manager && (manager.getHostId?.() ?? manager.requestClient.hostId) === hostId && (manager.requestClient.hostId === void 0 || manager.requestClient.hostId === hostId)
+    )
+  );
+  return matching.size === 1 ? matching.values().next().value ?? null : null;
+}
+
+// packages/desktop-control/src/renderer-host-routing.ts
+function installRendererHostRouting(root, target, discover, resolve, createPolicy) {
+  const existing = target.__codexhostHostRoutingV1;
+  if (existing) return existing;
+  target.__codexhostDraftPrewarmPolicyV1?.dispose?.();
+  let disposed = false;
+  let lastDiscovery = null;
+  const routes = /* @__PURE__ */ new Map();
+  const read = (composer) => {
+    const source = composer?.matches?.(
+      '[data-codex-composer], [contenteditable="true"][role="textbox"]'
+    ) ? { querySelectorAll: () => [composer] } : composer ?? root;
+    const discovery = discover(source);
+    if (composer) return discovery;
+    if (discovery.editorCount === 0 && lastDiscovery) return lastDiscovery;
+    lastDiscovery = discovery;
+    return discovery;
+  };
+  const lookup = (hostId, discovery) => {
+    if (disposed) return null;
+    try {
+      return resolve(discovery ?? read(), hostId);
+    } catch {
+      return null;
+    }
+  };
+  const retire = (hostId) => {
+    const entry = routes.get(hostId);
+    routes.delete(hostId);
+    entry?.route.policy.dispose();
+  };
+  const routeFor = (hostId, discovery) => {
+    const manager = lookup(hostId, discovery);
+    const previous = routes.get(hostId);
+    if (manager && previous?.route.manager === manager && previous.bridge === manager.requestClient && previous.prewarmed === manager.prewarmedThreadManager && previous.route.policy.owns(
+      manager,
+      manager.requestClient,
+      hostId,
+      manager.prewarmedThreadManager,
+      true
+    )) {
+      return previous.route;
+    }
+    retire(hostId);
+    if (!manager) return null;
+    const bridge = manager.requestClient;
+    const prewarmed = manager.prewarmedThreadManager;
+    const policy = createPolicy(
+      manager,
+      bridge,
+      hostId,
+      target,
+      prewarmed,
+      () => lookup(hostId) === manager && manager.requestClient === bridge && manager.prewarmedThreadManager === prewarmed
+    );
+    const route = { hostId, manager, policy };
+    routes.set(hostId, { route, bridge, prewarmed });
+    return route;
+  };
+  const publish = (route) => {
+    const policy = route?.policy;
+    if (target.__codexhostDraftPrewarmPolicyV1 === policy) return;
+    Object.defineProperty(target, "__codexhostDraftPrewarmPolicyV1", {
+      configurable: true,
+      value: policy
+    });
+    if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function") {
+      target.dispatchEvent(new CustomEvent("codexhost:draft-prewarm-policy-changed"));
+    }
+  };
+  const composerHostId = (discovery) => {
+    if (discovery.hostIds.length === 0 && discovery.registries.length > 0) return null;
+    const hostIds = new Set(
+      discovery.hostIds.length ? discovery.hostIds : discovery.managers.map(
+        (manager) => manager.getHostId?.() ?? manager.requestClient.hostId
+      )
+    );
+    const hostId = hostIds.size === 1 ? hostIds.values().next().value : null;
+    return typeof hostId === "string" && hostId ? hostId : null;
+  };
+  const routing = {
+    forHost(hostId) {
+      return hostId ? routeFor(hostId) : null;
+    },
+    hostIdForComposer(composer) {
+      if (disposed) return null;
+      try {
+        return composerHostId(read(composer));
+      } catch {
+        return null;
+      }
+    },
+    forComposer(composer) {
+      if (disposed) return null;
+      let discovery;
+      try {
+        discovery = read(composer);
+      } catch {
+        publish(null);
+        return null;
+      }
+      if (!composer) {
+        for (const [hostId2, entry] of routes) {
+          const manager = lookup(hostId2, discovery);
+          if (manager !== entry.route.manager || manager.requestClient !== entry.bridge || manager.prewarmedThreadManager !== entry.prewarmed)
+            retire(hostId2);
+        }
+      }
+      const hostId = composerHostId(discovery);
+      const route = hostId ? routeFor(hostId, discovery) : null;
+      if (!composer) publish(route);
+      return route;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const hostId of routes.keys()) retire(hostId);
+      lastDiscovery = null;
+      if (target.__codexhostHostRoutingV1 === routing) {
+        delete target.__codexhostHostRoutingV1;
+        publish(null);
+      }
+    }
+  };
+  Object.defineProperty(target, "__codexhostHostRoutingV1", { configurable: true, value: routing });
+  return routing;
+}
+
+// packages/desktop-control/src/renderer-draft-prewarm-policy.ts
+var REQUEST_MANAGER_WAIT_TIMEOUT_MS = 6e4;
+var REQUEST_MANAGER_POLL_INTERVAL_MS = 25;
+function directRendererInstaller() {
+  return `(() => {
+    const committedReactAncestors = ${committedReactAncestors.toString()};
+    const requestManagerFromHookState = ${requestManagerFromHookState.toString()};
+    const discoverRendererHosts = ${discoverRendererHosts.toString()};
+    const resolveRendererHostManager = ${resolveRendererHostManager.toString()};
+    const retainRendererHostResponses = ${retainRendererHostResponses.toString()};
+    const createDraftPrewarmPolicyBridge = ${createDraftPrewarmPolicyBridge.toString()};
+    const routing = (${installRendererHostRouting.toString()})(
+      document, window,
+      (root) => discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState),
+      (discovery, hostId) => resolveRendererHostManager(discovery, hostId, requestManagerFromHookState),
+      (manager, bridge, hostId, target, prewarmed, isCurrent) => createDraftPrewarmPolicyBridge(
+        manager, bridge, hostId, target, prewarmed, isCurrent, retainRendererHostResponses,
+      ),
+    );
+    if (!routing.forComposer()) throw new Error('Renderer request manager is ambiguous');
+    return { state: 'ready', reason: 'owned-request-bridge' };
+  })()`;
+}
+async function waitForDraftPrewarmPolicy(evaluate, expression) {
+  const deadline = Date.now() + REQUEST_MANAGER_WAIT_TIMEOUT_MS;
+  while (true) {
+    try {
+      const value = await evaluate(expression);
+      if (typeof value !== "object" || value === null || !("state" in value) || value.state !== "ready" || !("reason" in value) || value.reason !== "owned-request-bridge") {
+        throw new Error("Renderer draft prewarm policy returned an invalid status");
+      }
+      return { state: "ready", reason: "owned-request-bridge" };
+    } 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;
+      await new Promise(
+        (resolve) => setTimeout(resolve, Math.min(REQUEST_MANAGER_POLL_INTERVAL_MS, remaining))
+      );
+    }
+  }
+}
+function installRendererDraftPrewarmPolicyDirect(renderer) {
+  return waitForDraftPrewarmPolicy(
+    (expression) => renderer.evaluate(expression),
+    directRendererInstaller()
+  );
+}
+
+// packages/desktop-control/src/renderer-cdp-control-session.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+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));
+}
+function isPrimaryRendererUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "app:" && url.hostname === "-" && url.pathname === "/index.html" && url.search === "" && url.hash === "";
+  } catch {
+    return false;
+  }
+}
+function selectPrimaryRendererTarget(targets, preferredTargetId) {
+  const candidates = targets.filter(
+    (target) => target.type === "page" && isPrimaryRendererUrl(target.url)
+  );
+  return candidates.find((target) => target.id === preferredTargetId) ?? candidates.at(0) ?? null;
+}
+var RendererAdapterReadinessError = class extends Error {
+  constructor(state, reason) {
+    super(`Production Renderer Adapter is ${state}: ${reason}`);
+    this.state = state;
+    this.reason = reason;
+    this.name = "RendererAdapterReadinessError";
+  }
+  state;
+  reason;
+};
+function validateBindingStatus(value, expectedAgents) {
+  if (!isRecord2(value) || value.version !== 2 || !Array.isArray(value.enabledAgents) || value.enabledAgents.some((agent) => typeof agent !== "string") || !sameAgents(value.enabledAgents, expectedAgents) || !isRecord2(value.adapter)) {
+    throw new Error("Production Renderer binding returned an invalid status");
+  }
+  if (value.adapter.state !== "ready" || typeof value.adapter.reason !== "string") {
+    const state = typeof value.adapter.state === "string" ? value.adapter.state : "invalid";
+    const reason = typeof value.adapter.reason === "string" ? value.adapter.reason : "unknown";
+    throw new RendererAdapterReadinessError(state, reason);
+  }
+  return value;
+}
+async function waitForPrimaryTarget(endpoint, operations, timeoutMs, pollIntervalMs, preferredTargetId) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const target = selectPrimaryRendererTarget(
+        await operations.listTargets(endpoint),
+        preferredTargetId
+      );
+      if (target) return target;
+      lastError = new Error("Renderer CDP has no primary app://-/index.html page target");
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(pollIntervalMs);
+  }
+  const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
+  throw new Error(`Primary Codex Renderer CDP target did not become ready${detail}`);
+}
+async function evaluateSource(renderer, source) {
+  const response = await renderer.command("Runtime.evaluate", {
+    expression: source,
+    awaitPromise: true
+  });
+  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);
+  }
+}
+async function readBinding(renderer) {
+  return renderer.evaluate("window.__codexhostRendererBindingProbeV1?.status() ?? null");
+}
+async function waitForBinding(renderer, enabledAgents, timeoutMs, pollIntervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const value = await readBinding(renderer);
+      if (value !== null) return validateBindingStatus(value, enabledAgents);
+    } catch (error) {
+      lastError = error;
+      if (error instanceof RendererAdapterReadinessError && error.state !== "installing") {
+        throw error;
+      }
+    }
+    await sleep(pollIntervalMs);
+  }
+  const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
+  throw new Error(`Production Renderer binding did not become ready${detail}`);
+}
+async function installTarget(target, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations) {
+  const renderer = await operations.connect(target.webSocketDebuggerUrl);
+  try {
+    await renderer.command("Runtime.enable");
+    await renderer.command("Page.enable");
+    await renderer.command("Page.addScriptToEvaluateOnNewDocument", { source: rendererSource });
+    await evaluateSource(renderer, rendererSource);
+    const draftPrewarmPolicy = await operations.installDraftPrewarmPolicy(renderer);
+    const binding = await waitForBinding(renderer, enabledAgents, timeoutMs, pollIntervalMs);
+    return { renderer, snapshot: { target, draftPrewarmPolicy, binding } };
+  } catch (error) {
+    renderer.close();
+    throw error;
+  }
+}
+var InstalledRendererCdpControlSession = class {
+  constructor(renderer, rendererCdpEndpoint2, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, currentSnapshot) {
+    this.renderer = renderer;
+    this.rendererCdpEndpoint = rendererCdpEndpoint2;
+    this.rendererSource = rendererSource;
+    this.enabledAgents = enabledAgents;
+    this.timeoutMs = timeoutMs;
+    this.pollIntervalMs = pollIntervalMs;
+    this.operations = operations;
+    this.currentSnapshot = currentSnapshot;
+  }
+  renderer;
+  rendererCdpEndpoint;
+  rendererSource;
+  enabledAgents;
+  timeoutMs;
+  pollIntervalMs;
+  operations;
+  currentSnapshot;
+  #closed = false;
+  get snapshot() {
+    return this.currentSnapshot;
+  }
+  async ensureInstalled() {
+    if (this.#closed) throw new Error("Renderer CDP Control Session is closed");
+    const target = await waitForPrimaryTarget(
+      this.rendererCdpEndpoint,
+      this.operations,
+      this.timeoutMs,
+      this.pollIntervalMs,
+      this.currentSnapshot.target.id
+    );
+    if (target.id !== this.currentSnapshot.target.id) {
+      const replacement = await installTarget(
+        target,
+        this.rendererSource,
+        this.enabledAgents,
+        this.timeoutMs,
+        this.pollIntervalMs,
+        this.operations
+      );
+      this.renderer.close();
+      this.renderer = replacement.renderer;
+      this.currentSnapshot = replacement.snapshot;
+      return this.currentSnapshot;
+    }
+    try {
+      const existing = await readBinding(this.renderer);
+      if (existing === null) await evaluateSource(this.renderer, this.rendererSource);
+      const draftPrewarmPolicy = await this.operations.installDraftPrewarmPolicy(this.renderer);
+      const binding = await waitForBinding(
+        this.renderer,
+        this.enabledAgents,
+        this.timeoutMs,
+        this.pollIntervalMs
+      );
+      this.currentSnapshot = { target, draftPrewarmPolicy, binding };
+      return this.currentSnapshot;
+    } catch {
+      const replacement = await installTarget(
+        target,
+        this.rendererSource,
+        this.enabledAgents,
+        this.timeoutMs,
+        this.pollIntervalMs,
+        this.operations
+      );
+      this.renderer.close();
+      this.renderer = replacement.renderer;
+      this.currentSnapshot = replacement.snapshot;
+      return this.currentSnapshot;
+    }
+  }
+  async activateDesktop() {
+    if (this.#closed) throw new Error("Renderer CDP Control Session is closed");
+    await this.renderer.command("Page.bringToFront");
+    return 1;
+  }
+  executeRenderer(expression) {
+    if (this.#closed) return Promise.reject(new Error("Renderer CDP Control Session is closed"));
+    return this.renderer.evaluate(expression);
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.renderer.close();
+  }
+};
+var defaultOperations = {
+  listTargets: (endpoint) => listCdpTargets(endpoint),
+  connect: (webSocketDebuggerUrl) => CdpClient.connect(webSocketDebuggerUrl),
+  installDraftPrewarmPolicy: installRendererDraftPrewarmPolicyDirect
+};
+async function createRendererCdpControlSession(options) {
+  const enabledAgents = options.enabledAgents ?? ["codex", "pi"];
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const pollIntervalMs = options.pollIntervalMs ?? 250;
+  const operations = options.operations ?? defaultOperations;
+  const target = await waitForPrimaryTarget(
+    options.rendererCdpEndpoint,
+    operations,
+    timeoutMs,
+    pollIntervalMs
+  );
+  const installed = await installTarget(
+    target,
+    options.rendererSource,
+    enabledAgents,
+    timeoutMs,
+    pollIntervalMs,
+    operations
+  );
+  return new InstalledRendererCdpControlSession(
+    installed.renderer,
+    options.rendererCdpEndpoint,
+    options.rendererSource,
+    enabledAgents,
+    timeoutMs,
+    pollIntervalMs,
+    operations,
+    installed.snapshot
+  );
+}
+function installRendererCdpControlSession(options) {
+  return createRendererCdpControlSession(options);
+}
+
+// packages/desktop-control/src/production-controller.ts
+var PRODUCTION_INSTALL_TIMEOUT_MS = 9e4;
+var RENDERER_CSP_BOOTSTRAP = "globalThis.__zod_globalConfig ??= {}; globalThis.__zod_globalConfig.jitless = true;";
+var DESKTOP_CONTROLLER_READINESS_MAX_BYTES = 512;
+var TRANSIENT_INSTALL_ATTEMPTS = 3;
+var TRANSIENT_INSTALL_RETRY_MS = 250;
+var RECOVERY_RETRY_INITIAL_MS = 3e4;
+var RECOVERY_RETRY_MAX_MS = 3e5;
+var startupTraceStartedAt = Date.now();
+function startupTrace(stage, detail) {
+  if (process.env.CODEXHOST_STARTUP_TRACE !== "1") return;
+  const suffix = detail === void 0 ? "" : `: ${detail instanceof Error ? detail.message : String(detail)}`;
+  console.error(
+    `[codexhost startup +${Date.now() - startupTraceStartedAt}ms] controller: ${stage}${suffix}`
+  );
+}
+function serializeDesktopControllerReadiness(readiness) {
+  if (readiness.schemaVersion !== 2 || readiness.state !== "compatible" || !Array.isArray(readiness.issues) || readiness.issues.length !== 0 || Object.keys(readiness).length !== 3) {
+    throw new Error("Desktop Controller readiness is invalid");
+  }
+  const line = JSON.stringify(readiness);
+  if (Buffer.byteLength(line, "utf8") > DESKTOP_CONTROLLER_READINESS_MAX_BYTES) {
+    throw new Error("Desktop Controller readiness exceeds its size limit");
+  }
+  return line;
+}
+var defaultDependencies = {
+  readRenderer: (filePath) => readFile(filePath, "utf8"),
+  install: installRendererCdpControlSession,
+  startAttachmentServer: startControllerAttachmentServer,
+  ready: (readiness) => {
+    process.stdout.write(`${serializeDesktopControllerReadiness(readiness)}
+`);
+  },
+  sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+  monitorIntervalMs: 500
+};
+function rendererCdpEndpoint(value) {
+  const url = new URL(value);
+  if (url.protocol !== "http:" || !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname) || !url.port || url.username || url.password || url.pathname !== "/" && url.pathname !== "" || url.search || url.hash) {
+    throw new Error("--renderer-cdp-endpoint must be a loopback HTTP origin with an explicit port");
+  }
+  return url.origin;
+}
+function parseDesktopControllerArguments(arguments_) {
+  let endpoint;
+  let rendererPath;
+  let defaultAgent;
+  let attachmentPort;
+  let attachmentNonce;
+  for (let index = 0; index < arguments_.length; index += 1) {
+    const argument = arguments_[index];
+    const value = arguments_[index + 1];
+    if (argument === "--renderer-cdp-endpoint") {
+      if (endpoint !== void 0) {
+        throw new Error("--renderer-cdp-endpoint may only be provided once");
+      }
+      if (!value) throw new Error("--renderer-cdp-endpoint requires a value");
+      endpoint = rendererCdpEndpoint(value);
+      index += 1;
+      continue;
+    }
+    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);
+      index += 1;
+      continue;
+    }
+    if (argument === "--default-agent") {
+      if (defaultAgent !== void 0) throw new Error("--default-agent may only be provided once");
+      if (value !== "codex" && value !== "pi") {
+        throw new Error("--default-agent must be 'codex' or 'pi'");
+      }
+      defaultAgent = value;
+      index += 1;
+      continue;
+    }
+    if (argument === "--attachment-port") {
+      if (attachmentPort !== void 0) {
+        throw new Error("--attachment-port may only be provided once");
+      }
+      const port = Number(value);
+      if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error("--attachment-port must be a valid TCP port");
+      }
+      attachmentPort = port;
+      index += 1;
+      continue;
+    }
+    if (argument === "--attachment-nonce") {
+      if (attachmentNonce !== void 0) {
+        throw new Error("--attachment-nonce may only be provided once");
+      }
+      if (value === void 0 || !/^[0-9a-f]{32}$/.test(value)) {
+        throw new Error("--attachment-nonce must be 32 lowercase hexadecimal characters");
+      }
+      attachmentNonce = value;
+      index += 1;
+      continue;
+    }
+    throw new Error(`unknown Desktop Controller option: ${argument}`);
+  }
+  if (endpoint === void 0) throw new Error("--renderer-cdp-endpoint is required");
+  if (rendererPath === void 0) throw new Error("--renderer is required");
+  if (defaultAgent === void 0) throw new Error("--default-agent is required");
+  if (attachmentPort === void 0) throw new Error("--attachment-port is required");
+  if (attachmentNonce === void 0) throw new Error("--attachment-nonce is required");
+  return {
+    rendererCdpEndpoint: endpoint,
+    rendererPath,
+    defaultAgent,
+    attachmentPort,
+    attachmentNonce
+  };
+}
+function isTransientRendererInstallError(error) {
+  let current = error;
+  for (let depth = 0; depth < 4; depth += 1) {
+    const message = current instanceof Error ? current.message : String(current);
+    if (message.includes("Execution context was destroyed") || message.includes("Promise was collected")) {
+      return true;
+    }
+    current = current instanceof Error ? current.cause : void 0;
+    if (current === void 0) break;
+  }
+  return false;
+}
+async function installProductionSession(options, dependencies) {
+  for (let attempt = 1; attempt <= TRANSIENT_INSTALL_ATTEMPTS; attempt += 1) {
+    try {
+      return await dependencies.install(options);
+    } catch (error) {
+      if (attempt === TRANSIENT_INSTALL_ATTEMPTS || !isTransientRendererInstallError(error)) {
+        throw error;
+      }
+      await dependencies.sleep(TRANSIENT_INSTALL_RETRY_MS);
+    }
+  }
+  throw new Error("Desktop Controller exhausted Renderer installation attempts");
+}
+async function runDesktopController(options, signal, dependencies = defaultDependencies) {
+  const configuration = `Object.defineProperty(window, "__codexhostProductionConfigV1", { configurable: true, value: { defaultAgent: ${JSON.stringify(options.defaultAgent)} } });`;
+  const now = dependencies.now ?? Date.now;
+  let session;
+  let nextRecoveryAt = 0;
+  let recoveryDelayMs = RECOVERY_RETRY_INITIAL_MS;
+  const recordRecoveryFailure = () => {
+    nextRecoveryAt = now() + recoveryDelayMs;
+    recoveryDelayMs = Math.min(recoveryDelayMs * 2, RECOVERY_RETRY_MAX_MS);
+  };
+  const recordRecoverySuccess = () => {
+    nextRecoveryAt = 0;
+    recoveryDelayMs = RECOVERY_RETRY_INITIAL_MS;
+  };
+  const createSession = async () => {
+    startupTrace("reading Renderer bundle");
+    const rendererSource = await dependencies.readRenderer(options.rendererPath);
+    if (rendererSource.trim().length === 0) throw new Error("production Renderer Bundle is empty");
+    startupTrace("installing Renderer Session");
+    const installed = await installProductionSession(
+      {
+        rendererCdpEndpoint: options.rendererCdpEndpoint,
+        rendererSource: `${RENDERER_CSP_BOOTSTRAP}
+${configuration}
+${rendererSource}`,
+        enabledAgents: [
+          "codex",
+          "pi",
+          "claude-code",
+          "deepseek-harness",
+          "opencode",
+          "grok",
+          "omp",
+          "antigravity",
+          "kiro-cli",
+          "codebuddy",
+          "workbuddy",
+          "cursor-cli",
+          "hermes",
+          "qoder",
+          "qoder-cn",
+          "kimi-code"
+        ],
+        timeoutMs: PRODUCTION_INSTALL_TIMEOUT_MS
+      },
+      dependencies
+    );
+    startupTrace("Renderer Session installed");
+    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);
+    operation = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  };
+  const resetSession = () => {
+    session?.close();
+    session = void 0;
+  };
+  const ensureSession = async () => {
+    if (!session) session = await createSession();
+    else await session.ensureInstalled();
+    return session;
+  };
+  const recoverSession = async () => {
+    try {
+      const current = await ensureSession();
+      recordRecoverySuccess();
+      return current;
+    } catch (error) {
+      resetSession();
+      recordRecoveryFailure();
+      throw error;
+    }
+  };
+  let attachmentServer;
+  try {
+    startupTrace("starting attachment server");
+    attachmentServer = await dependencies.startAttachmentServer({
+      port: options.attachmentPort,
+      nonce: options.attachmentNonce,
+      attach: () => useSession(async () => {
+        const current = await recoverSession();
+        await current.activateDesktop();
+      })
+    });
+    startupTrace("attachment server ready");
+    startupTrace("publishing readiness");
+    dependencies.ready({
+      schemaVersion: 2,
+      state: "compatible",
+      issues: []
+    });
+    while (!signal.aborted) {
+      await dependencies.sleep(dependencies.monitorIntervalMs);
+      if (signal.aborted) continue;
+      await useSession(async () => {
+        if (!session && now() < nextRecoveryAt) return;
+        try {
+          await recoverSession();
+        } catch {
+        }
+      });
+    }
+  } finally {
+    await attachmentServer?.close();
+    await operation;
+    resetSession();
+  }
+}
+
+// packages/desktop-control/src/release-main.ts
+var abort = new AbortController();
+var stop = () => abort.abort();
+process.once("SIGINT", stop);
+process.once("SIGTERM", stop);
+try {
+  await runDesktopController(parseDesktopControllerArguments(process.argv.slice(2)), abort.signal);
+} catch (error) {
+  console.error(
+    `codexhost Desktop Controller: ${error instanceof Error ? error.message : String(error)}`
+  );
+  process.exitCode = 1;
+} finally {
+  process.removeListener("SIGINT", stop);
+  process.removeListener("SIGTERM", stop);
+}