@nuanu-ai/agentbrowse 0.1.0

package/README.md

@@ -0,0 +1,104 @@
+# @nuanu-ai/agentbrowse
+
+Standalone browser automation CLI for AI agents.
+
+`agentbrowse` launches and controls a CDP-reachable browser, navigates pages,
+observes UI state, performs actions, extracts data, captures screenshots, and
+optionally solves captchas when the active session supports it.
+
+This package is not a payment tool. Payment execution belongs in `agentpay`.
+
+## Install
+
+Run without installing globally:
+
+```bash
+npx @nuanu-ai/agentbrowse launch https://example.com
+```
+
+Or install globally:
+
+```bash
+npm i -g @nuanu-ai/agentbrowse
+agentbrowse launch https://example.com
+```
+
+## Requirements
+
+- Node.js 18+
+- a Chrome-compatible browser runtime available on the machine
+- an Anthropic API key for browsing commands
+
+## Commands
+
+Launch browser and optionally navigate:
+
+```bash
+agentbrowse launch https://example.com
+```
+
+Navigate current session:
+
+```bash
+agentbrowse navigate https://example.com/checkout
+```
+
+Act on the page:
+
+```bash
+agentbrowse act "click the Buy button"
+```
+
+Extract data:
+
+```bash
+agentbrowse extract "get product name and price"
+```
+
+Observe available actions/elements:
+
+```bash
+agentbrowse observe
+```
+
+Solve captcha when the active session supports it:
+
+```bash
+agentbrowse solve-captcha --timeout 90
+```
+
+Inspect or close the current session:
+
+```bash
+agentbrowse status
+agentbrowse close
+```
+
+## Configure
+
+Browsing commands use Anthropic via Stagehand:
+
+```bash
+export ANTHROPIC_API_KEY=...
+```
+
+Optional model override:
+
+```bash
+export AGENTBROWSE_MODEL=anthropic/claude-haiku-4-5-20251001
+```
+
+`solve-captcha` is separate and uses AgentPay gateway credentials only when
+that command is invoked.
+
+## Runtime model
+
+- `agentbrowse` persists the active browser session under `~/.agentpay`
+- browsing commands require `ANTHROPIC_API_KEY`
+- normal browsing commands do not require `AGENTPAY_API_KEY`
+- `solve-captcha` requires both:
+  - a session with captcha-solving capability
+  - AgentPay gateway configuration
+
+Human-readable progress is written to `stderr`. Command results are written to
+`stdout`.

package/dist/agentpay-gateway.d.ts

@@ -0,0 +1,8 @@
+export interface AgentpayGatewayConfig {
+    apiKey: string;
+    apiUrl: string;
+}
+export declare function tryResolveAgentpayGatewayConfig(): AgentpayGatewayConfig | null;
+export declare function resolveAgentpayGatewayConfig(): AgentpayGatewayConfig;
+export declare function applyAgentpayGatewayEnv(gateway: AgentpayGatewayConfig): void;
+//# sourceMappingURL=agentpay-gateway.d.ts.map

package/dist/agentpay-gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentpay-gateway.d.ts","sourceRoot":"","sources":["../src/agentpay-gateway.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAiCD,wBAAgB,+BAA+B,IAAI,qBAAqB,GAAG,IAAI,CAoB9E;AAED,wBAAgB,4BAA4B,IAAI,qBAAqB,CAMpE;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAG5E"}

package/dist/agentpay-gateway.js

