verybot 0.1.8

package/dist/cli/index.js

@@ -0,0 +1,96 @@
+import { handleConfigCommand } from "./config.js";
+import { handleClaudeLogin } from "./claude-login.js";
+import { getVersion } from "../version.js";
+const VERSION_FLAGS = new Set(["--version", "-v"]);
+const HELP_FLAGS = new Set(["--help", "-h", "help"]);
+const HANDLED_SUBCOMMANDS = new Set(["config", "claude-login"]);
+const HOST_FLAG = "--host";
+const PORT_FLAG = "--port";
+const HOST_FLAG_PREFIX = `${HOST_FLAG}=`;
+const PORT_FLAG_PREFIX = `${PORT_FLAG}=`;
+const PORT_MIN = 1;
+const PORT_MAX = 65_535;
+function printHelp() {
+    console.log(`Usage:
+  verybot
+  verybot --host <host> [--port <port>]
+  verybot config get [key]
+  verybot config set <key> <value>
+  verybot config regenerate_gateway_token
+  verybot claude-login
+`);
+}
+function parsePort(raw) {
+    const port = Number(raw);
+    const isValid = Number.isInteger(port) && port >= PORT_MIN && port <= PORT_MAX;
+    if (!isValid) {
+        throw new Error(`Invalid --port value "${raw}". Expected an integer between ${PORT_MIN} and ${PORT_MAX}.`);
+    }
+    return port;
+}
+function parseHost(raw) {
+    const host = raw.trim();
+    if (!host)
+        throw new Error("Missing value for --host");
+    return host;
+}
+function requireFlagValue(argv, idx, flag) {
+    const value = argv[idx + 1];
+    if (!value || value.startsWith("-")) {
+        throw new Error(`Missing value for ${flag}`);
+    }
+    return value;
+}
+/** Parse runtime flags used when launching the main gateway process. */
+export function parseRuntimeCliOptions(argv = process.argv.slice(2)) {
+    const first = argv[0];
+    if (!first)
+        return {};
+    if (VERSION_FLAGS.has(first) || HELP_FLAGS.has(first) || HANDLED_SUBCOMMANDS.has(first))
+        return {};
+    const options = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === HOST_FLAG) {
+            options.gatewayHost = parseHost(requireFlagValue(argv, i, HOST_FLAG));
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith(HOST_FLAG_PREFIX)) {
+            options.gatewayHost = parseHost(arg.slice(HOST_FLAG_PREFIX.length));
+            continue;
+        }
+        if (arg === PORT_FLAG) {
+            options.gatewayPort = parsePort(requireFlagValue(argv, i, PORT_FLAG));
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith(PORT_FLAG_PREFIX)) {
+            options.gatewayPort = parsePort(arg.slice(PORT_FLAG_PREFIX.length));
+        }
+    }
+    return options;
+}
+/**
+ * Route lightweight CLI subcommands without booting the gateway.
+ * Returns a promise (or null) so the caller can await async commands.
+ */
+export function handleCli() {
+    const [cmd, sub, ...rest] = process.argv.slice(2);
+    if (cmd && VERSION_FLAGS.has(cmd)) {
+        console.log(`verybot v${getVersion()}`);
+        return Promise.resolve();
+    }
+    if (cmd && HELP_FLAGS.has(cmd)) {
+        printHelp();
+        return Promise.resolve();
+    }
+    if (cmd === "config") {
+        handleConfigCommand(sub, rest);
+        return Promise.resolve();
+    }
+    if (cmd === "claude-login") {
+        return handleClaudeLogin();
+    }
+    return null;
+}

