@browserbasehq/browse-cli 0.5.0-alpha-34598b9 → 0.5.0-alpha-a4ca430

package/README.md

@@ -239,7 +239,6 @@ browse status
 |----------|-------------|
 | `BROWSE_SESSION` | Default session name (alternative to `--session`) |
 | `BROWSERBASE_API_KEY` | Browserbase API key (required for `browse env remote`) |
-| `BROWSERBASE_PROJECT_ID` | Browserbase project ID (optional, passed through if set) |
 
 ## Element References
 

package/dist/index.js

@@ -14413,7 +14413,7 @@ var init_api2 = __esm({
       }),
       modelName: external_exports.string().meta({
         description: "Model name string with provider prefix (e.g., 'openai/gpt-5-nano')",
-        example: "openai/gpt-5-nano"
+        example: "openai/gpt-5.4-mini"
       }),
       apiKey: external_exports.string().optional().meta({
         description: "API key for the model provider",
@@ -14556,7 +14556,7 @@ var init_api2 = __esm({
     SessionStartRequestSchema = external_exports.object({
       modelName: external_exports.string().meta({
         description: "Model name to use for AI operations",
-        example: "openai/gpt-4o"
+        example: "openai/gpt-5.4-mini"
       }),
       domSettleTimeoutMs: external_exports.number().optional().meta({
         description: "Timeout in ms to wait for DOM to settle",
@@ -161660,9 +161660,6 @@ var StagehandAPIClient = class {
     browserbaseSessionID
     // browser,  TODO for local browsers
   }) {
-    if (!modelApiKey) {
-      throw new StagehandAPIError("modelApiKey is required");
-    }
     this.modelApiKey = modelApiKey;
     this.modelProvider = modelName?.includes("/") ? modelName.split("/")[0] : void 0;
     this.region = browserbaseSessionCreateParams?.region;
@@ -161943,7 +161940,7 @@ var StagehandAPIClient = class {
       const apiKey = provider && provider !== this.modelProvider ? loadApiKeyFromEnv(provider, this.logger) ?? this.modelApiKey : this.modelApiKey;
       return {
         modelName: model,
-        apiKey
+        ...apiKey ? { apiKey } : {}
       };
     }
     if (!model.apiKey) {
@@ -161951,7 +161948,7 @@ var StagehandAPIClient = class {
       const apiKey = provider && provider !== this.modelProvider ? loadApiKeyFromEnv(provider, this.logger) ?? this.modelApiKey : this.modelApiKey;
       return {
         ...model,
-        apiKey
+        ...apiKey ? { apiKey } : {}
       };
     }
     return model;
@@ -162078,7 +162075,7 @@ var StagehandAPIClient = class {
       "x-bb-session-id": this.sessionId,
       // we want real-time logs, so we stream the response
       "x-stream-response": "true",
-      "x-model-api-key": this.modelApiKey,
+      ...this.modelApiKey ? { "x-model-api-key": this.modelApiKey } : {},
       "x-language": "typescript",
       "x-sdk-version": STAGEHAND_VERSION
     };
@@ -164650,6 +164647,7 @@ var os3 = __toESM(require("os"));
 var net2 = __toESM(require("net"));
 var import_child_process4 = require("child_process");
 var readline = __toESM(require("readline"));
+var import_ws3 = __toESM(require("ws"));
 
 // package.json
 var version3 = "0.5.0";
@@ -166807,6 +166805,181 @@ networkCmd.command("clear").description("Clear all captured requests").action(as
     process.exit(1);
   }
 });
+var CDP_DEFAULT_DOMAINS = ["Network", "Console", "Runtime", "Log", "Page"];
+program.command("cdp <url|port>").description(
+  "Attach to a CDP target and stream DevTools protocol events as NDJSON.\nAccepts a WebSocket URL (ws://...) or a bare port number (e.g. 9222).\nOutput is one JSON object per line, suitable for piping to files or jq."
+).option(
+  "--domain <domains...>",
+  `CDP domains to enable (repeatable). Default: ${CDP_DEFAULT_DOMAINS.join(",")}`
+).option("--pretty", "Human-readable output instead of JSON").action(
+  async (target, cmdOpts) => {
+    const wsUrl = await resolveWsTarget(target);
+    const domains = cmdOpts.domain ?? CDP_DEFAULT_DOMAINS;
+    const usePretty = cmdOpts.pretty ?? process.stdout.isTTY ?? false;
+    let messageId = 1;
+    const pendingIds = /* @__PURE__ */ new Set();
+    const targetSessionMap = /* @__PURE__ */ new Map();
+    function sendCDP(ws, method, params = {}, sessionId) {
+      const id = messageId++;
+      pendingIds.add(id);
+      const msg = { id, method, params };
+      if (sessionId) msg.sessionId = sessionId;
+      ws.send(JSON.stringify(msg));
+      return id;
+    }
+    function enableDomainsForSession(ws, sessionId) {
+      for (const domain2 of domains) {
+        if (domain2 === "Network") {
+          sendCDP(
+            ws,
+            "Network.enable",
+            { maxTotalBufferSize: 1e6, maxResourceBufferSize: 1e5 },
+            sessionId
+          );
+        } else {
+          sendCDP(ws, `${domain2}.enable`, {}, sessionId);
+        }
+      }
+    }
+    function writeEvent(message) {
+      try {
+        process.stdout.write(JSON.stringify(message) + "\n");
+      } catch (err) {
+        if (err.code === "EPIPE") process.exit(0);
+        throw err;
+      }
+    }
+    function writePrettyEvent(message) {
+      if (!message.method) return;
+      const params = message.params;
+      let line = `[${message.method}]`;
+      try {
+        switch (message.method) {
+          case "Network.requestWillBeSent": {
+            const req = params?.request;
+            if (req) line += ` ${req.method ?? "?"} ${req.url ?? ""}`;
+            break;
+          }
+          case "Network.responseReceived": {
+            const resp = params?.response;
+            if (resp) line += ` ${resp.status ?? "?"} ${resp.url ?? ""}`;
+            break;
+          }
+          case "Network.loadingFailed": {
+            const errorText = params?.errorText ?? (params?.canceled ? "Canceled" : "Unknown");
+            line += ` ${errorText}`;
+            break;
+          }
+          case "Runtime.consoleAPICalled": {
+            const type = params?.type ?? "log";
+            const args = params?.args ?? [];
+            const text2 = args.map((a2) => a2.description ?? a2.value ?? "").join(" ");
+            line += ` [${type}] ${text2}`;
+            break;
+          }
+          case "Runtime.exceptionThrown": {
+            const detail = params?.exceptionDetails;
+            line += ` ${detail?.exception?.description ?? detail?.text ?? "Unknown exception"}`;
+            break;
+          }
+          case "Page.frameNavigated": {
+            const url2 = params?.frame?.url ?? "";
+            if (url2) line += ` ${url2}`;
+            break;
+          }
+          case "Target.attachedToTarget": {
+            const info = params?.targetInfo;
+            if (info) line += ` [${info.type ?? "?"}] ${info.url ?? ""}`;
+            break;
+          }
+          default:
+            break;
+        }
+      } catch {
+      }
+      try {
+        process.stdout.write(line + "\n");
+      } catch (err) {
+        if (err.code === "EPIPE") process.exit(0);
+        throw err;
+      }
+    }
+    const emit = usePretty ? writePrettyEvent : writeEvent;
+    await new Promise((resolve4) => {
+      const ws = new import_ws3.default(wsUrl);
+      let closed = false;
+      function cleanup() {
+        if (closed) return;
+        closed = true;
+        if (ws.readyState === import_ws3.default.OPEN || ws.readyState === import_ws3.default.CONNECTING) {
+          ws.close();
+        }
+        resolve4();
+      }
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+      ws.on("open", () => {
+        if (usePretty) {
+          process.stderr.write(`Connected to ${wsUrl}
+`);
+        }
+        sendCDP(ws, "Target.setAutoAttach", {
+          autoAttach: true,
+          flatten: true,
+          waitForDebuggerOnStart: false,
+          filter: [{ type: "page" }]
+        });
+        sendCDP(ws, "Target.setDiscoverTargets", {
+          discover: true,
+          filter: [{ type: "page" }]
+        });
+      });
+      ws.on("message", (raw) => {
+        let data;
+        try {
+          data = JSON.parse(raw.toString());
+        } catch {
+          return;
+        }
+        if (data.id !== void 0 && pendingIds.has(data.id)) {
+          pendingIds.delete(data.id);
+          if (data.error) {
+            process.stderr.write(
+              `CDP error (id=${data.id}): ${data.error.message}
+`
+            );
+          }
+          return;
+        }
+        if (data.method === "Target.attachedToTarget" && data.params) {
+          const p2 = data.params;
+          if (p2.targetInfo?.type === "page") {
+            targetSessionMap.set(p2.targetInfo.targetId, p2.sessionId);
+            enableDomainsForSession(ws, p2.sessionId);
+          }
+        }
+        if (data.method === "Target.detachedFromTarget" && data.params) {
+          const p2 = data.params;
+          const targetId = p2.targetId ?? [...targetSessionMap.entries()].find(
+            ([, sid]) => sid === p2.sessionId
+          )?.[0];
+          if (targetId) targetSessionMap.delete(targetId);
+        }
+        emit(data);
+      });
+      ws.on("error", (err) => {
+        process.stderr.write(`Error: ${err.message}
+`);
+      });
+      ws.on("close", () => {
+        if (!closed && usePretty) {
+          process.stderr.write("Disconnected.\n");
+        }
+        cleanup();
+      });
+    });
+  }
+);
 program.parse();
 /*! Bundled license information:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserbasehq/browse-cli",
-  "version": "0.5.0-alpha-34598b9",
+  "version": "0.5.0-alpha-a4ca430",
   "description": "Browser automation CLI for AI agents, built on Stagehand",
   "type": "commonjs",
   "license": "MIT",
@@ -52,6 +52,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.11.30",
+    "@types/ws": "^8.5.13",
     "devtools-protocol": "^0.0.1464554",
     "eslint": "^10.0.2",
     "tsup": "^8.2.1",