clawdbot 2026.1.4-1

package/dist/browser/config.js

@@ -0,0 +1,140 @@
+import { DEFAULT_CLAWD_BROWSER_COLOR, DEFAULT_CLAWD_BROWSER_CONTROL_URL, DEFAULT_CLAWD_BROWSER_ENABLED, DEFAULT_CLAWD_BROWSER_PROFILE_NAME, } from "./constants.js";
+import { CDP_PORT_RANGE_START } from "./profiles.js";
+function isLoopbackHost(host) {
+    const h = host.trim().toLowerCase();
+    return (h === "localhost" ||
+        h === "127.0.0.1" ||
+        h === "0.0.0.0" ||
+        h === "[::1]" ||
+        h === "::1" ||
+        h === "[::]" ||
+        h === "::");
+}
+function normalizeHexColor(raw) {
+    const value = (raw ?? "").trim();
+    if (!value)
+        return DEFAULT_CLAWD_BROWSER_COLOR;
+    const normalized = value.startsWith("#") ? value : `#${value}`;
+    if (!/^#[0-9a-fA-F]{6}$/.test(normalized))
+        return DEFAULT_CLAWD_BROWSER_COLOR;
+    return normalized.toUpperCase();
+}
+export function parseHttpUrl(raw, label) {
+    const trimmed = raw.trim();
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`${label} must be http(s), got: ${parsed.protocol.replace(":", "")}`);
+    }
+    const port = parsed.port && Number.parseInt(parsed.port, 10) > 0
+        ? Number.parseInt(parsed.port, 10)
+        : parsed.protocol === "https:"
+            ? 443
+            : 80;
+    if (Number.isNaN(port) || port <= 0 || port > 65535) {
+        throw new Error(`${label} has invalid port: ${parsed.port}`);
+    }
+    return {
+        parsed,
+        port,
+        normalized: parsed.toString().replace(/\/$/, ""),
+    };
+}
+/**
+ * Ensure the default "clawd" profile exists in the profiles map.
+ * Auto-creates it with the legacy CDP port (from browser.cdpUrl) or first port if missing.
+ */
+function ensureDefaultProfile(profiles, defaultColor, legacyCdpPort) {
+    const result = { ...profiles };
+    if (!result[DEFAULT_CLAWD_BROWSER_PROFILE_NAME]) {
+        result[DEFAULT_CLAWD_BROWSER_PROFILE_NAME] = {
+            cdpPort: legacyCdpPort ?? CDP_PORT_RANGE_START,
+            color: defaultColor,
+        };
+    }
+    return result;
+}
+export function resolveBrowserConfig(cfg) {
+    const enabled = cfg?.enabled ?? DEFAULT_CLAWD_BROWSER_ENABLED;
+    const controlInfo = parseHttpUrl(cfg?.controlUrl ?? DEFAULT_CLAWD_BROWSER_CONTROL_URL, "browser.controlUrl");
+    const controlPort = controlInfo.port;
+    const defaultColor = normalizeHexColor(cfg?.color);
+    const rawCdpUrl = (cfg?.cdpUrl ?? "").trim();
+    let cdpInfo;
+    if (rawCdpUrl) {
+        cdpInfo = parseHttpUrl(rawCdpUrl, "browser.cdpUrl");
+    }
+    else {
+        const derivedPort = controlPort + 1;
+        if (derivedPort > 65535) {
+            throw new Error(`browser.controlUrl port (${controlPort}) is too high; cannot derive CDP port (${derivedPort})`);
+        }
+        const derived = new URL(controlInfo.normalized);
+        derived.port = String(derivedPort);
+        cdpInfo = {
+            parsed: derived,
+            port: derivedPort,
+            normalized: derived.toString().replace(/\/$/, ""),
+        };
+    }
+    const headless = cfg?.headless === true;
+    const noSandbox = cfg?.noSandbox === true;
+    const attachOnly = cfg?.attachOnly === true;
+    const executablePath = cfg?.executablePath?.trim() || undefined;
+    const defaultProfile = cfg?.defaultProfile ?? DEFAULT_CLAWD_BROWSER_PROFILE_NAME;
+    // Use legacy cdpUrl port for backward compatibility when no profiles configured
+    const legacyCdpPort = rawCdpUrl ? cdpInfo.port : undefined;
+    const profiles = ensureDefaultProfile(cfg?.profiles, defaultColor, legacyCdpPort);
+    const cdpProtocol = cdpInfo.parsed.protocol === "https:" ? "https" : "http";
+    return {
+        enabled,
+        controlUrl: controlInfo.normalized,
+        controlHost: controlInfo.parsed.hostname,
+        controlPort,
+        cdpProtocol,
+        cdpHost: cdpInfo.parsed.hostname,
+        cdpIsLoopback: isLoopbackHost(cdpInfo.parsed.hostname),
+        color: defaultColor,
+        executablePath,
+        headless,
+        noSandbox,
+        attachOnly,
+        defaultProfile,
+        profiles,
+    };
+}
+/**
+ * Resolve a profile by name from the config.
+ * Returns null if the profile doesn't exist.
+ */
+export function resolveProfile(resolved, profileName) {
+    const profile = resolved.profiles[profileName];
+    if (!profile)
+        return null;
+    const rawProfileUrl = profile.cdpUrl?.trim() ?? "";
+    let cdpHost = resolved.cdpHost;
+    let cdpPort = profile.cdpPort ?? 0;
+    let cdpUrl = "";
+    if (rawProfileUrl) {
+        const parsed = parseHttpUrl(rawProfileUrl, `browser.profiles.${profileName}.cdpUrl`);
+        cdpHost = parsed.parsed.hostname;
+        cdpPort = parsed.port;
+        cdpUrl = parsed.normalized;
+    }
+    else if (cdpPort) {
+        cdpUrl = `${resolved.cdpProtocol}://${resolved.cdpHost}:${cdpPort}`;
+    }
+    else {
+        throw new Error(`Profile "${profileName}" must define cdpPort or cdpUrl.`);
+    }
+    return {
+        name: profileName,
+        cdpPort,
+        cdpUrl,
+        cdpHost,
+        cdpIsLoopback: isLoopbackHost(cdpHost),
+        color: profile.color,
+    };
+}
+export function shouldStartLocalBrowserServer(resolved) {
+    return isLoopbackHost(resolved.controlHost);
+}

