@nuanu-ai/agentbrowse 0.1.0

package/dist/commands/status.js

@@ -0,0 +1,47 @@
+/**
+ * browse status — Check browser state (alive, current URL, title).
+ */
+import { loadSession, isSessionAlive, getSessionPort, supportsCaptchaSolve } from '../session.js';
+import { outputJSON } from '../output.js';
+export async function status() {
+    const session = loadSession();
+    const port = getSessionPort(session);
+    if (!session || !isSessionAlive(session)) {
+        // Try CDP endpoint directly — Chrome may have been launched externally
+        try {
+            const res = await fetch(`http://localhost:${port}/json/version`);
+            if (res.ok) {
+                // Chrome is running but no session file — get page info via CDP
+                const listRes = await fetch(`http://localhost:${port}/json/list`);
+                const targets = (await listRes.json());
+                const page = targets.find((t) => t.type === 'page' && !t.url.startsWith('devtools://'));
+                outputJSON({
+                    success: true,
+                    alive: true,
+                    url: page?.url ?? 'unknown',
+                    title: page?.title ?? 'unknown',
+                });
+            }
+        }
+        catch {
+            // Chrome not running
+        }
+        outputJSON({ success: true, alive: false });
+    }
+    // Session exists and PID is alive — get page info via CDP
+    try {
+        const listRes = await fetch(`http://localhost:${port}/json/list`);
+        const targets = (await listRes.json());
+        const page = targets.find((t) => t.type === 'page' && !t.url.startsWith('devtools://'));
+        outputJSON({
+            success: true,
+            alive: true,
+            captchaSolveCapable: supportsCaptchaSolve(session),
+            url: page?.url ?? 'unknown',
+            title: page?.title ?? 'unknown',
+        });
+    }
+    catch {
+        outputJSON({ success: true, alive: false });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+import { config as loadEnv } from 'dotenv';
+loadEnv();
+import { loadSession } from './session.js';
+import { outputError, fatal, info } from './output.js';
+const USAGE = `Usage: agentbrowse <command> [args] [options]
+
+Commands:
+  launch [url] [options]          Launch browser, optionally navigate to URL
+  solve-captcha [--timeout <s>]   Wait for captcha and solve it on current page
+  navigate <url>                  Navigate current tab to URL
+  act "<instruction>"             Perform an action (click, type, scroll...)
+  extract "<instruction>"         Extract data from the page
+  observe ["<instruction>"]       Discover available actions/elements
+  screenshot [--path <file>]      Capture a screenshot
+  status                          Check browser state
+  close                           Close browser and clean up
+
+Options:
+  --compact                       Launch browser in compact window size (1280x900, default)
+  --full                          Launch browser in full-size window
+  --profile <name>                Solver profile name for launch (default: "default")
+  --headless                      Launch browser in headless mode
+  --schema '<json>'               Schema for extract (e.g. '{"price":"number"}')
+  --variables '<json>'            Variables for act (sensitive, not sent to LLM)
+  --path <file>                   Output path for screenshot
+  --timeout <seconds>             Timeout for solve-captcha command (default: 90)
+  --help                          Show this help message
+
+Environment:
+  ANTHROPIC_API_KEY               Required for browsing commands
+  AGENTBROWSE_MODEL               Optional model override for browsing commands
+  AGENTPAY_API_KEY                Required only for solve-captcha / gateway-backed solve
+  AGENTPAY_API_URL                Optional API base URL override for solve-captcha`;
+const KNOWN_COMMANDS = new Set([
+    'launch',
+    'navigate',
+    'solve-captcha',
+    'solve',
+    'captcha-solve',
+    'act',
+    'extract',
+    'observe',
+    'screenshot',
+    'status',
+    'close',
+]);
+function getCommand() {
+    const rawArgs = process.argv.slice(2);
+    if (rawArgs.length === 0 || rawArgs[0] === '--help') {
+        info(USAGE);
+        process.exit(0);
+    }
+    const command = rawArgs[0];
+    const args = rawArgs.slice(1);
+    return { command, args };
+}
+/** Parse --key value or --key 'value' from args array. */
+function getFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    return args[idx + 1];
+}
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+/** Get the first positional argument (not starting with --). */
+function getPositional(args, valueFlags = []) {
+    const valueFlagSet = new Set(valueFlags);
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            if (valueFlagSet.has(arg)) {
+                i += 1;
+            }
+            continue;
+        }
+        return arg;
+    }
+    return undefined;
+}
+function parseLaunchArgs(args) {
+    let url;
+    let compact = true;
+    let profile;
+    let headless = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--headless') {
+            headless = true;
+            continue;
+        }
+        if (arg === '--compact') {
+            compact = true;
+            continue;
+        }
+        if (arg === '--full') {
+            compact = false;
+            continue;
+        }
+        if (arg === '--profile') {
+            const value = args[i + 1];
+            if (!value || value.startsWith('--')) {
+                outputError('Usage: agentbrowse launch [url] [--profile <name>] [--headless]');
+            }
+            profile = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            outputError(`Unknown launch option: ${arg}`);
+        }
+        if (url) {
+            outputError('Usage: agentbrowse launch [url] [--profile <name>] [--headless]');
+        }
+        url = arg;
+    }
+    return { url, compact, profile, headless };
+}
+function parseCaptchaTimeout(args) {
+    const timeoutRaw = getFlag(args, '--timeout');
+    const timeout = timeoutRaw ? Number(timeoutRaw) : undefined;
+    if (timeoutRaw && (!Number.isFinite(timeout) || timeout <= 0)) {
+        outputError('Invalid --timeout value. Expected a positive number of seconds.');
+    }
+    return timeout;
+}
+/** Require an active browser session, return CDP URL. */
+function requireSession() {
+    const session = loadSession();
+    if (session)
+        return session.cdpUrl;
+    // Fallback: try CDP on port 9222 directly
+    // (Chrome may have been launched by agentpay-cli or externally)
+    // Caller will handle connection errors.
+    return 'ws://localhost:9222';
+}
+async function main() {
+    const parsed = getCommand();
+    if (!parsed)
+        process.exit(1);
+    const { command, args } = parsed;
+    if (!KNOWN_COMMANDS.has(command)) {
+        outputError(`Unknown command: ${command}\n\n${USAGE}`);
+    }
+    switch (command) {
+        case 'launch': {
+            const { launch } = await import('./commands/launch.js');
+            const launchArgs = parseLaunchArgs(args);
+            await launch(launchArgs.url, {
+                compact: launchArgs.compact,
+                profile: launchArgs.profile,
+                headless: launchArgs.headless,
+            });
+            break;
+        }
+        case 'navigate': {
+            const url = getPositional(args);
+            if (!url)
+                outputError('Usage: agentbrowse navigate <url>');
+            const { navigate } = await import('./commands/navigate.js');
+            await navigate(requireSession(), url);
+            break;
+        }
+        case 'solve-captcha': {
+            const timeout = parseCaptchaTimeout(args);
+            const { captchaSolve } = await import('./commands/captcha-solve.js');
+            await captchaSolve(loadSession(), timeout);
+            break;
+        }
+        // Backward-compatible alias.
+        case 'solve': {
+            const target = getPositional(args, ['--timeout']);
+            if (target !== 'captcha') {
+                outputError('Usage: agentbrowse solve captcha [--timeout <seconds>]');
+            }
+            const timeout = parseCaptchaTimeout(args);
+            const { captchaSolve } = await import('./commands/captcha-solve.js');
+            await captchaSolve(loadSession(), timeout);
+            break;
+        }
+        // Backward-compatible alias.
+        case 'captcha-solve': {
+            const timeout = parseCaptchaTimeout(args);
+            const { captchaSolve } = await import('./commands/captcha-solve.js');
+            await captchaSolve(loadSession(), timeout);
+            break;
+        }
+        case 'act': {
+            const instruction = getPositional(args, ['--variables']);
+            if (!instruction)
+                outputError('Usage: agentbrowse act "<instruction>"');
+            let variables;
+            const varsJson = getFlag(args, '--variables');
+            if (varsJson) {
+                try {
+                    variables = JSON.parse(varsJson);
+                }
+                catch {
+                    outputError('Invalid --variables JSON');
+                }
+            }
+            const { act } = await import('./commands/act.js');
+            await act(requireSession(), instruction, variables);
+            break;
+        }
+        case 'extract': {
+            const instruction = getPositional(args, ['--schema']);
+            if (!instruction)
+                outputError('Usage: agentbrowse extract "<instruction>"');
+            const schemaJson = getFlag(args, '--schema');
+            const { extract } = await import('./commands/extract.js');
+            await extract(requireSession(), instruction, schemaJson);
+            break;
+        }
+        case 'observe': {
+            const instruction = getPositional(args);
+            const { observe } = await import('./commands/observe.js');
+            await observe(requireSession(), instruction);
+            break;
+        }
+        case 'screenshot': {
+            if (hasFlag(args, '--help')) {
+                info('Usage: agentbrowse screenshot [--path <file>]');
+                process.exit(0);
+            }
+            const filePath = getFlag(args, '--path');
+            const { screenshot } = await import('./commands/screenshot.js');
+            await screenshot(requireSession(), filePath);
+            break;
+        }
+        case 'status': {
+            const { status } = await import('./commands/status.js');
+            await status();
+            break;
+        }
+        case 'close': {
+            const { close } = await import('./commands/close.js');
+            await close();
+            break;
+        }
+    }
+}
+main().catch((err) => {
+    fatal(err instanceof Error ? err.message : String(err));
+});

