@browserbasehq/cli 0.0.1

package/dist/lib/functions/dev.js

@@ -0,0 +1,331 @@
+import Browserbase from "@browserbasehq/sdk";
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { mkdir, readdir, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { fail } from "../command.js";
+import { resolveEntrypoint, resolveFunctionsProjectConfig, } from "./shared.js";
+class InvocationBridge {
+    nextConnection = null;
+    invokeConnection = null;
+    currentRequestId = null;
+    currentSessionId = null;
+    cleanupSessionCallback = null;
+    runtimeConnected = false;
+    setCleanupSessionCallback(callback) {
+        this.cleanupSessionCallback = callback;
+    }
+    holdNextConnection(response) {
+        this.runtimeConnected = true;
+        if (this.nextConnection) {
+            this.nextConnection.response.writeHead(503, {
+                "content-type": "application/json",
+            });
+            this.nextConnection.response.end(JSON.stringify({ error: "Another runtime process connected." }));
+        }
+        this.nextConnection = { response };
+    }
+    isRuntimeConnected() {
+        return this.runtimeConnected && this.nextConnection !== null;
+    }
+    hasActiveInvocation() {
+        return this.invokeConnection !== null;
+    }
+    async completeWithSuccess(requestId, payload) {
+        if (requestId !== this.currentRequestId || !this.invokeConnection) {
+            return false;
+        }
+        this.invokeConnection.response.writeHead(200, {
+            "content-type": "application/json",
+        });
+        this.invokeConnection.response.end(JSON.stringify(payload ?? {}));
+        await this.cleanupSession();
+        this.reset();
+        return true;
+    }
+    async completeWithError(requestId, payload) {
+        if (requestId !== this.currentRequestId || !this.invokeConnection) {
+            return false;
+        }
+        this.invokeConnection.response.writeHead(500, {
+            "content-type": "application/json",
+        });
+        this.invokeConnection.response.end(JSON.stringify({ error: payload }));
+        await this.cleanupSession();
+        this.reset();
+        return true;
+    }
+    triggerInvocation(functionName, params, context, response) {
+        if (!this.nextConnection || this.invokeConnection) {
+            return false;
+        }
+        const requestId = randomUUID();
+        this.currentRequestId = requestId;
+        this.currentSessionId = context.session.id;
+        this.invokeConnection = { response };
+        this.nextConnection.response.writeHead(200, {
+            "content-type": "application/json",
+            "Lambda-Runtime-Aws-Request-Id": requestId,
+            "Lambda-Runtime-Deadline-Ms": String(Date.now() + 300_000),
+            "Lambda-Runtime-Invoked-Function-Arn": `arn:aws:lambda:local:function:${functionName}`,
+        });
+        this.nextConnection.response.end(JSON.stringify({
+            functionName,
+            params,
+            context,
+        }));
+        this.nextConnection = null;
+        return true;
+    }
+    async cleanupSession() {
+        if (this.cleanupSessionCallback && this.currentSessionId) {
+            await this.cleanupSessionCallback(this.currentSessionId);
+        }
+    }
+    reset() {
+        this.invokeConnection = null;
+        this.currentRequestId = null;
+        this.currentSessionId = null;
+    }
+}
+class BrowserSessionManager {
+    client;
+    projectId;
+    constructor(apiKey, projectId, baseUrl) {
+        this.client = new Browserbase({
+            apiKey,
+            baseURL: baseUrl,
+        });
+        this.projectId = projectId;
+    }
+    async createSession(sessionConfig) {
+        const session = await this.client.sessions.create({
+            projectId: this.projectId,
+            ...sessionConfig,
+        });
+        return {
+            id: session.id,
+            connectUrl: session.connectUrl,
+        };
+    }
+    async closeSession(sessionId) {
+        await this.client.sessions.update(sessionId, {
+            projectId: this.projectId,
+            status: "REQUEST_RELEASE",
+        });
+    }
+}
+class ManifestStore {
+    manifestsPath = join(process.cwd(), ".browserbase", "functions", "manifests");
+    manifests = new Map();
+    async load() {
+        this.manifests.clear();
+        if (!existsSync(this.manifestsPath)) {
+            return;
+        }
+        const entries = await readdir(this.manifestsPath);
+        for (const entry of entries) {
+            if (!entry.endsWith(".json")) {
+                continue;
+            }
+            const manifest = JSON.parse(await readFile(join(this.manifestsPath, entry), "utf8"));
+            this.manifests.set(manifest.name, manifest);
+        }
+    }
+    get(name) {
+        return this.manifests.get(name);
+    }
+}
+class RuntimeProcess {
+    process = null;
+    entrypoint;
+    runtimeApi;
+    verbose;
+    constructor(entrypoint, runtimeApi, verbose) {
+        this.entrypoint = entrypoint;
+        this.runtimeApi = runtimeApi;
+        this.verbose = verbose;
+    }
+    async start() {
+        const require = createRequire(import.meta.url);
+        const tsxCli = require.resolve("tsx/cli");
+        this.process = spawn(process.execPath, [tsxCli, "watch", "--clear-screen=false", this.entrypoint], {
+            cwd: process.cwd(),
+            env: {
+                ...process.env,
+                AWS_LAMBDA_RUNTIME_API: this.runtimeApi,
+                BB_FUNCTIONS_PHASE: "runtime",
+                NODE_ENV: "local",
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        this.process.stdout?.on("data", (chunk) => {
+            const text = chunk.toString().trim();
+            if (!text) {
+                return;
+            }
+            console.log(this.verbose ? `[runtime] ${text}` : text);
+        });
+        this.process.stderr?.on("data", (chunk) => {
+            const text = chunk.toString().trim();
+            if (!text) {
+                return;
+            }
+            console.error(this.verbose ? `[runtime:error] ${text}` : text);
+        });
+        this.process.on("error", (error) => {
+            fail(`Failed to start functions runtime: ${error.message}`);
+        });
+    }
+    async stop() {
+        if (!this.process) {
+            return;
+        }
+        await new Promise((resolve) => {
+            const child = this.process;
+            child.once("exit", () => resolve());
+            child.kill("SIGTERM");
+        });
+        this.process = null;
+    }
+}
+export async function startFunctionsDevServer(options) {
+    const entrypoint = await resolveEntrypoint(options.entrypoint);
+    if (!Number.isInteger(options.port) || options.port < 1 || options.port > 65_535) {
+        fail("Port must be an integer between 1 and 65535.");
+    }
+    const config = resolveFunctionsProjectConfig(options);
+    const runtimeApi = `${options.host}:${options.port}`;
+    const bridge = new InvocationBridge();
+    const sessionManager = new BrowserSessionManager(config.apiKey, config.projectId, config.apiUrl);
+    const manifestStore = new ManifestStore();
+    bridge.setCleanupSessionCallback(async (sessionId) => {
+        await sessionManager.closeSession(sessionId);
+    });
+    await mkdir(join(process.cwd(), ".browserbase", "functions", "manifests"), {
+        recursive: true,
+    });
+    const server = await startServer(options.host, options.port, bridge, manifestStore, sessionManager);
+    const runtime = new RuntimeProcess(entrypoint, runtimeApi, options.verbose);
+    await runtime.start();
+    await waitForRuntime(bridge, manifestStore);
+    console.log(`Functions dev server running at http://${options.host}:${options.port}`);
+    const shutdown = async () => {
+        await runtime.stop();
+        await new Promise((resolve) => server.close(() => resolve()));
+    };
+    process.on("SIGINT", async () => {
+        await shutdown();
+        process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+        await shutdown();
+        process.exit(0);
+    });
+}
+async function startServer(host, port, bridge, manifestStore, sessionManager) {
+    const server = createServer(async (request, response) => {
+        await routeRequest(request, response, bridge, manifestStore, sessionManager);
+    });
+    await new Promise((resolve, reject) => {
+        server.listen(port, host, () => resolve());
+        server.on("error", reject);
+    });
+    return server;
+}
+async function waitForRuntime(bridge, manifestStore) {
+    const deadline = Date.now() + 10_000;
+    while (Date.now() < deadline) {
+        if (bridge.isRuntimeConnected()) {
+            await manifestStore.load();
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    await manifestStore.load();
+}
+async function routeRequest(request, response, bridge, manifestStore, sessionManager) {
+    const method = request.method || "GET";
+    const url = new URL(request.url || "/", `http://${request.headers.host || "127.0.0.1"}`);
+    const path = url.pathname;
+    if (method === "GET" && path === "/") {
+        sendJson(response, 200, { ok: true });
+        return;
+    }
+    if (method === "GET" && path === "/2018-06-01/runtime/invocation/next") {
+        bridge.holdNextConnection(response);
+        return;
+    }
+    const invokeMatch = path.match(/^\/v1\/functions\/([^/]+)\/invoke$/);
+    if (method === "POST" && invokeMatch?.[1]) {
+        await manifestStore.load();
+        const functionName = invokeMatch[1];
+        const manifest = manifestStore.get(functionName);
+        if (!manifest) {
+            sendJson(response, 404, {
+                error: `Function "${functionName}" was not found in .browserbase/functions/manifests.`,
+            });
+            return;
+        }
+        if (bridge.hasActiveInvocation()) {
+            sendJson(response, 503, { error: "Another invocation is already in progress." });
+            return;
+        }
+        const body = await readJsonBody(request);
+        const params = body && typeof body === "object" && body !== null && !Array.isArray(body)
+            ? (body.params || {})
+            : {};
+        const session = await sessionManager.createSession(manifest.config?.sessionConfig);
+        const accepted = bridge.triggerInvocation(functionName, params, { session }, response);
+        if (!accepted) {
+            await sessionManager.closeSession(session.id);
+            sendJson(response, 503, { error: "No runtime is connected yet." });
+        }
+        return;
+    }
+    const responseMatch = path.match(/^\/2018-06-01\/runtime\/invocation\/([^/]+)\/response$/);
+    if (method === "POST" && responseMatch?.[1]) {
+        const payload = await readJsonBody(request);
+        const completed = await bridge.completeWithSuccess(responseMatch[1], payload);
+        sendJson(response, completed ? 202 : 400, completed ? { ok: true } : { error: "Request ID mismatch." });
+        return;
+    }
+    const errorMatch = path.match(/^\/2018-06-01\/runtime\/invocation\/([^/]+)\/error$/);
+    if (method === "POST" && errorMatch?.[1]) {
+        const payload = (await readJsonBody(request));
+        const completed = await bridge.completeWithError(errorMatch[1], {
+            errorMessage: payload?.errorMessage || "Unknown runtime error",
+            errorType: payload?.errorType || "RuntimeError",
+            stackTrace: Array.isArray(payload?.stackTrace) ? payload.stackTrace : [],
+        });
+        sendJson(response, completed ? 202 : 400, completed ? { ok: true } : { error: "Request ID mismatch." });
+        return;
+    }
+    sendJson(response, 404, { error: "Not found." });
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    if (chunks.length === 0) {
+        return {};
+    }
+    const text = Buffer.concat(chunks).toString("utf8");
+    if (!text) {
+        return {};
+    }
+    return JSON.parse(text);
+}
+function sendJson(response, statusCode, payload) {
+    response.writeHead(statusCode, {
+        "content-type": "application/json",
+        "access-control-allow-origin": "*",
+        "access-control-allow-methods": "GET, POST, OPTIONS",
+        "access-control-allow-headers": "content-type",
+    });
+    response.end(JSON.stringify(payload));
+}

package/dist/lib/functions/init.js

@@ -0,0 +1,102 @@
+import { spawnSync } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fail } from "../command.js";
+import { ensureCommand } from "./shared.js";
+const envTemplate = `# Browserbase Configuration
+# Get your API key and project ID from https://browserbase.com/settings
+
+BROWSERBASE_API_KEY=your_api_key_here
+BROWSERBASE_PROJECT_ID=your_project_id_here
+`;
+const gitignoreTemplate = `node_modules/
+.env
+.env.local
+dist/
+*.log
+.DS_Store
+`;
+const starterFunctionTemplate = `import { defineFn } from "@browserbasehq/sdk-functions";
+import { chromium } from "playwright-core";
+
+defineFn("my-function", async (context) => {
+  const browser = await chromium.connectOverCDP(context.session.connectUrl);
+  const page = browser.contexts()[0]!.pages()[0]!;
+
+  await page.goto("https://news.ycombinator.com");
+  await page.waitForSelector(".athing", { timeout: 30_000 });
+
+  const titles = await page.$$eval(".athing .titleline > a", (elements) =>
+    elements.slice(0, 3).map((element) => element.textContent),
+  );
+
+  return {
+    message: "Fetched top Hacker News titles",
+    titles,
+  };
+});
+`;
+const tsconfigTemplate = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true
+  }
+}
+`;
+export async function initFunctionsProject({ projectName, packageManager, }) {
+    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(projectName)) {
+        fail(`Invalid project name "${projectName}". Use a leading letter, then letters, numbers, hyphens, or underscores.`);
+    }
+    ensureCommand(packageManager);
+    const projectRoot = resolve(projectName);
+    if (existsSync(projectRoot)) {
+        fail(`Directory already exists: ${projectRoot}`);
+    }
+    await mkdir(projectRoot, { recursive: true });
+    const packageJson = {
+        name: projectName,
+        private: true,
+        type: "module",
+        scripts: {
+            dev: "bb functions dev index.ts",
+            publish: "bb functions publish index.ts",
+        },
+    };
+    await writeFile(join(projectRoot, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
+    await writeFile(join(projectRoot, ".env"), envTemplate);
+    await writeFile(join(projectRoot, ".gitignore"), gitignoreTemplate);
+    await writeFile(join(projectRoot, "index.ts"), starterFunctionTemplate);
+    await writeFile(join(projectRoot, "tsconfig.json"), tsconfigTemplate);
+    const install = packageManager === "pnpm" ? ["add"] : ["install"];
+    const installDev = packageManager === "pnpm" ? ["add", "-D"] : ["install", "--save-dev"];
+    const dependencies = ["@browserbasehq/sdk-functions", "playwright-core"];
+    const devDependencies = ["typescript", "@types/node"];
+    runPackageManager(packageManager, [...install, ...dependencies], projectRoot);
+    runPackageManager(packageManager, [...installDev, ...devDependencies], projectRoot);
+    if (!existsSync(join(projectRoot, ".git"))) {
+        spawnSync("git", ["init"], {
+            cwd: projectRoot,
+            stdio: "ignore",
+        });
+    }
+    console.log(`Initialized Browserbase Functions project in ${projectRoot}`);
+    console.log("");
+    console.log("Next steps:");
+    console.log(`  cd ${projectName}`);
+    console.log("  Edit .env with your Browserbase credentials");
+    console.log(`  ${packageManager === "pnpm" ? "pnpm" : "npm run"} dev`);
+}
+function runPackageManager(packageManager, args, cwd) {
+    const result = spawnSync(packageManager, args, {
+        cwd,
+        stdio: "inherit",
+    });
+    if (result.error || result.status !== 0) {
+        fail(`Failed to install dependencies with ${packageManager}.`);
+    }
+}

package/dist/lib/functions/invoke.js

@@ -0,0 +1,28 @@
+import { fail, parseOptionalJsonValueArg } from "../command.js";
+import { functionsGet, functionsPost, pollUntil, resolveFunctionsApiConfig, } from "./shared.js";
+export async function invokeFunction(options) {
+    const config = resolveFunctionsApiConfig(options);
+    if (options.checkStatus) {
+        const status = await functionsGet(config, `/v1/functions/invocations/${options.checkStatus}`);
+        console.log(JSON.stringify(status, null, 2));
+        return;
+    }
+    if (!options.functionId) {
+        fail("functionId is required unless --check-status is used.");
+    }
+    const params = parseOptionalJsonValueArg(options.params, "params");
+    const invocation = await functionsPost(config, `/v1/functions/${options.functionId}/invoke`, { params });
+    if (options.noWait) {
+        console.log(JSON.stringify(invocation, null, 2));
+        return;
+    }
+    const finalStatus = await pollUntil(() => functionsGet(config, `/v1/functions/invocations/${invocation.id}`), {
+        done: (result) => !["PENDING", "RUNNING"].includes(result.status),
+        intervalMs: 1_000,
+        maxAttempts: 900,
+    });
+    console.log(JSON.stringify(finalStatus, null, 2));
+    if (finalStatus.status === "FAILED") {
+        process.exitCode = 1;
+    }
+}

package/dist/lib/functions/publish.js

@@ -0,0 +1,131 @@
+import archiver from "archiver";
+import ignore from "ignore";
+import { createWriteStream, existsSync, readFileSync } from "node:fs";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, relative } from "node:path";
+import { randomUUID } from "node:crypto";
+import { fail } from "../command.js";
+import { functionsGet, parseErrorMessage, pollUntil, resolveEntrypoint, resolveFunctionsProjectConfig, } from "./shared.js";
+const defaultIgnorePatterns = [
+    "node_modules/",
+    ".git/",
+    ".env",
+    ".env.*",
+    "*.log",
+    ".DS_Store",
+    "dist/",
+    "build/",
+    "*.zip",
+    "*.tar",
+    "*.tar.gz",
+    ".vscode/",
+    ".idea/",
+];
+export async function publishFunction(options) {
+    const entrypoint = await resolveEntrypoint(options.entrypoint);
+    const config = resolveFunctionsProjectConfig(options);
+    const archivePath = await createArchive(process.cwd(), options.dryRun);
+    const metadata = {
+        entrypoint: relative(process.cwd(), entrypoint),
+        projectId: config.projectId,
+    };
+    if (options.dryRun) {
+        console.log(JSON.stringify({
+            dryRun: true,
+            apiUrl: config.apiUrl,
+            projectId: config.projectId,
+            entrypoint: metadata.entrypoint,
+            archivePath,
+        }, null, 2));
+        return;
+    }
+    const formData = new FormData();
+    formData.append("metadata", JSON.stringify(metadata));
+    formData.append("archive", new Blob([await readFile(archivePath)], {
+        type: "application/gzip",
+    }), "archive.tar.gz");
+    const uploadResponse = await fetch(`${config.apiUrl}/v1/functions/builds`, {
+        method: "POST",
+        headers: {
+            "x-bb-api-key": config.apiKey,
+        },
+        body: formData,
+    });
+    if (!uploadResponse.ok) {
+        fail(await parseErrorMessage(uploadResponse));
+    }
+    const uploaded = (await uploadResponse.json());
+    if (!uploaded.id) {
+        fail("Build upload completed without returning a build ID.");
+    }
+    const build = await pollUntil(() => functionsGet(config, `/v1/functions/builds/${uploaded.id}`), {
+        done: (result) => !["PENDING", "RUNNING"].includes(result.status),
+        intervalMs: 2_000,
+        maxAttempts: 100,
+    });
+    console.log(JSON.stringify(build, null, 2));
+    if (build.status === "FAILED") {
+        process.exitCode = 1;
+    }
+}
+async function createArchive(root, dryRun) {
+    const archivePath = join(tmpdir(), `browserbase-functions-${randomUUID()}.tar.gz`);
+    const ignoreMatcher = await loadIgnoreMatcher(root);
+    const entries = await listArchiveEntries(root, root, ignoreMatcher);
+    if (dryRun) {
+        console.log(JSON.stringify({ files: entries }, null, 2));
+    }
+    await new Promise((resolve, reject) => {
+        const output = createWriteStream(archivePath);
+        const archive = archiver("tar", {
+            gzip: true,
+            gzipOptions: { level: 9 },
+        });
+        archive.on("error", reject);
+        archive.on("warning", (warning) => {
+            if (warning.code === "ENOENT") {
+                return;
+            }
+            reject(warning);
+        });
+        output.on("close", () => resolve());
+        output.on("error", reject);
+        archive.pipe(output);
+        for (const entry of entries) {
+            archive.file(join(root, entry), { name: entry });
+        }
+        archive.finalize().catch(reject);
+    });
+    return archivePath;
+}
+async function loadIgnoreMatcher(root) {
+    const matcher = ignore();
+    matcher.add(defaultIgnorePatterns);
+    const gitignorePath = join(root, ".gitignore");
+    if (existsSync(gitignorePath)) {
+        matcher.add(readFileSync(gitignorePath, "utf8"));
+    }
+    return matcher;
+}
+async function listArchiveEntries(root, current, matcher) {
+    const entries = await readdir(current, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const absolutePath = join(current, entry.name);
+        const relativePath = relative(root, absolutePath) || ".";
+        const ignorePath = entry.isDirectory() ? `${relativePath}/` : relativePath;
+        if (relativePath !== "." && matcher.ignores(ignorePath)) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            files.push(...(await listArchiveEntries(root, absolutePath, matcher)));
+            continue;
+        }
+        const fileStats = await stat(absolutePath);
+        if (fileStats.isFile()) {
+            files.push(relativePath);
+        }
+    }
+    return files.sort();
+}