remote-agent-browser 0.1.0 → 0.2.0

package/README.md

@@ -12,27 +12,17 @@ pnpm add remote-agent-browser
 
 ## Use
 
-```ts
-import { createAgentBrowser } from 'remote-agent-browser'
-
-const browser = await createAgentBrowser()
-
-try {
-  const { results } = await browser.run([
-    ['open', 'https://example.com'],
-    ['snapshot', '-i', '--json'],
-  ])
-
-  console.log(results[1].stdout)
-} finally {
-  await browser.close()
-}
-```
-
-`createAgentBrowser()` starts a fresh Vercel Sandbox from the prebuilt browser
+`AgentBrowser.create()` starts a fresh Vercel Sandbox from the prebuilt browser
 image. Commands in one client share the same page, cookies, tabs, and element
 references. `close()` closes Chromium and stops the Sandbox.
 
+## Examples
+
+- [Capture a screenshot](./examples/screenshot/README.md) — capture a full-page
+  PNG and save it locally.
+- [Agent Bash tool integration](./examples/agent-bash-tool/README.md) — let an
+  agent use normal `agent-browser <command>` invocations through its Bash tool.
+
 ## Authentication
 
 Authentication is automatic when running on Vercel through
@@ -43,16 +33,26 @@ For local development, link a Vercel project and pull its environment:
 ```bash
 vercel link
 vercel env pull .env.local
-node --env-file=.env.local example.mjs
+node --env-file=.env.local examples/screenshot/index.mjs
 ```
 
 ## API
 
-### `createAgentBrowser()`
+### `AgentBrowser.create()`
 
 Starts a fresh browser in a disposable Vercel Sandbox. Always call
 `browser.close()` when finished.
 
+Pass agent-browser global options with `args`. They are placed before
+every command, which is required for launch settings such as color scheme,
+profiles, proxies, and init scripts:
+
+```ts
+const browser = await AgentBrowser.create({
+  args: ['--color-scheme', 'dark', '--enable', 'react-devtools'],
+})
+```
+
 ### `browser.run(commands)`
 
 Run several agent-browser commands in the same session:
