verybot 0.1.8

package/dist/computer/browser/manager.js

@@ -0,0 +1,344 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { chromium } from "playwright-extra";
+import StealthPlugin from "puppeteer-extra-plugin-stealth";
+import { BROWSER_PROFILE_DIR, BROWSER_PROFILES_DIR } from "../../paths.js";
+import { logger } from "../../logger.js";
+import { buildProfileBadgeScript } from "./profile-badge.js";
+// Guard against double-registration (e.g. test runners that re-evaluate modules).
+let stealthApplied = false;
+function ensureStealth() {
+    if (stealthApplied)
+        return;
+    chromium.use(StealthPlugin());
+    stealthApplied = true;
+}
+const DEFAULT_PROFILE = "default";
+const PROFILE_NAME_MAX_LENGTH = 50;
+const PROFILE_NAME_PATTERN = /^[a-zA-Z0-9-]+$/;
+/** Chromium launch flags: automation-control hiding + clean launch defaults. */
+const LAUNCH_ARGS = [
+    "--disable-blink-features=AutomationControlled",
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-component-update",
+];
+/** Validate a profile name. Throws on invalid input. */
+export function validateProfileName(name) {
+    if (!name || name.length > PROFILE_NAME_MAX_LENGTH) {
+        throw new Error(`Profile name must be 1-${PROFILE_NAME_MAX_LENGTH} characters. Got: "${name}"`);
+    }
+    if (!PROFILE_NAME_PATTERN.test(name)) {
+        throw new Error(`Profile name may only contain letters, digits, and hyphens. Got: "${name}"`);
+    }
+}
+export class BrowserManager {
+    static cachedCleanUAByMode = new Map();
+    context = null;
+    config;
+    roleRefs = {};
+    sessionRoleRefs = new Map();
+    activeProfile;
+    tempProfileDir = null;
+    // NEW: Session-aware page tracking (for per-tab mode)
+    sessionPages = new Map();
+    currentSessionKey = null;
+    constructor(config) {
+        this.config = config;
+        const profile = config.profile ?? DEFAULT_PROFILE;
+        if (profile !== DEFAULT_PROFILE)
+            validateProfileName(profile);
+        this.activeProfile = profile;
+    }
+    isPerTabMode() {
+        return this.config.mode === "per-tab-per-session";
+    }
+    resolveSessionKey(sessionKey) {
+        return sessionKey ?? this.currentSessionKey;
+    }
+    ensureSessionPages(sessionKey) {
+        const existing = this.sessionPages.get(sessionKey);
+        if (existing)
+            return existing;
+        const created = [];
+        this.sessionPages.set(sessionKey, created);
+        return created;
+    }
+    trackPageForSession(page, sessionKey) {
+        const pages = this.ensureSessionPages(sessionKey);
+        if (!pages.includes(page))
+            pages.push(page);
+        page.once("close", () => {
+            const ownedPages = this.sessionPages.get(sessionKey);
+            if (!ownedPages)
+                return;
+            const idx = ownedPages.indexOf(page);
+            if (idx !== -1)
+                ownedPages.splice(idx, 1);
+            if (ownedPages.length === 0)
+                this.sessionPages.delete(sessionKey);
+        });
+    }
+    pruneClosedPages(sessionKey) {
+        const pages = this.sessionPages.get(sessionKey);
+        if (!pages)
+            return;
+        const openPages = pages.filter((p) => !p.isClosed());
+        if (openPages.length === 0) {
+            this.sessionPages.delete(sessionKey);
+            return;
+        }
+        if (openPages.length !== pages.length)
+            this.sessionPages.set(sessionKey, openPages);
+    }
+    /**
+     * 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) {
+        this.currentSessionKey = key;
+    }
+    /**
+     * Get the current session key (if set).
+     */
+    getSessionKey() {
+        return this.currentSessionKey;
+    }
+    /**
+     * MODIFIED: launch() now session-aware
+     * If mode is "per-tab-per-session" and sessionKey is set,
+     * pages are tracked per session.
+     */
+    async launch(sessionKey) {
+        ensureStealth();
+        const key = this.resolveSessionKey(sessionKey);
+        if (this.context) {
+            // Per-tab mode: check session-specific pages first
+            if (this.isPerTabMode() &&
+                key) {
+                this.pruneClosedPages(key);
+                const sessionPageList = this.sessionPages.get(key) ?? [];
+                if (sessionPageList.length > 0) {
+                    return sessionPageList[sessionPageList.length - 1];
+                }
+                const newPage = await this.context.newPage();
+                this.trackPageForSession(newPage, key);
+                return newPage;
+            }
+            // Shared/per-browser mode: keep using the active page when available.
+            const pages = this.context.pages();
+            const current = pages[pages.length - 1];
+            if (current && !current.isClosed())
+                return current;
+            return await this.context.newPage();
+        }
+        // ... rest of launch() logic unchanged
+        const isTemp = this.config.profileDir === "temp";
+        const profileDir = isTemp
+            ? mkdtempSync(join(tmpdir(), "verybot-browser-"))
+            : this.resolveProfileDir();
+        this.tempProfileDir = isTemp ? profileDir : null;
+        const headless = this.config.headless ?? true;
+        const userAgent = this.config.userAgent ?? (await this.detectCleanUA(headless));
+        const isMac = process.platform === "darwin";
+        const deviceScaleFactor = isMac ? 2 : 1;
+        const viewport = { width: isMac ? 1512 : 1920, height: isMac ? 982 : 1080 };
+        // Always set a clean UA on persistent-context launch to cover the first page.
+        this.context = await chromium.launchPersistentContext(profileDir, {
+            headless,
+            viewport,
+            deviceScaleFactor,
+            userAgent,
+            args: LAUNCH_ARGS,
+        });
+        if (!isTemp) {
+            await this.context.addInitScript(buildProfileBadgeScript(this.activeProfile));
+        }
+        logger.info(`Browser launched (profile: ${this.activeProfile}, mode: ${this.config.mode ?? "shared"})`);
+        const pages = this.context.pages();
+        const page = pages[pages.length - 1] ?? (await this.context.newPage());
+        if (this.isPerTabMode() && key) {
+            this.trackPageForSession(page, key);
+        }
+        return 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.
+     */
+    async detectCleanUA(headless) {
+        const cacheKey = headless ? "headless" : "headful";
+        const cachedUA = BrowserManager.cachedCleanUAByMode.get(cacheKey);
+        if (cachedUA)
+            return cachedUA;
+        const probeProfileDir = mkdtempSync(join(tmpdir(), "verybot-browser-ua-probe-"));
+        const probeContext = await chromium.launchPersistentContext(probeProfileDir, {
+            headless,
+            args: ["--no-first-run"],
+        });
+        try {
+            const probePage = probeContext.pages()[0] ?? (await probeContext.newPage());
+            const rawUA = await probePage.evaluate(() => navigator.userAgent);
+            const cleanUA = rawUA.replace(/HeadlessChrome/g, "Chrome");
+            BrowserManager.cachedCleanUAByMode.set(cacheKey, cleanUA);
+            return cleanUA;
+        }
+        finally {
+            await probeContext.close();
+            if (existsSync(probeProfileDir)) {
+                rmSync(probeProfileDir, { recursive: true, force: true });
+            }
+        }
+    }
+    /** Resolve the user-data directory for the active named profile. */
+    resolveProfileDir() {
+        if (this.config.profileDir && this.config.profileDir !== "temp") {
+            return this.config.profileDir;
+        }
+        // Named profile → dedicated subdirectory under BROWSER_PROFILES_DIR
+        if (this.activeProfile !== DEFAULT_PROFILE) {
+            const dir = join(BROWSER_PROFILES_DIR, this.activeProfile);
+            mkdirSync(dir, { recursive: true });
+            return dir;
+        }
+        // Default profile → legacy shared dir
+        return BROWSER_PROFILE_DIR;
+    }
+    /** Close current browser and switch to a different named profile. */
+    async switchProfile(name) {
+        validateProfileName(name);
+        await this.close();
+        this.activeProfile = name;
+        logger.info(`Switched to browser profile: ${name}`);
+    }
+    /** Get the currently active profile name. */
+    getActiveProfile() {
+        return this.activeProfile;
+    }
+    /** Update config for next browser launch. Closes existing browser if headless mode changed. */
+    async updateConfig(config) {
+        const headlessChanged = this.context && (config.headless ?? true) !== (this.config.headless ?? true);
+        this.config = { ...this.config, ...config };
+        if (headlessChanged) {
+            logger.info("Headless mode changed — closing browser so next launch uses new setting");
+            await this.close();
+        }
+    }
+    /**
+     * MODIFIED: getPage() respects session boundary in per-tab mode
+     */
+    getPage(sessionKey) {
+        if (!this.context)
+            return null;
+        const key = this.resolveSessionKey(sessionKey);
+        // Per-tab mode: return session's own page
+        if (this.isPerTabMode() &&
+            key) {
+            this.pruneClosedPages(key);
+            const pages = this.sessionPages.get(key) ?? [];
+            return pages.length > 0 ? pages[pages.length - 1] : null;
+        }
+        // Shared mode or no session key: return last page globally
+        const pages = this.context.pages();
+        return pages[pages.length - 1] ?? null;
+    }
+    /** Check if the browser is currently launched. */
+    isLaunched() {
+        return this.context !== null;
+    }
+    /** Store role refs from the latest snapshot. */
+    setRoleRefs(refs, sessionKey) {
+        const key = this.resolveSessionKey(sessionKey);
+        if (this.isPerTabMode() && key) {
+            this.sessionRoleRefs.set(key, refs);
+            return;
+        }
+        this.roleRefs = refs;
+    }
+    /** Get stored role refs from the latest snapshot. */
+    getRoleRefs(sessionKey) {
+        const key = this.resolveSessionKey(sessionKey);
+        if (this.isPerTabMode() && key) {
+            return this.sessionRoleRefs.get(key) ?? {};
+        }
+        return this.roleRefs;
+    }
+    /**
+     * Resolve a ref string (e.g. "e5") to a Playwright Locator.
+     * Ported from main project's pw-session.ts:refLocator.
+     */
+    refLocator(ref, sessionKey) {
+        const page = this.getPage(sessionKey);
+        if (!page)
+            throw new Error("Browser not launched. Use browser_navigate first.");
+        const normalized = ref.startsWith("@")
+            ? ref.slice(1)
+            : ref.startsWith("ref=")
+                ? ref.slice(4)
+                : ref;
+        const refs = this.getRoleRefs(sessionKey);
+        const info = refs[normalized];
+        if (!info) {
+            throw new Error(`Unknown ref "${normalized}". Take a new snapshot and use a ref from that snapshot.`);
+        }
+        const locator = info.name
+            ? page.getByRole(info.role, { name: info.name, exact: true })
+            : page.getByRole(info.role);
+        return info.nth !== undefined ? locator.nth(info.nth) : locator;
+    }
+    /**
+     * NEW: Get all pages for a session (useful for debugging/cleanup).
+     */
+    getSessionPages(sessionKey) {
+        return this.sessionPages.get(sessionKey) ?? [];
+    }
+    /**
+     * MODIFIED: close() now clears session page tracking
+     */
+    async close() {
+        if (this.context) {
+            await this.context.close();
+            this.context = null;
+        }
+        this.roleRefs = {};
+        this.sessionRoleRefs.clear();
+        this.sessionPages.clear(); // NEW
+        this.currentSessionKey = null; // NEW
+        if (this.tempProfileDir) {
+            try {
+                if (existsSync(this.tempProfileDir)) {
+                    rmSync(this.tempProfileDir, { recursive: true, force: true });
+                }
+            }
+            catch (err) {
+                logger.warn(`Failed to remove temp browser profile dir ${this.tempProfileDir}: ${err}`);
+            }
+            finally {
+                this.tempProfileDir = null;
+            }
+        }
+        logger.info("Browser closed");
+    }
+    /**
+     * NEW: Clear pages for a specific session (called on session cleanup)
+     */
+    async clearSessionPages(sessionKey) {
+        const pages = this.sessionPages.get(sessionKey);
+        this.sessionRoleRefs.delete(sessionKey);
+        if (!pages)
+            return;
+        // Close all pages for this session
+        for (const page of [...pages]) {
+            try {
+                await page.close();
+            }
+            catch (err) {
+                logger.warn(`Failed to close page during session cleanup: ${err}`);
+            }
+        }
+        this.sessionPages.delete(sessionKey);
+        if (this.currentSessionKey === sessionKey)
+            this.currentSessionKey = null;
+    }
+}

package/dist/computer/browser/profile-badge.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Injectable JS script that renders a floating profile badge at the top of
+ * every page. Injected via `context.addInitScript()` so it runs on every
+ * navigation within the persistent browser context.
+ *
+ * The badge color is deterministic — derived from a simple hash of the profile
+ * name so each profile always gets the same hue.
+ */
+/**
+ * Build the init-script source string for a given profile name.
+ * The returned string is plain JS (no imports) safe for `addInitScript`.
+ */
+export declare function buildProfileBadgeScript(profileName: string): string;

package/dist/computer/browser/profile-badge.js

@@ -0,0 +1,67 @@
+/**
+ * Injectable JS script that renders a floating profile badge at the top of
+ * every page. Injected via `context.addInitScript()` so it runs on every
+ * navigation within the persistent browser context.
+ *
+ * The badge color is deterministic — derived from a simple hash of the profile
+ * name so each profile always gets the same hue.
+ */
+const BADGE_ID = "__verybot_profile_badge__";
+/**
+ * Build the init-script source string for a given profile name.
+ * The returned string is plain JS (no imports) safe for `addInitScript`.
+ */
+export function buildProfileBadgeScript(profileName) {
+    // Defense-in-depth: reject anything outside [a-zA-Z0-9-] even if caller validated
+    if (!/^[a-zA-Z0-9-]+$/.test(profileName)) {
+        throw new Error(`Unsafe profile name for badge script: "${profileName}"`);
+    }
+    // Deterministic hue from profile name (djb2 hash → 0-360)
+    let hash = 5381;
+    for (let i = 0; i < profileName.length; i++) {
+        hash = ((hash << 5) + hash + profileName.charCodeAt(i)) >>> 0;
+    }
+    const hue = hash % 360;
+    // Also override document.title so the window is identifiable
+    const upperName = profileName.toUpperCase();
+    return `
+(function() {
+  if (document.getElementById("${BADGE_ID}")) return;
+
+  /* --- title prefix --- */
+  var origTitle = document.title;
+  document.title = "[${upperName}] " + origTitle;
+  new MutationObserver(function() {
+    if (!document.title.startsWith("[${upperName}] ")) {
+      document.title = "[${upperName}] " + document.title;
+    }
+  }).observe(document.querySelector("title") || document.head, { childList: true, subtree: true, characterData: true });
+
+  /* --- badge bar --- */
+  var bar = document.createElement("div");
+  bar.id = "${BADGE_ID}";
+  bar.style.cssText =
+    "position:fixed;top:0;left:0;right:0;height:28px;z-index:2147483647;" +
+    "background:hsl(${hue},65%,45%);color:#fff;font:bold 13px/28px sans-serif;" +
+    "display:flex;align-items:center;padding:0 12px;box-shadow:0 1px 4px rgba(0,0,0,.25);";
+
+  var dot = document.createElement("span");
+  dot.textContent = "\\u25CF ";
+  dot.style.marginRight = "6px";
+  bar.appendChild(dot);
+
+  var label = document.createElement("span");
+  label.textContent = "${upperName}";
+  label.style.flex = "1";
+  bar.appendChild(label);
+
+  var close = document.createElement("span");
+  close.textContent = "\\u2715";
+  close.style.cssText = "cursor:pointer;padding:0 4px;font-size:15px;opacity:.8;";
+  close.addEventListener("click", function() { bar.remove(); });
+  bar.appendChild(close);
+
+  document.documentElement.appendChild(bar);
+})();
+`;
+}

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

@@ -0,0 +1,5 @@
+/** Compress a screenshot PNG to JPEG, reducing quality until under the size limit. */
+export declare function compressScreenshot(png: Buffer): Promise<{
+    base64: string;
+    mediaType: string;
+}>;

package/dist/computer/browser/screenshot.js

@@ -0,0 +1,21 @@
+import sharp from "sharp";
+import { logger } from "../../logger.js";
+/** Anthropic API rejects base64 images over 5 MB. Compress PNG -> JPEG to stay under. */
+const MAX_IMAGE_BYTES = 3_500_000;
+const JPEG_QUALITY_START = 80;
+const JPEG_QUALITY_MIN = 40;
+const JPEG_QUALITY_STEP = 10;
+/** Compress a screenshot PNG to JPEG, reducing quality until under the size limit. */
+export async function compressScreenshot(png) {
+    let lastJpeg = null;
+    for (let quality = JPEG_QUALITY_START; quality >= JPEG_QUALITY_MIN; quality -= JPEG_QUALITY_STEP) {
+        lastJpeg = await sharp(png).jpeg({ quality }).toBuffer();
+        if (lastJpeg.length <= MAX_IMAGE_BYTES) {
+            logger.info(`Browser: screenshot compressed ${png.length} -> ${lastJpeg.length} bytes (JPEG q${quality})`);
+            return { base64: lastJpeg.toString("base64"), mediaType: "image/jpeg" };
+        }
+    }
+    // Last resort: use the already-computed lowest quality buffer
+    logger.info(`Browser: screenshot compressed ${png.length} -> ${lastJpeg.length} bytes (JPEG q${JPEG_QUALITY_MIN}, may exceed limit)`);
+    return { base64: lastJpeg.toString("base64"), mediaType: "image/jpeg" };
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Parses Playwright's ariaSnapshot() output,
+ * assigns refs (e1, e2…) to interactive/content elements, and returns an
+ * annotated snapshot string plus a RoleRefMap for resolving refs back to locators.
+ */
+export type RoleRef = {
+    role: string;
+    name?: string;
+    /** Index used only when role+name duplicates exist. */
+    nth?: number;
+};
+export type RoleRefMap = Record<string, RoleRef>;
+export type RoleSnapshotOptions = {
+    /** Only include interactive elements (buttons, links, inputs, etc.). */
+    interactive?: boolean;
+    /** Maximum depth to include (0 = root only). */
+    maxDepth?: number;
+    /** Remove unnamed structural elements and empty branches. */
+    compact?: boolean;
+};
+/** Validate and normalize a ref string like "e5", "@e5", or "ref=e5". Returns null if invalid. */
+export declare function parseRoleRef(raw: string): string | null;
+/**
+ * Parse Playwright's `ariaSnapshot()` text, assign refs to interactive/content
+ * elements, and return the annotated snapshot + a map from ref → role info.
+ */
+export declare function buildRoleSnapshotFromAriaSnapshot(ariaSnapshot: string, options?: RoleSnapshotOptions): {
+    snapshot: string;
+    refs: RoleRefMap;
+};