comisai 1.0.4

package/node_modules/@comis/skills/dist/browser/browser-service.js

@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * In-process browser control service.
+ *
+ * Provides a facade over Playwright, Chrome detection, CDP helpers,
+ * snapshots, screenshots, and UI actions. Replaces Comis's HTTP
+ * server pattern with direct in-process function calls.
+ *
+ * The BrowserService interface is what the platform browser tool
+ * delegates to via rpcCall.
+ *
+ * @module
+ */
+import { resolveBrowserConfig } from "./config.js";
+import { launchChrome, stopChrome, } from "./chrome-detection.js";
+import { getCdpTargets, getCdpVersion, filterPageTargets, } from "./cdp.js";
+import { createSession, closeSession, getPage, createNewPage, getTargetId, isConnected, ensurePageState, } from "./playwright-session.js";
+import { executeAction, } from "./playwright-actions.js";
+import { takeSnapshot, } from "./playwright-snapshots.js";
+import { takeScreenshot, generatePdf, } from "./screenshots.js";
+// ── Constants ────────────────────────────────────────────────────────
+/**
+ * Allowed URL protocols for browser navigation.
+ * Blocks file://, javascript:, data:, etc. at the service layer.
+ * about: is allowed because about:blank is used as the default new-tab URL.
+ */
+const ALLOWED_NAV_PROTOCOLS = new Set(["http:", "https:", "about:"]);
+// ── Implementation ───────────────────────────────────────────────────
+/**
+ * Create an in-process browser control service.
+ *
+ * @param partialConfig - Partial browser config (defaults applied)
+ * @returns BrowserService instance
+ */
+export function createBrowserService(partialConfig, spawnEnv) {
+    const config = resolveBrowserConfig(partialConfig);
+    let running = null;
+    let lastTargetId = null;
+    function cdpUrl() {
+        return `http://127.0.0.1:${config.cdpPort}`;
+    }
+    const service = {
+        async status() {
+            try {
+                const version = await getCdpVersion(cdpUrl(), 1500);
+                const targets = version
+                    ? await getCdpTargets(cdpUrl(), 1500).catch(() => [])
+                    : [];
+                const pageTabs = filterPageTargets(targets);
+                return {
+                    running: running !== null,
+                    chromeVersion: version?.Browser,
+                    cdpPort: config.cdpPort,
+                    activeTabs: pageTabs.length,
+                    connected: isConnected(),
+                };
+            }
+            catch {
+                return {
+                    running: running !== null,
+                    cdpPort: config.cdpPort,
+                    activeTabs: 0,
+                    connected: isConnected(),
+                };
+            }
+        },
+        async start() {
+            if (running)
+                return; // Already started
+            // Launch Chrome
+            const chrome = await launchChrome(config, spawnEnv);
+            running = chrome;
+            // Connect Playwright via CDP
+            await createSession(cdpUrl());
+        },
+        async stop() {
+            // Disconnect Playwright
+            await closeSession();
+            // Stop Chrome process
+            if (running) {
+                await stopChrome(running);
+                running = null;
+            }
+        },
+        async navigate(params) {
+            const url = String(params.url ?? "").trim();
+            if (!url)
+                throw new Error("url is required");
+            // Defense-in-depth: validate URL protocol before page.goto().
+            // The browser-tool layer already validates via validateUrl(), but this
+            // guards against direct BrowserService.navigate() calls bypassing the tool.
+            let parsed;
+            try {
+                parsed = new URL(url);
+            }
+            catch {
+                throw new Error("Invalid URL");
+            }
+            if (!ALLOWED_NAV_PROTOCOLS.has(parsed.protocol)) {
+                throw new Error(`Blocked protocol: ${parsed.protocol} -- only http/https allowed`);
+            }
+            const page = await getPage(cdpUrl(), params.targetId);
+            ensurePageState(page);
+            await page.goto(url, {
+                timeout: Math.max(1000, Math.min(120_000, config.timeoutMs ?? 20_000)),
+            });
+            const targetId = await getTargetId(page).catch(() => null);
+            if (targetId)
+                lastTargetId = targetId;
+            return {
+                url: page.url(),
+                title: await page.title().catch(() => ""),
+                targetId,
+            };
+        },
+        async snapshot(params) {
+            const page = await getPage(cdpUrl(), params.targetId);
+            return takeSnapshot(page, {
+                interactive: params.interactive,
+                maxDepth: params.maxDepth,
+                compact: params.compact,
+                selector: params.selector,
+                maxChars: params.maxChars ?? config.snapshotMaxChars,
+            });
+        },
+        async screenshot(params) {
+            const page = await getPage(cdpUrl(), params.targetId);
+            return takeScreenshot(page, {
+                fullPage: params.fullPage,
+                ref: params.ref,
+                element: params.element,
+                type: params.type,
+                quality: params.quality ?? config.screenshotQuality,
+            });
+        },
+        async pdf(params) {
+            const page = await getPage(cdpUrl(), params.targetId);
+            return generatePdf(page);
+        },
+        async act(params) {
+            const page = await getPage(cdpUrl(), params.targetId);
+            return executeAction(page, params);
+        },
+        async tabs() {
+            try {
+                const targets = await getCdpTargets(cdpUrl());
+                return filterPageTargets(targets).map((t) => ({
+                    targetId: t.id,
+                    title: t.title,
+                    url: t.url,
+                    type: t.type,
+                }));
+            }
+            catch {
+                return [];
+            }
+        },
+        async openTab(params) {
+            const url = String(params.url ?? "").trim() || "about:blank";
+            const { page, targetId } = await createNewPage(cdpUrl(), url);
+            if (targetId)
+                lastTargetId = targetId;
+            return {
+                targetId: targetId ?? "",
+                title: await page.title().catch(() => ""),
+                url: page.url(),
+                type: "page",
+            };
+        },
+        async focusTab(params) {
+            const page = await getPage(cdpUrl(), params.targetId);
+            await page.bringToFront();
+            lastTargetId = params.targetId;
+        },
+        async closeTab(params) {
+            const targetId = params.targetId ?? lastTargetId;
+            if (!targetId)
+                throw new Error("No tab to close (no targetId)");
+            const page = await getPage(cdpUrl(), targetId);
+            await page.close();
+        },
+        async console(params) {
+            const page = await getPage(cdpUrl(), params.targetId);
+            const state = ensurePageState(page);
+            const entries = state.console;
+            if (!params.level)
+                return [...entries];
+            return entries.filter((e) => e.type === params.level);
+        },
+    };
+    return service;
+}