package/dist/computer/browser/actions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Thin wrappers around Playwright APIs that use BrowserManager for state.
+ * Each action returns a serializable result suitable for tool output.
+ */
+import type { BrowserManager } from "./manager.js";
+/** Prefix a tool output string with the active profile name. */
+export declare function withProfilePrefix(browser: BrowserManager, text: string): string;
+/** Navigate to a URL. Returns the page URL + title + snapshot. */
+export declare function navigate(browser: BrowserManager, url: string, sessionKey?: string): Promise<string>;
+/**
+ * Take an a11y snapshot of the current page, assign refs, store them in manager.
+ * Returns raw snapshot text without a profile prefix — callers add the prefix.
+ */
+export declare function takeSnapshot(browser: BrowserManager, sessionKey?: string): Promise<string>;
+/** Take a screenshot, compress it, return base64 + mediaType. */
+export declare function takeScreenshot(browser: BrowserManager, fullPage?: boolean, sessionKey?: string): Promise<{
+    base64: string;
+    mediaType: string;
+}>;
+/** Click an element by ref. Returns confirmation + auto-snapshot. */
+export declare function click(browser: BrowserManager, ref: string, sessionKey?: string): Promise<string>;
+/** Type text into an input by ref. Optionally submit with Enter. */
+export declare function type(browser: BrowserManager, ref: string, text: string, submit?: boolean, sessionKey?: string): Promise<string>;
+/** Press a keyboard key or combo (e.g. "Enter", "Control+A"). */
+export declare function pressKey(browser: BrowserManager, key: string, sessionKey?: string): Promise<string>;
+/** Switch the browser to a different named profile. Closes the current browser. */
+export declare function switchProfile(browser: BrowserManager, name: string): Promise<string>;
+/** List existing named profiles by reading BROWSER_PROFILES_DIR. */
+export declare function listProfiles(): string[];
+/** Translate Playwright errors into helpful messages for the agent. */
+export declare function toAIFriendlyError(err: unknown): string;

package/dist/computer/browser/actions.js