@@ -0,0 +1,58 @@
+import { readConfig } from './solver/config.js';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const DEFAULT_AGENTPAY_API_URL = 'https://durcottggsiesxxqzvbb.supabase.co/functions/v1/api';
+function trimOrUndefined(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeApiUrl(value) {
+    return value.replace(/\/$/, '');
+}
+function readAgentpayCliConfig() {
+    const primaryPath = join(homedir(), '.agentpay', 'config.json');
+    const legacyPath = join(homedir(), '.agentpay', 'agentpay-cli', 'config.json');
+    try {
+        return JSON.parse(readFileSync(primaryPath, 'utf-8'));
+    }
+    catch {
+        try {
+            return JSON.parse(readFileSync(legacyPath, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+}
+export function tryResolveAgentpayGatewayConfig() {
+    const solverConfig = readConfig();
+    const cliConfig = readAgentpayCliConfig();
+    const apiKey = trimOrUndefined(process.env.AGENTPAY_API_KEY) ||
+        trimOrUndefined(solverConfig.agentpay?.apiKey) ||
+        trimOrUndefined(cliConfig.agentpay?.apiKey);
+    const apiUrl = trimOrUndefined(process.env.AGENTPAY_API_URL) ||
+        trimOrUndefined(solverConfig.agentpay?.apiUrl) ||
+        trimOrUndefined(cliConfig.agentpay?.apiUrl) ||
+        DEFAULT_AGENTPAY_API_URL;
+    if (!apiKey) {
+        return null;
+    }
+    return {
+        apiKey,
+        apiUrl: normalizeApiUrl(apiUrl),
+    };
+}
+export function resolveAgentpayGatewayConfig() {
+    const gateway = tryResolveAgentpayGatewayConfig();
+    if (!gateway) {
+        throw new Error('Captcha solving requires API key configuration.');
+    }
+    return gateway;
+}
+export function applyAgentpayGatewayEnv(gateway) {
+    process.env.AGENTPAY_API_KEY = gateway.apiKey;
+    process.env.AGENTPAY_API_URL = gateway.apiUrl;
+}

package/dist/commands/act.d.ts

@@ -0,0 +1,5 @@
+/**
+ * browse act "<instruction>" [--variables '<json>'] — Perform an action on the page.
+ */
+export declare function act(cdpUrl: string, instruction: string, variables?: Record<string, string>): Promise<void>;
+//# sourceMappingURL=act.d.ts.map

package/dist/commands/act.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"act.d.ts","sourceRoot":"","sources":["../../src/commands/act.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,wBAAsB,GAAG,CACvB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC,CA0Bf"}

package/dist/commands/act.js

@@ -0,0 +1,30 @@
+/**
+ * browse act "<instruction>" [--variables '<json>'] — Perform an action on the page.
+ */
+import { connectStagehand, getPageInfo } from '../stagehand.js';
+import { outputJSON, outputError } from '../output.js';
+export async function act(cdpUrl, instruction, variables) {
+    let stagehand;
+    try {
+        stagehand = await connectStagehand(cdpUrl);
+    }
+    catch (err) {
+        outputError(`Failed to connect to browser: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        const result = await stagehand.act(instruction, variables ? { variables } : undefined);
+        const { url, title } = await getPageInfo(stagehand);
+        await stagehand.close();
+        outputJSON({
+            success: result.success,
+            action: result.actionDescription ?? instruction,
+            message: result.message,
+            url,
+            title,
+        });
+    }
+    catch (err) {
+        await stagehand.close();
+        outputError(`Act failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/commands/captcha-solve.d.ts

@@ -0,0 +1,6 @@
+/**
+ * browse solve-captcha [--timeout <seconds>] — Solve captcha on current page.
+ */
+import type { BrowseSession } from '../session.js';
+export declare function captchaSolve(session: BrowseSession | null, timeoutSeconds?: number): Promise<void>;
+//# sourceMappingURL=captcha-solve.d.ts.map

package/dist/commands/captcha-solve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captcha-solve.d.ts","sourceRoot":"","sources":["../../src/commands/captcha-solve.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAOnD,wBAAsB,YAAY,CAChC,OAAO,EAAE,aAAa,GAAG,IAAI,EAC7B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CA+Bf"}

package/dist/commands/captcha-solve.js

@@ -0,0 +1,36 @@
+/**
+ * browse solve-captcha [--timeout <seconds>] — Solve captcha on current page.
+ */
+import { solveCaptchasByCdp } from '../solver/captcha-runtime.js';
+import { supportsCaptchaSolve } from '../session.js';
+import { info, outputError, outputJSON } from '../output.js';
+import { applyAgentpayGatewayEnv, resolveAgentpayGatewayConfig } from '../agentpay-gateway.js';
+const DEFAULT_TIMEOUT_SECONDS = 90;
+export async function captchaSolve(session, timeoutSeconds) {
+    if (!session) {
+        outputError('Captcha solving requires an active browser session started with browse launch.');
+    }
+    if (!supportsCaptchaSolve(session)) {
+        outputError('Current browser session does not support captcha solving.');
+    }
+    const gateway = resolveAgentpayGatewayConfig();
+    applyAgentpayGatewayEnv(gateway);
+    const cdpUrl = session.cdpUrl;
+    const timeoutMs = Math.max(1, timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 1000;
+    info(`[captcha] solve-captcha started (timeout ${Math.ceil(timeoutMs / 1000)}s, endpoint ${cdpUrl})`);
+    const result = await solveCaptchasByCdp(cdpUrl, gateway.apiKey, {
+        timeoutMs,
+        solveTimeoutMs: Math.min(timeoutMs, 120000),
+        apiUrl: gateway.apiUrl,
+        onProgress: (message) => info(message),
+    });
+    outputJSON({
+        success: true,
+        solved: result.solved,
+        verified: result.verified,
+        unresolved: result.unresolved,
+        unresolvedCaptchas: result.unresolvedCaptchas,
+        detected: result.detected,
+        timedOut: result.timedOut,
+    });
+}

package/dist/commands/close.d.ts

@@ -0,0 +1,5 @@
+/**
+ * browse close — Close the browser and clean up session.
+ */
+export declare function close(): Promise<void>;
+//# sourceMappingURL=close.d.ts.map

package/dist/commands/close.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close.d.ts","sourceRoot":"","sources":["../../src/commands/close.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,wBAAsB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CA0B3C"}

package/dist/commands/close.js

@@ -0,0 +1,32 @@
+/**
+ * browse close — Close the browser and clean up session.
+ */
+import { execSync } from 'node:child_process';
+import { loadSession, deleteSession, getSessionPort } from '../session.js';
+import { outputJSON, info } from '../output.js';
+export async function close() {
+    const session = loadSession();
+    const port = getSessionPort(session);
+    // Kill Chrome on the current session CDP port regardless of session state
+    try {
+        const out = execSync(`lsof -ti :${port}`, { encoding: 'utf-8' }).trim();
+        if (out) {
+            for (const pid of out.split('\n')) {
+                try {
+                    process.kill(Number(pid), 'SIGTERM');
+                }
+                catch {
+                    /* already dead */
+                }
+            }
+            info(`Killed Chrome on port ${port}`);
+        }
+    }
+    catch {
+        /* no process on port */
+    }
+    if (session) {
+        deleteSession();
+    }
+    outputJSON({ success: true });
+}

package/dist/commands/extract.d.ts

@@ -0,0 +1,5 @@
+/**
+ * browse extract "<instruction>" [--schema '<json>'] — Extract structured data.
+ */
+export declare function extract(cdpUrl: string, instruction: string, schemaJson?: string): Promise<void>;
+//# sourceMappingURL=extract.d.ts.map

package/dist/commands/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/commands/extract.ts"],"names":[],"mappings":"AAAA;;GAEG;AA2BH,wBAAsB,OAAO,CAC3B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CA4Bf"}

package/dist/commands/extract.js

@@ -0,0 +1,59 @@
+/**
+ * browse extract "<instruction>" [--schema '<json>'] — Extract structured data.
+ */
+import { z } from 'zod';
+import { connectStagehand, getPageInfo } from '../stagehand.js';
+import { outputJSON, outputError } from '../output.js';
+/**
+ * Build a Zod schema from a simple JSON type descriptor.
+ * Supports: "string", "number", "boolean", and nested objects.
+ *
+ * Example: {"price": "number", "name": "string"} → z.object({price: z.number(), name: z.string()})
+ */
+function buildSchema(descriptor) {
+    const shape = {};
+    for (const [key, value] of Object.entries(descriptor)) {
+        if (value === 'string')
+            shape[key] = z.string();
+        else if (value === 'number')
+            shape[key] = z.number();
+        else if (value === 'boolean')
+            shape[key] = z.boolean();
+        else if (typeof value === 'object' && value !== null) {
+            shape[key] = buildSchema(value);
+        }
+        else {
+            shape[key] = z.unknown();
+        }
+    }
+    return z.object(shape);
+}
+export async function extract(cdpUrl, instruction, schemaJson) {
+    let stagehand;
+    try {
+        stagehand = await connectStagehand(cdpUrl);
+    }
+    catch (err) {
+        outputError(`Failed to connect to browser: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        if (schemaJson) {
+            const descriptor = JSON.parse(schemaJson);
+            const schema = buildSchema(descriptor);
+            const data = await stagehand.extract(instruction, schema);
+            const { url, title } = await getPageInfo(stagehand);
+            await stagehand.close();
+            outputJSON({ success: true, data, url, title });
+        }
+        else {
+            const result = await stagehand.extract(instruction);
+            const { url, title } = await getPageInfo(stagehand);
+            await stagehand.close();
+            outputJSON({ success: true, extraction: result.extraction, url, title });
+        }
+    }
+    catch (err) {
+        await stagehand.close();
+        outputError(`Extract failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/commands/launch.d.ts

@@ -0,0 +1,10 @@
+/**
+ * browse launch [url] — Start browser session, optionally navigate.
+ */
+export type LaunchCliOptions = {
+    compact?: boolean;
+    profile?: string;
+    headless?: boolean;
+};
+export declare function launch(url?: string, opts?: LaunchCliOptions): Promise<void>;
+//# sourceMappingURL=launch.d.ts.map

package/dist/commands/launch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launch.d.ts","sourceRoot":"","sources":["../../src/commands/launch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAkBH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,wBAAsB,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQjF"}

package/dist/commands/launch.js

@@ -0,0 +1,132 @@
+/**
+ * browse launch [url] — Start browser session, optionally navigate.
+ */
+import { execSync } from 'node:child_process';
+import { readConfig } from '../solver/config.js';
+import { ensureProfile } from '../solver/profile-manager.js';
+import { launchSolver } from '../solver/browser-launcher.js';
+import { saveSession } from '../session.js';
+import { findChromePid } from '../stagehand.js';
+import { outputJSON, outputError } from '../output.js';
+import { applyAgentpayGatewayEnv, tryResolveAgentpayGatewayConfig } from '../agentpay-gateway.js';
+const CDP_PORT = 9222;
+const DEFAULT_PROFILE = 'default';
+const COMPACT_WINDOW = {
+    width: 1280,
+    height: 900,
+};
+export async function launch(url, opts) {
+    await killChromeOnPort(CDP_PORT);
+    const compact = opts?.compact ?? true;
+    const profileName = opts?.profile ?? DEFAULT_PROFILE;
+    const headless = opts?.headless ?? false;
+    await launchManaged(url, profileName, headless, compact);
+}
+async function killChromeOnPort(port) {
+    const pids = getPidsOnPort(port);
+    if (pids.length === 0)
+        return;
+    for (const pid of pids) {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            // Skip stale PID.
+        }
+    }
+    for (let i = 0; i < 20; i++) {
+        if (getPidsOnPort(port).length === 0)
+            return;
+        await sleep(100);
+    }
+    for (const pid of getPidsOnPort(port)) {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            // Skip stale PID.
+        }
+    }
+}
+async function launchManaged(url, profileName, headless, compact) {
+    let session;
+    try {
+        const profile = ensureProfile(profileName);
+        const config = readConfig();
+        const gateway = tryResolveAgentpayGatewayConfig();
+        if (gateway) {
+            applyAgentpayGatewayEnv(gateway);
+        }
+        session = await launchSolver(profile, {
+            headless: headless || config.defaults?.headless,
+            url,
+            cdpPort: CDP_PORT,
+            windowSize: compact ? COMPACT_WINDOW : undefined,
+            captchaSolver: gateway
+                ? {
+                    apiKey: gateway.apiKey,
+                    apiUrl: gateway.apiUrl,
+                    autoSolve: config.defaults?.captchaAutoSolve !== false,
+                }
+                : undefined,
+        });
+    }
+    catch (err) {
+        outputError(`Failed to launch browser: ${formatUnknownError(err)}`);
+    }
+    const chromePid = findChromePid(CDP_PORT) ?? process.pid;
+    saveSession({
+        cdpUrl: session.cdpUrl,
+        pid: chromePid,
+        port: CDP_PORT,
+        profile: profileName,
+        launchedAt: new Date().toISOString(),
+        capabilities: {
+            captchaSolve: true,
+        },
+    });
+    const currentUrl = session.page.url();
+    const title = await session.page.title();
+    await session.disconnect();
+    outputJSON({
+        success: true,
+        runtime: 'managed',
+        captchaSolveCapable: true,
+        profile: profileName,
+        cdpUrl: session.cdpUrl,
+        url: currentUrl,
+        title,
+    });
+}
+function getPidsOnPort(port) {
+    try {
+        const out = execSync(`lsof -ti :${port}`, { encoding: 'utf-8' }).trim();
+        if (!out)
+            return [];
+        return out
+            .split('\n')
+            .map((value) => Number(value))
+            .filter((value) => Number.isFinite(value) && value > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function formatUnknownError(err) {
+    if (err instanceof Error)
+        return err.message;
+    if (typeof err === 'string')
+        return err;
+    if (err && typeof err === 'object') {
+        try {
+            return JSON.stringify(err);
+        }
+        catch {
+            return Object.prototype.toString.call(err);
+        }
+    }
+    return String(err);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/commands/navigate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * browse navigate <url> — Navigate the current tab to a URL.
+ */
+export declare function navigate(cdpUrl: string, targetUrl: string): Promise<void>;
+//# sourceMappingURL=navigate.d.ts.map

package/dist/commands/navigate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigate.d.ts","sourceRoot":"","sources":["../../src/commands/navigate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB/E"}

package/dist/commands/navigate.js

@@ -0,0 +1,26 @@
+/**
+ * browse navigate <url> — Navigate the current tab to a URL.
+ */
+import { connectStagehand, getPageInfo } from '../stagehand.js';
+import { outputJSON, outputError, info } from '../output.js';
+export async function navigate(cdpUrl, targetUrl) {
+    let stagehand;
+    try {
+        stagehand = await connectStagehand(cdpUrl);
+    }
+    catch (err) {
+        outputError(`Failed to connect to browser: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        const page = stagehand.context.pages()[0];
+        await page.goto(targetUrl, { waitUntil: 'domcontentloaded' });
+        info(`Navigated to: ${targetUrl}`);
+    }
+    catch (err) {
+        await stagehand.close();
+        outputError(`Navigation failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const { url, title } = await getPageInfo(stagehand);
+    await stagehand.close();
+    outputJSON({ success: true, url, title });
+}

package/dist/commands/observe.d.ts

@@ -0,0 +1,5 @@
+/**
+ * browse observe ["<instruction>"] — Discover available actions on the page.
+ */
+export declare function observe(cdpUrl: string, instruction?: string): Promise<void>;
+//# sourceMappingURL=observe.d.ts.map

package/dist/commands/observe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../../src/commands/observe.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,wBAAsB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgCjF"}

package/dist/commands/observe.js

@@ -0,0 +1,36 @@
+/**
+ * browse observe ["<instruction>"] — Discover available actions on the page.
+ */
+import { connectStagehand, getPageInfo } from '../stagehand.js';
+import { outputJSON, outputError } from '../output.js';
+export async function observe(cdpUrl, instruction) {
+    let stagehand;
+    try {
+        stagehand = await connectStagehand(cdpUrl);
+    }
+    catch (err) {
+        outputError(`Failed to connect to browser: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        const actions = instruction
+            ? await stagehand.observe(instruction)
+            : await stagehand.observe();
+        const { url, title } = await getPageInfo(stagehand);
+        await stagehand.close();
+        outputJSON({
+            success: true,
+            actions: actions.map((a) => ({
+                description: a.description,
+                selector: a.selector,
+                method: a.method,
+                arguments: a.arguments,
+            })),
+            url,
+            title,
+        });
+    }
+    catch (err) {
+        await stagehand.close();
+        outputError(`Observe failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/commands/screenshot.d.ts

@@ -0,0 +1,5 @@
+/**
+ * browse screenshot [--path <file>] — Capture a screenshot of the current page.
+ */
+export declare function screenshot(cdpUrl: string, filePath?: string): Promise<void>;
+//# sourceMappingURL=screenshot.d.ts.map

package/dist/commands/screenshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenshot.d.ts","sourceRoot":"","sources":["../../src/commands/screenshot.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyBjF"}

package/dist/commands/screenshot.js

@@ -0,0 +1,27 @@
+/**
+ * browse screenshot [--path <file>] — Capture a screenshot of the current page.
+ */
+import { connectStagehand, getPageInfo } from '../stagehand.js';
+import { outputJSON, outputError, info } from '../output.js';
+export async function screenshot(cdpUrl, filePath) {
+    const outputPath = filePath ?? `/tmp/browse-screenshot-${Date.now()}.png`;
+    let stagehand;
+    try {
+        stagehand = await connectStagehand(cdpUrl);
+    }
+    catch (err) {
+        outputError(`Failed to connect to browser: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        const page = stagehand.context.pages()[0];
+        await page.screenshot({ path: outputPath });
+        info(`Screenshot saved: ${outputPath}`);
+        const { url, title } = await getPageInfo(stagehand);
+        await stagehand.close();
+        outputJSON({ success: true, path: outputPath, url, title });
+    }
+    catch (err) {
+        await stagehand.close();
+        outputError(`Screenshot failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,5 @@
+/**
+ * browse status — Check browser state (alive, current URL, title).
+ */
+export declare function status(): Promise<void>;
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,wBAAsB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAgD5C"}