package/node_modules/@comis/skills/dist/browser/cdp.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Chrome DevTools Protocol helpers.
+ *
+ * Provides lightweight HTTP-based helpers for querying Chrome's CDP
+ * endpoints (/json/list, /json/version). These do NOT use WebSocket
+ * for protocol messages -- Playwright handles that via connectOverCDP.
+ *
+ * Ported from Comis browser/cdp.ts + cdp.helpers.ts, stripped of
+ * WebSocket CDP messaging, extension relay auth, and complex helpers.
+ *
+ * @module
+ */
+/** A CDP target as returned by /json/list. */
+export type CdpTarget = {
+    id: string;
+    type: string;
+    title: string;
+    url: string;
+    webSocketDebuggerUrl?: string;
+    devtoolsFrontendUrl?: string;
+    description?: string;
+    faviconUrl?: string;
+};
+/** Chrome version info as returned by /json/version. */
+export type CdpVersion = {
+    Browser?: string;
+    "Protocol-Version"?: string;
+    "User-Agent"?: string;
+    "V8-Version"?: string;
+    "WebKit-Version"?: string;
+    webSocketDebuggerUrl?: string;
+};
+/**
+ * Append a path to a CDP base URL, preserving existing path components.
+ */
+export declare function appendCdpPath(cdpUrl: string, path: string): string;
+/**
+ * Fetch the list of CDP targets from Chrome.
+ *
+ * @param cdpUrl - Base CDP URL (e.g., "http://127.0.0.1:9222")
+ * @param timeoutMs - Request timeout in milliseconds
+ * @returns Array of CDP targets
+ */
+export declare function getCdpTargets(cdpUrl: string, timeoutMs?: number): Promise<CdpTarget[]>;
+/**
+ * Fetch Chrome version information.
+ *
+ * @param cdpUrl - Base CDP URL (e.g., "http://127.0.0.1:9222")
+ * @param timeoutMs - Request timeout in milliseconds
+ * @returns Chrome version data, or null if unreachable
+ */
+export declare function getCdpVersion(cdpUrl: string, timeoutMs?: number): Promise<CdpVersion | null>;
+/**
+ * Filter CDP targets to only page-type targets.
+ */
+export declare function filterPageTargets(targets: CdpTarget[]): CdpTarget[];
+/**
+ * Find a CDP target by its targetId.
+ */
+export declare function findTargetById(targets: CdpTarget[], targetId: string): CdpTarget | undefined;