@@ -0,0 +1,148 @@
+/**
+ * Thin wrappers around Playwright APIs that use BrowserManager for state.
+ * Each action returns a serializable result suitable for tool output.
+ */
+import { readdirSync } from "node:fs";
+import { buildRoleSnapshotFromAriaSnapshot } from "./snapshot.js";
+import { compressScreenshot } from "./screenshot.js";
+import { BROWSER_PROFILES_DIR } from "../../paths.js";
+import { logger } from "../../logger.js";
+const NAVIGATION_TIMEOUT_MS = 30_000;
+const ACTION_TIMEOUT_MS = 10_000;
+const POST_ACTION_SETTLE_MS = 500;
+const POST_KEY_SETTLE_MS = 300;
+const TEXT_PREVIEW_LENGTH = 50;
+const ALLOWED_SCHEMES = new Set(["http:", "https:"]);
+/** Allowed keyboard keys for browser_press_key. */
+const ALLOWED_KEYS = new Set([
+    "Enter", "Escape", "Tab", "Backspace", "Delete", "Space",
+    "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight",
+    "Home", "End", "PageUp", "PageDown",
+    "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",
+]);
+/** Modifier+key pattern (e.g. "Control+A", "Meta+Shift+V"). */
+const MODIFIER_KEY_PATTERN = /^(Control|Meta|Alt|Shift)(\+(Control|Meta|Alt|Shift))*\+[A-Za-z0-9]$/;
+/** Prefix a tool output string with the active profile name. */
+export function withProfilePrefix(browser, text) {
+    return `[profile: ${browser.getActiveProfile()}] ${text}`;
+}
+/** Navigate to a URL. Returns the page URL + title + snapshot. */
+export async function navigate(browser, url, sessionKey) {
+    // Validate URL scheme to prevent SSRF (file://, javascript:, etc.)
+    const parsed = new URL(url);
+    if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
+        throw new Error(`Unsupported URL scheme: ${parsed.protocol}. Only http and https are allowed.`);
+    }
+    const page = await browser.launch(sessionKey);
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: NAVIGATION_TIMEOUT_MS });
+    const title = await page.title();
+    // Auto-snapshot after navigation
+    const snapshot = await takeSnapshot(browser, sessionKey);
+    return withProfilePrefix(browser, `Navigated to: ${page.url()}\nTitle: ${title}\n\n${snapshot}`);
+}
+/**
+ * Take an a11y snapshot of the current page, assign refs, store them in manager.
+ * Returns raw snapshot text without a profile prefix — callers add the prefix.
+ */
+export async function takeSnapshot(browser, sessionKey) {
+    const page = browser.getPage(sessionKey);
+    if (!page)
+        throw new Error("Browser not open. Use browser_navigate first.");
+    const ariaText = await page.locator(":root").ariaSnapshot();
+    const { snapshot, refs } = buildRoleSnapshotFromAriaSnapshot(ariaText);
+    browser.setRoleRefs(refs, sessionKey);
+    const refCount = Object.keys(refs).length;
+    return `[${page.url()}]\n${snapshot}\n\n(${refCount} refs assigned — use ref like "e1" to interact)`;
+}
+/** Take a screenshot, compress it, return base64 + mediaType. */
+export async function takeScreenshot(browser, fullPage, sessionKey) {
+    const page = browser.getPage(sessionKey);
+    if (!page)
+        throw new Error("Browser not open. Use browser_navigate first.");
+    const png = await page.screenshot({ fullPage: fullPage ?? false });
+    return compressScreenshot(Buffer.from(png));
+}
+/** Click an element by ref. Returns confirmation + auto-snapshot. */
+export async function click(browser, ref, sessionKey) {
+    const locator = browser.refLocator(ref, sessionKey);
+    await locator.click({ timeout: ACTION_TIMEOUT_MS });
+    // Short wait for navigation/rendering to settle
+    const pageAfterClick = browser.getPage(sessionKey);
+    if (pageAfterClick)
+        await pageAfterClick.waitForTimeout(POST_ACTION_SETTLE_MS);
+    // Auto-snapshot after click
+    const snapshot = await takeSnapshot(browser, sessionKey);
+    return withProfilePrefix(browser, `Clicked ref=${ref}\n\n${snapshot}`);
+}
+/** Type text into an input by ref. Optionally submit with Enter. */
+export async function type(browser, ref, text, submit, sessionKey) {
+    const locator = browser.refLocator(ref, sessionKey);
+    await locator.fill(text, { timeout: ACTION_TIMEOUT_MS });
+    if (submit) {
+        await locator.press("Enter");
+        const pageAfterSubmit = browser.getPage(sessionKey);
+        if (pageAfterSubmit)
+            await pageAfterSubmit.waitForTimeout(POST_ACTION_SETTLE_MS);
+    }
+    // Auto-snapshot after typing
+    const snapshot = await takeSnapshot(browser, sessionKey);
+    const preview = text.length > TEXT_PREVIEW_LENGTH
+        ? `${text.slice(0, TEXT_PREVIEW_LENGTH)}...`
+        : text;
+    return withProfilePrefix(browser, `Typed "${preview}" into ref=${ref}${submit ? " (submitted)" : ""}\n\n${snapshot}`);
+}
+/** Press a keyboard key or combo (e.g. "Enter", "Control+A"). */
+export async function pressKey(browser, key, sessionKey) {
+    const page = browser.getPage(sessionKey);
+    if (!page)
+        throw new Error("Browser not open. Use browser_navigate first.");
+    // Validate key to prevent arbitrary keyboard sequences
+    if (!ALLOWED_KEYS.has(key) && !MODIFIER_KEY_PATTERN.test(key)) {
+        throw new Error(`Key "${key}" is not allowed. Use single keys (Enter, Escape, ArrowDown, Tab, etc.) or modifier combos (Control+A, Meta+C, etc.).`);
+    }
+    await page.keyboard.press(key);
+    await page.waitForTimeout(POST_KEY_SETTLE_MS);
+    return withProfilePrefix(browser, `Pressed key: ${key}`);
+}
+/** Switch the browser to a different named profile. Closes the current browser. */
+export async function switchProfile(browser, name) {
+    const previous = browser.getActiveProfile();
+    await browser.switchProfile(name);
+    const profiles = listProfiles();
+    return withProfilePrefix(browser, `Switched from "${previous}" to "${name}". Browser closed — it will relaunch with the new profile on next navigation.\n\nAvailable profiles: ${profiles.join(", ")}`);
+}
+/** List existing named profiles by reading BROWSER_PROFILES_DIR. */
+export function listProfiles() {
+    try {
+        const entries = readdirSync(BROWSER_PROFILES_DIR, { withFileTypes: true });
+        const profiles = entries
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+        // Always include "default" even if dir doesn't exist under profiles/
+        if (!profiles.includes("default"))
+            profiles.unshift("default");
+        return profiles;
+    }
+    catch (err) {
+        logger.warn(`Failed to list browser profiles: ${err instanceof Error ? err.message : err}`);
+        return ["default"];
+    }
+}
+/** Translate Playwright errors into helpful messages for the agent. */
+export function toAIFriendlyError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("Timeout")) {
+        return `Action timed out -- the element may not be visible or the page may still be loading. Try taking a fresh snapshot.`;
+    }
+    if (msg.includes("not attached") || msg.includes("detached")) {
+        return `Element is no longer on the page (DOM changed). Take a fresh snapshot and use updated refs.`;
+    }
+    if (msg.includes("intercepts pointer events") || msg.includes("is not clickable")) {
+        return `Element is hidden behind another element. Try scrolling or closing overlays first.`;
+    }
+    if (msg.includes("Unknown ref") || msg.includes("not allowed") || msg.includes("Unsupported URL") || msg.includes("Profile name")) {
+        return msg;
+    }
+    logger.error(`Browser action error: ${msg}`);
+    return `Browser error: ${msg}`;
+}

