@parall/daemon 1.34.0 → 1.35.0

package/bundle/parall-daemon.js

@@ -27118,6 +27118,7 @@ var ENDPOINTS = {
   // Org-scoped
   ORG: (orgId) => `${API_BASE}/orgs/${orgId}`,
   ORG_MEMBERS: (orgId) => `${API_BASE}/orgs/${orgId}/members`,
+  TEAMS: (orgId) => `${API_BASE}/orgs/${orgId}/teams`,
   ORG_MEMBERS_ONLINE: (orgId) => `${API_BASE}/orgs/${orgId}/members/online`,
   ORG_MEMBER: (orgId, userId) => `${API_BASE}/orgs/${orgId}/members/${userId}`,
   ORG_MEMBER_CHATS: (orgId, memberId) => `${API_BASE}/orgs/${orgId}/members/${memberId}/chats`,
@@ -27162,6 +27163,7 @@ var ENDPOINTS = {
   AGENT: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}`,
   AGENT_API_KEYS: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/api-keys`,
   AGENT_API_KEY: (orgId, agentId, key) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/api-keys/${key}`,
+  AGENT_API_KEY_REGENERATE: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/api-keys/regenerate`,
   AGENT_AVATAR: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/avatar`,
   AGENT_ACTIVITY: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/activity`,
   AGENT_MONITOR: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/monitor`,
@@ -27201,6 +27203,7 @@ var ENDPOINTS = {
   MACHINE_AGENT_WORKSPACE_SETUP: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}/workspace/setup`,
   MACHINE_LLM_SOURCE: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/llm-source`,
   MACHINE_PROVIDER_ENABLED: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/provider-enabled`,
+  MACHINE_CAPABILITIES: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/capabilities`,
   MACHINE_RUNTIME_AUTH: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth`,
   MACHINE_KEYS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys`,
   MACHINE_KEY: (orgId, machineId, keyId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys/${keyId}`,
@@ -27221,6 +27224,12 @@ var ENDPOINTS = {
   MACHINES_ME_AGENT_WORKSPACE_STATE: (agentId) => `${API_BASE}/machines/me/agents/${agentId}/workspace-state`,
   MACHINES_ME_WS_TICKET: `${API_BASE}/machines/me/ws/ticket`,
   MACHINES_ME_BROWSE_RESPONSE: (requestId) => `${API_BASE}/machines/me/browse-response/${requestId}`,
+  // Hosted browser live-viewer control plane (api-server, NOT clip-service):
+  // the web client drives WebRTC signaling + tab nav through VIEWER_COMMAND;
+  // api-server brokers each command to the host daemon via the machine:{id}
+  // request/reply bridge (mirrors filesystem browse), and the daemon replies on
+  // VIEWER_RESPONSE. See docs/engineering-design/hosted-browser-provider-design.md.
+  MACHINES_ME_BROWSER_PROFILE_VIEWER_RESPONSE: (requestId) => `${API_BASE}/machines/me/browser-profiles/viewer-response/${requestId}`,
   // Tasks (org-scoped)
   TASKS: (orgId) => `${API_BASE}/orgs/${orgId}/tasks`,
   TASK: (orgId, taskId) => `${API_BASE}/orgs/${orgId}/tasks/${taskId}`,
@@ -27286,6 +27295,9 @@ var ENDPOINTS = {
   // Wiki Path Scopes (AFCS ACL)
   WIKI_PATH_SCOPES: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/path-scopes`,
   WIKI_PATH_SCOPE: (orgId, wikiId, scopeId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/path-scopes/${scopeId}`,
+  // Wiki Path Restrictions (AFCS narrowing ACL — private subtrees)
+  WIKI_RESTRICTIONS: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/restrictions`,
+  WIKI_RESTRICTION: (orgId, wikiId, restrictionId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/restrictions/${restrictionId}`,
   WIKI_ACCESS_STATUS: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/access-status`,
   WIKI_ACCESS_REQUESTS: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/access-requests`,
   // Wiki History (commits, file commits, blame)
@@ -27351,6 +27363,7 @@ var ENDPOINTS = {
   // Clips (org-scoped, served by clip-service)
   CLIPS: (orgId) => `${CLIP_BASE}/orgs/${orgId}/clips`,
   CLIP: (orgId, clipId) => `${CLIP_BASE}/orgs/${orgId}/clips/${clipId}`,
+  CLIPS_BULK_METADATA: (orgId) => `${CLIP_BASE}/orgs/${orgId}/clips/bulk-metadata`,
   CLIP_AGENTS: (orgId, clipId) => `${CLIP_BASE}/orgs/${orgId}/clips/${clipId}/agents`,
   AGENT_CLIPS: (orgId, agentId) => `${CLIP_BASE}/orgs/${orgId}/agents/${agentId}/clips`,
   AGENT_CLIP: (orgId, agentId, clipId) => `${CLIP_BASE}/orgs/${orgId}/agents/${agentId}/clips/${clipId}`,
@@ -27363,6 +27376,9 @@ var ENDPOINTS = {
   BROWSER_PROFILE_RESET: (orgId, profileId) => `${CLIP_BASE}/orgs/${orgId}/browser-profiles/${profileId}/reset`,
   BROWSER_PROFILE_CONSENTS: (orgId, profileId) => `${CLIP_BASE}/orgs/${orgId}/browser-profiles/${profileId}/consents`,
   BROWSER_PROFILE_CONSENT: (orgId, profileId, clipId) => `${CLIP_BASE}/orgs/${orgId}/browser-profiles/${profileId}/consents/${clipId}`,
+  // Live viewer command — on api-server (API_BASE), not clip-service: it rides
+  // the machine control-plane request/reply bridge that lives in api-server.
+  BROWSER_PROFILE_VIEWER_COMMAND: (orgId, profileId) => `${API_BASE}/orgs/${orgId}/browser-profiles/${profileId}/viewer/command`,
   // Clip registry (global, served by clip-service → Pinix Hub proxy)
   CLIP_REGISTRY: () => `${CLIP_BASE}/registry/clips`
 };
@@ -27439,6 +27455,7 @@ var WS_EVENTS = {
   MACHINE_CONFIG_UPDATED: "machine.config.updated",
   MACHINE_CLIP_SYNC: "machine.clip.sync",
   MACHINE_BROWSER_PROFILE_LIFECYCLE: "machine.browser_profile.lifecycle",
+  MACHINE_BROWSER_PROFILE_VIEWER: "machine.browser_profile.viewer",
   AGENT_NEW_SESSION: "agent.new_session",
   CLIP_CREATED: "clip.created",
   CLIP_REMOVED: "clip.removed",
@@ -27590,7 +27607,10 @@ var ParallClient = class _ParallClient {
         method,
         headers,
         body: body ? JSON.stringify(body) : void 0,
-        signal
+        signal,
+        // keepalive lets a request fired during page unload (e.g. the browser
+        // viewer's stream.close on pagehide) outlive the document.
+        keepalive: opts?.keepalive
       });
     } catch (err) {
       throw _ParallClient.normalizeFetchError(err);
@@ -27761,6 +27781,10 @@ var ParallClient = class _ParallClient {
     const res = await this.request("GET", ENDPOINTS.ORG_MEMBERS(orgId));
     return res.data;
   }
+  async getTeams(orgId) {
+    const res = await this.request("GET", ENDPOINTS.TEAMS(orgId));
+    return res.data;
+  }
   async getOnlineMembers(orgId) {
     const res = await this.request("GET", ENDPOINTS.ORG_MEMBERS_ONLINE(orgId));
     return res.user_ids ?? [];
@@ -27999,6 +28023,10 @@ var ParallClient = class _ParallClient {
   async createAgentApiKey(orgId, agentId) {
     return this.request("POST", ENDPOINTS.AGENT_API_KEYS(orgId, agentId));
   }
+  /** Revokes all of the agent's active API keys and mints a replacement. */
+  async regenerateAgentApiKey(orgId, agentId) {
+    return this.request("POST", ENDPOINTS.AGENT_API_KEY_REGENERATE(orgId, agentId));
+  }
   async revokeAgentApiKey(orgId, agentId, key) {
     return this.request("DELETE", ENDPOINTS.AGENT_API_KEY(orgId, agentId, key));
   }
@@ -28170,6 +28198,17 @@ var ParallClient = class _ParallClient {
       provider_enabled: providerEnabled
     });
   }
+  /**
+   * Replace the machine's capability set (admin). Primary use: healing a
+   * machine that registered without `browser_provider` during the capability
+   * migration's rolling-deploy window. Removing `agent_host` is rejected by the
+   * server while agents are attached (409 AGENTS_STILL_ATTACHED).
+   */
+  async patchMachineCapabilities(orgId, machineId, capabilities) {
+    return this.request("PATCH", ENDPOINTS.MACHINE_CAPABILITIES(orgId, machineId), {
+      capabilities
+    });
+  }
   /** Get machine-level runtime auth state. */
   async getMachineRuntimeAuth(orgId, machineId) {
     return this.request("GET", ENDPOINTS.MACHINE_RUNTIME_AUTH(orgId, machineId));
@@ -28260,6 +28299,22 @@ var ParallClient = class _ParallClient {
   async postBrowseResponse(requestId, response) {
     return this.request("POST", ENDPOINTS.MACHINES_ME_BROWSE_RESPONSE(requestId), response);
   }
+  /**
+   * `POST /machines/me/browser-profiles/viewer-response/{requestId}` — daemon
+   * reply to a `machine.browser_profile.viewer` control command. Wakes the
+   * api-server request/reply bridge (mirrors {@link postBrowseResponse}).
+   */
+  async postBrowserProfileViewerResponse(requestId, response) {
+    return this.request("POST", ENDPOINTS.MACHINES_ME_BROWSER_PROFILE_VIEWER_RESPONSE(requestId), response);
+  }
+  /**
+   * `POST /orgs/{orgId}/browser-profiles/{profileId}/viewer/command` — drive the
+   * hosted browser live viewer (WebRTC signaling + tab nav). Authz: profile
+   * owner or org admin. api-server brokers the command to the host daemon.
+   */
+  async browserViewerCommand(orgId, profileId, req, opts) {
+    return this.request("POST", ENDPOINTS.BROWSER_PROFILE_VIEWER_COMMAND(orgId, profileId), req, void 0, false, opts);
+  }
   async resizeMachine(orgId, machineId, spec) {
     return this.request("PATCH", ENDPOINTS.MACHINE_SPEC(orgId, machineId), spec);
   }
@@ -28636,6 +28691,17 @@ var ParallClient = class _ParallClient {
   async deleteWikiPathScope(orgId, wikiId, scopeId) {
     await this.request("DELETE", ENDPOINTS.WIKI_PATH_SCOPE(orgId, wikiId, scopeId));
   }
+  // ---- Wiki Path Restrictions (narrowing ACL — private subtrees) ----
+  async getWikiRestrictions(orgId, wikiId) {
+    const res = await this.request("GET", ENDPOINTS.WIKI_RESTRICTIONS(orgId, wikiId));
+    return res.data;
+  }
+  async createWikiRestriction(orgId, wikiId, data) {
+    return this.request("POST", ENDPOINTS.WIKI_RESTRICTIONS(orgId, wikiId), data);
+  }
+  async deleteWikiRestriction(orgId, wikiId, restrictionId) {
+    await this.request("DELETE", ENDPOINTS.WIKI_RESTRICTION(orgId, wikiId, restrictionId));
+  }
   async getWikiAccessStatus(orgId, wikiId, path15) {
     return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path15 ? { path: path15 } : void 0);
   }
@@ -28798,6 +28864,10 @@ var ParallClient = class _ParallClient {
   async updateClip(orgId, clipId, req) {
     return this.request("PATCH", ENDPOINTS.CLIP(orgId, clipId), req);
   }
+  /** Atomically set display_name and/or description on multiple clip instances (application metadata). */
+  async bulkUpdateClipMetadata(orgId, req) {
+    return this.request("POST", ENDPOINTS.CLIPS_BULK_METADATA(orgId), req);
+  }
   async deleteClip(orgId, clipId) {
     await this.request("DELETE", ENDPOINTS.CLIP(orgId, clipId));
   }
@@ -29698,7 +29768,7 @@ async function runCLI(args) {
 init_config();
 
 // ts/daemon/dist/supervisor.js
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import * as fs12 from "node:fs";
 import * as path13 from "node:path";
 
@@ -32001,13 +32071,561 @@ var ClipProvider = class _ClipProvider {
 };
 
 // ts/daemon/dist/clip-runtime/browser-profile-manager.js
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7 } from "node:fs";
 import { createRequire } from "node:module";
-import * as net from "node:net";
 import * as path9 from "node:path";
 import { fileURLToPath } from "node:url";
+
+// ts/daemon/dist/clip-runtime/browser-viewer-streamer.js
+import { spawn as spawn3 } from "node:child_process";
+
+// ts/daemon/dist/clip-runtime/subprocess.js
+import * as net from "node:net";
+function formatErrorForLog(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return message.replace(/\s+/g, " ").slice(0, 300);
+}
+async function findFreePort() {
+  return new Promise((resolve8, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      server.close(() => {
+        if (address && typeof address === "object") {
+          resolve8(address.port);
+        } else {
+          reject(new Error("failed to allocate free port"));
+        }
+      });
+    });
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
+}
+
+// ts/daemon/dist/clip-runtime/browser-viewer-streamer.js
+var BB_VIEWER_HEALTH_TIMEOUT_MS = 1e4;
+var BB_VIEWER_COMMAND_TIMEOUT_MS = 15e3;
+var BB_VIEWER_UNANSWERED_REAP_MS = 9e4;
+var BB_VIEWER_TERM_GRACE_MS = 5e3;
+var BrowserViewerStreamer = class {
+  host;
+  // Live bb-viewer (WebRTC streamer) subprocess per profile. One per profile;
+  // see StreamerState. Cleaned up on stream.close, stopProfile, resetProfile,
+  // and stop().
+  streamers = /* @__PURE__ */ new Map();
+  // Set by shutdown(): an in-flight spawnStreamer has no map entry yet, so a
+  // shutdown during its health poll would otherwise let the bb-viewer child
+  // survive daemon stop (on BYOC nothing else reaps it).
+  stopping = false;
+  constructor(host) {
+    this.host = host;
+  }
+  /**
+   * Handle a viewer control command for a profile. Throws on any failure (the
+   * supervisor maps a throw to a `{error:{message}}` reply); never returns a
+   * partial result. `data.input` / `data.turn` / `data.session_id` come from
+   * MachineBrowserProfileViewerData.
+   */
+  async handleViewerCommand(profileId, sessionId, command, input, turn) {
+    if (!profileId)
+      throw new Error("browser profile id is required");
+    switch (command) {
+      case "stream.start":
+        return this.viewerStreamStart(profileId, sessionId, turn);
+      case "stream.answer":
+        return this.viewerStreamAnswer(profileId, sessionId, input);
+      case "stream.close":
+        return this.viewerStreamClose(profileId, sessionId, input);
+      case "stream.switch":
+        return this.viewerStreamSwitch(profileId, sessionId, input);
+      case "close":
+        return this.viewerCloseTab(profileId, sessionId, input);
+      case "tab_list":
+      case "tab_new":
+      case "open":
+      case "reload":
+      case "back":
+      case "forward":
+        return this.viewerForwardNav(profileId, sessionId, command, input);
+      default:
+        throw new Error(`unknown viewer command: ${command}`);
+    }
+  }
+  /**
+   * stream.start — spawn a FRESH bb-viewer for this profile (killing any prior
+   * one), resolve the profile's account-scoped page-target CDP ws URL, and run
+   * the streamer's `connect` command. Records sessionId on the streamer entry.
+   */
+  async viewerStreamStart(profileId, sessionId, turn) {
+    this.killProfileStreamer(profileId);
+    const cdpUrl = await this.host.withDaemonRecovery(() => this.resolveAccountPageCdpUrl(profileId), `viewer stream.start ${profileId}`);
+    await this.bringTargetToFront(cdpUrl);
+    const streamer = await this.spawnStreamer(profileId, sessionId, turn);
+    try {
+      const result = await this.streamerCommand(streamer, "connect", { cdpUrl });
+      streamer.streamedTabId = targetIdFromCdpUrl(cdpUrl);
+      const reapTimer = setTimeout(() => {
+        const current = this.streamers.get(profileId);
+        if (current === streamer && !current.answered) {
+          this.host.log.warn(`[bb-viewer] no stream.answer for ${profileId} within ${BB_VIEWER_UNANSWERED_REAP_MS / 1e3}s; reaping abandoned streamer`);
+          this.killProfileStreamer(profileId);
+        }
+      }, BB_VIEWER_UNANSWERED_REAP_MS);
+      reapTimer.unref?.();
+      return { ...result, streamed_tab_id: streamer.streamedTabId };
+    } catch (err) {
+      this.killProfileStreamer(profileId);
+      throw err;
+    }
+  }
+  /**
+   * stream.answer — apply the client's WebRTC answer to the profile's streamer.
+   * Rejects if the streamer's sessionId no longer matches (a stale viewer
+   * session from a superseded stream.start).
+   */
+  async viewerStreamAnswer(profileId, sessionId, input) {
+    const streamer = this.streamers.get(profileId);
+    if (!streamer)
+      throw new Error("no active viewer streamer for profile");
+    if (streamer.sessionId !== sessionId)
+      throw new Error("stale viewer session");
+    streamer.answered = true;
+    return this.streamerCommand(streamer, "answer", input ?? {});
+  }
+  /**
+   * stream.close — best-effort stop the streamer, then kill + remove it. A
+   * stale session's close (independent HTTP legs can arrive out of order after
+   * a retry) must NOT tear down a successor session's live streamer, so a
+   * mismatched sessionId is ignored. An EMPTY sessionId gets the same stale
+   * treatment — a client closed mid-handshake never received a session id, and
+   * its unscoped close racing the next session's stream.start would kill that
+   * session's live streamer (React StrictMode's dev double-mount exercises
+   * exactly this ordering). The only unscoped close is an explicit
+   * `{force:true}` input, reserved for a server-initiated admin disconnect.
+   */
+  async viewerStreamClose(profileId, sessionId, input) {
+    const streamer = this.streamers.get(profileId);
+    if (streamer) {
+      const force = input?.force === true;
+      if (!force && streamer.sessionId !== sessionId) {
+        return { ok: true, stale: true };
+      }
+      try {
+        await this.streamerCommand(streamer, "stop", {});
+      } catch (err) {
+        this.host.log.warn(`[bb-viewer] stop command failed for ${profileId} (killing anyway): ${formatErrorForLog(err)}`);
+      }
+      this.killProfileStreamer(profileId);
+    }
+    return { ok: true };
+  }
+  /**
+   * stream.switch — point the existing streamer at a different account-scoped
+   * tab. input {tab} is the bb-browser short tab id / target id. Guarded by
+   * sessionId like stream.answer: a superseded session must not steer the
+   * current streamer, and an EMPTY sessionId is rejected the same way — every
+   * real caller has its session id by the time it can switch (it arrives with
+   * the stream.start response), so a session-less switch is by definition not
+   * the current viewer.
+   */
+  async viewerStreamSwitch(profileId, sessionId, input) {
+    const streamer = this.streamers.get(profileId);
+    if (!streamer)
+      throw new Error("no active viewer streamer for profile");
+    if (!sessionId || streamer.sessionId !== sessionId)
+      throw new Error("stale viewer session");
+    const tab = input?.tab;
+    if (tab === void 0 || tab === null || tab === "") {
+      throw new Error("stream.switch requires input.tab");
+    }
+    const cdpUrl = await this.host.withDaemonRecovery(() => this.resolveAccountPageCdpUrl(profileId, tab), `viewer stream.switch ${profileId}`);
+    await this.bringTargetToFront(cdpUrl);
+    const result = await this.streamerCommand(streamer, "switch", { cdpUrl });
+    streamer.streamedTabId = targetIdFromCdpUrl(cdpUrl);
+    return { ...result, streamed_tab_id: streamer.streamedTabId };
+  }
+  /**
+   * close — close an account tab via bb-browser, then, if the closed tab was
+   * the one being streamed, re-point the streamer at the profile's next active
+   * tab. Without the re-switch the streamer stays bound to a destroyed CDP
+   * target and the viewer goes black. Returns `streamed_tab_id` when a
+   * re-switch happened so the client can adopt the new active tab.
+   */
+  async viewerCloseTab(profileId, sessionId, input) {
+    const ref = viewerTabRef(input ?? {});
+    const closedTargetId = ref !== void 0 ? await this.accountTabTargetId(profileId, ref) : await this.accountActivePageTargetId(profileId);
+    const result = await this.viewerForwardNav(profileId, sessionId, "close", {
+      ...input ?? {},
+      tabId: closedTargetId
+    });
+    const streamer = this.streamers.get(profileId);
+    if (!streamer || !streamer.streamedTabId || streamer.streamedTabId !== closedTargetId) {
+      return result;
+    }
+    const cdpUrl = await this.host.withDaemonRecovery(() => this.resolveAccountPageCdpUrl(profileId), `viewer close re-switch ${profileId}`);
+    await this.bringTargetToFront(cdpUrl);
+    const sw = await this.streamerCommand(streamer, "switch", { cdpUrl });
+    streamer.streamedTabId = targetIdFromCdpUrl(cdpUrl);
+    return { ...result, ...sw, streamed_tab_id: streamer.streamedTabId };
+  }
+  /**
+   * Bring a CDP page target to the foreground via Chrome's DevTools HTTP
+   * endpoint (`/json/activate/{targetId}`, same host:port as the CDP ws). Chrome
+   * does not composite backgrounded tabs, so `Page.startScreencast` on a
+   * background tab yields zero frames (black viewer). Best-effort: a failure
+   * must not block the stream. host:port + targetId are parsed from the cdpUrl
+   * (`ws://host:port/devtools/page/<targetId>`) to avoid an extra /status call.
+   */
+  async bringTargetToFront(cdpUrl) {
+    const m = /^ws:\/\/([^/]+)\/devtools\/page\/(.+)$/.exec(cdpUrl);
+    if (!m)
+      return;
+    const [, hostPort, targetId] = m;
+    try {
+      const resp = await fetch(`http://${hostPort}/json/activate/${targetId}`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!resp.ok) {
+        this.host.log.warn(`[bb-viewer] activate target ${targetId} returned ${resp.status} (continuing)`);
+      }
+    } catch (err) {
+      this.host.log.warn(`[bb-viewer] activate target ${targetId} failed (continuing): ${formatErrorForLog(err)}`);
+    }
+  }
+  /**
+   * Forward a navigation command (tab_list/tab_new/open/reload/back/forward/
+   * close) to bb-browser scoped to the profile's account. This lets the human
+   * in the live viewer navigate and handle OAuth popups directly. Reuses the
+   * same account-scoped sendCommand path the agent invokes use.
+   *
+   * SECURITY — the `account` field alone does NOT scope tab addressing:
+   * bb-browser's ensurePageTarget resolves a client-supplied tab/tabId against
+   * EVERY page target in the shared Chrome (all accounts), and tab_list
+   * returns every tab with `account` as a mere annotation (verified in
+   * @pinixai/bb-browser-pro@0.15.0 dist/daemon.js ensurePageTarget/tab_list).
+   * On a multi-profile host that would let one profile's viewer list,
+   * navigate, and close other profiles' logged-in tabs. So before forwarding:
+   * (a) any tab ref must resolve through accountTabTargetId, which throws on
+   * tabs the profile's account does not own; (b) ref-less tab-addressed
+   * commands are pinned to the profile's own active tab instead of
+   * bb-browser's account-blind global current tab; (c) tab_list output is
+   * filtered to the profile's own rows; and (d) open/tab_new URLs must be
+   * http(s)/about:blank — file:// or chrome:// would read the host
+   * filesystem / browser internals straight into the video stream.
+   */
+  async viewerForwardNav(profileId, sessionId, command, input) {
+    if (command !== "tab_list") {
+      const streamer = this.streamers.get(profileId);
+      if (streamer && streamer.sessionId !== sessionId) {
+        throw new Error("stale viewer session");
+      }
+    }
+    return this.host.withDaemonRecovery(async () => {
+      await this.host.ensureAccount(profileId);
+      const request3 = { ...input ?? {} };
+      if (command === "open" || command === "tab_new") {
+        assertViewerNavigableUrl(request3.url);
+      }
+      const ref = viewerTabRef(request3);
+      if (ref !== void 0) {
+        request3.tabId = await this.accountTabTargetId(profileId, ref);
+        delete request3.tab;
+      } else if (REFLESS_PIN_NAV.has(command)) {
+        request3.tabId = await this.accountActivePageTargetId(profileId);
+      }
+      const result = await this.host.sendBrowserCommand({
+        ...request3,
+        method: command,
+        account: profileId
+      });
+      return command === "tab_list" ? filterTabListToAccount(result, profileId) : result;
+    }, `viewer ${command} ${profileId}`);
+  }
+  /**
+   * Resolve `ws://<cdpHost>:<cdpPort>/devtools/page/<targetId>` for a PAGE
+   * target owned by THIS profile's account — NOT bb-browser's global current
+   * tab (which `getCurrentTabCdpUrl`/`getTabCdpUrl` in the bundled daemon use
+   * via `cdp.currentTargetId`, an account-blind global; see daemon.js
+   * line ~10389/10410). When `tabRef` is given (stream.switch) we resolve that
+   * specific account tab; otherwise the profile's active page tab.
+   *
+   * Evidence from the installed @pinixai/bb-browser-pro@0.15.0 dist/daemon.js:
+   *  - GET /status (handleStatus, line ~1659-1668) returns `cdpHost` + `cdpPort`
+   *    — the CDP host/port the daemon's Chrome listens on.
+   *  - The CDP page ws URL format is `ws://<cdp.host>:<cdp.port>/devtools/page/<page.id>`
+   *    (getCurrentTabCdpUrl, line ~10392), where `page.id` is the full CDP
+   *    targetId (getTargets maps `t.targetId` → `.id`, line ~2461-2466).
+   *  - tab_list (command handler, line ~1041-1059) returns per-tab
+   *    `{ tabId: t.id, tab: <shortId>, account: <accountName>, url, ... }`, so
+   *    `tabId` is exactly the full targetId for the devtools URL and `account`
+   *    is the per-tab attribution we filter on (reused by findAccountTabOnHost).
+   */
+  async resolveAccountPageCdpUrl(profileId, tabRef) {
+    await this.host.ensureAccount(profileId);
+    const { host, port } = await this.host.cdpEndpoint();
+    const targetId = tabRef !== void 0 ? await this.accountTabTargetId(profileId, tabRef) : await this.accountActivePageTargetId(profileId);
+    return `ws://${host}:${port}/devtools/page/${targetId}`;
+  }
+  /**
+   * Full CDP targetId of the profile account's active page tab (the owned tab
+   * Chrome marks active, else the first owned tab). If the account owns no
+   * page tab yet, open `about:blank` for it first (mirrors the agent-invoke
+   * path's "always give a fresh account an owned tab" rule).
+   */
+  async accountActivePageTargetId(profileId) {
+    let targetId = await this.firstAccountPageTargetId(profileId);
+    if (targetId !== void 0)
+      return targetId;
+    await this.host.sendBrowserCommand({
+      method: "tab_new",
+      account: profileId,
+      url: "about:blank"
+    });
+    targetId = await this.firstAccountPageTargetId(profileId);
+    if (targetId === void 0) {
+      throw new Error(`no page tab found for profile account ${profileId}`);
+    }
+    return targetId;
+  }
+  /**
+   * Full CDP targetId (`tabId`) of the account's active page tab: the owned tab
+   * Chrome marks `active` when it belongs to this account, else the first owned
+   * tab (the global active flag is account-blind — another profile's tab may
+   * hold it, which must not leak here).
+   */
+  async firstAccountPageTargetId(profileId) {
+    const tabs = await this.accountTabs(profileId);
+    let firstOwned;
+    for (const t of tabs) {
+      if (t.account !== profileId)
+        continue;
+      const tabId = t.tabId;
+      if (typeof tabId !== "string" || !tabId)
+        continue;
+      if (t.active === true)
+        return tabId;
+      firstOwned ??= tabId;
+    }
+    return firstOwned;
+  }
+  /**
+   * Full CDP targetId for a specific account tab, addressed by the bb-browser
+   * short tab id (`tab`) or full target id (`tabId`). Used by stream.switch.
+   */
+  async accountTabTargetId(profileId, tabRef) {
+    const ref = String(tabRef);
+    const tabs = await this.accountTabs(profileId);
+    for (const t of tabs) {
+      if (t.account !== profileId)
+        continue;
+      const tabId = typeof t.tabId === "string" ? t.tabId : void 0;
+      const shortTab = t.tab === void 0 ? void 0 : String(t.tab);
+      if (tabId && tabId === ref || shortTab && shortTab === ref) {
+        if (!tabId)
+          break;
+        return tabId;
+      }
+    }
+    throw new Error(`tab ${ref} not found for profile account ${profileId}`);
+  }
+  /** `tab_list {account}` rows, typed to the fields we read (tabId/tab/account/active). */
+  async accountTabs(profileId) {
+    const list = await this.host.sendBrowserCommand({ method: "tab_list", account: profileId });
+    return Array.isArray(list.tabs) ? list.tabs : [];
+  }
+  // ---- bb-viewer streamer lifecycle ----
+  /**
+   * Spawn a bb-viewer streamer for the profile and wait until healthy. Binary
+   * is PRLL_BB_VIEWER_BIN (our image sets it to /usr/local/bin/bb-viewer),
+   * defaulting to `bb-viewer` on PATH — we NEVER download it. A free port is
+   * allocated per streamer. Stores the entry in `this.streamers` once healthy.
+   */
+  async spawnStreamer(profileId, sessionId, turn) {
+    if (this.stopping)
+      throw new Error("viewer streamer is shutting down");
+    const bin = process.env.PRLL_BB_VIEWER_BIN ?? "bb-viewer";
+    const port = await findFreePort();
+    const args = ["--api-only", "--port", String(port)];
+    if (turn?.url) {
+      args.push("--turn-url", turn.url, "--turn-user", turn.username ?? "", "--turn-cred", turn.credential ?? "");
+    }
+    const streamerEnv = {};
+    for (const key of ["PATH", "HOME", "LANG", "LC_ALL", "TMPDIR", "DISPLAY"]) {
+      const val = process.env[key];
+      if (val !== void 0)
+        streamerEnv[key] = val;
+    }
+    this.host.log.info(`[bb-viewer] spawning for profile ${profileId} on port ${port}`);
+    const child = spawn3(bin, args, { stdio: ["ignore", "pipe", "pipe"], env: streamerEnv });
+    let childError = null;
+    child.once("error", (err) => {
+      childError = err;
+    });
+    child.once("exit", () => {
+      const current = this.streamers.get(profileId);
+      if (current?.child === child) {
+        this.streamers.delete(profileId);
+        this.host.log.warn(`[bb-viewer] streamer for ${profileId} exited; cleared stale entry`);
+      }
+    });
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString("utf8").trim();
+      if (text)
+        this.host.log.info(`[bb-viewer] ${text}`);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString("utf8").trim();
+      if (text)
+        this.host.log.warn(`[bb-viewer] ${text}`);
+    });
+    const deadline = Date.now() + BB_VIEWER_HEALTH_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      if (this.stopping) {
+        this.killChild(child, "streamer for stopping daemon");
+        throw new Error("viewer streamer is shutting down");
+      }
+      if (childError) {
+        throw childError;
+      }
+      if (child.exitCode !== null || child.signalCode !== null) {
+        throw new Error("bb-viewer exited during startup");
+      }
+      try {
+        const resp = await fetch(`http://127.0.0.1:${port}/health`, {
+          signal: AbortSignal.timeout(2e3)
+        });
+        if (resp.ok) {
+          const streamer = { child, port, sessionId };
+          this.streamers.set(profileId, streamer);
+          this.host.log.info(`[bb-viewer] ready for profile ${profileId} on port ${port}`);
+          return streamer;
+        }
+      } catch {
+      }
+      await sleep(200);
+    }
+    this.killChild(child, "unhealthy streamer");
+    throw new Error("bb-viewer did not become healthy in time");
+  }
+  /**
+   * SIGTERM with a SIGKILL escalation: a bb-viewer that hangs or ignores TERM
+   * would otherwise outlive its teardown holding the port + CDP session (the
+   * shell-level pattern-kill only exists on the hosted pod, not BYOC). The
+   * escalation timer is unref'd so it never holds the daemon open; it is
+   * cleared on exit. Caveat: a daemon process that exits immediately after
+   * shutdown() abandons the timer — acceptable, the TERM was still sent.
+   */
+  killChild(child, label) {
+    if (child.exitCode !== null || child.signalCode !== null)
+      return;
+    try {
+      child.kill("SIGTERM");
+    } catch {
+      return;
+    }
+    const killTimer = setTimeout(() => {
+      if (child.exitCode === null && child.signalCode === null) {
+        this.host.log.warn(`[bb-viewer] ${label} ignored SIGTERM; escalating to SIGKILL`);
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }
+    }, BB_VIEWER_TERM_GRACE_MS);
+    killTimer.unref?.();
+    child.once("exit", () => clearTimeout(killTimer));
+  }
+  /**
+   * POST a command to the profile's bb-viewer `/command` endpoint. Parses the
+   * `{result}` / `{error:{message}}` envelope (bb-viewer api.go) and returns
+   * the inner result, throwing the error message on failure.
+   */
+  async streamerCommand(streamer, method, params) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), BB_VIEWER_COMMAND_TIMEOUT_MS);
+    try {
+      const resp = await fetch(`http://127.0.0.1:${streamer.port}/command`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ method, params }),
+        signal: controller.signal
+      });
+      const text = await resp.text();
+      const parsed = text ? JSON.parse(text) : {};
+      if (parsed.error) {
+        throw new Error(parsed.error.message || `bb-viewer ${method} failed`);
+      }
+      if (!resp.ok) {
+        throw new Error(`bb-viewer ${method} returned ${resp.status}: ${text}`);
+      }
+      return parsed.result ?? {};
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** Kill + remove the profile's bb-viewer streamer, if any. Idempotent. */
+  killProfileStreamer(profileId) {
+    const streamer = this.streamers.get(profileId);
+    if (!streamer)
+      return;
+    this.streamers.delete(profileId);
+    this.killChild(streamer.child, `streamer for ${profileId}`);
+  }
+  /**
+   * Tear down every profile streamer and refuse new spawns (daemon stop).
+   * Idempotent.
+   */
+  shutdown() {
+    this.stopping = true;
+    for (const profileId of [...this.streamers.keys()]) {
+      this.killProfileStreamer(profileId);
+    }
+  }
+};
+function targetIdFromCdpUrl(cdpUrl) {
+  return /\/devtools\/page\/(.+)$/.exec(cdpUrl)?.[1];
+}
+var REFLESS_PIN_NAV = /* @__PURE__ */ new Set(["reload", "back", "forward", "close"]);
+function viewerTabRef(request3) {
+  for (const key of ["tabId", "tab"]) {
+    const v = request3[key];
+    if (typeof v === "string" && v !== "" || typeof v === "number")
+      return String(v);
+  }
+  return void 0;
+}
+var VIEWER_NAVIGABLE_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+function assertViewerNavigableUrl(raw) {
+  if (raw === void 0 || raw === null || raw === "")
+    return;
+  if (typeof raw !== "string")
+    throw new Error("url must be a string");
+  if (raw === "about:blank")
+    return;
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new Error(`invalid url: ${raw}`);
+  }
+  if (!VIEWER_NAVIGABLE_PROTOCOLS.has(parsed.protocol)) {
+    throw new Error(`url scheme not allowed in the live viewer: ${parsed.protocol.replace(/:$/, "")}`);
+  }
+}
+function filterTabListToAccount(result, account) {
+  const tabs = Array.isArray(result.tabs) ? result.tabs : [];
+  const owned = tabs.filter((t) => t?.account === account);
+  return { ...result, tabs: owned, activeIndex: owned.findIndex((t) => t?.active === true) };
+}
+
+// ts/daemon/dist/clip-runtime/browser-profile-manager.js
 var BB_BROWSER_DAEMON_START_TIMEOUT_MS = 15e3;
 var BrowserCommandError = class extends Error {
   method;
@@ -32027,9 +32645,20 @@ var BrowserProfileManager = class {
   ensuredAccounts = /* @__PURE__ */ new Set();
   ensuringAccounts = /* @__PURE__ */ new Map();
   reportedStatuses = /* @__PURE__ */ new Map();
+  // Live viewer orchestration (bb-viewer streamer subprocesses + viewer nav)
+  // lives in BrowserViewerStreamer; the manager hands it the account-scoped
+  // bb-browser command path via the host interface.
+  viewer;
   constructor(opts) {
     this.opts = opts;
     mkdirSync5(this.opts.homeDir, { recursive: true });
+    this.viewer = new BrowserViewerStreamer({
+      log: this.opts.log,
+      sendBrowserCommand: (request3) => this.sendCommand(request3),
+      ensureAccount: (account) => this.ensureAccount(account),
+      withDaemonRecovery: (operation, label) => this.withDaemonRecovery(operation, label),
+      cdpEndpoint: () => this.cdpEndpoint()
+    });
   }
   async invoke({ profileId, account, command, input }) {
     if (!profileId)
@@ -32096,12 +32725,14 @@ var BrowserProfileManager = class {
     if (!profileId)
       throw new Error("browser profile id is required");
     this.reportedStatuses.delete(profileId);
+    this.viewer.killProfileStreamer(profileId);
     this.reportStatus(profileId, "stopped");
   }
   async resetProfile(profileId) {
     if (!profileId)
       throw new Error("browser profile id is required");
     this.reportedStatuses.delete(profileId);
+    this.viewer.killProfileStreamer(profileId);
     try {
       await this.withDaemonRecovery(() => this.resetProfileOnce(profileId), `reset profile ${profileId}`);
       this.reportStatus(profileId, "stopped");
@@ -32112,6 +32743,7 @@ var BrowserProfileManager = class {
     }
   }
   async stop() {
+    this.viewer.shutdown();
     const daemon = this.daemon;
     this.daemon = null;
     this.starting = null;
@@ -32128,6 +32760,25 @@ var BrowserProfileManager = class {
       daemon.child.kill("SIGTERM");
     }
   }
+  /**
+   * Viewer control command entrypoint — delegates to BrowserViewerStreamer
+   * (browser-viewer-streamer.ts), which owns the per-profile bb-viewer
+   * subprocesses and viewer tab navigation.
+   */
+  async handleViewerCommand(profileId, sessionId, command, input, turn) {
+    return this.viewer.handleViewerCommand(profileId, sessionId, command, input, turn);
+  }
+  /** Read cdpHost/cdpPort from the bb-browser daemon `GET /status`. */
+  async cdpEndpoint() {
+    const daemon = await this.ensureDaemon();
+    const status = await this.post("/status", daemon, void 0, 5e3);
+    const host = status.cdpHost?.trim();
+    const port = status.cdpPort;
+    if (!host || typeof port !== "number" || !Number.isFinite(port)) {
+      throw new Error("bb-browser /status did not report a CDP endpoint");
+    }
+    return { host, port };
+  }
   async prepareOpenProfile(profileId, url) {
     const accountCreated = await this.ensureAccount(profileId, url !== "about:blank" ? url : void 0);
     await this.sendCommand({ method: "tab_list", account: profileId });
@@ -32386,7 +33037,7 @@ var BrowserProfileManager = class {
     const port = await findFreePort();
     const token = randomToken();
     const daemonPath = resolveBbBrowserDaemonPath();
-    const child = spawn3(process.execPath, [daemonPath, "--host", host, "--port", String(port), "--token", token], {
+    const child = spawn4(process.execPath, [daemonPath, "--host", host, "--port", String(port), "--token", token], {
       env: {
         ...process.env,
         BB_BROWSER_HOME: this.opts.homeDir
@@ -32500,10 +33151,6 @@ function comparableUrl(url) {
     return null;
   }
 }
-function formatErrorForLog(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  return message.replace(/\s+/g, " ").slice(0, 300);
-}
 function resolveBbBrowserDaemonPath() {
   const sibling = path9.join(path9.dirname(fileURLToPath(import.meta.url)), "bb-browser-daemon.js");
   if (existsSync8(sibling))
@@ -32518,29 +33165,9 @@ function resolveBbBrowserDaemonPath() {
   }
   return full;
 }
-async function findFreePort() {
-  return new Promise((resolve8, reject) => {
-    const server = net.createServer();
-    server.unref();
-    server.on("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      server.close(() => {
-        if (address && typeof address === "object") {
-          resolve8(address.port);
-        } else {
-          reject(new Error("failed to allocate free port"));
-        }
-      });
-    });
-  });
-}
 function randomToken() {
   return randomBytes(16).toString("hex");
 }
-function sleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
-}
 
 // ts/daemon/dist/supervisor.js
 init_config();
@@ -32940,7 +33567,7 @@ function shellQuote(value) {
 }
 
 // ts/daemon/dist/workspace.js
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import * as fs11 from "node:fs";
 import * as path12 from "node:path";
@@ -33244,7 +33871,7 @@ function runCommand(cmd, args, cwd, timeoutMs = 12e4, env = process.env) {
         clearTimeout(killTimer);
       fn();
     };
-    const child = spawn4(cmd, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn5(cmd, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
     timeoutTimer = setTimeout(() => {
       timedOut = true;
       child.kill("SIGTERM");
@@ -33397,7 +34024,12 @@ var DaemonSupervisor = class {
   children = /* @__PURE__ */ new Map();
   spawningAgents = /* @__PURE__ */ new Set();
   pendingWorkspaceSetup = /* @__PURE__ */ new Set();
-  browserProfileLifecycleQueues = /* @__PURE__ */ new Map();
+  // ONE queue per profile for BOTH lifecycle (open/stop/reset) and viewer
+  // (stream.*/nav) commands. They mutate the same streamer + account state, so
+  // two independent queues would let a stop/reset interleave with an in-flight
+  // stream.start (the kill fires before the streamer registers and misses it,
+  // leaving a live streamer on a profile the server just marked stopped).
+  browserProfileOpQueues = /* @__PURE__ */ new Map();
   workspaceSetupRetryTimers = /* @__PURE__ */ new Map();
   cancelledSpawns = /* @__PURE__ */ new Set();
   ws = null;
@@ -33558,6 +34190,10 @@ var DaemonSupervisor = class {
       this.log.info(`WS: browser profile lifecycle requested \u2014 profile=${data.profile_id} action=${data.action}`);
       void this.enqueueBrowserProfileLifecycle(data);
     });
+    this.ws.on("machine.browser_profile.viewer", (data) => {
+      this.log.info(`WS: browser profile viewer command \u2014 profile=${data.profile_id} command=${data.command}`);
+      this.enqueueBrowserProfileViewer(data);
+    });
     this.ws.onStateChange((state) => {
       if (state === "disconnected" || state === "reconnecting") {
         this.log.warn(`machine WS state: ${state}`);
@@ -33869,17 +34505,45 @@ var DaemonSupervisor = class {
     }
   }
   enqueueBrowserProfileLifecycle(data) {
-    const previous = this.browserProfileLifecycleQueues.get(data.profile_id) ?? Promise.resolve();
+    return this.enqueueBrowserProfileOp(data.profile_id, () => this.handleBrowserProfileLifecycle(data));
+  }
+  enqueueBrowserProfileOp(profileId, op) {
+    const previous = this.browserProfileOpQueues.get(profileId) ?? Promise.resolve();
     const next = previous.catch(() => {
-    }).then(() => this.handleBrowserProfileLifecycle(data));
-    this.browserProfileLifecycleQueues.set(data.profile_id, next);
+    }).then(op);
+    this.browserProfileOpQueues.set(profileId, next);
     void next.finally(() => {
-      if (this.browserProfileLifecycleQueues.get(data.profile_id) === next) {
-        this.browserProfileLifecycleQueues.delete(data.profile_id);
+      if (this.browserProfileOpQueues.get(profileId) === next) {
+        this.browserProfileOpQueues.delete(profileId);
       }
     });
     return next;
   }
+  /**
+   * Handle one viewer control command and reply via REST. Always answers the
+   * request/reply bridge exactly once ({result} on success, {error:{message}}
+   * on failure) and never throws into the WS event loop — mirrors
+   * handleFilesystemBrowse. Serialized per profile by enqueueBrowserProfileViewer.
+   */
+  async handleBrowserProfileViewer(data) {
+    if (!this.browserProfileManager) {
+      await this.client.postBrowserProfileViewerResponse(data.request_id, {
+        error: { message: "Browser profile runtime is disabled on this daemon" }
+      }).catch((err) => this.log.warn(`browser profile viewer negative ACK failed: ${String(err)}`));
+      return;
+    }
+    try {
+      const result = await this.browserProfileManager.handleViewerCommand(data.profile_id, data.session_id, data.command, data.input, data.turn);
+      await this.client.postBrowserProfileViewerResponse(data.request_id, { result });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.log.warn(`browser profile viewer command failed (profile=${data.profile_id}, command=${data.command}): ${message}`);
+      await this.client.postBrowserProfileViewerResponse(data.request_id, { error: { message } }).catch((replyErr) => this.log.warn(`browser profile viewer error ACK failed: ${String(replyErr)}`));
+    }
+  }
+  enqueueBrowserProfileViewer(data) {
+    void this.enqueueBrowserProfileOp(data.profile_id, () => this.handleBrowserProfileViewer(data));
+  }
   async handleClipSync(_data) {
     await this.reconcileMachineClips();
   }
@@ -34356,7 +35020,7 @@ var DaemonSupervisor = class {
     const env = adapter.buildEnv(baseEnv, state.agentId, state.orgId, state.credential.api_key, dirs, effectiveProviderConfig);
     const spawnCmd = adapter.args.length > 0 ? `${adapter.bin} ${adapter.args.join(" ")}` : adapter.bin;
     this.log.info(`spawning agent ${state.agentId} runtime=${state.runtimeType} cmd=${spawnCmd} (attempt ${state.restartAttempts + 1})`);
-    const child = spawn5(adapter.bin, adapter.args, {
+    const child = spawn6(adapter.bin, adapter.args, {
       env,
       stdio: ["ignore", "inherit", "inherit"],
       detached: false