package/dist/output.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Structured output helpers.
+ * Human-readable text to stdout/stderr.
+ */
+export interface BrowseResult {
+    success: boolean;
+    error?: string;
+    url?: string;
+    title?: string;
+    [key: string]: unknown;
+}
+/** Write result to stdout and exit. Errors go to stderr with exit 1. */
+export declare function outputJSON(result: BrowseResult): never;
+/** Write error to stderr and exit 1. */
+export declare function outputError(error: string): never;
+/** Write a progress/info message to stderr. */
+export declare function info(message: string): void;
+/** Fatal crash — unhandled error, exit 1. */
+export declare function fatal(message: string): never;
+//# sourceMappingURL=output.d.ts.map

package/dist/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../src/output.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AASD,wEAAwE;AACxE,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,CAsBtD;AAED,wCAAwC;AACxC,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAEhD;AAED,+CAA+C;AAC/C,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE1C;AAED,6CAA6C;AAC7C,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAG5C"}

package/dist/output.js

@@ -0,0 +1,48 @@
+/**
+ * Structured output helpers.
+ * Human-readable text to stdout/stderr.
+ */
+/** Format a value for display. Objects/arrays → indented JSON, rest → string. */
+function formatValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'object')
+        return JSON.stringify(value, null, 2);
+    return String(value);
+}
+/** Write result to stdout and exit. Errors go to stderr with exit 1. */
+export function outputJSON(result) {
+    if (!result.success) {
+        process.stderr.write(`${result.error}\n`);
+        process.exit(1);
+    }
+    const { success: _, ...rest } = result;
+    const entries = Object.entries(rest).filter(([, v]) => v !== undefined);
+    if (entries.length === 0) {
+        process.exit(0);
+    }
+    const maxKey = Math.max(...entries.map(([k]) => k.length));
+    for (const [key, value] of entries) {
+        const formatted = formatValue(value);
+        if (typeof value === 'object' && value !== null) {
+            process.stdout.write(`${key}:\n${formatted}\n`);
+        }
+        else {
+            process.stdout.write(`${key.padEnd(maxKey)}  ${formatted}\n`);
+        }
+    }
+    process.exit(0);
+}
+/** Write error to stderr and exit 1. */
+export function outputError(error) {
+    outputJSON({ success: false, error });
+}
+/** Write a progress/info message to stderr. */
+export function info(message) {
+    process.stderr.write(`${message}\n`);
+}
+/** Fatal crash — unhandled error, exit 1. */
+export function fatal(message) {
+    process.stderr.write(`[agentbrowse] Fatal: ${message}\n`);
+    process.exit(1);
+}