package/dist/computer/browser/context-manager.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Browser Context Manager - manages browser instances across multiple sessions.
+ */
+import type { BrowserManager } from "./manager.js";
+import type { BrowserConfig } from "./manager.js";
+/**
+ * Get or create a BrowserManager for the given session.
+ */
+export declare function getBrowserManager(sessionId: string, config?: BrowserConfig): BrowserManager;
+/**
+ * Release a session's browser manager and clean up resources.
+ */
+export declare function releaseBrowserManager(sessionId: string): Promise<void>;
+/**
+ * Close all browser managers and clean up resources.
+ */
+export declare function closeAllBrowsers(): Promise<void>;
+/**
+ * Get all active sessions.
+ */
+export declare function getActiveSessions(): string[];
+/**
+ * Get browser statistics.
+ */
+export declare function getBrowserStats(): {
+    totalSessions: number;
+    activeSessions: string[];
+};

package/dist/computer/browser/context-manager.js

@@ -0,0 +1,78 @@
+/**
+ * Browser Context Manager - manages browser instances across multiple sessions.
+ */
+import { BrowserManager as BM } from "./manager.js";
+import { logger } from "../../logger.js";
+/**
+ * Global registry of browser managers per session.
+ */
+const SESSION_MANAGERS = new Map();
+/**
+ * Get or create a BrowserManager for the given session.
+ */
+export function getBrowserManager(sessionId, config) {
+    if (SESSION_MANAGERS.has(sessionId)) {
+        return SESSION_MANAGERS.get(sessionId);
+    }
+    const finalConfig = config || {};
+    const manager = new BM(finalConfig);
+    manager.setSessionKey(sessionId);
+    SESSION_MANAGERS.set(sessionId, manager);
+    logger.info(`Created BrowserManager for session: ${sessionId}`);
+    return manager;
+}
+/**
+ * Release a session's browser manager and clean up resources.
+ */
+export async function releaseBrowserManager(sessionId) {
+    const manager = SESSION_MANAGERS.get(sessionId);
+    if (!manager)
+        return;
+    logger.info(`Releasing BrowserManager for session: ${sessionId}`);
+    const pages = manager.getSessionPages(sessionId);
+    for (const page of pages) {
+        try {
+            await page.close();
+        }
+        catch (err) {
+            logger.warn(`Failed to close page for session ${sessionId}: ${err}`);
+        }
+    }
+    SESSION_MANAGERS.delete(sessionId);
+}
+/**
+ * Close all browser managers and clean up resources.
+ */
+export async function closeAllBrowsers() {
+    const managers = Array.from(SESSION_MANAGERS.values());
+    const seenContexts = new Set();
+    for (const manager of managers) {
+        const contextId = manager['context']?.toString();
+        if (contextId && !seenContexts.has(contextId)) {
+            try {
+                await manager.close();
+                seenContexts.add(contextId);
+            }
+            catch (err) {
+                logger.warn(`Failed to close browser: ${err}`);
+            }
+        }
+    }
+    SESSION_MANAGERS.clear();
+    logger.info("All browsers closed");
+}
+/**
+ * Get all active sessions.
+ */
+export function getActiveSessions() {
+    return Array.from(SESSION_MANAGERS.keys());
+}
+/**
+ * Get browser statistics.
+ */
+export function getBrowserStats() {
+    return {
+        totalSessions: SESSION_MANAGERS.size,
+        activeSessions: getActiveSessions(),
+    };
+}