package/node_modules/@comis/skills/dist/browser/cdp.js

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Chrome DevTools Protocol helpers.
+ *
+ * Provides lightweight HTTP-based helpers for querying Chrome's CDP
+ * endpoints (/json/list, /json/version). These do NOT use WebSocket
+ * for protocol messages -- Playwright handles that via connectOverCDP.
+ *
+ * Ported from Comis browser/cdp.ts + cdp.helpers.ts, stripped of
+ * WebSocket CDP messaging, extension relay auth, and complex helpers.
+ *
+ * @module
+ */
+// ── Helpers ──────────────────────────────────────────────────────────
+/**
+ * Append a path to a CDP base URL, preserving existing path components.
+ */
+export function appendCdpPath(cdpUrl, path) {
+    const url = new URL(cdpUrl);
+    const basePath = url.pathname.replace(/\/$/, "");
+    const suffix = path.startsWith("/") ? path : `/${path}`;
+    url.pathname = `${basePath}${suffix}`;
+    return url.toString();
+}
+/**
+ * Fetch JSON from a URL with a timeout.
+ */
+async function fetchJson(url, timeoutMs = 1500) {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { signal: ctrl.signal });
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status}`);
+        }
+        return (await res.json());
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+// ── Public API ───────────────────────────────────────────────────────
+/**
+ * Fetch the list of CDP targets from Chrome.
+ *
+ * @param cdpUrl - Base CDP URL (e.g., "http://127.0.0.1:9222")
+ * @param timeoutMs - Request timeout in milliseconds
+ * @returns Array of CDP targets
+ */
+export async function getCdpTargets(cdpUrl, timeoutMs = 1500) {
+    const raw = await fetchJson(appendCdpPath(cdpUrl, "/json/list"), timeoutMs);
+    return raw
+        .filter((t) => Boolean(t.id))
+        .map((t) => ({
+        id: t.id ?? "",
+        type: t.type ?? "other",
+        title: t.title ?? "",
+        url: t.url ?? "",
+        webSocketDebuggerUrl: t.webSocketDebuggerUrl,
+        devtoolsFrontendUrl: t.devtoolsFrontendUrl,
+        description: t.description,
+        faviconUrl: t.faviconUrl,
+    }));
+}
+/**
+ * Fetch Chrome version information.
+ *
+ * @param cdpUrl - Base CDP URL (e.g., "http://127.0.0.1:9222")
+ * @param timeoutMs - Request timeout in milliseconds
+ * @returns Chrome version data, or null if unreachable
+ */
+export async function getCdpVersion(cdpUrl, timeoutMs = 1500) {
+    try {
+        return await fetchJson(appendCdpPath(cdpUrl, "/json/version"), timeoutMs);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Filter CDP targets to only page-type targets.
+ */
+export function filterPageTargets(targets) {
+    return targets.filter((t) => t.type === "page");
+}
+/**
+ * Find a CDP target by its targetId.
+ */
+export function findTargetById(targets, targetId) {
+    return targets.find((t) => t.id === targetId);
+}

package/node_modules/@comis/skills/dist/browser/chrome-detection.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Chrome executable detection and process management.
+ *
+ * Finds installed Chrome/Chromium binaries on Linux and macOS, then
+ * launches Chrome with the --remote-debugging-port flag for CDP access.
+ *
+ * Ported from Comis browser/chrome.executables.ts + chrome.ts,
+ * stripped of Windows support, extension relay, and profile decoration.
+ *
+ * @module
+ */
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { BrowserConfig } from "./config.js";
+export type BrowserExecutable = {
+    kind: "chrome" | "chromium" | "brave" | "edge" | "canary" | "custom";
+    path: string;
+};
+export type RunningChrome = {
+    pid: number;
+    exe: BrowserExecutable;
+    userDataDir: string;
+    cdpPort: number;
+    startedAt: number;
+    proc: ChildProcessWithoutNullStreams;
+};
+/**
+ * Find an installed Chrome/Chromium executable.
+ *
+ * Checks custom path first (from config), then standard OS locations.
+ * Returns null if no browser is found.
+ */
+export declare function findChrome(chromePath?: string): BrowserExecutable | null;
+/**
+ * Launch Chrome with CDP remote debugging enabled.
+ *
+ * @returns A RunningChrome handle for process management.
+ * @throws If no browser executable is found or Chrome fails to start.
+ */
+export declare function launchChrome(config: BrowserConfig, spawnEnv?: Record<string, string>): Promise<RunningChrome>;
+/**
+ * Stop a running Chrome process.
+ *
+ * Sends SIGTERM first, then SIGKILL after timeout.
+ */
+export declare function stopChrome(running: RunningChrome, timeoutMs?: number): Promise<void>;

package/node_modules/@comis/skills/dist/browser/chrome-detection.js

@@ -0,0 +1,256 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Chrome executable detection and process management.
+ *
+ * Finds installed Chrome/Chromium binaries on Linux and macOS, then
+ * launches Chrome with the --remote-debugging-port flag for CDP access.
+ *
+ * Ported from Comis browser/chrome.executables.ts + chrome.ts,
+ * stripped of Windows support, extension relay, and profile decoration.
+ *
+ * @module
+ */
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import { DEFAULT_CDP_PORT, DEFAULT_BROWSER_PROFILE } from "./constants.js";
+// ── Chrome Detection ─────────────────────────────────────────────────
+function exists(filePath) {
+    try {
+        return fs.existsSync(filePath);
+    }
+    catch {
+        return false;
+    }
+}
+function findFirstExecutable(candidates) {
+    for (const candidate of candidates) {
+        if (exists(candidate.path)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/** Find Chrome on macOS. */
+function findChromeMac() {
+    const home = os.homedir();
+    const candidates = [
+        {
+            kind: "chrome",
+            path: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        },
+        {
+            kind: "chrome",
+            path: `${home}/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`,
+        },
+        {
+            kind: "brave",
+            path: "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+        },
+        {
+            kind: "brave",
+            path: `${home}/Applications/Brave Browser.app/Contents/MacOS/Brave Browser`,
+        },
+        {
+            kind: "edge",
+            path: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+        },
+        {
+            kind: "edge",
+            path: `${home}/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge`,
+        },
+        {
+            kind: "chromium",
+            path: "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        },
+        {
+            kind: "chromium",
+            path: `${home}/Applications/Chromium.app/Contents/MacOS/Chromium`,
+        },
+        {
+            kind: "canary",
+            path: "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+        },
+        {
+            kind: "canary",
+            path: `${home}/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary`,
+        },
+    ];
+    return findFirstExecutable(candidates);
+}
+/** Find Chrome on Linux. */
+function findChromeLinux() {
+    const candidates = [
+        { kind: "chrome", path: "/usr/bin/google-chrome" },
+        { kind: "chrome", path: "/usr/bin/google-chrome-stable" },
+        { kind: "chrome", path: "/usr/bin/chrome" },
+        { kind: "brave", path: "/usr/bin/brave-browser" },
+        { kind: "brave", path: "/usr/bin/brave-browser-stable" },
+        { kind: "brave", path: "/usr/bin/brave" },
+        { kind: "brave", path: "/snap/bin/brave" },
+        { kind: "edge", path: "/usr/bin/microsoft-edge" },
+        { kind: "edge", path: "/usr/bin/microsoft-edge-stable" },
+        { kind: "chromium", path: "/usr/bin/chromium" },
+        { kind: "chromium", path: "/usr/bin/chromium-browser" },
+        { kind: "chromium", path: "/snap/bin/chromium" },
+    ];
+    return findFirstExecutable(candidates);
+}
+/**
+ * Find an installed Chrome/Chromium executable.
+ *
+ * Checks custom path first (from config), then standard OS locations.
+ * Returns null if no browser is found.
+ */
+export function findChrome(chromePath) {
+    if (chromePath) {
+        if (!exists(chromePath)) {
+            return null;
+        }
+        return { kind: "custom", path: chromePath };
+    }
+    const platform = process.platform;
+    if (platform === "darwin")
+        return findChromeMac();
+    if (platform === "linux")
+        return findChromeLinux();
+    return null;
+}
+// ── Chrome Launcher ──────────────────────────────────────────────────
+/**
+ * Resolve user data directory for the browser profile.
+ */
+function resolveUserDataDir(profileName) {
+    const configDir = 
+    // eslint-disable-next-line no-restricted-syntax -- XDG standard directory detection, not secret access
+    process.env["XDG_CONFIG_HOME"] || `${os.homedir()}/.config`;
+    return `${configDir}/comis/browser/${profileName}/user-data`;
+}
+/**
+ * Check if Chrome is reachable at the given CDP URL.
+ */
+async function isChromeReachable(cdpUrl, timeoutMs = 500) {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+        const res = await fetch(`${cdpUrl}/json/version`, {
+            signal: ctrl.signal,
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+/**
+ * Launch Chrome with CDP remote debugging enabled.
+ *
+ * @returns A RunningChrome handle for process management.
+ * @throws If no browser executable is found or Chrome fails to start.
+ */
+export async function launchChrome(config, spawnEnv) {
+    const exe = findChrome(config.chromePath);
+    if (!exe) {
+        throw new Error("No supported browser found (Chrome/Brave/Edge/Chromium on macOS or Linux).");
+    }
+    const cdpPort = config.cdpPort ?? DEFAULT_CDP_PORT;
+    const profileName = config.defaultProfile ?? DEFAULT_BROWSER_PROFILE;
+    const userDataDir = resolveUserDataDir(profileName);
+    fs.mkdirSync(userDataDir, { recursive: true });
+    const args = [
+        `--remote-debugging-port=${cdpPort}`,
+        `--user-data-dir=${userDataDir}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-sync",
+        "--disable-background-networking",
+        "--disable-component-update",
+        "--disable-features=Translate,MediaRouter",
+        "--disable-session-crashed-bubble",
+        "--hide-crash-restore-bubble",
+        "--password-store=basic",
+    ];
+    if (config.headless !== false) {
+        args.push("--headless=new");
+        args.push("--disable-gpu");
+    }
+    if (config.noSandbox) {
+        args.push("--no-sandbox");
+        args.push("--disable-setuid-sandbox");
+    }
+    if (process.platform === "linux") {
+        args.push("--disable-dev-shm-usage");
+    }
+    if (config.viewport) {
+        args.push(`--window-size=${config.viewport.width},${config.viewport.height}`);
+    }
+    // Always open a blank tab to ensure a target exists.
+    args.push("about:blank");
+    const startedAt = Date.now();
+    // Use filtered env instead of raw process.env
+    const chromeEnv = spawnEnv
+        ? { ...spawnEnv, HOME: os.homedir() }
+        // eslint-disable-next-line no-restricted-syntax -- PATH for subprocess spawn, not secret access (fallback when no spawnEnv provided)
+        : { PATH: process.env["PATH"] ?? "", HOME: os.homedir() };
+    const proc = spawn(exe.path, args, {
+        stdio: "pipe",
+        env: chromeEnv,
+    });
+    // Wait for CDP to become reachable.
+    const cdpUrl = `http://127.0.0.1:${cdpPort}`;
+    const readyDeadline = Date.now() + 15_000;
+    while (Date.now() < readyDeadline) {
+        if (await isChromeReachable(cdpUrl, 500)) {
+            break;
+        }
+        await new Promise((r) => setTimeout(r, 200));
+    }
+    if (!(await isChromeReachable(cdpUrl, 500))) {
+        try {
+            proc.kill("SIGKILL");
+        }
+        catch {
+            // ignore
+        }
+        throw new Error(`Failed to start Chrome CDP on port ${cdpPort} for profile "${profileName}".`);
+    }
+    return {
+        pid: proc.pid ?? -1,
+        exe,
+        userDataDir,
+        cdpPort,
+        startedAt,
+        proc,
+    };
+}
+/**
+ * Stop a running Chrome process.
+ *
+ * Sends SIGTERM first, then SIGKILL after timeout.
+ */
+export async function stopChrome(running, timeoutMs = 2500) {
+    const proc = running.proc;
+    if (proc.killed || proc.exitCode !== null)
+        return;
+    try {
+        proc.kill("SIGTERM");
+    }
+    catch {
+        // ignore
+    }
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (proc.exitCode !== null || proc.killed)
+            return;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    try {
+        proc.kill("SIGKILL");
+    }
+    catch {
+        // ignore
+    }
+}

