@codexhost/cli-win32-arm64 0.3.1 → 0.3.3

package/README.md

@@ -7,7 +7,7 @@ Run Pi and Claude Code as first-class external harnesses inside Codex Desktop.
 ## Install
 
 ```bash
-npm install -g @codexhost/cli@0.3.1
+npm install -g @codexhost/cli@0.3.3
 ```
 
 Do not install this package directly. npm selects it through the optional dependencies of `@codexhost/cli`.
@@ -22,6 +22,8 @@ codexhost --version
 codexhost inspect
 codexhost launch
 codexhost remote install
+codexhost remote start
+codexhost remote stop
 codexhost remote status
 codexhost remote uninstall
 ```

package/app/codexhost-distribution.json

@@ -1 +1 @@
-{"schemaVersion":1,"version":"0.3.1","distribution":"npm","target":"windows-arm64"}
+{"schemaVersion":1,"version":"0.3.3","distribution":"npm","target":"windows-arm64"}

package/app/desktop-controller.mjs

@@ -558,16 +558,376 @@ async function readMainProcessTitlePolicyCounters(inspector) {
 }
 
 // packages/desktop-control/src/renderer-draft-prewarm-runtime.ts
-function installDraftPrewarmPolicyBridge(bridge, hostId, target, prewarmedThreadManager) {
+function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewarmedThreadManager) {
   const existing = target.__codexhostDraftPrewarmPolicyV1;
-  if (existing?.owns?.length === 3 && existing.owns(bridge, hostId, prewarmedThreadManager) === true) {
+  if (existing?.owns?.length === 4 && existing.owns(manager, bridge, hostId, prewarmedThreadManager) === true) {
     return { state: "ready", reason: "owned-request-bridge" };
   }
   existing?.dispose?.();
   const originalSend = bridge.sendRequest;
   const originalPrewarm = bridge.prewarmThreadStart;
+  const originalOnNotification = manager.onNotification;
+  const originalDispatchAppServerResponse = manager.dispatchAppServerResponse;
   let selectedModel = null;
   const isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const isRemoteControlHost = hostId.startsWith("remote-control:");
+  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 (!isRecord5(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 || !isRecord5(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" && isRecord5(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" && isRecord5(request.parameters) && typeof request.parameters.threadId === "string") {
+      knownExternalThreadIds.delete(request.parameters.threadId);
+      knownOfficialThreadIds.delete(request.parameters.threadId);
+    }
+  };
+  const handleBridgeFrame = (value) => {
+    if (!isRecord5(value)) {
+      failBridge("received a non-object app-server frame");
+      return;
+    }
+    if (value.method === bridgeReadyMethod && value.id === void 0) {
+      if (isRecord5(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" && isRecord5(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" && isRecord5(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" || !isRecord5(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 (!isRecord5(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 = isRecord5(value) && Array.isArray(value.threads) ? value.threads : null;
+      const ownership = ownerships?.[0];
+      if (!ownerships || !isRecord5(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 isRecord5(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 (selectedModel === null || !isRecord5(parameters) || parameters.ephemeral === true) {
       return parameters;
@@ -576,19 +936,62 @@ function installDraftPrewarmPolicyBridge(bridge, hostId, target, prewarmedThread
   };
   const routedSend = (method, parameters, options) => {
     const routedParameters = method === "thread/start" ? routeThreadStart(parameters) : parameters;
-    return options === void 0 ? originalSend.call(bridge, method, routedParameters) : originalSend.call(bridge, method, routedParameters, options);
+    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()
+      );
+    }
+    return shouldUseBridge(method, routedParameters) ? sendBridged() : sendDirect();
   };
   const routedPrewarm = (parameters, options) => {
     const routedParameters = routeThreadStart(parameters);
+    if (shouldUseBridge("thread/start", routedParameters)) {
+      return routedSend("thread/start", routedParameters, options);
+    }
     return options === void 0 ? originalPrewarm.call(bridge, routedParameters) : originalPrewarm.call(bridge, routedParameters, options);
   };
   bridge.sendRequest = routedSend;
   bridge.prewarmThreadStart = routedPrewarm;
+  const routedWindowMessage = (event) => {
+    const message = event.data;
+    if (!isRecord5(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(candidate, candidateHostId, candidatePrewarmedThreadManager) {
-      return candidate === bridge && candidateHostId === hostId && candidatePrewarmedThreadManager === prewarmedThreadManager;
+    owns(candidateManager, candidate, candidateHostId, candidatePrewarmedThreadManager) {
+      return candidateManager === manager && candidate === bridge && candidateHostId === hostId && candidatePrewarmedThreadManager === prewarmedThreadManager;
     },
     select(model) {
       if (model !== null && (typeof model !== "string" || !model.startsWith("codexhost/"))) {
@@ -607,6 +1010,30 @@ function installDraftPrewarmPolicyBridge(bridge, hostId, target, prewarmedThread
       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;
     }
   });
@@ -648,10 +1075,13 @@ async function installDraftPrewarmPolicyInRenderer(contents, findRequestManagerE
     const manager = managerProperties.result?.find(
       (property) => property.name === "manager"
     )?.value;
+    const requestClient = managerProperties.result?.find(
+      (property) => property.name === "requestClient"
+    )?.value;
     const prewarmedThreadManager = managerProperties.result?.find(
       (property) => property.name === "prewarmedThreadManager"
     )?.value;
-    if (candidateCount !== 1 || typeof hostId !== "string" || hostId.length === 0 || typeof manager?.objectId !== "string") {
+    if (candidateCount !== 1 || typeof hostId !== "string" || hostId.length === 0 || typeof manager?.objectId !== "string" || typeof requestClient?.objectId !== "string") {
       throw new Error("Renderer request manager is ambiguous");
     }
     if (typeof prewarmedThreadManager?.objectId !== "string") {
@@ -660,7 +1090,11 @@ async function installDraftPrewarmPolicyInRenderer(contents, findRequestManagerE
     const installed = await contents.debugger.sendCommand("Runtime.callFunctionOn", {
       objectId: manager.objectId,
       functionDeclaration: installRendererPolicyFunction,
-      arguments: [{ value: hostId }, { objectId: prewarmedThreadManager.objectId }],
+      arguments: [
+        { objectId: requestClient.objectId },
+        { value: hostId },
+        { objectId: prewarmedThreadManager.objectId }
+      ],
       awaitPromise: true,
       returnByValue: true
     });
@@ -748,12 +1182,19 @@ var FIND_REQUEST_MANAGER_EXPRESSION = `(() => {
   return {
     candidateCount: selected == null ? candidates.length : 1,
     hostId: selected?.hostId ?? null,
-    manager: selected?.requestClient ?? null,
+    manager: selected?.manager ?? null,
+    requestClient: selected?.requestClient ?? null,
     prewarmedThreadManager: selected?.prewarmedThreadManager ?? null,
   };
 })()`;
-var INSTALL_RENDERER_POLICY_FUNCTION = `function(hostId, prewarmedThreadManager) {
-  return (${installDraftPrewarmPolicyBridge.toString()})(this, hostId, window, prewarmedThreadManager);
+var INSTALL_RENDERER_POLICY_FUNCTION = `function(requestClient, hostId, prewarmedThreadManager) {
+  return (${installDraftPrewarmPolicyBridge.toString()})(
+    this,
+    requestClient,
+    hostId,
+    window,
+    prewarmedThreadManager,
+  );
 }`;
 var REQUEST_MANAGER_WAIT_TIMEOUT_MS = 6e4;
 var REQUEST_MANAGER_POLL_INTERVAL_MS = 25;
@@ -826,12 +1267,16 @@ function validateBindingStatus(value, expectedAgents) {
   }
   return value;
 }