@@ -77,10 +77,53 @@ await browser.exec('find', {
 })
 ```
 
+### Typed JSON
+
+Set `output: 'json'` for commands that support `--json`. `exec<T>()` adds the
+flag, unwraps the CLI response envelope, and keeps the normal command fields
+alongside the typed `data` value:
+
+```ts
+type UrlResult = { url: string }
+
+const result = await browser.exec<UrlResult>('get', {
+  args: ['url'],
+  output: 'json',
+})
+console.log(result.data.url, result.ok)
+```
+
+### File transfer
+
+Upload local buffers through a page's file input, or collect a browser download
+without exposing the Sandbox filesystem:
+
+```ts
+await browser.upload('#avatar', [
+  { name: 'avatar.png', bytes: await readFile('avatar.png') },
+])
+
+const { file } = await browser.download('#export', { filename: 'report.csv' })
+await writeFile('report.csv', file.bytes)
+```
+
+When no output path is supplied, other file-producing commands collect their
+artifact in `result.file`. This includes screenshots, PDFs, traces, profiles,
+HAR files, saved browser state, and recordings:
+
+```ts
+await browser.exec('network', { args: ['har', 'start'] })
+// ...interact with the page...
+const result = await browser.exec('network', { args: ['har', 'stop'] })
+await writeFile('capture.har', result.file.bytes)
+```
+
 ### Convenience methods
 
-- `browser.snapshot(url)` opens a page and returns its interactive snapshot.
-- `browser.screenshot(url, { fullPage: true })` returns a PNG buffer.
+- `browser.snapshot(url?)` optionally opens a page, then returns its interactive
+  snapshot. Omit the URL to inspect the current page.
+- `browser.screenshot(url?, { fullPage: true })` optionally opens a page, then
+  returns a PNG buffer. Pass the options object first to capture the current page.
 - `browser.close()` closes the session and stops the Sandbox.
 
 All methods use the same disposable browser session until `close()` is called.

package/dist/index.d.ts

@@ -4,11 +4,16 @@
  * The library has two layers:
  *  - `AgentBrowser` (browser.ts): a thin, session-oriented client over the
  *    `agent-browser` CLI running somewhere that can execute commands.
- *  - `createAgentBrowser` (create.ts): provisions a Vercel Sandbox from a
+ *  - `AgentBrowser.create()` (create.ts): provisions a Vercel Sandbox from a
  *    browser-ready image and returns an `AgentBrowser` backed by it.
  */
 /** One agent-browser CLI invocation result. */
-type BrowserCommandResult = {
+type BrowserFile = {
+    path: string;
+    bytes: Buffer;
+    contentType: string;
+};
+type BrowserCommandResult<T = never> = {
     /** The CLI args that ran, e.g. ["snapshot", "-i", "--json"] */
     args: string[];
     ok: boolean;
@@ -16,11 +21,14 @@ type BrowserCommandResult = {
     stdout: string;
     stderr: string;
     /** File bytes collected from the sandbox for file-producing commands. */
-    file?: {
-        path: string;
-        bytes: Buffer;
-        contentType: string;
-    };
+    file?: BrowserFile;
+} & ([T] extends [never] ? {} : {
+    data: T;
+});
+/** A local file to make available to an upload command. */
+type BrowserUploadFile = {
+    name: string;
+    bytes: Buffer;
 };
 /** A batch of commands run sequentially in one session. */
 type BrowserRunResult = {
@@ -36,6 +44,9 @@ type RunOptions = {
     /** Per-command timeout in ms. */
     timeoutMs?: number;
 };
+type ScreenshotOptions = RunOptions & {
+    fullPage?: boolean;
+};
 type ExecOptions = {
     session?: string;
     /** Positional CLI args, e.g. ["@e3"] for click. */
@@ -43,6 +54,18 @@ type ExecOptions = {
     /** Flags serialized to --kebab-case (true → bare flag, arrays → repeated). */
     flags?: Record<string, unknown>;
     timeoutMs?: number;
+    /** Leave command output as text. This is the default. */
+    output?: 'text';
+};
+type JsonExecOptions = Omit<ExecOptions, 'output'> & {
+    output: 'json';
+};
+type BrowserClientOptions = {
+    session?: string;
+    /** agent-browser CLI arguments inserted before every command. */
+    args?: string[];
+    /** Whether close() also tears down the command runner. Default: true. */
+    ownsRunner?: boolean;
 };
 /**
  * Minimal command executor the browser client needs. Implemented by the
@@ -61,23 +84,34 @@ interface CommandRunner {
     }>;
     /** Read a file's bytes from the remote environment. */
     readFile(path: string): Promise<Buffer>;
+    /** Write file bytes into the remote environment. */
+    writeFile(path: string, bytes: Buffer): Promise<void>;
     /** Tear the remote environment down. */
     close(): Promise<void>;
 }
 /** Session-oriented remote browser client. */
-interface AgentBrowser {
+interface AgentBrowser$1 {
     /** The runner's session name this client uses by default. */
     readonly session: string;
     /** Run a batch of agent-browser arg-arrays sequentially. */
     run(commands: string[][], opts?: RunOptions): Promise<BrowserRunResult>;
-    /** Run one agent-browser command by name. */
+    /** Run one command and unwrap its typed --json data payload. */
+    exec<T>(command: string, opts: JsonExecOptions): Promise<BrowserCommandResult<T>>;
+    /** Run one agent-browser command with text output. */
     exec(command: string, opts?: ExecOptions): Promise<BrowserCommandResult>;
-    /** Open a URL and return the interactive accessibility snapshot (JSON). */
-    snapshot(url: string, opts?: RunOptions): Promise<BrowserRunResult>;
-    /** Open a URL and return a PNG screenshot. */
-    screenshot(url: string, opts?: RunOptions & {
-        fullPage?: boolean;
+    /** Upload one or more local buffers through a file input. */
+    upload(selector: string, files: BrowserUploadFile[], opts?: Pick<ExecOptions, 'session' | 'timeoutMs'>): Promise<BrowserCommandResult>;
+    /** Download a file triggered by an element and return its bytes. */
+    download(selector: string, opts?: Pick<ExecOptions, 'session' | 'timeoutMs'> & {
+        filename?: string;
     }): Promise<{
+        file: BrowserFile;
+        result: BrowserCommandResult;
+    }>;
+    /** Optionally open a URL, then return the interactive accessibility snapshot. */
+    snapshot(urlOrOptions?: string | RunOptions, opts?: RunOptions): Promise<BrowserRunResult>;
+    /** Optionally open a URL, then return a PNG screenshot. */
+    screenshot(urlOrOptions?: string | ScreenshotOptions, opts?: ScreenshotOptions): Promise<{
         png: Buffer;
         result: BrowserRunResult;
     }>;
@@ -99,6 +133,8 @@ type CreateAgentBrowserOptions = {
     vcpus?: number;
     /** Extra env vars for every command inside the sandbox. */
     env?: Record<string, string>;
+    /** agent-browser CLI arguments inserted before every command. */
+    args?: string[];
 };
 /**
  * Create an agent-browser client running inside a fresh Vercel Sandbox.
@@ -112,9 +148,9 @@ type CreateAgentBrowserOptions = {
  * `vercel login`), via @vercel/sandbox.
  *
  * ```ts
