@codexhost/cli-linux-x64 0.2.2

package/app/desktop-controller.mjs

@@ -0,0 +1,1519 @@
+// 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();
+  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}`) {
+        void options.attach().then(
+          () => respond(socket, "ready"),
+          () => respond(socket, "failed")
+        );
+        return;
+      }
+      if (line === `COMPATIBILITY_UPDATE ${options.nonce}`) {
+        socket.setTimeout(2e4);
+        void options.compatibilityUpdate().then(
+          (outcome) => respond(socket, outcome),
+          () => respond(socket, "failed")
+        );
+        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 nonEmptyString(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`CDP target '${field}' must be non-empty text`);
+  }
+  return 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 parseTarget(value) {
+  if (!isRecord(value)) throw new Error("CDP target must be an object");
+  const target = {
+    id: nonEmptyString(value.id, "id"),
+    type: nonEmptyString(value.type, "type"),
+    title: typeof value.title === "string" ? value.title : "",
+    url: nonEmptyString(value.url, "url"),
+    webSocketDebuggerUrl: nonEmptyString(value.webSocketDebuggerUrl, "webSocketDebuggerUrl")
+  };
+  loopbackUrl(target.webSocketDebuggerUrl, ["ws:", "wss:"]);
+  return target;
+}
+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);
+}
+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/main-process-title-policy.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resultRecord(value, command) {
+  if (!isRecord2(value)) throw new Error(`${command} returned an invalid result`);
+  if (isRecord2(value.exceptionDetails)) {
+    const exception = value.exceptionDetails.exception;
+    const description = isRecord2(exception) ? exception.description : null;
+    const text = value.exceptionDetails.text;
+    throw new Error(
+      typeof description === "string" ? description : typeof text === "string" ? text : `${command} failed`
+    );
+  }
+  return value;
+}
+function remoteObjectId(value, label) {
+  if (!isRecord2(value) || typeof value.objectId !== "string") {
+    throw new Error(`${label} is unavailable`);
+  }
+  return value.objectId;
+}
+function properties(value, command) {
+  const result = resultRecord(value, command).result;
+  if (!Array.isArray(result)) throw new Error(`${command} returned invalid properties`);
+  return result.filter(isRecord2);
+}
+var ELECTRON_MODULE_EXPRESSION = `(() => {
+  const mainModule = process.mainModule;
+  if (mainModule != null && typeof mainModule.require === 'function') {
+    return mainModule.require('electron');
+  }
+  const { createRequire } = process.getBuiltinModule('module');
+  return createRequire(process.execPath)('electron');
+})()`;
+var CONNECT_APP_HOST_CHANNEL = "codex_desktop:connect-app-host";
+var REVIEWED_TITLE_SERVICE_IDENTITIES = ["Dhe", "Nye", "wbe", "nxe", "tTe"];
+var POLICY_STATE_SYMBOL = "codexhost.main-process-title-policy.v1";
+var SERVICE_OWNER_SYMBOL = "codexhost.main-process-title-policy.owner.v1";
+var RENDERER_READY_EXPRESSION = "(() => { Object.defineProperty(window, '__codexhostMainProcessTitlePolicyV1', { configurable: true, value: { state: 'ready' } }); return 'ready'; })()";
+var INSTALL_POLICY_FUNCTION = `async function (rendererWebContentsId) {
+  const mainModule = process.mainModule;
+  const electron = mainModule != null && typeof mainModule.require === 'function'
+    ? mainModule.require('electron')
+    : process.getBuiltinModule('module').createRequire(process.execPath)('electron');
+  const selected = electron.webContents.fromId(rendererWebContentsId);
+  if (selected == null || selected.isDestroyed() || selected.getType() !== 'window') {
+    throw new Error('Owned Renderer unavailable for title policy');
+  }
+
+  const context = this(selected);
+  if (context == null || typeof context.createAppHost !== 'function') {
+    throw new Error('WindowContext unavailable for title policy');
+  }
+  const stateSymbol = Symbol.for(${JSON.stringify(POLICY_STATE_SYMBOL)});
+  const ownerSymbol = Symbol.for(${JSON.stringify(SERVICE_OWNER_SYMBOL)});
+  globalThis[stateSymbol]?.dispose?.();
+
+  const originalCreateAppHost = context.createAppHost;
+  const sampleHost = originalCreateAppHost.call(context, selected);
+  const sampleService = sampleHost?.services?.threadMetadataGeneration;
+  const servicePrototype = sampleService == null ? null : Object.getPrototypeOf(sampleService);
+  const originalGenerateTitle = servicePrototype?.generateTitle;
+  if (
+    servicePrototype == null ||
+    typeof originalGenerateTitle !== 'function' ||
+    !Function.prototype.toString.call(originalGenerateTitle).includes('Failed to generate thread title')
+  ) {
+    throw new Error('ThreadMetadataGenerationService signature mismatch');
+  }
+  const rawServiceClass = sampleService?.constructor?.name;
+  const serviceClass = typeof rawServiceClass === 'string' && /^[A-Za-z_$][A-Za-z0-9_$]{0,63}$/.test(rawServiceClass)
+    ? rawServiceClass
+    : 'unknown';
+  const warnings = ${JSON.stringify(REVIEWED_TITLE_SERVICE_IDENTITIES)}.includes(serviceClass)
+    ? []
+    : [{
+        capability: 'title-isolation',
+        reason: 'unreviewed-title-service-identity',
+        observedIdentity: serviceClass,
+      }];
+
+  const counters = {
+    codexTitleCalls: 0,
+    piTitleSkips: 0,
+    externalTitleSkips: 0,
+    ambiguousTitleSkips: 0,
+  };
+  const ownedWebContentsIds = new Set();
+  const ownService = (service, contents) => {
+    const existingOwner = service[ownerSymbol];
+    if (existingOwner != null && existingOwner !== contents) {
+      throw new Error('Thread metadata service ownership mismatch');
+    }
+    if (existingOwner == null) {
+      Object.defineProperty(service, ownerSymbol, { value: contents });
+    }
+    ownedWebContentsIds.add(contents.id);
+  };
+  ownService(sampleService, selected);
+  const wrappedCreateAppHost = function (contents) {
+    const host = originalCreateAppHost.call(this, contents);
+    const service = host?.services?.threadMetadataGeneration;
+    if (service != null) ownService(service, contents);
+    return host;
+  };
+  const wrappedGenerateTitle = async function (params) {
+    const owner = this[ownerSymbol];
+    if (owner == null || owner.isDestroyed()) {
+      counters.ambiguousTitleSkips += 1;
+      return null;
+    }
+    let selection = null;
+    try {
+      selection = await owner.executeJavaScript(
+        "window.__codexhostRendererBindingProbeV1?.lockedSelection() ?? null",
+        true,
+      );
+    } catch {}
+    if (selection?.phase !== 'locked') {
+      counters.ambiguousTitleSkips += 1;
+      return null;
+    }
+    if (selection.agent === 'pi') {
+      counters.piTitleSkips += 1;
+      return null;
+    }
+    if (selection.agent !== 'codex') {
+      counters.externalTitleSkips += 1;
+      return null;
+    }
+    counters.codexTitleCalls += 1;
+    return originalGenerateTitle.call(this, params);
+  };
+
+  context.createAppHost = wrappedCreateAppHost;
+  servicePrototype.generateTitle = wrappedGenerateTitle;
+  const state = {
+    counters,
+    ownedWebContentsIds,
+    dispose() {
+      if (context.createAppHost === wrappedCreateAppHost) {
+        context.createAppHost = originalCreateAppHost;
+      }
+      if (servicePrototype.generateTitle === wrappedGenerateTitle) {
+        servicePrototype.generateTitle = originalGenerateTitle;
+      }
+      if (globalThis[stateSymbol] === state) delete globalThis[stateSymbol];
+    },
+  };
+  globalThis[stateSymbol] = state;
+  return {
+    state: 'ready',
+    reason: 'ready',
+    requiresRendererReload: true,
+    warnings,
+  };
+}`;
+async function installMainProcessTitlePolicy(inspector, rendererWebContentsId) {
+  if (!Number.isInteger(rendererWebContentsId) || rendererWebContentsId <= 0) {
+    throw new Error("Renderer webContents ID must be a positive integer");
+  }
+  const listenerResponse = resultRecord(
+    await inspector.command("Runtime.evaluate", {
+      expression: `(${ELECTRON_MODULE_EXPRESSION}).ipcMain.listeners(${JSON.stringify(
+        CONNECT_APP_HOST_CHANNEL
+      )})[0]`
+    }),
+    "Runtime.evaluate"
+  );
+  const listener = listenerResponse.result;
+  const listenerId = remoteObjectId(listener, "connect-app-host listener");
+  const listenerProperties = resultRecord(
+    await inspector.command("Runtime.getProperties", { objectId: listenerId }),
+    "Runtime.getProperties"
+  );
+  const internalProperties = listenerProperties.internalProperties;
+  if (!Array.isArray(internalProperties)) {
+    throw new Error("connect-app-host listener scopes are unavailable");
+  }
+  const scopes = internalProperties.find(
+    (property) => isRecord2(property) && property.name === "[[Scopes]]"
+  );
+  const scopesId = remoteObjectId(
+    isRecord2(scopes) ? scopes.value : null,
+    "connect-app-host listener scopes"
+  );
+  const scopeProperties = properties(
+    await inspector.command("Runtime.getProperties", {
+      objectId: scopesId,
+      ownProperties: true
+    }),
+    "Runtime.getProperties"
+  );
+  const localScope = scopeProperties.find((property) => property.name === "0");
+  const localScopeId = remoteObjectId(localScope?.value, "connect-app-host local scope");
+  const localProperties = properties(
+    await inspector.command("Runtime.getProperties", {
+      objectId: localScopeId,
+      ownProperties: true
+    }),
+    "Runtime.getProperties"
+  );
+  const getContext = localProperties.find(
+    (property) => property.name === "f" && typeof property.value?.objectId === "string"
+  );
+  const getContextId = remoteObjectId(getContext?.value, "getContextForWebContents");
+  const installPromise = resultRecord(
+    await inspector.command("Runtime.callFunctionOn", {
+      objectId: getContextId,
+      functionDeclaration: INSTALL_POLICY_FUNCTION,
+      arguments: [{ value: rendererWebContentsId }]
+    }),
+    "Runtime.callFunctionOn"
+  );
+  const promiseObjectId = remoteObjectId(
+    installPromise.result,
+    "Main-process title policy installation promise"
+  );
+  const installResponse = resultRecord(
+    await inspector.command("Runtime.awaitPromise", {
+      promiseObjectId,
+      returnByValue: true
+    }),
+    "Runtime.awaitPromise"
+  );
+  const remoteResult = installResponse.result;
+  const value = isRecord2(remoteResult) ? remoteResult.value : null;
+  if (!isRecord2(value) || value.state !== "ready" || value.reason !== "ready" || value.requiresRendererReload !== true || !Array.isArray(value.warnings) || value.warnings.length > 1 || value.warnings.some(
+    (warning) => !isRecord2(warning) || warning.capability !== "title-isolation" || warning.reason !== "unreviewed-title-service-identity" || typeof warning.observedIdentity !== "string" || !/^[A-Za-z_$][A-Za-z0-9_$]{0,63}$/.test(warning.observedIdentity) || Object.keys(warning).length !== 3
+  )) {
+    throw new Error("Main-process title policy returned an invalid status");
+  }
+  return value;
+}
+async function markRendererTitlePolicyReady(inspector, rendererWebContentsId) {
+  if (!Number.isInteger(rendererWebContentsId) || rendererWebContentsId <= 0) {
+    throw new Error("Renderer webContents ID must be a positive integer");
+  }
+  const value = await inspector.evaluate(`(async () => {
+    const state = globalThis[Symbol.for(${JSON.stringify(POLICY_STATE_SYMBOL)})];
+    if (state == null) throw new Error('Main-process title policy is unavailable');
+    const mainModule = process.mainModule;
+    const electron = mainModule != null && typeof mainModule.require === 'function'
+      ? mainModule.require('electron')
+      : process.getBuiltinModule('module').createRequire(process.execPath)('electron');
+    const selected = electron.webContents.fromId(${rendererWebContentsId});
+    if (selected == null || selected.isDestroyed() || selected.getType() !== 'window') {
+      throw new Error('Owned Renderer unavailable for title policy readiness');
+    }
+    if (!state.ownedWebContentsIds.has(selected.id)) {
+      throw new Error('Renderer metadata service ownership is unavailable');
+    }
+    const marker = selected.executeJavaScript(
+      ${JSON.stringify(RENDERER_READY_EXPRESSION)},
+      true,
+    );
+    const markerTimeout = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error('Renderer readiness marker timed out')), 2_000);
+    });
+    await Promise.race([marker, markerTimeout]);
+    return { state: 'ready', reason: 'owned-metadata-service' };
+  })()`);
+  if (!isRecord2(value) || value.state !== "ready" || value.reason !== "owned-metadata-service") {
+    throw new Error("Renderer title policy returned an invalid readiness status");
+  }
+  return value;
+}
+async function readMainProcessTitlePolicyCounters(inspector) {
+  const value = await inspector.evaluate(`(() => {
+    const state = globalThis[Symbol.for(${JSON.stringify(POLICY_STATE_SYMBOL)})];
+    return state == null ? null : { ...state.counters };
+  })()`);
+  if (value === null) return null;
+  if (!isRecord2(value) || !Number.isInteger(value.codexTitleCalls) || !Number.isInteger(value.piTitleSkips) || !Number.isInteger(value.externalTitleSkips) || !Number.isInteger(value.ambiguousTitleSkips)) {
+    throw new Error("Main-process title policy returned invalid counters");
+  }
+  return value;
+}
+
+// packages/desktop-control/src/renderer-draft-prewarm-runtime.ts
+function installDraftPrewarmPolicyBridge(bridge, hostId, target) {
+  const existing = target.__codexhostDraftPrewarmPolicyV1;
+  existing?.dispose?.();
+  const originalSend = bridge.sendRequest;
+  let selectedModel = null;
+  let clearInFlight = null;
+  const isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const routeCollaborationMode = (method, parameters) => {
+    if (selectedModel === null || !isRecord5(parameters)) return parameters;
+    const collaborationMode = parameters.collaborationMode;
+    const settings = isRecord5(collaborationMode) ? collaborationMode.settings : null;
+    if (!isRecord5(collaborationMode) || !isRecord5(settings)) {
+      throw new Error(`Codex ${method} omitted collaborationMode.settings`);
+    }
+    return {
+      ...parameters,
+      collaborationMode: {
+        ...collaborationMode,
+        settings: { ...settings, model: selectedModel }
+      }
+    };
+  };
+  const routeThreadStart = (method, parameters) => {
+    if (selectedModel === null || !isRecord5(parameters)) return parameters;
+    const threadParams = method === "prewarm-thread-start-for-host" ? parameters.params : parameters.method === "thread/start" ? parameters.params : null;
+    if (!isRecord5(threadParams) || threadParams.ephemeral === true) return parameters;
+    return { ...parameters, params: { ...threadParams, model: selectedModel } };
+  };
+  const routedSend = (method, parameters, options) => {
+    const routedParameters = method === "start-conversation" || method === "prewarm-conversation-for-host" ? routeCollaborationMode(method, parameters) : method === "prewarm-thread-start-for-host" || method === "send-cli-request-for-host" ? routeThreadStart(method, parameters) : parameters;
+    return options === void 0 ? originalSend.call(bridge, method, routedParameters) : originalSend.call(bridge, method, routedParameters, options);
+  };
+  bridge.sendRequest = routedSend;
+  const policy = Object.freeze({
+    state: "ready",
+    select(model) {
+      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;
+      return true;
+    },
+    clear() {
+      if (clearInFlight === null) {
+        clearInFlight = Promise.resolve(
+          originalSend.call(bridge, "clear-prewarmed-threads-for-host", { hostId })
+        ).then(() => void 0).finally(() => {
+          clearInFlight = null;
+        });
+      }
+      return clearInFlight;
+    },
+    dispose() {
+      if (bridge.sendRequest === routedSend) bridge.sendRequest = originalSend;
+      selectedModel = null;
+    }
+  });
+  Object.defineProperty(target, "__codexhostDraftPrewarmPolicyV1", {
+    configurable: true,
+    value: policy
+  });
+  return { state: "ready", reason: "owned-request-bridge" };
+}
+async function installDraftPrewarmPolicyInRenderer(contents, findRequestManagerExpression, installRendererPolicyFunction) {
+  if (contents === null || contents.isDestroyed() || contents.getType() !== "window") {
+    throw new Error("Owned Renderer is unavailable for draft prewarm policy");
+  }
+  let attachedHere = false;
+  try {
+    if (!contents.debugger.isAttached()) {
+      contents.debugger.attach("1.3");
+      attachedHere = true;
+    }
+    await contents.debugger.sendCommand("Runtime.enable");
+    const managerResult = await contents.debugger.sendCommand("Runtime.evaluate", {
+      expression: findRequestManagerExpression
+    });
+    const managerResultId = managerResult.result?.objectId;
+    if (typeof managerResultId !== "string") {
+      throw new Error("Renderer request manager inspection failed");
+    }
+    const managerProperties = await contents.debugger.sendCommand("Runtime.getProperties", {
+      objectId: managerResultId,
+      ownProperties: true
+    });
+    const candidateCount = managerProperties.result?.find(
+      (property) => property.name === "candidateCount"
+    )?.value?.value;
+    const hostId = managerProperties.result?.find((property) => property.name === "hostId")?.value?.value;
+    const manager = managerProperties.result?.find(
+      (property) => property.name === "manager"
+    )?.value;
+    if (candidateCount !== 1 || hostId !== "local" || typeof manager?.objectId !== "string") {
+      throw new Error("Renderer request manager is ambiguous");
+    }
+    const managerFunctions = await contents.debugger.sendCommand("Runtime.getProperties", {
+      objectId: manager.objectId
+    });
+    let managerSendRequestId = managerFunctions.result?.find(
+      (property) => property.name === "sendRequest"
+    )?.value?.objectId;
+    const managerPrototypeId = managerFunctions.internalProperties?.find(
+      (property) => property.name === "[[Prototype]]"
+    )?.value?.objectId;
+    if (typeof managerSendRequestId !== "string" && typeof managerPrototypeId === "string") {
+      const prototypeFunctions = await contents.debugger.sendCommand("Runtime.getProperties", {
+        objectId: managerPrototypeId,
+        ownProperties: true
+      });
+      managerSendRequestId = prototypeFunctions.result?.find(
+        (property) => property.name === "sendRequest"
+      )?.value?.objectId;
+    }
+    if (typeof managerSendRequestId !== "string") {
+      throw new Error("Renderer request manager sendRequest is unavailable");
+    }
+    const functionProperties = await contents.debugger.sendCommand("Runtime.getProperties", {
+      objectId: managerSendRequestId
+    });
+    const scopesId = functionProperties.internalProperties?.find(
+      (property) => property.name === "[[Scopes]]"
+    )?.value?.objectId;
+    const hostBridgeCandidates = [];
+    if (typeof scopesId === "string") {
+      const scopes = await contents.debugger.sendCommand("Runtime.getProperties", {
+        objectId: scopesId,
+        ownProperties: true
+      });
+      for (const scope of scopes.result ?? []) {
+        if (typeof scope.value?.objectId !== "string") continue;
+        const scopeProperties = await contents.debugger.sendCommand("Runtime.getProperties", {
+          objectId: scope.value.objectId,
+          ownProperties: true
+        });
+        for (const property of scopeProperties.result ?? []) {
+          if (property.value?.type !== "object" || typeof property.value.objectId !== "string") {
+            continue;
+          }
+          const candidateSignature = await contents.debugger.sendCommand(
+            "Runtime.callFunctionOn",
+            {
+              objectId: property.value.objectId,
+              functionDeclaration: "function(){const send=this.sendRequest;return typeof send==='function'&&Function.prototype.toString.call(send).includes('messageHandler')}",
+              returnByValue: true
+            }
+          );
+          if (candidateSignature.result?.value === true) {
+            hostBridgeCandidates.push({
+              name: String(property.name),
+              objectId: property.value.objectId
+            });
+          }
+        }
+      }
+    }
+    const hostBridge = hostBridgeCandidates[0];
+    if (hostBridgeCandidates.length !== 1 || !hostBridge) {
+      throw new Error("Renderer Host request bridge is ambiguous");
+    }
+    const installed = await contents.debugger.sendCommand("Runtime.callFunctionOn", {
+      objectId: hostBridge.objectId,
+      functionDeclaration: installRendererPolicyFunction,
+      arguments: [{ value: hostId }],
+      awaitPromise: true,
+      returnByValue: true
+    });
+    return installed.result?.value;
+  } finally {
+    if (attachedHere && contents.debugger.isAttached()) contents.debugger.detach();
+  }
+}
+
+// packages/desktop-control/src/renderer-draft-prewarm-policy.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var FIND_REQUEST_MANAGER_EXPRESSION = `(() => {
+  const editors = [...document.querySelectorAll(
+    '[data-codex-composer], [contenteditable="true"][role="textbox"]',
+  )];
+  if (editors.length !== 1) {
+    return { candidateCount: 0, hostId: null, sendRequest: null };
+  }
+  let element = editors[0];
+  let fiber = null;
+  while (element != null && fiber == null) {
+    const key = Object.getOwnPropertyNames(element).find((name) =>
+      name.startsWith('__reactFiber$'),
+    );
+    if (key != null) fiber = element[key];
+    element = element.parentElement;
+  }
+  const managers = new Set();
+  for (let depth = 0; fiber != null && depth < 200; depth += 1, fiber = fiber.return) {
+    let hook = fiber.memoizedState;
+    for (let index = 0; hook != null && index < 120; index += 1, hook = hook.next) {
+      const value = hook.memoizedState;
+      if (
+        value != null &&
+        typeof value === 'object' &&
+        value.requestClient != null &&
+        typeof value.requestClient.prewarmThreadStart === 'function' &&
+        typeof value.sendRequest === 'function' &&
+        Function.prototype.toString.call(value.sendRequest).includes(
+          'send-cli-request-for-host',
+        )
+      ) {
+        managers.add(value);
+      }
+    }
+  }
+  const manager = managers.size === 1 ? managers.values().next().value : null;
+  return {
+    candidateCount: managers.size,
+    hostId: manager?.getHostId?.() ?? null,
+    manager,
+  };
+})()`;
+var INSTALL_RENDERER_POLICY_FUNCTION = `function(hostId) {
+  return (${installDraftPrewarmPolicyBridge.toString()})(this, hostId, window);
+}`;
+var REQUEST_MANAGER_WAIT_TIMEOUT_MS = 6e4;
+var REQUEST_MANAGER_POLL_INTERVAL_MS = 25;
+function mainProcessInstaller(rendererWebContentsId) {
+  return `async function () {
+    const mainModule = process.mainModule;
+    const electron = mainModule != null && typeof mainModule.require === 'function'
+      ? mainModule.require('electron')
+      : process.getBuiltinModule('module').createRequire(process.execPath)('electron');
+    const contents = electron.webContents.fromId(${rendererWebContentsId});
+    return (${installDraftPrewarmPolicyInRenderer.toString()})(
+      contents,
+      ${JSON.stringify(FIND_REQUEST_MANAGER_EXPRESSION)},
+      ${JSON.stringify(INSTALL_RENDERER_POLICY_FUNCTION)}
+    );
+  }`;
+}
+async function installRendererDraftPrewarmPolicy(inspector, rendererWebContentsId) {
+  if (!Number.isInteger(rendererWebContentsId) || rendererWebContentsId <= 0) {
+    throw new Error("Renderer webContents ID must be a positive integer");
+  }
+  const installer = mainProcessInstaller(rendererWebContentsId);
+  const deadline = Date.now() + REQUEST_MANAGER_WAIT_TIMEOUT_MS;
+  while (true) {
+    try {
+      const value = await inspector.evaluate(`(${installer})()`);
+      if (!isRecord3(value) || value.state !== "ready" || value.reason !== "owned-request-bridge") {
+        throw new Error("Renderer draft prewarm policy returned an invalid status");
+      }
+      return value;
+    } 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));
+      });
+    }
+  }
+}
+
+// packages/desktop-control/src/renderer-control-session.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function sameAgents(actual, expected) {
+  return actual.length === expected.length && actual.every((agent, index) => agent === expected[index]);
+}
+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 (!isRecord4(value) || value.version !== 2 || !Array.isArray(value.enabledAgents) || value.enabledAgents.some((agent) => typeof agent !== "string") || !sameAgents(value.enabledAgents, expectedAgents) || !isRecord4(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;
+}
+function selectRendererWebContents(contents) {
+  const candidates = contents.filter(
+    (item) => item.type === "window" && item.surface === "primary" && item.runtime.available && item.runtime.elementCount !== null
+  ).toSorted(
+    (left, right) => (right.runtime.elementCount ?? 0) - (left.runtime.elementCount ?? 0)
+  );
+  return candidates.find((candidate) => (candidate.runtime.elementCount ?? 0) > 0) ?? null;
+}
+async function waitForRendererTitlePolicyReady(markReadiness, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const pollIntervalMs = options.pollIntervalMs ?? 250;
+  const now = options.now ?? Date.now;
+  const wait = options.sleep ?? sleep;
+  const deadline = now() + timeoutMs;
+  let lastError;
+  while (now() < deadline) {
+    try {
+      return await markReadiness();
+    } catch (error) {
+      lastError = error;
+    }
+    await wait(pollIntervalMs);
+  }
+  const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
+  throw new Error(`Renderer title policy ownership did not become ready${detail}`);
+}
+async function waitForInspectorTarget(endpoint, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const pollIntervalMs = options.pollIntervalMs ?? 250;
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const targets = await listCdpTargets(endpoint, options.fetchImpl);
+      const inspector = targets.find((target) => target.type === "node");
+      if (inspector) return inspector;
+      lastError = new Error("Inspector has no Node target");
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(pollIntervalMs);
+  }
+  const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
+  throw new Error(`Electron main-process Inspector did not become ready${detail}`);
+}
+var electronModuleExpression = `(() => {
+  const mainModule = process.mainModule;
+  if (mainModule != null && typeof mainModule.require === 'function') {
+    return mainModule.require('electron');
+  }
+  const { createRequire } = process.getBuiltinModule('module');
+  return createRequire(process.execPath)('electron');
+})()`;
+var webContentsRuntimeExpression = "(() => ({ elementCount: document.querySelectorAll('*').length }))()";
+async function inspectElectronWebContents(inspector) {
+  const value = await inspector.evaluate(`(async () => {
+    const { webContents } = ${electronModuleExpression};
+    const result = [];
+    for (const contents of webContents.getAllWebContents()) {
+      let runtime = { available: false, elementCount: null };
+      try {
+        const evaluation = contents.executeJavaScript(${JSON.stringify(webContentsRuntimeExpression)}, true);
+        const timeout = new Promise((_, reject) => {
+          setTimeout(() => reject(new Error('Renderer inspection timed out')), 2_000);
+        });
+        runtime = { available: true, ...(await Promise.race([evaluation, timeout])) };
+      } catch {}
+      result.push({
+        id: contents.id,
+        type: contents.getType(),
+        surface: contents.getURL().includes('avatar-overlay') ? 'overlay' : 'primary',
+        runtime,
+      });
+    }
+    return result;
+  })()`);
+  if (!Array.isArray(value)) throw new Error("Electron webContents inspection returned an array");
+  return value.map((item) => {
+    if (!isRecord4(item) || !Number.isInteger(item.id) || typeof item.type !== "string" || !["primary", "overlay"].includes(String(item.surface)) || !isRecord4(item.runtime)) {
+      throw new Error("Electron webContents inspection returned an invalid item");
+    }
+    return {
+      id: item.id,
+      type: item.type,
+      surface: item.surface,
+      runtime: {
+        available: item.runtime.available === true,
+        elementCount: Number.isInteger(item.runtime.elementCount) ? item.runtime.elementCount : null
+      }
+    };
+  });
+}
+async function activateElectronDesktop(inspector) {
+  const value = await inspector.evaluate(`(() => {
+    const { BrowserWindow } = ${electronModuleExpression};
+    const windows = BrowserWindow.getAllWindows().filter((window) => !window.isDestroyed());
+    for (const window of windows) {
+      if (window.isMinimized()) window.restore();
+      window.show();
+      window.focus();
+    }
+    return windows.length;
+  })()`);
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error("Electron Desktop activation found no live window");
+  }
+  return value;
+}
+async function executeInWebContents(inspector, rendererWebContentsId, source) {
+  return inspector.evaluate(`(async () => {
+    const { webContents } = ${electronModuleExpression};
+    const contents = webContents.fromId(${rendererWebContentsId});
+    if (contents == null || contents.isDestroyed()) throw new Error('Renderer webContents is unavailable');
+    const result = await contents.executeJavaScript(${JSON.stringify(source)}, true);
+    return result === undefined ? null : result;
+  })()`);
+}
+async function reloadRenderer(inspector, rendererWebContentsId) {
+  await executeInWebContents(inspector, rendererWebContentsId, "location.reload(); null");
+}
+var defaultOperations = {
+  inspect: inspectElectronWebContents,
+  installTitlePolicy: installMainProcessTitlePolicy,
+  markTitlePolicyReady: markRendererTitlePolicyReady,
+  installDraftPrewarmPolicy: installRendererDraftPrewarmPolicy,
+  readDraftPrewarmPolicy: (inspector, rendererWebContentsId) => executeInWebContents(
+    inspector,
+    rendererWebContentsId,
+    "window.__codexhostDraftPrewarmPolicyV1?.state ?? null"
+  ),
+  reload: reloadRenderer,
+  execute: executeInWebContents,
+  readBinding: (inspector, rendererWebContentsId) => executeInWebContents(
+    inspector,
+    rendererWebContentsId,
+    "window.__codexhostRendererBindingProbeV1?.status() ?? null"
+  ),
+  readTitlePolicyCounters: readMainProcessTitlePolicyCounters
+};
+async function waitForRenderer(inspector, operations, timeoutMs, pollIntervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  let candidateCount = 0;
+  while (Date.now() < deadline) {
+    const inventory = await operations.inspect(inspector);
+    candidateCount = inventory.length;
+    const renderer = selectRendererWebContents(inventory);
+    if (renderer) return renderer;
+    await sleep(pollIntervalMs);
+  }
+  throw new Error(`Inspector did not find a live Electron Renderer (${candidateCount} seen)`);
+}
+async function waitForBinding(inspector, operations, rendererWebContentsId, enabledAgents, timeoutMs, pollIntervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const value = await operations.readBinding(inspector, rendererWebContentsId);
+      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}`);
+}
+var InstalledRendererControlSession = class {
+  constructor(inspector, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, snapshot) {
+    this.inspector = inspector;
+    this.rendererSource = rendererSource;
+    this.enabledAgents = enabledAgents;
+    this.timeoutMs = timeoutMs;
+    this.pollIntervalMs = pollIntervalMs;
+    this.operations = operations;
+    this.#snapshot = snapshot;
+  }
+  inspector;
+  rendererSource;
+  enabledAgents;
+  timeoutMs;
+  pollIntervalMs;
+  operations;
+  #closed = false;
+  #snapshot;
+  get snapshot() {
+    return this.#snapshot;
+  }
+  async ensureInstalled() {
+    if (this.#closed) throw new Error("Renderer Control Session is closed");
+    const selected = await waitForRenderer(
+      this.inspector,
+      this.operations,
+      this.timeoutMs,
+      this.pollIntervalMs
+    );
+    const existing = await this.operations.readBinding(this.inspector, selected.id).catch(() => null);
+    if (existing !== null) {
+      const policyState = await this.operations.readDraftPrewarmPolicy?.(this.inspector, selected.id).catch(() => null);
+      const draftPrewarmPolicy2 = policyState === "ready" ? this.#snapshot.draftPrewarmPolicy : await this.operations.installDraftPrewarmPolicy(this.inspector, selected.id);
+      let binding2;
+      try {
+        binding2 = validateBindingStatus(existing, this.enabledAgents);
+      } catch (error) {
+        if (!(error instanceof RendererAdapterReadinessError)) throw error;
+        await this.operations.execute(this.inspector, selected.id, this.rendererSource);
+        binding2 = await waitForBinding(
+          this.inspector,
+          this.operations,
+          selected.id,
+          this.enabledAgents,
+          this.timeoutMs,
+          this.pollIntervalMs
+        );
+      }
+      this.#snapshot = {
+        ...this.#snapshot,
+        renderer: selected,
+        draftPrewarmPolicy: draftPrewarmPolicy2,
+        binding: binding2
+      };
+      return this.#snapshot;
+    }
+    const titlePolicyReadiness = await waitForRendererTitlePolicyReady(
+      () => this.operations.markTitlePolicyReady(this.inspector, selected.id),
+      { timeoutMs: this.timeoutMs, pollIntervalMs: this.pollIntervalMs }
+    );
+    await activateElectronDesktop(this.inspector);
+    await this.operations.execute(this.inspector, selected.id, this.rendererSource);
+    const draftPrewarmPolicy = await this.operations.installDraftPrewarmPolicy(
+      this.inspector,
+      selected.id
+    );
+    const binding = await waitForBinding(
+      this.inspector,
+      this.operations,
+      selected.id,
+      this.enabledAgents,
+      this.timeoutMs,
+      this.pollIntervalMs
+    );
+    this.#snapshot = {
+      ...this.#snapshot,
+      renderer: selected,
+      titlePolicyReadiness,
+      draftPrewarmPolicy,
+      binding
+    };
+    return this.#snapshot;
+  }
+  activateDesktop() {
+    if (this.#closed) return Promise.reject(new Error("Renderer Control Session is closed"));
+    return activateElectronDesktop(this.inspector);
+  }
+  async requestCompatibilityUpdate() {
+    const value = await this.executeRenderer(
+      "window.__codexhostRendererBindingProbeV1?.requestCompatibilityUpdate?.() ?? 'unavailable'"
+    );
+    if (value !== "update-started" && value !== "current" && value !== "unavailable") {
+      throw new Error("Renderer returned an invalid compatibility update outcome");
+    }
+    return value;
+  }
+  executeRenderer(expression) {
+    if (this.#closed) return Promise.reject(new Error("Renderer Control Session is closed"));
+    return this.operations.execute(
+      this.inspector,
+      this.#snapshot.renderer.id,
+      expression
+    );
+  }
+  readTitlePolicyCounters() {
+    if (this.#closed) return Promise.reject(new Error("Renderer Control Session is closed"));
+    return this.operations.readTitlePolicyCounters(this.inspector);
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.inspector.close();
+  }
+};
+var startupTraceStartedAt = Date.now();
+function startupTrace(stage) {
+  if (process.env.CODEXHOST_STARTUP_TRACE !== "1") return;
+  console.error(
+    `[codexhost startup +${Date.now() - startupTraceStartedAt}ms] renderer-session: ${stage}`
+  );
+}
+async function createRendererControlSession(options) {
+  const enabledAgents = options.enabledAgents ?? ["codex", "pi"];
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const pollIntervalMs = options.pollIntervalMs ?? 250;
+  const operations = options.operations ?? defaultOperations;
+  startupTrace("waiting for initial Renderer");
+  const initial = await waitForRenderer(options.inspector, operations, timeoutMs, pollIntervalMs);
+  startupTrace("installing title policy");
+  const titlePolicy = await operations.installTitlePolicy(options.inspector, initial.id);
+  startupTrace("reloading Renderer");
+  await operations.reload(options.inspector, initial.id);
+  startupTrace("waiting for reloaded Renderer");
+  const selected = await waitForRenderer(options.inspector, operations, timeoutMs, pollIntervalMs);
+  startupTrace("waiting for title policy readiness");
+  const titlePolicyReadiness = await waitForRendererTitlePolicyReady(
+    () => operations.markTitlePolicyReady(options.inspector, selected.id),
+    {
+      timeoutMs,
+      pollIntervalMs
+    }
+  );
+  startupTrace("injecting Renderer bundle");
+  await operations.execute(options.inspector, selected.id, options.rendererSource);
+  startupTrace("installing draft routing policy");
+  const draftPrewarmPolicy = await operations.installDraftPrewarmPolicy(
+    options.inspector,
+    selected.id
+  );
+  startupTrace("waiting for Renderer binding");
+  const binding = await waitForBinding(
+    options.inspector,
+    operations,
+    selected.id,
+    enabledAgents,
+    timeoutMs,
+    pollIntervalMs
+  );
+  return new InstalledRendererControlSession(
+    options.inspector,
+    options.rendererSource,
+    enabledAgents,
+    timeoutMs,
+    pollIntervalMs,
+    operations,
+    {
+      renderer: selected,
+      titlePolicy,
+      titlePolicyReadiness,
+      draftPrewarmPolicy,
+      binding
+    }
+  );
+}
+async function installRendererControlSession(options) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const pollIntervalMs = options.pollIntervalMs ?? 250;
+  startupTrace("waiting for Electron Inspector target");
+  const target = await waitForInspectorTarget(options.inspectorEndpoint, {
+    timeoutMs,
+    pollIntervalMs
+  });
+  startupTrace("connecting to Electron Inspector");
+  const inspector = await CdpClient.connect(target.webSocketDebuggerUrl);
+  try {
+    startupTrace("enabling Inspector Runtime domain");
+    await inspector.command("Runtime.enable");
+    return await createRendererControlSession({
+      ...options,
+      inspector,
+      timeoutMs,
+      pollIntervalMs
+    });
+  } catch (error) {
+    inspector.close();
+    throw error;
+  }
+}
+
+// packages/desktop-control/src/production-controller.ts
+var PRODUCTION_INSTALL_TIMEOUT_MS = 9e4;
+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 startupTraceStartedAt2 = Date.now();
+function startupTrace2(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() - startupTraceStartedAt2}ms] controller: ${stage}${suffix}`
+  );
+}
+function validCompatibilityIssue(state, issue) {
+  const keys = Object.keys(issue);
+  if (state === "compatible-with-warning") {
+    return issue.capability === "title-isolation" && issue.reason === "unreviewed-title-service-identity" && typeof issue.observedIdentity === "string" && /^[A-Za-z_$][A-Za-z0-9_$]{0,63}$/.test(issue.observedIdentity) && keys.length === 3;
+  }
+  if (state === "degraded") {
+    return [
+      "permission-control",
+      "sidebar-decoration",
+      "fork-control",
+      "usage-surface",
+      "settings-surface"
+    ].includes(issue.capability) && issue.reason === "capability-unavailable" && issue.observedIdentity === void 0 && keys.length === 2;
+  }
+  return false;
+}
+function serializeDesktopControllerReadiness(readiness) {
+  if (readiness.schemaVersion !== 2 || !["compatible", "compatible-with-warning", "degraded"].includes(readiness.state) || !Array.isArray(readiness.issues) || readiness.issues.length > 1 || readiness.state === "compatible" && readiness.issues.length !== 0 || readiness.state !== "compatible" && (readiness.issues.length !== 1 || !readiness.issues[0] || !validCompatibilityIssue(readiness.state, readiness.issues[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: installRendererControlSession,
+  startAttachmentServer: startControllerAttachmentServer,
+  ready: (readiness) => {
+    process.stdout.write(`${serializeDesktopControllerReadiness(readiness)}
+`);
+  },
+  sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+  monitorIntervalMs: 500
+};
+function inspectorEndpoint(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("--inspector-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 === "--inspector-endpoint") {
+      if (endpoint !== void 0) throw new Error("--inspector-endpoint may only be provided once");
+      if (!value) throw new Error("--inspector-endpoint requires a value");
+      endpoint = inspectorEndpoint(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("--inspector-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 {
+    inspectorEndpoint: endpoint,
+    rendererPath,
+    defaultAgent,
+    attachmentPort,
+    attachmentNonce
+  };
+}
+function isTransientElectronInstallError(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 || !isTransientElectronInstallError(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 () => {
+    startupTrace2("reading Renderer bundle");
+    const rendererSource = await dependencies.readRenderer(options.rendererPath);
+    if (rendererSource.trim().length === 0) throw new Error("production Renderer Bundle is empty");
+    startupTrace2("installing Renderer Session");
+    const installed = await installProductionSession(
+      {
+        inspectorEndpoint: options.inspectorEndpoint,
+        rendererSource: `${configuration}
+${rendererSource}`,
+        enabledAgents: ["codex", "pi", "claude-code", "deepseek-harness", "grok"],
+        timeoutMs: PRODUCTION_INSTALL_TIMEOUT_MS
+      },
+      dependencies
+    );
+    startupTrace2("Renderer Session installed");
+    return installed;
+  };
+  startupTrace2("initialization started");
+  try {
+    session = await createSession();
+    recordRecoverySuccess();
+  } catch (error) {
+    startupTrace2("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 {
+    startupTrace2("starting attachment server");
+    attachmentServer = await dependencies.startAttachmentServer({
+      port: options.attachmentPort,
+      nonce: options.attachmentNonce,
+      attach: () => useSession(async () => {
+        const current = await recoverSession();
+        await current.activateDesktop();
+      }),
+      compatibilityUpdate: () => useSession(async () => {
+        const current = await recoverSession();
+        return current.requestCompatibilityUpdate();
+      })
+    });
+    startupTrace2("attachment server ready");
+    const issues = session?.snapshot.titlePolicy.warnings ?? [];
+    startupTrace2("publishing readiness");
+    dependencies.ready({
+      schemaVersion: 2,
+      state: issues.length === 0 ? "compatible" : "compatible-with-warning",
+      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);
+}