package/dist/browser/constants.js

@@ -0,0 +1,4 @@
+export const DEFAULT_CLAWD_BROWSER_ENABLED = true;
+export const DEFAULT_CLAWD_BROWSER_CONTROL_URL = "http://127.0.0.1:18791";
+export const DEFAULT_CLAWD_BROWSER_COLOR = "#FF4500";
+export const DEFAULT_CLAWD_BROWSER_PROFILE_NAME = "clawd";

package/dist/browser/profiles-service.js

@@ -0,0 +1,122 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig, writeConfigFile } from "../config/config.js";
+import { resolveClawdUserDataDir } from "./chrome.js";
+import { parseHttpUrl, resolveProfile } from "./config.js";
+import { allocateCdpPort, allocateColor, getUsedColors, getUsedPorts, isValidProfileName, } from "./profiles.js";
+import { movePathToTrash } from "./trash.js";
+const HEX_COLOR_RE = /^#[0-9A-Fa-f]{6}$/;
+export function createBrowserProfilesService(ctx) {
+    const listProfiles = async () => {
+        return await ctx.listProfiles();
+    };
+    const createProfile = async (params) => {
+        const name = params.name.trim();
+        const rawCdpUrl = params.cdpUrl?.trim() || undefined;
+        if (!isValidProfileName(name)) {
+            throw new Error("invalid profile name: use lowercase letters, numbers, and hyphens only");
+        }
+        const state = ctx.state();
+        const resolvedProfiles = state.resolved.profiles;
+        if (name in resolvedProfiles) {
+            throw new Error(`profile "${name}" already exists`);
+        }
+        const cfg = loadConfig();
+        const rawProfiles = cfg.browser?.profiles ?? {};
+        if (name in rawProfiles) {
+            throw new Error(`profile "${name}" already exists`);
+        }
+        const usedColors = getUsedColors(resolvedProfiles);
+        const profileColor = params.color && HEX_COLOR_RE.test(params.color)
+            ? params.color
+            : allocateColor(usedColors);
+        let profileConfig;
+        if (rawCdpUrl) {
+            const parsed = parseHttpUrl(rawCdpUrl, "browser.profiles.cdpUrl");
+            profileConfig = { cdpUrl: parsed.normalized, color: profileColor };
+        }
+        else {
+            const usedPorts = getUsedPorts(resolvedProfiles);
+            const cdpPort = allocateCdpPort(usedPorts);
+            if (cdpPort === null) {
+                throw new Error("no available CDP ports in range");
+            }
+            profileConfig = { cdpPort, color: profileColor };
+        }
+        const nextConfig = {
+            ...cfg,
+            browser: {
+                ...cfg.browser,
+                profiles: {
+                    ...rawProfiles,
+                    [name]: profileConfig,
+                },
+            },
+        };
+        await writeConfigFile(nextConfig);
+        state.resolved.profiles[name] = profileConfig;
+        const resolved = resolveProfile(state.resolved, name);
+        if (!resolved) {
+            throw new Error(`profile "${name}" not found after creation`);
+        }
+        return {
+            ok: true,
+            profile: name,
+            cdpPort: resolved.cdpPort,
+            cdpUrl: resolved.cdpUrl,
+            color: resolved.color,
+            isRemote: !resolved.cdpIsLoopback,
+        };
+    };
+    const deleteProfile = async (nameRaw) => {
+        const name = nameRaw.trim();
+        if (!name)
+            throw new Error("profile name is required");
+        if (!isValidProfileName(name)) {
+            throw new Error("invalid profile name");
+        }
+        const cfg = loadConfig();
+        const profiles = cfg.browser?.profiles ?? {};
+        if (!(name in profiles)) {
+            throw new Error(`profile "${name}" not found`);
+        }
+        const defaultProfile = cfg.browser?.defaultProfile ?? "clawd";
+        if (name === defaultProfile) {
+            throw new Error(`cannot delete the default profile "${name}"; change browser.defaultProfile first`);
+        }
+        let deleted = false;
+        const state = ctx.state();
+        const resolved = resolveProfile(state.resolved, name);
+        if (resolved?.cdpIsLoopback) {
+            try {
+                await ctx.forProfile(name).stopRunningBrowser();
+            }
+            catch {
+                // ignore
+            }
+            const userDataDir = resolveClawdUserDataDir(name);
+            const profileDir = path.dirname(userDataDir);
+            if (fs.existsSync(profileDir)) {
+                await movePathToTrash(profileDir);
+                deleted = true;
+            }
+        }
+        const { [name]: _removed, ...remainingProfiles } = profiles;
+        const nextConfig = {
+            ...cfg,
+            browser: {
+                ...cfg.browser,
+                profiles: remainingProfiles,
+            },
+        };
+        await writeConfigFile(nextConfig);
+        delete state.resolved.profiles[name];
+        state.profiles.delete(name);
+        return { ok: true, profile: name, deleted };
+    };
+    return {
+        listProfiles,
+        createProfile,
+        deleteProfile,
+    };
+}

