@browserbasehq/cli 0.0.1

package/dist/lib/functions/shared.js

@@ -0,0 +1,116 @@
+import { spawnSync } from "node:child_process";
+import { stat } from "node:fs/promises";
+import { extname, resolve } from "node:path";
+import { fail, outputJson, resolveApiKey, resolveProjectId } from "../command.js";
+const defaultFunctionsApiUrl = "https://api.browserbase.com";
+export function resolveFunctionsApiConfig(args) {
+    return {
+        apiKey: resolveApiKey(args),
+        apiUrl: args.apiUrl ||
+            process.env.BROWSERBASE_API_BASE_URL ||
+            process.env.BROWSERBASE_BASE_URL ||
+            defaultFunctionsApiUrl,
+    };
+}
+export function resolveFunctionsProjectConfig(args) {
+    return {
+        ...resolveFunctionsApiConfig(args),
+        projectId: resolveProjectId(args, { required: true }) ||
+            fail("Missing Browserbase project ID."),
+    };
+}
+export async function parseErrorMessage(response) {
+    try {
+        const data = await response.json();
+        if (typeof data === "object" && data !== null) {
+            const message = data.message || data.error;
+            if (message) {
+                return message;
+            }
+        }
+    }
+    catch {
+        try {
+            const text = await response.text();
+            if (text) {
+                return text;
+            }
+        }
+        catch {
+            return `${response.status} ${response.statusText}`;
+        }
+    }
+    return `${response.status} ${response.statusText}`;
+}
+export async function functionsGet(config, path) {
+    const response = await fetch(`${config.apiUrl}${path}`, {
+        headers: {
+            "x-bb-api-key": config.apiKey,
+        },
+    });
+    if (!response.ok) {
+        fail(await parseErrorMessage(response));
+    }
+    return (await response.json());
+}
+export async function functionsPost(config, path, body) {
+    const response = await fetch(`${config.apiUrl}${path}`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "x-bb-api-key": config.apiKey,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        fail(await parseErrorMessage(response));
+    }
+    return (await response.json());
+}
+export async function pollUntil(loader, options) {
+    const intervalMs = options.intervalMs ?? 1_000;
+    const maxAttempts = options.maxAttempts ?? 120;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        const result = await loader();
+        if (options.done(result)) {
+            return result;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    fail("Timed out while waiting for the Browserbase Functions operation to complete.");
+}
+export async function resolveEntrypoint(entrypoint) {
+    const absolutePath = resolve(entrypoint);
+    let stats;
+    try {
+        stats = await stat(absolutePath);
+    }
+    catch {
+        fail(`Entrypoint file not found: ${absolutePath}`);
+    }
+    if (!stats.isFile()) {
+        fail(`Entrypoint must be a file: ${absolutePath}`);
+    }
+    const extension = extname(absolutePath).toLowerCase();
+    if (![".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts"].includes(extension)) {
+        fail(`Unsupported entrypoint extension: ${extension}`);
+    }
+    return absolutePath;
+}
+export function ensureCommand(command) {
+    const result = spawnSync(command, ["--version"], { stdio: "ignore" });
+    if (result.error || result.status !== 0) {
+        fail(`${command} is required but was not found on PATH.`);
+    }
+}
+export function printFunctionsJsonOrMessage(value, options = {}) {
+    if (options.json) {
+        outputJson(value);
+        return;
+    }
+    if (options.message) {
+        console.log(options.message);
+        return;
+    }
+    outputJson(value);
+}

package/dist/lib/open.js

@@ -0,0 +1,29 @@
+import { spawn } from "node:child_process";
+import { CommandFailure } from "./command.js";
+export async function openUrl(url) {
+    let binary;
+    let args;
+    if (process.platform === "darwin") {
+        binary = "open";
+        args = [url];
+    }
+    else if (process.platform === "win32") {
+        binary = "cmd";
+        args = ["/c", "start", "", url];
+    }
+    else {
+        binary = "xdg-open";
+        args = [url];
+    }
+    await new Promise((resolve, reject) => {
+        const child = spawn(binary, args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.on("error", (error) => {
+            reject(new CommandFailure(`Failed to open ${url}: ${error.message}`));
+        });
+        child.on("spawn", () => resolve());
+        child.unref();
+    });
+}

package/dist/lib/process.js

@@ -0,0 +1,45 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { delimiter, join } from "node:path";
+import { spawn } from "node:child_process";
+const windowsExtensions = (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM")
+    .split(";")
+    .filter(Boolean);
+export async function findExecutable(command) {
+    const pathEnv = process.env.PATH;
+    if (!pathEnv) {
+        return null;
+    }
+    const candidates = process.platform === "win32"
+        ? pathEnv
+            .split(delimiter)
+            .flatMap((segment) => windowsExtensions.map((extension) => join(segment, `${command}${extension.toLowerCase()}`)))
+        : pathEnv.split(delimiter).map((segment) => join(segment, command));
+    for (const candidate of candidates) {
+        try {
+            await access(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export async function spawnPassthrough(command, args, options = {}) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: "inherit",
+            env: options.env,
+            cwd: options.cwd,
+        });
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                resolve(1);
+                return;
+            }
+            resolve(code ?? 0);
+        });
+    });
+}

package/dist/main.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { run } from "./cli.js";
+process.exitCode = await run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@browserbasehq/cli",
+  "version": "0.0.1",
+  "description": "Browserbase CLI for platform APIs, functions, and browse passthrough.",
+  "type": "module",
+  "private": false,
+  "bin": {
+    "bb": "dist/main.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/browserbase/cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/browserbase/cli/issues"
+  },
+  "homepage": "https://github.com/browserbase/cli#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "check": "tsc --noEmit -p tsconfig.json",
+    "cli": "bun run src/main.ts",
+    "changeset": "changeset",
+    "lint": "bun run check",
+    "release": "bun run build && changeset publish",
+    "test": "bun run build && vitest run",
+    "version": "changeset version",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@browserbasehq/sdk": "^2.8.0",
+    "archiver": "^7.0.1",
+    "commander": "^14.0.1",
+    "dotenv": "^16.5.0",
+    "ignore": "^7.0.5",
+    "tsx": "^4.20.6"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.8",
+    "@types/archiver": "^6.0.3",
+    "@types/node": "^24.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  }
+}