- * import { createAgentBrowser } from 'remote-agent-browser'
+ * import { AgentBrowser } from 'remote-agent-browser'
  *
- * const browser = await createAgentBrowser()
+ * const browser = await AgentBrowser.create()
  * const { results } = await browser.run([
  *   ['open', 'https://example.com'],
  *   ['snapshot', '-i', '--json'],
@@ -122,7 +158,7 @@ type CreateAgentBrowserOptions = {
  * await browser.close()
  * ```
  */
-declare function createAgentBrowser(opts?: CreateAgentBrowserOptions): Promise<AgentBrowser>;
+declare function createAgentBrowser(opts?: CreateAgentBrowserOptions): Promise<AgentBrowser$1>;
 
 /**
  * Create a session-oriented browser client over any CommandRunner.
@@ -132,10 +168,13 @@ declare function createAgentBrowser(opts?: CreateAgentBrowserOptions): Promise<A
  * explicit session name to share state across clients, or let it default to
  * an ephemeral per-client session that is closed on `close()`.
  */
-declare function createBrowserClient(runner: CommandRunner, opts?: {
-    session?: string;
-    ownsRunner?: boolean;
-}): AgentBrowser;
+declare function createBrowserClient(runner: CommandRunner, opts?: BrowserClientOptions): AgentBrowser$1;
+
+/** Create AgentBrowser clients backed by a fresh Vercel Sandbox. */
+declare const AgentBrowser: {
+    create: typeof createAgentBrowser;
+};
+type AgentBrowser = AgentBrowser$1;
 
-export { createAgentBrowser, createBrowserClient };
-export type { AgentBrowser, BrowserCommandResult, BrowserRunResult, CommandRunner, CreateAgentBrowserOptions, ExecOptions, RunOptions };
+export { AgentBrowser, createAgentBrowser, createBrowserClient };
+export type { BrowserClientOptions, BrowserCommandResult, BrowserRunResult, CommandRunner, CreateAgentBrowserOptions, ExecOptions, JsonExecOptions, RunOptions };

package/dist/index.js

@@ -1,34 +1,21 @@
 import { randomUUID } from 'node:crypto';
 import { Sandbox } from '@vercel/sandbox';
 
-/** Commands whose output is a file we pull back as bytes. */ const FILE_OUTPUT = {
-    screenshot: {
-        subcommand: null,
-        ext: 'png',
-        contentType: 'image/png'
-    },
-    pdf: {
-        subcommand: null,
-        ext: 'pdf',
-        contentType: 'application/pdf'
-    },
-    trace: {
-        subcommand: 'stop',
-        ext: 'json',
-        contentType: 'application/json'
-    },
-    profiler: {
-        subcommand: 'stop',
-        ext: 'json',
-        contentType: 'application/json'
-    },
-    record: {
-        subcommand: 'stop',
-        ext: 'webm',
-        contentType: 'video/webm'
-    }
-};
+const FLAGS_WITH_VALUE = new Set([
+    '--screenshot-dir',
+    '--screenshot-quality',
+    '--screenshot-format',
+    '--format',
+    '--width',
+    '--height',
+    '--margin',
+    '--scale'
+]);
 const SESSION_NAME = /^[\w.-]{1,64}$/;
+function safeFilename(name) {
+    const filename = name.split(/[\\/]/).at(-1)?.replace(/[^\w.-]/g, '-');
+    return filename || 'file';
+}
 /** { json: true, fullPage: true, depth: 2 } → ["--json", "--full-page", "--depth", "2"] */ function flagsToArgs(flags) {
     const args = [];
     for (const [key, value] of Object.entries(flags)){
@@ -45,13 +32,70 @@ const SESSION_NAME = /^[\w.-]{1,64}$/;
     }
     return args;
 }
-function withSession(session, args) {
+function withSession(session, clientArgs, commandArgs) {
     return [
         '--session',
         session,
-        ...args
+        ...clientArgs,
+        ...commandArgs
     ];
 }
+function positionalArgs(args) {
+    const positionals = [];
+    for(let index = 0; index < args.length; index++){
+        const arg = args[index];
+        if (!arg.startsWith('-')) {
+            positionals.push(arg);
+        } else if (!arg.includes('=') && FLAGS_WITH_VALUE.has(arg)) {
+            index++;
+        }
+    }
+    return positionals;
+}
+function flagValue(args, flag) {
+    const prefixed = args.find((arg)=>arg.startsWith(`${flag}=`));
+    if (prefixed) return prefixed.slice(flag.length + 1);
+    const index = args.lastIndexOf(flag);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function outputSpec(args) {
+    const [command, ...rest] = args;
+    const positionals = positionalArgs(rest);
+    if (command === 'screenshot' && positionals.length === 0) {
+        const format = flagValue(rest, '--screenshot-format')?.toLowerCase();
+        return format === 'jpeg' ? {
+            ext: 'jpeg',
+            contentType: 'image/jpeg'
+        } : {
+            ext: 'png',
+            contentType: 'image/png'
+        };
+    }
+    if (command === 'pdf' && positionals.length === 0) {
+        return {
+            ext: 'pdf',
+            contentType: 'application/pdf'
+        };
+    }
+    if ((command === 'trace' || command === 'profiler') && positionals.length === 1 && positionals[0] === 'stop') {
+        return {
+            ext: 'json',
+            contentType: 'application/json'
+        };
+    }
+    if (command === 'network' && positionals.length === 2 && positionals[0] === 'har' && positionals[1] === 'stop') {
+        return {
+            ext: 'har',
+            contentType: 'application/json'
+        };
+    }
+    if (command === 'state' && positionals.length === 1 && positionals[0] === 'save') {
+        return {
+            ext: 'json',
+            contentType: 'application/json'
+        };
+    }
+}
 /**
  * Create a session-oriented browser client over any CommandRunner.
  *
@@ -64,28 +108,47 @@ function withSession(session, args) {
     if (!SESSION_NAME.test(session)) {
         throw new Error(`session must match [A-Za-z0-9_.-]{1,64}, got "${session}"`);
     }
+    const clientArgs = [
+        ...opts.args ?? []
+    ];
     const ownsRunner = opts.ownsRunner ?? true;
+    const recordings = new Map();
     let closed = false;
     function assertOpen() {
         if (closed) throw new Error('AgentBrowser is closed');
     }
     async function execCommand(args, timeoutMs, useSession = session) {
         const [name, ...rest] = args;
-        // File-producing commands: inject a remote path and pull the bytes back,
-        // unless the caller already supplied an output path themselves.
-        const fileSpec = name ? FILE_OUTPUT[name] : undefined;
-        const positionals = rest.filter((a)=>!a.startsWith('-'));
-        const wantsFile = fileSpec && (fileSpec.subcommand === null ? positionals.length === 0 : positionals.length === 1 && positionals[0] === fileSpec.subcommand);
-        let finalArgs = withSession(useSession, args);
+        // File-producing commands get a temporary remote output path when the
+        // caller did not provide one. The bytes are pulled back after completion.
+        let fileSpec = outputSpec(args);
+        const recordAction = name === 'record' ? positionalArgs(rest) : [];
+        const startsRecording = recordAction.length === 1 && (recordAction[0] === 'start' || recordAction[0] === 'restart');
+        const stopsRecording = recordAction.length === 1 && recordAction[0] === 'stop';
+        let finalArgs = withSession(useSession, clientArgs, args);
         let remotePath;
-        if (wantsFile) {
+        if (fileSpec) {
             remotePath = `/tmp/agent-browser-${randomUUID()}.${fileSpec.ext}`;
-            // screenshot <path> is the first positional for these commands
-            finalArgs = withSession(useSession, [
+            finalArgs = withSession(useSession, clientArgs, [
                 name,
                 ...rest,
                 remotePath
             ]);
+        } else if (startsRecording) {
+            fileSpec = {
+                ext: 'webm',
+                contentType: 'video/webm'
+            };
+            remotePath = `/tmp/agent-browser-${randomUUID()}.webm`;
+            finalArgs = withSession(useSession, clientArgs, [
+                name,
+                recordAction[0],
+                remotePath
+            ]);
+        } else if (stopsRecording) {
+            const recording = recordings.get(useSession);
+            remotePath = recording?.path;
+            fileSpec = recording?.spec;
         }
         const run = await runner.run('agent-browser', finalArgs, {
             timeoutMs
@@ -97,7 +160,12 @@ function withSession(session, args) {
             stdout: run.stdout,
             stderr: run.stderr
         };
-        if (result.ok && remotePath && fileSpec) {
+        if (result.ok && startsRecording && remotePath && fileSpec) {
+            recordings.set(useSession, {
+                path: remotePath,
+                spec: fileSpec
+            });
+        } else if (result.ok && remotePath && fileSpec) {
             try {
                 result.file = {
                     path: remotePath,
@@ -109,8 +177,45 @@ function withSession(session, args) {
                 result.stderr += `\ncommand succeeded but ${remotePath} could not be read: ${error instanceof Error ? error.message : String(error)}`;
             }
         }
+        if (stopsRecording) recordings.delete(useSession);
         return result;
     }
+    async function exec(command, execOpts = {}) {
+        assertOpen();
+        const jsonOutput = execOpts.output === 'json';
+        const flags = jsonOutput ? {
+            ...execOpts.flags,
+            json: true
+        } : execOpts.flags;
+        const args = [
+            command,
+            ...execOpts.args ?? [],
+            ...flags ? flagsToArgs(flags) : []
+        ];
+        const useSession = execOpts.session ?? session;
+        if (!SESSION_NAME.test(useSession)) {
+            throw new Error(`session must match [A-Za-z0-9_.-]{1,64}, got "${useSession}"`);
+        }
+        const result = await execCommand(args, execOpts.timeoutMs, useSession);
+        if (!jsonOutput) return result;
+        if (!result.ok) {
+            const details = result.stderr.trim() || result.stdout.trim() || 'unknown error';
+            throw new Error(`agent-browser ${command} failed with exit code ${result.exitCode}: ${details}`);
+        }
+        let envelope;
+        try {
+            envelope = JSON.parse(result.stdout);
+        } catch (error) {
+            throw new SyntaxError(`agent-browser ${command} did not return valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (typeof envelope !== 'object' || envelope === null || !('success' in envelope) || envelope.success !== true || !('data' in envelope)) {
+            throw new SyntaxError(`agent-browser ${command} did not return a successful JSON envelope`);
+        }
+        return {
+            ...result,
+            data: envelope.data
+        };
+    }
     return {
         session,
         async run (commands, runOpts = {}) {
@@ -144,44 +249,81 @@ function withSession(session, args) {
                 ok: results.every((r)=>r.ok)
             };
         },
-        async exec (command, execOpts = {}) {
+        exec,
+        async upload (selector, files, execOpts = {}) {
             assertOpen();
-            const args = [
-                command,
-                ...execOpts.args ?? [],
-                ...execOpts.flags ? flagsToArgs(execOpts.flags) : []
-            ];
-            const useSession = execOpts.session ?? session;
-            if (!SESSION_NAME.test(useSession)) {
-                throw new Error(`session must match [A-Za-z0-9_.-]{1,64}, got "${useSession}"`);
+            if (files.length === 0) throw new Error('upload requires at least one file');
+            const remotePaths = [];
+            for (const file of files){
+                const remotePath = `/tmp/agent-browser-${randomUUID()}-${safeFilename(file.name)}`;
+                await runner.writeFile(remotePath, file.bytes);
+                remotePaths.push(remotePath);
             }
-            return execCommand(args, execOpts.timeoutMs, useSession);
+            return this.exec('upload', {
+                ...execOpts,
+                args: [
+                    selector,
+                    ...remotePaths
+                ]
+            });
         },
-        async snapshot (url, runOpts = {}) {
-            return this.run([
+        async download (selector, execOpts = {}) {
+            assertOpen();
+            const remotePath = `/tmp/agent-browser-${randomUUID()}-${safeFilename(execOpts.filename ?? 'download')}`;
+            const result = await this.exec('download', {
+                session: execOpts.session,
+                timeoutMs: execOpts.timeoutMs,
+                args: [
+                    selector,
+                    remotePath
+                ]
+            });
+            if (!result.ok) throw new Error(`download failed: ${result.stderr || result.stdout}`);
+            try {
+                result.file = {
+                    path: remotePath,
+                    bytes: await runner.readFile(remotePath),
+                    contentType: 'application/octet-stream'
+                };
+            } catch (error) {
+                throw new Error(`download succeeded but ${remotePath} could not be read: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return {
+                file: result.file,
+                result
+            };
+        },
+        async snapshot (urlOrOptions, opts = {}) {
+            const url = typeof urlOrOptions === 'string' ? urlOrOptions : undefined;
+            const runOpts = typeof urlOrOptions === 'string' ? opts : urlOrOptions ?? {};
+            const commands = url ? [
                 [
                     'open',
                     url
-                ],
-                [
-                    'snapshot',
-                    '-i',
-                    '--json'
                 ]
-            ], runOpts);
+            ] : [];
+            commands.push([
+                'snapshot',
+                '-i',
+                '--json'
+            ]);
+            return this.run(commands, runOpts);
         },
-        async screenshot (url, runOpts = {}) {
+        async screenshot (urlOrOptions, opts = {}) {
+            const url = typeof urlOrOptions === 'string' ? urlOrOptions : undefined;
+            const runOpts = typeof urlOrOptions === 'string' ? opts : urlOrOptions ?? {};
             const shotArgs = [
                 'screenshot'
             ];
             if (runOpts.fullPage) shotArgs.push('--full');
-            const run = await this.run([
+            const commands = url ? [
                 [
                     'open',
                     url
-                ],
-                shotArgs
-            ], runOpts);
+                ]
+            ] : [];
+            commands.push(shotArgs);
+            const run = await this.run(commands, runOpts);
             const file = run.results.find((r)=>r.file)?.file;
             if (!file) {
                 throw new Error(`screenshot failed: ${run.results.map((r)=>r.stderr || r.stdout).join('\n') || 'no output'}`);
@@ -195,7 +337,7 @@ function withSession(session, args) {
             if (closed) return;
             closed = true;
             // Close the CLI session's browser first so the sandbox can stop cleanly.
-            await runner.run('agent-browser', withSession(session, [
+            await runner.run('agent-browser', withSession(session, clientArgs, [
                 'close'
             ]), {
                 timeoutMs: 15_000
@@ -266,6 +408,14 @@ const BASE_ENV = {
         }
         return Buffer.from(stdout.trim(), 'base64');
     }
+    async writeFile(path, bytes) {
+        await this.sandbox.writeFiles([
+            {
+                path,
+                content: bytes
+            }
+        ]);
+    }
     async close() {
         await this.sandbox.stop().catch(()=>{});
     }
@@ -307,9 +457,9 @@ const BASE_ENV = {
  * `vercel login`), via @vercel/sandbox.
  *
  * ```ts
- * import { createAgentBrowser } from 'remote-agent-browser'
+ * import { AgentBrowser } from 'remote-agent-browser'
  *
- * const browser = await createAgentBrowser()
+ * const browser = await AgentBrowser.create()
  * const { results } = await browser.run([
  *   ['open', 'https://example.com'],
  *   ['snapshot', '-i', '--json'],
@@ -325,8 +475,15 @@ const BASE_ENV = {
     });
     return createBrowserClient(runner, {
         session: opts.session,
+        args: opts.args,
         ownsRunner: true
     });
 }
 
-export { createAgentBrowser, createBrowserClient };
+// Public library surface: create an agent browser in a Vercel Sandbox and
+// drive it with the agent-browser CLI.
+/** Create AgentBrowser clients backed by a fresh Vercel Sandbox. */ const AgentBrowser = {
+    create: createAgentBrowser
+};
+
+export { AgentBrowser, createAgentBrowser, createBrowserClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-agent-browser",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Run agent-browser in a Vercel Sandbox created from a browser-ready container image",
   "license": "MIT",
   "repository": {
@@ -27,8 +27,7 @@
     "test:unit": "node --run build && node --test tests/unit.test.mjs"
   },
   "files": [
-    "dist",
-    "Dockerfile.sandbox"
+    "dist"
   ],
   "dependencies": {
     "@vercel/sandbox": "^2.9.0"

package/Dockerfile.sandbox

@@ -1,19 +0,0 @@
-FROM node:24-slim
-
-# Keep the browser and its native CLI in the image so Sandbox creation never
-# installs packages at runtime. Debian Chromium supports amd64 and arm64.
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        chromium \
-        fonts-liberation \
-        fonts-noto-color-emoji \
-    && rm -rf /var/lib/apt/lists/* \
-    && npm install -g --allow-scripts=agent-browser agent-browser
-
-ENV AGENT_BROWSER_EXECUTABLE_PATH=/usr/bin/chromium
-ENV AGENT_BROWSER_ARGS="--no-sandbox,--disable-dev-shm-usage,--disable-gpu"
-ENV AGENT_BROWSER_DEFAULT_TIMEOUT=25000
-
-# Vercel Sandbox uses bash to execute commands in custom images.
-WORKDIR /vercel/sandbox
-CMD ["/bin/bash"]