package/dist/browser/profiles.js

@@ -0,0 +1,85 @@
+/**
+ * CDP port allocation for browser profiles.
+ *
+ * Port range: 18800-18899 (100 profiles max)
+ * Ports are allocated once at profile creation and persisted in config.
+ *
+ * Reserved ports (do not use for CDP):
+ *   18789 - Gateway WebSocket
+ *   18790 - Bridge
+ *   18791 - Browser control server
+ *   18792-18799 - Reserved for future one-off services (canvas at 18793)
+ */
+export const CDP_PORT_RANGE_START = 18800;
+export const CDP_PORT_RANGE_END = 18899;
+export const PROFILE_NAME_REGEX = /^[a-z0-9][a-z0-9-]*$/;
+export function isValidProfileName(name) {
+    if (!name || name.length > 64)
+        return false;
+    return PROFILE_NAME_REGEX.test(name);
+}
+export function allocateCdpPort(usedPorts) {
+    for (let port = CDP_PORT_RANGE_START; port <= CDP_PORT_RANGE_END; port++) {
+        if (!usedPorts.has(port))
+            return port;
+    }
+    return null;
+}
+export function getUsedPorts(profiles) {
+    if (!profiles)
+        return new Set();
+    const used = new Set();
+    for (const profile of Object.values(profiles)) {
+        if (typeof profile.cdpPort === "number") {
+            used.add(profile.cdpPort);
+            continue;
+        }
+        const rawUrl = profile.cdpUrl?.trim();
+        if (!rawUrl)
+            continue;
+        try {
+            const parsed = new URL(rawUrl);
+            const port = parsed.port && Number.parseInt(parsed.port, 10) > 0
+                ? Number.parseInt(parsed.port, 10)
+                : parsed.protocol === "https:"
+                    ? 443
+                    : 80;
+            if (!Number.isNaN(port) && port > 0 && port <= 65535) {
+                used.add(port);
+            }
+        }
+        catch {
+            // ignore invalid URLs
+        }
+    }
+    return used;
+}
+export const PROFILE_COLORS = [
+    "#FF4500", // Orange-red (clawd default)
+    "#0066CC", // Blue
+    "#00AA00", // Green
+    "#9933FF", // Purple
+    "#FF6699", // Pink
+    "#00CCCC", // Cyan
+    "#FF9900", // Orange
+    "#6666FF", // Indigo
+    "#CC3366", // Magenta
+    "#339966", // Teal
+];
+export function allocateColor(usedColors) {
+    // Find first unused color from palette
+    for (const color of PROFILE_COLORS) {
+        if (!usedColors.has(color.toUpperCase())) {
+            return color;
+        }
+    }
+    // All colors used, cycle based on count
+    const index = usedColors.size % PROFILE_COLORS.length;
+    // biome-ignore lint/style/noNonNullAssertion: Array is non-empty constant
+    return PROFILE_COLORS[index] ?? PROFILE_COLORS[0];
+}
+export function getUsedColors(profiles) {
+    if (!profiles)
+        return new Set();
+    return new Set(Object.values(profiles).map((p) => p.color.toUpperCase()));
+}