package/dist/computer/browser/manager.d.ts

@@ -0,0 +1,91 @@
+import type { Page } from "playwright";
+import type { RoleRefMap } from "./snapshot.js";
+import type { BrowserModeConfig } from "./types.js";
+/** Validate a profile name. Throws on invalid input. */
+export declare function validateProfileName(name: string): void;
+export interface BrowserConfig extends BrowserModeConfig {
+    headless?: boolean;
+    /**
+     * Chrome user-data-dir.
+     * - `undefined` (default): uses the shared persistent profile (`BROWSER_PROFILE_DIR`).
+     * - `"temp"`: creates a fresh temp dir per launch (used for worker isolation).
+     * - any other string: uses that path as-is.
+     */
+    profileDir?: string | "temp";
+    /** Named profile (e.g. "work", "personal"). Default: "default". */
+    profile?: string;
+    /** Custom User-Agent string. When unset, auto-detects a clean UA from the real browser. */
+    userAgent?: string;
+}
+export declare class BrowserManager {
+    private static cachedCleanUAByMode;
+    private context;
+    private config;
+    private roleRefs;
+    private sessionRoleRefs;
+    private activeProfile;
+    private tempProfileDir;
+    private sessionPages;
+    private currentSessionKey;
+    constructor(config: BrowserConfig);
+    private isPerTabMode;
+    private resolveSessionKey;
+    private ensureSessionPages;
+    private trackPageForSession;
+    private pruneClosedPages;
+    /**
+     * Set the current session key for page tracking (per-tab-per-session mode).
+     * Called by buildRunTools() to bind tools to a specific session.
+     */
+    setSessionKey(key: string | null): void;
+    /**
+     * Get the current session key (if set).
+     */
+    getSessionKey(): string | null;
+    /**
+     * MODIFIED: launch() now session-aware
+     * If mode is "per-tab-per-session" and sessionKey is set,
+     * pages are tracked per session.
+     */
+    launch(sessionKey?: string): Promise<Page>;
+    /**
+     * Probe-launch Chromium once per mode to derive a stable UA without "HeadlessChrome".
+     * This protects the initial page in persistent contexts where plugin hooks may not run yet.
+     */
+    private detectCleanUA;
+    /** Resolve the user-data directory for the active named profile. */
+    private resolveProfileDir;
+    /** Close current browser and switch to a different named profile. */
+    switchProfile(name: string): Promise<void>;
+    /** Get the currently active profile name. */
+    getActiveProfile(): string;
+    /** Update config for next browser launch. Closes existing browser if headless mode changed. */
+    updateConfig(config: BrowserConfig): Promise<void>;
+    /**
+     * MODIFIED: getPage() respects session boundary in per-tab mode
+     */
+    getPage(sessionKey?: string): Page | null;
+    /** Check if the browser is currently launched. */
+    isLaunched(): boolean;
+    /** Store role refs from the latest snapshot. */
+    setRoleRefs(refs: RoleRefMap, sessionKey?: string): void;
+    /** Get stored role refs from the latest snapshot. */
+    getRoleRefs(sessionKey?: string): RoleRefMap;
+    /**
+     * Resolve a ref string (e.g. "e5") to a Playwright Locator.
+     * Ported from main project's pw-session.ts:refLocator.
+     */
+    refLocator(ref: string, sessionKey?: string): import("playwright-core").Locator;
+    /**
+     * NEW: Get all pages for a session (useful for debugging/cleanup).
+     */
+    getSessionPages(sessionKey: string): Page[];
+    /**
+     * MODIFIED: close() now clears session page tracking
+     */
+    close(): Promise<void>;
+    /**
+     * NEW: Clear pages for a specific session (called on session cleanup)
+     */
+    clearSessionPages(sessionKey: string): Promise<void>;
+}