package/dist/session.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Session persistence for agentbrowse.
+ * Stores CDP URL + Chrome PID in ~/.agentpay/browse-session.json
+ */
+export interface BrowseSession {
+    cdpUrl: string;
+    pid: number;
+    launchedAt: string;
+    port?: number;
+    profile?: string;
+    capabilities?: {
+        captchaSolve?: boolean;
+    };
+}
+export declare function saveSession(session: BrowseSession): void;
+export declare function loadSession(): BrowseSession | null;
+export declare function getSessionPort(session: BrowseSession | null): number;
+export declare function deleteSession(): void;
+export declare function supportsCaptchaSolve(session: BrowseSession | null): boolean;
+/** Check if the Chrome process from the session is still alive. */
+export declare function isSessionAlive(session: BrowseSession): boolean;
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE;QACb,YAAY,CAAC,EAAE,OAAO,CAAC;KACxB,CAAC;CACH;AAQD,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAGxD;AAED,wBAAgB,WAAW,IAAI,aAAa,GAAG,IAAI,CASlD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,GAAG,MAAM,CAapE;AAED,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,GAAG,OAAO,CAE3E;AAED,mEAAmE;AACnE,wBAAgB,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAO9D"}

package/dist/session.js

@@ -0,0 +1,63 @@
+/**
+ * Session persistence for agentbrowse.
+ * Stores CDP URL + Chrome PID in ~/.agentpay/browse-session.json
+ */
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const SESSION_DIR = join(homedir(), '.agentpay');
+const SESSION_PATH = join(SESSION_DIR, 'browse-session.json');
+function ensureDir() {
+    if (!existsSync(SESSION_DIR)) {
+        mkdirSync(SESSION_DIR, { recursive: true });
+    }
+}
+export function saveSession(session) {
+    ensureDir();
+    writeFileSync(SESSION_PATH, JSON.stringify(session, null, 2));
+}
+export function loadSession() {
+    if (!existsSync(SESSION_PATH))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(SESSION_PATH, 'utf-8'));
+        if (!raw.cdpUrl || !raw.pid)
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+export function getSessionPort(session) {
+    if (session?.port)
+        return session.port;
+    if (session?.cdpUrl) {
+        try {
+            const url = new URL(session.cdpUrl);
+            if (url.port)
+                return Number(url.port);
+        }
+        catch {
+            // Ignore malformed cdpUrl and use default fallback.
+        }
+    }
+    return 9222;
+}
+export function deleteSession() {
+    if (existsSync(SESSION_PATH))
+        unlinkSync(SESSION_PATH);
+}
+export function supportsCaptchaSolve(session) {
+    return session?.capabilities?.captchaSolve === true;
+}
+/** Check if the Chrome process from the session is still alive. */
+export function isSessionAlive(session) {
+    try {
+        process.kill(session.pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/solver/browser-launcher.d.ts

@@ -0,0 +1,12 @@
+import type { Browser, Page } from 'puppeteer';
+import type { LaunchOptions, ProfileInfo } from './types.js';
+export type SolverSession = {
+    browser: Browser;
+    page: Page;
+    cdpUrl: string;
+    profile: ProfileInfo;
+    close: () => Promise<void>;
+    disconnect: () => Promise<void>;
+};
+export declare function launchSolver(profile: ProfileInfo, opts?: LaunchOptions): Promise<SolverSession>;
+//# sourceMappingURL=browser-launcher.d.ts.map

package/dist/solver/browser-launcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-launcher.d.ts","sourceRoot":"","sources":["../../src/solver/browser-launcher.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAsB,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAWjF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,WAAW,CAAC;IACrB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC,CAAC;AAcF,wBAAsB,YAAY,CAChC,OAAO,EAAE,WAAW,EACpB,IAAI,CAAC,EAAE,aAAa,GACnB,OAAO,CAAC,aAAa,CAAC,CA0ExB"}