package/dist/browser/pw-ai.js

@@ -0,0 +1,2 @@
+export { closePlaywrightBrowserConnection, ensurePageState, getPageForTargetId, refLocator, } from "./pw-session.js";
+export { armDialogViaPlaywright, armFileUploadViaPlaywright, clickViaPlaywright, closePageViaPlaywright, dragViaPlaywright, evaluateViaPlaywright, fillFormViaPlaywright, getConsoleMessagesViaPlaywright, hoverViaPlaywright, navigateViaPlaywright, pdfViaPlaywright, pressKeyViaPlaywright, resizeViewportViaPlaywright, selectOptionViaPlaywright, setInputFilesViaPlaywright, snapshotAiViaPlaywright, takeScreenshotViaPlaywright, typeViaPlaywright, waitForViaPlaywright, } from "./pw-tools-core.js";

package/dist/browser/pw-session.js

@@ -0,0 +1,144 @@
+import { chromium } from "playwright-core";
+import { formatErrorMessage } from "../infra/errors.js";
+import { getChromeWebSocketUrl } from "./chrome.js";
+const pageStates = new WeakMap();
+const observedContexts = new WeakSet();
+const observedPages = new WeakSet();
+const MAX_CONSOLE_MESSAGES = 500;
+let cached = null;
+let connecting = null;
+function normalizeCdpUrl(raw) {
+    return raw.replace(/\/$/, "");
+}
+export function ensurePageState(page) {
+    const existing = pageStates.get(page);
+    if (existing)
+        return existing;
+    const state = {
+        console: [],
+        armIdUpload: 0,
+        armIdDialog: 0,
+    };
+    pageStates.set(page, state);
+    if (!observedPages.has(page)) {
+        observedPages.add(page);
+        page.on("console", (msg) => {
+            const entry = {
+                type: msg.type(),
+                text: msg.text(),
+                timestamp: new Date().toISOString(),
+                location: msg.location(),
+            };
+            state.console.push(entry);
+            if (state.console.length > MAX_CONSOLE_MESSAGES)
+                state.console.shift();
+        });
+        page.on("close", () => {
+            pageStates.delete(page);
+            observedPages.delete(page);
+        });
+    }
+    return state;
+}
+function observeContext(context) {
+    if (observedContexts.has(context))
+        return;
+    observedContexts.add(context);
+    for (const page of context.pages())
+        ensurePageState(page);
+    context.on("page", (page) => ensurePageState(page));
+}
+function observeBrowser(browser) {
+    for (const context of browser.contexts())
+        observeContext(context);
+}
+async function connectBrowser(cdpUrl) {
+    const normalized = normalizeCdpUrl(cdpUrl);
+    if (cached?.cdpUrl === normalized)
+        return cached;
+    if (connecting)
+        return await connecting;
+    const connectWithRetry = async () => {
+        let lastErr;
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            try {
+                const timeout = 5000 + attempt * 2000;
+                const wsUrl = await getChromeWebSocketUrl(normalized, timeout).catch(() => null);
+                const endpoint = wsUrl ?? normalized;
+                const browser = await chromium.connectOverCDP(endpoint, { timeout });
+                const connected = { browser, cdpUrl: normalized };
+                cached = connected;
+                observeBrowser(browser);
+                browser.on("disconnected", () => {
+                    if (cached?.browser === browser)
+                        cached = null;
+                });
+                return connected;
+            }
+            catch (err) {
+                lastErr = err;
+                const delay = 250 + attempt * 250;
+                await new Promise((r) => setTimeout(r, delay));
+            }
+        }
+        if (lastErr instanceof Error) {
+            throw lastErr;
+        }
+        const message = lastErr
+            ? formatErrorMessage(lastErr)
+            : "CDP connect failed";
+        throw new Error(message);
+    };
+    connecting = connectWithRetry().finally(() => {
+        connecting = null;
+    });
+    return await connecting;
+}
+async function getAllPages(browser) {
+    const contexts = browser.contexts();
+    const pages = contexts.flatMap((c) => c.pages());
+    return pages;
+}
+async function pageTargetId(page) {
+    const session = await page.context().newCDPSession(page);
+    try {
+        const info = (await session.send("Target.getTargetInfo"));
+        const targetId = String(info?.targetInfo?.targetId ?? "").trim();
+        return targetId || null;
+    }
+    finally {
+        await session.detach().catch(() => { });
+    }
+}
+async function findPageByTargetId(browser, targetId) {
+    const pages = await getAllPages(browser);
+    for (const page of pages) {
+        const tid = await pageTargetId(page).catch(() => null);
+        if (tid && tid === targetId)
+            return page;
+    }
+    return null;
+}
+export async function getPageForTargetId(opts) {
+    const { browser } = await connectBrowser(opts.cdpUrl);
+    const pages = await getAllPages(browser);
+    if (!pages.length)
+        throw new Error("No pages available in the connected browser.");
+    const first = pages[0];
+    if (!opts.targetId)
+        return first;
+    const found = await findPageByTargetId(browser, opts.targetId);
+    if (!found)
+        throw new Error("tab not found");
+    return found;
+}
+export function refLocator(page, ref) {
+    return page.locator(`aria-ref=${ref}`);
+}
+export async function closePlaywrightBrowserConnection() {
+    const cur = cached;
+    cached = null;
+    if (!cur)
+        return;
+    await cur.browser.close().catch(() => { });
+}