-function selectRendererWebContents(contents) {
+function selectRendererWebContents(contents, preferredRendererId) {
   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)
   );
+  const preferred = candidates.find(
+    (candidate) => candidate.id === preferredRendererId && (candidate.runtime.elementCount ?? 0) > 0
+  );
+  if (preferred) return preferred;
   return candidates.find((candidate) => (candidate.runtime.elementCount ?? 0) > 0) ?? null;
 }
 async function waitForRendererTitlePolicyReady(markReadiness, options = {}) {
@@ -959,13 +1404,13 @@ var defaultOperations = {
   ),
   readTitlePolicyCounters: readMainProcessTitlePolicyCounters
 };
-async function waitForRenderer(inspector, operations, timeoutMs, pollIntervalMs) {
+async function waitForRenderer(inspector, operations, timeoutMs, pollIntervalMs, preferredRendererId) {
   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);
+    const renderer = selectRendererWebContents(inventory, preferredRendererId);
     if (renderer) return renderer;
     await sleep(pollIntervalMs);
   }
@@ -1016,7 +1461,8 @@ var InstalledRendererControlSession = class {
       this.inspector,
       this.operations,
       this.timeoutMs,
-      this.pollIntervalMs
+      this.pollIntervalMs,
+      this.#snapshot.renderer.id
     );
     const existing = await this.operations.readBinding(this.inspector, selected.id).catch(() => null);
     if (existing !== null) {
@@ -1124,7 +1570,13 @@ async function createRendererControlSession(options) {
   startupTrace("reloading Renderer");
   await operations.reload(options.inspector, initial.id);
   startupTrace("waiting for reloaded Renderer");
-  const selected = await waitForRenderer(options.inspector, operations, timeoutMs, pollIntervalMs);
+  const selected = await waitForRenderer(
+    options.inspector,
+    operations,
+    timeoutMs,
+    pollIntervalMs,
+    initial.id
+  );
   startupTrace("waiting for title policy readiness");
   const titlePolicyReadiness = await waitForRendererTitlePolicyReady(
     () => operations.markTitlePolicyReady(options.inspector, selected.id),