package/node_modules/@comis/skills/dist/browser/config.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Browser service configuration.
+ *
+ * Defines the BrowserConfig interface and a resolver that fills in
+ * defaults from constants.ts. Config is accepted as a parameter --
+ * no global config system dependency.
+ *
+ * @module
+ */
+/**
+ * Configuration for the browser service.
+ *
+ * All fields are optional; resolveBrowserConfig() fills in defaults.
+ */
+export interface BrowserConfig {
+    /** Whether the browser service is enabled. */
+    enabled: boolean;
+    /** Override Chrome executable path. */
+    chromePath?: string;
+    /** CDP debugging port (default 9222). */
+    cdpPort?: number;
+    /** Default browser profile name. */
+    defaultProfile?: string;
+    /** Viewport dimensions. */
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    /** Run Chrome headless (default true for server usage). */
+    headless?: boolean;
+    /** Disable Chrome sandbox (needed in some container envs). */
+    noSandbox?: boolean;
+    /** Maximum screenshot dimension in px (default 2000). */
+    screenshotMaxSide?: number;
+    /** JPEG compression quality (default 80). */
+    screenshotQuality?: number;
+    /** Maximum snapshot text length. */
+    snapshotMaxChars?: number;
+    /** Default action timeout in ms. */
+    timeoutMs?: number;
+}
+/**
+ * Resolve a full BrowserConfig from a partial, filling in defaults.
+ */
+export declare function resolveBrowserConfig(partial?: Partial<BrowserConfig>): BrowserConfig;