browser-pilot-cli 0.4.0 → 0.5.0

package/dist/daemon.js

@@ -291,6 +291,7 @@ var ERROR_CODES = [
   "action_not_verified",
   "command_cancelled",
   "command_expired",
+  "wait_timeout",
   "unknown_outcome",
   "artifact_not_found",
   "artifact_expired",
@@ -1896,7 +1897,7 @@ function schemaSensitivities(schema, result = /* @__PURE__ */ new Set()) {
   }
   return result;
 }
-function assertToolManifest(definitions = TOOL_DEFINITIONS) {
+function assertToolDefinitions(definitions = TOOL_DEFINITIONS) {
   const names = /* @__PURE__ */ new Set();
   const knownCapabilities = new Set(CAPABILITIES);
   for (const definition of definitions) {
@@ -1960,13 +1961,7 @@ function validateToolResult(name, value) {
   assertSchemaValue(definition.outputSchema, value, `${name} result`);
   return value;
 }
-function getToolManifest(capabilities, availableTools, protocol) {
-  const granted = capabilities ? new Set(capabilities) : null;
-  const available = availableTools ? new Set(availableTools) : null;
-  const tools = TOOL_DEFINITIONS.filter((definition) => (!granted || definition.requiredCapabilities.every((capability) => granted.has(capability))) && (!available || available.has(definition.name)) && (!protocol || isToolAvailableInProtocol(definition.name, protocol)));
-  return { schemaVersion: 1, tools };
-}
-assertToolManifest();
+assertToolDefinitions();
 
 // src/protocol/validation.ts
 var CLIENT_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{2,127}$/;
@@ -1978,6 +1973,21 @@ var TARGET_ID_PATTERN = /^target:[A-Za-z0-9._:-]+$/;
 var ARTIFACT_ID_PATTERN = /^artifact:[A-Za-z0-9._:-]+$/;
 var COMMAND_ID_PATTERN = /^command:[A-Za-z0-9._:-]+$/;
 var EVENT_CURSOR_PATTERN = /^cursor:(0|[1-9][0-9]{0,15})$/;
+var COMMAND_STATUSES = /* @__PURE__ */ new Set([
+  "accepted",
+  "dispatched",
+  "completed",
+  "unknown_outcome",
+  "cancelled",
+  "expired"
+]);
+var ARTIFACT_KINDS = /* @__PURE__ */ new Set([
+  "screenshot",
+  "screenshot_preview",
+  "pdf",
+  "download",
+  "upload_input"
+]);
 var MIN_NEGOTIATED_TRANSPORT_BYTES = 64 * 1024;
 var MAX_DECLARED_TRANSPORT_BYTES = 1024 * 1024 * 1024;
 function isRecord2(value) {
@@ -2103,17 +2113,13 @@ function parseTransportLimitPreferences(value) {
 }
 function validateInitializeParams(value) {
   if (!isRecord2(value)) throw invalidArgument("initialize params must be an object", "params");
-  assertOnlyKeys(value, ["client", "protocol", "requestedCapabilities", "launchMode", "limits"]);
+  assertOnlyKeys(value, ["client", "protocol", "requestedCapabilities", "limits"]);
   if (!isRecord2(value.client)) throw invalidArgument("client must be an object", "client");
   assertOnlyKeys(value.client, ["id", "name", "version", "instanceId"], "client");
   const requested = value.requestedCapabilities;
   if (!Array.isArray(requested) || requested.some((item) => typeof item !== "string" || item.length === 0 || item.length > 128)) {
     throw invalidArgument("requestedCapabilities must be an array of non-empty strings", "requestedCapabilities");
   }
-  const launchMode = value.launchMode;
-  if (launchMode !== "one-shot" && launchMode !== "embedded") {
-    throw invalidArgument("launchMode must be one-shot or embedded", "launchMode");
-  }
   return {
     client: {
       id: requireString(value.client, "id", { pattern: CLIENT_ID_PATTERN, maxLength: 128 }),
@@ -2123,7 +2129,6 @@ function validateInitializeParams(value) {
     },
     protocol: parseProtocolRange(value.protocol),
     requestedCapabilities: [...new Set(requested)],
-    launchMode,
     ...value.limits !== void 0 ? { limits: parseTransportLimitPreferences(value.limits) } : {}
   };
 }
@@ -2143,9 +2148,6 @@ function validateTtlMs(record2) {
 function validateOpaqueId(record2, key, pattern) {
   return requireString(record2, key, { pattern, maxLength: 128 });
 }
-function validateToolsListParams(value) {
-  return validateOptionalEmptyParams(value);
-}
 function validateShutdownParams(value) {
   return validateOptionalEmptyParams(value);
 }
@@ -2201,6 +2203,25 @@ function validateCommandAccessParams(value) {
     } : {}
   };
 }
+function validateCommandListParams(value) {
+  if (!isRecord2(value)) throw invalidArgument("Command list params must be an object", "params");
+  assertOnlyKeys(value, ["workspaceId", "limit", "statuses"]);
+  if (value.limit !== void 0 && (!Number.isSafeInteger(value.limit) || Number(value.limit) < 1 || Number(value.limit) > 100)) {
+    throw invalidArgument("limit must be an integer from 1 through 100", "limit");
+  }
+  if (value.statuses !== void 0 && (!Array.isArray(value.statuses) || value.statuses.length === 0 || value.statuses.some((status) => typeof status !== "string" || !COMMAND_STATUSES.has(status)))) {
+    throw invalidArgument("statuses must contain valid Command statuses", "statuses");
+  }
+  return {
+    workspaceId: validateOpaqueId(
+      value,
+      "workspaceId",
+      WORKSPACE_ID_PATTERN
+    ),
+    ...value.limit !== void 0 ? { limit: Number(value.limit) } : {},
+    ...value.statuses !== void 0 ? { statuses: value.statuses } : {}
+  };
+}
 function validateEventsPollParams(value) {
   if (!isRecord2(value)) throw invalidArgument("events/poll params must be an object", "params");
   assertOnlyKeys(value, ["workspaceId", "cursor", "limit"]);
@@ -2226,6 +2247,18 @@ function validateArtifactAccessParams(value) {
     artifactId: validateOpaqueId(value, "artifactId", ARTIFACT_ID_PATTERN)
   };
 }
+function validateArtifactListParams(value) {
+  if (!isRecord2(value)) throw invalidArgument("Artifact list params must be an object", "params");
+  assertOnlyKeys(value, ["workspaceId", "leaseId", "kinds"]);
+  if (value.kinds !== void 0 && (!Array.isArray(value.kinds) || value.kinds.length === 0 || value.kinds.some((kind) => typeof kind !== "string" || !ARTIFACT_KINDS.has(kind)))) {
+    throw invalidArgument("kinds must contain valid Artifact kinds", "kinds");
+  }
+  return {
+    workspaceId: validateOpaqueId(value, "workspaceId", WORKSPACE_ID_PATTERN),
+    leaseId: validateOpaqueId(value, "leaseId", LEASE_ID_PATTERN),
+    ...value.kinds !== void 0 ? { kinds: value.kinds } : {}
+  };
+}
 function validateArtifactExportParams(value) {
   if (!isRecord2(value)) throw invalidArgument("artifacts/export params must be an object", "params");
   assertOnlyKeys(value, ["workspaceId", "leaseId", "artifactId", "path", "overwrite"]);
@@ -2437,6 +2470,11 @@ var MemoryCommandRuntime = class {
     this.sweep();
     return this.outcome(this.requireOwned(context));
   }
+  list(context) {
+    this.sweep();
+    const statuses = context.statuses ? new Set(context.statuses) : void 0;
+    return [...this.records.values()].filter((record2) => record2.principalId === context.principalId && record2.workspaceId === context.workspaceId && (!statuses || statuses.has(record2.status))).sort((left, right) => right.acceptedAt - left.acceptedAt).slice(0, context.limit ?? 20).map(descriptor);
+  }
   cancel(context) {
     this.sweep();
     const record2 = this.requireOwned(context);
@@ -2899,7 +2937,6 @@ var MemoryBrokerRuntime = class {
         preserveIfGenerationStale: true
       });
     }));
-    this.listenerCleanup.push(this.events.subscribe((event) => this.deliverNotification(event)));
     options.toolExecutor?.setEventPublisher?.((event) => {
       this.publishBrowserEvent(event);
     });
@@ -2936,7 +2973,7 @@ var MemoryBrokerRuntime = class {
   limits;
   principals = /* @__PURE__ */ new Map();
   principalIdsByKey = /* @__PURE__ */ new Map();
-  connectionsByBridge = /* @__PURE__ */ new Map();
+  connectionsByClientSession = /* @__PURE__ */ new Map();
   connectionsById = /* @__PURE__ */ new Map();
   workspaces = /* @__PURE__ */ new Map();
   leases = /* @__PURE__ */ new Map();
@@ -2959,30 +2996,27 @@ var MemoryBrokerRuntime = class {
   events;
   listenerCleanup = [];
   workspaceCleanup = /* @__PURE__ */ new Map();
-  async call(bridgeSessionId, method, params) {
-    this.assertBridgeSessionId(bridgeSessionId);
+  async call(clientSessionId, method, params) {
+    this.assertClientSessionId(clientSessionId);
     this.sweepExpiredLeases();
-    if (method === "initialize") return this.initialize(bridgeSessionId, params);
-    const connection = this.requireConnection(bridgeSessionId);
+    if (method === "initialize") return this.initialize(clientSessionId, params);
+    const connection = this.requireConnection(clientSessionId);
     connection.value.lastSeenAt = this.now();
     switch (method) {
-      case "tools/list":
-        validateToolsListParams(params);
-        return asJson(getToolManifest(
-          connection.grantedCapabilities,
-          this.options.toolExecutor?.supportedTools,
-          connection.value.protocol
-        ));
       case "tools/call":
         return this.callTool(connection, params);
       case "commands/get":
         return this.getCommand(connection, params);
+      case "commands/list":
+        return this.listCommands(connection, params);
       case "commands/cancel":
         return this.cancelCommand(connection, params);
       case "events/poll":
         return this.pollEvents(connection, params);
       case "artifacts/get":
         return this.getArtifact(connection, params);
+      case "artifacts/list":
+        return this.listArtifacts(connection, params);
       case "artifacts/export":
         return this.exportArtifact(connection, params);
       case "artifacts/import":
@@ -3013,12 +3047,11 @@ var MemoryBrokerRuntime = class {
         });
     }
   }
-  disconnect(bridgeSessionId) {
-    const connection = this.connectionsByBridge.get(bridgeSessionId);
+  disconnect(clientSessionId) {
+    const connection = this.connectionsByClientSession.get(clientSessionId);
     if (!connection) return;
     this.commands.releaseConnection(connection.value.id);
-    this.resolveNotificationWaiter(connection, void 0);
-    this.connectionsByBridge.delete(bridgeSessionId);
+    this.connectionsByClientSession.delete(clientSessionId);
     this.connectionsById.delete(connection.value.id);
     for (const [leaseId, lease] of this.leases) {
       if (lease.connectionId !== connection.value.id) continue;
@@ -3028,40 +3061,11 @@ var MemoryBrokerRuntime = class {
     this.cleanupUnusedPrincipal(connection.value.principalId);
   }
   close() {
-    for (const bridgeSessionId of [...this.connectionsByBridge.keys()]) {
-      this.disconnect(bridgeSessionId);
+    for (const clientSessionId of [...this.connectionsByClientSession.keys()]) {
+      this.disconnect(clientSessionId);
     }
     for (const cleanup2 of this.listenerCleanup.splice(0)) cleanup2();
   }
-  async nextNotification(bridgeSessionId, options = {}) {
-    const connection = this.requireConnection(bridgeSessionId);
-    const waitMs = options.waitMs ?? 25e3;
-    if (!Number.isSafeInteger(waitMs) || waitMs < 0 || waitMs > 3e4) {
-      throw invalidArgument("Notification waitMs must be from 0 through 30000", "waitMs");
-    }
-    const queued = connection.notifications.shift();
-    if (queued || waitMs === 0 || options.signal?.aborted) return queued;
-    if (connection.notificationWaiter) {
-      throw invalidArgument("Only one notification poll may be active per bridge Connection");
-    }
-    return new Promise((resolve3) => {
-      const waiter = { resolve: resolve3, signal: options.signal };
-      const finish = () => this.resolveNotificationWaiter(connection, void 0);
-      waiter.timer = setTimeout(finish, waitMs);
-      waiter.timer.unref();
-      if (options.signal) {
-        waiter.onAbort = finish;
-        options.signal.addEventListener("abort", finish, { once: true });
-      }
-      connection.notificationWaiter = waiter;
-    });
-  }
-  async *notifications(bridgeSessionId, signal) {
-    while (!signal.aborted) {
-      const notification = await this.nextNotification(bridgeSessionId, { waitMs: 3e4, signal });
-      if (notification) yield notification;
-    }
-  }
   publishBrowserEvent(input) {
     const workspace = this.workspaces.get(input.workspaceId);
     if (!workspace || workspace.value.state !== "active") return void 0;
@@ -3159,9 +3163,9 @@ var MemoryBrokerRuntime = class {
         expired += 1;
       }
     }
-    for (const connection of [...this.connectionsByBridge.values()]) {
+    for (const connection of [...this.connectionsByClientSession.values()]) {
       if (connection.value.lastSeenAt + this.connectionIdleTtlMs <= now) {
-        this.disconnect(connection.bridgeSessionId);
+        this.disconnect(connection.clientSessionId);
       }
     }
     const leasedWorkspaceIds = /* @__PURE__ */ new Set();
@@ -3178,32 +3182,25 @@ var MemoryBrokerRuntime = class {
   stats() {
     return {
       principals: this.principals.size,
-      connections: this.connectionsByBridge.size,
+      connections: this.connectionsByClientSession.size,
       activeWorkspaces: [...this.workspaces.values()].filter((record2) => record2.value.state === "active").length,
       activeLeases: [...this.leases.values()].filter((lease) => lease.state === "active").length
     };
   }
   lifecycleSummary() {
-    let embeddedConnections = 0;
-    let oneShotConnections = 0;
-    for (const connection of this.connectionsByBridge.values()) {
-      if (connection.value.launchMode === "embedded") embeddedConnections += 1;
-      else oneShotConnections += 1;
-    }
     const stats = this.stats();
     return {
-      embeddedConnections,
-      oneShotConnections,
+      connections: stats.connections,
       activeWorkspaces: stats.activeWorkspaces,
       activeLeases: stats.activeLeases
     };
   }
-  initialize(bridgeSessionId, value) {
+  initialize(clientSessionId, value) {
     const params = validateInitializeParams(value);
-    const existing = this.connectionsByBridge.get(bridgeSessionId);
+    const existing = this.connectionsByClientSession.get(clientSessionId);
     if (existing) {
-      if (params.launchMode !== "one-shot" || existing.value.launchMode !== "one-shot" || existing.client.id !== params.client.id || existing.client.name !== params.client.name || existing.client.version !== params.client.version || existing.client.instanceId !== params.client.instanceId) {
-        throw invalidArgument("This bridge connection is already initialized", "method");
+      if (existing.client.id !== params.client.id || existing.client.name !== params.client.name || existing.client.version !== params.client.version || existing.client.instanceId !== params.client.instanceId) {
+        throw invalidArgument("This client session is already initialized", "method");
       }
       const protocol2 = negotiateProtocol(params.protocol);
       if (params.limits && (protocol2.major < 1 || protocol2.major === 1 && protocol2.minor < 1)) {
@@ -3214,10 +3211,10 @@ var MemoryBrokerRuntime = class {
       const capabilities2 = negotiateCapabilities(params.requestedCapabilities, this.allowedCapabilities);
       const limits2 = negotiateProtocolLimits(params.limits, this.limits);
       if (protocol2.major !== existing.value.protocol.major || protocol2.minor !== existing.value.protocol.minor || capabilities2.granted.length !== existing.grantedCapabilities.length || capabilities2.granted.some((capability, index) => capability !== existing.grantedCapabilities[index]) || limits2.maxMessageBytes !== existing.limits.maxMessageBytes || limits2.maxResultBytes !== existing.limits.maxResultBytes || limits2.maxArtifactBytes !== existing.limits.maxArtifactBytes || limits2.eventJournalSize !== existing.limits.eventJournalSize) {
-        throw new BrowserPilotError("protocol_incompatible", "One-shot connection cannot change its negotiated contract", {
+        throw new BrowserPilotError("protocol_incompatible", "Client session cannot change its negotiated contract", {
           remediation: {
             code: "restart_browser_pilot",
-            message: "Restart Browser Pilot before using a different one-shot protocol contract.",
+            message: "Restart Browser Pilot before using a different client protocol contract.",
             actionRequired: true
           }
         });
@@ -3235,7 +3232,7 @@ var MemoryBrokerRuntime = class {
         limits: { ...existing.limits }
       });
     }
-    if (this.connectionsByBridge.size >= this.maxConnections) {
+    if (this.connectionsByClientSession.size >= this.maxConnections) {
       throw new BrowserPilotError("result_too_large", "Broker connection limit reached", {
         context: { maxConnections: this.maxConnections }
       });
@@ -3255,7 +3252,6 @@ var MemoryBrokerRuntime = class {
       id: connectionId,
       principalId: principal.id,
       clientInstanceId: params.client.instanceId,
-      launchMode: params.launchMode,
       protocol,
       connectedAt: now,
       lastSeenAt: now
@@ -3273,13 +3269,12 @@ var MemoryBrokerRuntime = class {
     };
     const connection = {
       value: connectionValue,
-      bridgeSessionId,
+      clientSessionId,
       client: { ...params.client },
       grantedCapabilities: [...capabilities.granted],
-      limits,
-      notifications: []
+      limits
     };
-    this.connectionsByBridge.set(bridgeSessionId, connection);
+    this.connectionsByClientSession.set(clientSessionId, connection);
     this.connectionsById.set(connectionId, connection);
     return asJson(initializeResult);
   }
@@ -3471,10 +3466,10 @@ var MemoryBrokerRuntime = class {
     this.principals.set(id, principal);
     return principal;
   }
-  requireConnection(bridgeSessionId) {
-    const connection = this.connectionsByBridge.get(bridgeSessionId);
+  requireConnection(clientSessionId) {
+    const connection = this.connectionsByClientSession.get(clientSessionId);
     if (connection) return connection;
-    throw new BrowserPilotError("not_initialized", "Bridge connection is not initialized", {
+    throw new BrowserPilotError("not_initialized", "Client session is not initialized", {
       rpcCode: -32002
     });
   }
@@ -3614,7 +3609,7 @@ var MemoryBrokerRuntime = class {
     }
   }
   cleanupUnusedPrincipal(principalId) {
-    const hasConnection = [...this.connectionsByBridge.values()].some((connection) => connection.value.principalId === principalId);
+    const hasConnection = [...this.connectionsByClientSession.values()].some((connection) => connection.value.principalId === principalId);
     const hasWorkspace = [...this.workspaces.values()].some((record2) => record2.value.principalId === principalId);
     if (hasConnection || hasWorkspace) return;
     const principal = this.principals.get(principalId);
@@ -3822,36 +3817,6 @@ var MemoryBrokerRuntime = class {
     this.requireWorkspace(connection, params.workspaceId, true);
     return asJson(this.events.poll(params.workspaceId, params.cursor, params.limit));
   }
-  deliverNotification(event) {
-    const workspace = this.workspaces.get(event.workspaceId);
-    if (!workspace) return;
-    const notification = {
-      jsonrpc: "2.0",
-      method: "events/event",
-      params: { event }
-    };
-    for (const connection of this.connectionsByBridge.values()) {
-      if (connection.value.principalId !== workspace.value.principalId || !connection.grantedCapabilities.includes("event.read")) continue;
-      if (connection.notificationWaiter) {
-        this.resolveNotificationWaiter(connection, structuredClone(notification));
-        continue;
-      }
-      connection.notifications.push(structuredClone(notification));
-      if (connection.notifications.length > connection.limits.eventJournalSize) {
-        connection.notifications.shift();
-      }
-    }
-  }
-  resolveNotificationWaiter(connection, notification) {
-    const waiter = connection.notificationWaiter;
-    if (!waiter) return;
-    connection.notificationWaiter = void 0;
-    if (waiter.timer) clearTimeout(waiter.timer);
-    if (waiter.signal && waiter.onAbort) {
-      waiter.signal.removeEventListener("abort", waiter.onAbort);
-    }
-    waiter.resolve(notification);
-  }
   getCommand(connection, value) {
     const params = validateCommandAccessParams(value);
     if (params.workspaceId) this.requireWorkspace(connection, params.workspaceId, true);
@@ -3861,6 +3826,18 @@ var MemoryBrokerRuntime = class {
       ...params.workspaceId ? { workspaceId: params.workspaceId } : {}
     }));
   }
+  listCommands(connection, value) {
+    const params = validateCommandListParams(value);
+    this.requireWorkspace(connection, params.workspaceId, true);
+    return asJson({
+      commands: this.commands.list({
+        principalId: connection.value.principalId,
+        workspaceId: params.workspaceId,
+        ...params.limit !== void 0 ? { limit: params.limit } : {},
+        ...params.statuses ? { statuses: params.statuses } : {}
+      })
+    });
+  }
   cancelCommand(connection, value) {
     const params = validateCommandAccessParams(value);
     if (params.workspaceId) this.requireWorkspace(connection, params.workspaceId, true);
@@ -3881,6 +3858,13 @@ var MemoryBrokerRuntime = class {
     const record2 = await this.requireArtifactStore().get(params.workspaceId, params.artifactId);
     return asJson({ artifact: record2.descriptor, path: record2.path });
   }
+  async listArtifacts(connection, value) {
+    const params = validateArtifactListParams(value);
+    this.requireArtifactContext(connection, params.workspaceId, params.leaseId);
+    return asJson({
+      artifacts: await this.requireArtifactStore().list(params.workspaceId, params.kinds)
+    });
+  }
   async exportArtifact(connection, value) {
     const params = validateArtifactExportParams(value);
     this.requireArtifactContext(connection, params.workspaceId, params.leaseId);
@@ -3944,9 +3928,9 @@ var MemoryBrokerRuntime = class {
       context: { leaseId: lease.id, missingCapabilities: missing }
     });
   }
-  assertBridgeSessionId(value) {
+  assertClientSessionId(value) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{2,127}$/.test(value)) {
-      throw invalidArgument("Invalid internal bridge session ID", "bridgeSessionId");
+      throw invalidArgument("Invalid internal client session ID", "clientSessionId");
     }
   }
   nextId(kind, records) {
@@ -5164,6 +5148,7 @@ import { spawn } from "child_process";
 // src/client.ts
 import http from "http";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+var BROKER_RPC_VERSION = 2;
 
 // src/chrome.ts
 import { createHash as createHash3 } from "crypto";
@@ -10933,7 +10918,10 @@ var BrowserToolService = class {
           context: { workspaceId: workspace.id }
         });
       }
+      this.markDispatched(context);
       await this.connectBrowser();
+    } else {
+      this.markDispatched(context);
     }
     if (this.binding.instance.state !== "connected") {
       throw new BrowserPilotError("browser_disconnected", "Browser connection did not become ready", {
@@ -10941,7 +10929,6 @@ var BrowserToolService = class {
         context: { workspaceId: workspace.id }
       });
     }
-    this.markDispatched(context);
     return asJson2({
       workspaceId: workspace.id,
       leaseId: lease.id,
@@ -13604,6 +13591,13 @@ var ArtifactStore = class {
   async get(workspaceId, artifactId) {
     return this.withLock(async () => clone2(await this.requireRecordUnlocked(workspaceId, artifactId)));
   }
+  async list(workspaceId, kinds) {
+    return this.withLock(async () => {
+      await this.sweepUnlocked();
+      const selectedKinds = kinds ? new Set(kinds) : void 0;
+      return [...this.records.values()].filter((record2) => record2.descriptor.workspaceId === workspaceId && (!selectedKinds || selectedKinds.has(record2.descriptor.kind))).sort((left, right) => right.descriptor.createdAt - left.descriptor.createdAt).map((record2) => ({ ...record2.descriptor }));
+    });
+  }
   async export(workspaceId, artifactId, destination, overwrite = false) {
     if (!isAbsolute4(destination)) throw invalidArgument("Artifact export path must be absolute", "path");
     const target = resolve2(destination);
@@ -14317,7 +14311,7 @@ var ManagedTargetJanitorClient = class {
 };
 
 // src/version.ts
-var BROWSER_PILOT_VERSION = "0.4.0";
+var BROWSER_PILOT_VERSION = "0.5.0";
 
 // src/daemon.ts
 var CLI_EXECUTABLE_PATH = publicExecutablePath(import.meta.url);
@@ -14843,7 +14837,7 @@ async function main() {
         res.end(JSON.stringify({
           ok: true,
           wsUrl: currentWsUrl,
-          brokerProtocol: 1,
+          brokerProtocol: BROKER_RPC_VERSION,
           brokerProcessIdentity,
           serviceVersion: BROWSER_PILOT_VERSION,
           executableVersion: executable.version,
@@ -14871,14 +14865,14 @@ async function main() {
           }
           const body = JSON.parse(await readBody(req, DEFAULT_PROTOCOL_LIMITS.maxMessageBytes + 4096));
           if (!isRecord3(body)) throw invalidArgument("Broker RPC body must be an object", "body");
-          if (typeof body.bridgeSessionId !== "string") {
-            throw invalidArgument("bridgeSessionId is required", "bridgeSessionId");
+          if (typeof body.clientSessionId !== "string") {
+            throw invalidArgument("clientSessionId is required", "clientSessionId");
           }
           if (typeof body.method !== "string" || body.method.length === 0 || body.method.length > 256) {
             throw invalidArgument("method is required", "method");
           }
           const result = await broker.call(
-            body.bridgeSessionId,
+            body.clientSessionId,
             body.method,
             body.params
           );
@@ -14891,47 +14885,6 @@ async function main() {
           return;
         }
       }
-      if (req.method === "POST" && url.pathname === "/broker/disconnect") {
-        try {
-          const body = JSON.parse(await readBody(req, 4096));
-          if (!isRecord3(body) || typeof body.bridgeSessionId !== "string") {
-            throw invalidArgument("bridgeSessionId is required", "bridgeSessionId");
-          }
-          broker.disconnect(body.bridgeSessionId);
-          res.writeHead(200);
-          res.end(JSON.stringify({ ok: true }));
-          return;
-        } catch (error) {
-          res.writeHead(200);
-          res.end(JSON.stringify({ error: asBrowserPilotError(error).toJsonRpcError() }));
-          return;
-        }
-      }
-      if (req.method === "POST" && url.pathname === "/broker/events/next") {
-        const abort = new AbortController();
-        res.once("close", () => abort.abort());
-        try {
-          const body = JSON.parse(await readBody(req, 4096));
-          if (!isRecord3(body) || typeof body.bridgeSessionId !== "string" || !Number.isSafeInteger(body.waitMs)) {
-            throw invalidArgument("bridgeSessionId and integer waitMs are required");
-          }
-          const notification = await broker.nextNotification(body.bridgeSessionId, {
-            waitMs: Number(body.waitMs),
-            signal: abort.signal
-          });
-          if (!res.destroyed) {
-            res.writeHead(200);
-            res.end(JSON.stringify({ notification }));
-          }
-          return;
-        } catch (error) {
-          if (!res.destroyed) {
-            res.writeHead(200);
-            res.end(JSON.stringify({ error: asBrowserPilotError(error).toJsonRpcError() }));
-          }
-          return;
-        }
-      }
       if (req.method === "POST" && url.pathname === "/cdp") {
         const body = await readBody(req);
         const { method, params, sessionId } = JSON.parse(body);
@@ -15012,7 +14965,7 @@ async function main() {
             });
           }
           const clients = broker.lifecycleSummary();
-          if (clients.embeddedConnections > 0 || clients.activeLeases > 0) {
+          if (clients.activeLeases > 0) {
             throw new BrowserPilotError("broker_in_use", "Browser Pilot has other live clients and cannot be stopped", {
               retryable: true,
               context: clients,