@pasko70/pibo 1.9.9 → 1.9.10

package/dist/tools/browser-use-cdp.js

@@ -0,0 +1,259 @@
+const DEFAULT_CDP_URL = 'http://127.0.0.1:56663';
+const DEFAULT_TIMEOUT_MS = 2500;
+async function isCdpPortReachable(port) {
+    try {
+        const response = await fetchWithTimeout(`http://127.0.0.1:${port}/json/version`, 800);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function discoverCdpUrl() {
+    const candidates = [];
+    if (process.env.BROWSER_USE_HOME) {
+        candidates.push(join(process.env.BROWSER_USE_HOME, 'pibo-cdp'));
+    }
+    if (process.env.HOME) {
+        candidates.push(join(process.env.HOME, '.pibo', 'tools', 'browser-use', 'home', 'pibo-cdp'));
+        candidates.push(join(process.env.HOME, '.browser-use', 'pibo-cdp'));
+    }
+    for (const stateDir of candidates) {
+        try {
+            if (!existsSync(stateDir))
+                continue;
+            const entries = readdirSync(stateDir)
+                .filter((f) => f.endsWith('.port'))
+                .map((f) => {
+                const path = join(stateDir, f);
+                const portText = readFileSync(path, 'utf-8').trim();
+                const port = Number.parseInt(portText, 10);
+                const mtime = statSync(path).mtimeMs;
+                return { port, mtime, valid: Number.isFinite(port) && port > 0 };
+            })
+                .filter((e) => e.valid)
+                .sort((a, b) => b.mtime - a.mtime);
+            for (const entry of entries) {
+                if (await isCdpPortReachable(entry.port)) {
+                    return `http://127.0.0.1:${entry.port}`;
+                }
+            }
+        }
+        catch {
+            // ignore discovery errors for this candidate
+        }
+    }
+    return DEFAULT_CDP_URL;
+}
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const CHAT_TARGET_PROBE = `(() => {
+  const text = String(document.body?.innerText || "");
+  const textareas = [...document.querySelectorAll("textarea")].map((textarea) => ({
+    placeholder: textarea.placeholder || "",
+    disabled: Boolean(textarea.disabled),
+    value: textarea.value || "",
+  }));
+  return {
+    title: document.title || "",
+    text: text.slice(0, 3000),
+    textareas,
+  };
+})()`;
+export async function listBrowserUseCdpTargets(options = {}) {
+    const cdpUrl = await normalizeCdpUrl(options.cdpUrl);
+    const probe = options.probe !== false;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const targets = await fetchChromeTargets(cdpUrl, timeoutMs);
+    const rows = [];
+    for (const target of targets) {
+        const row = normalizeChromeTarget(target);
+        if (probe && row.url.includes('/apps/chat') && row.webSocketDebuggerUrl) {
+            rows.push(await probeChatTarget(row, timeoutMs));
+        }
+        else {
+            rows.push(row);
+        }
+    }
+    return rows;
+}
+export function selectBestChatTarget(targets) {
+    return targets
+        .filter((target) => target.url.includes('/apps/chat'))
+        .filter((target) => target.webSocketDebuggerUrl)
+        .filter((target) => target.auth !== 'unauthenticated')
+        .filter((target) => target.composer)
+        .sort((left, right) => scoreChatTarget(right) - scoreChatTarget(left))[0];
+}
+export function formatBrowserUseTargets(targets) {
+    const lines = ['id\turl\tauth\tcomposer\ttitle'];
+    for (const target of targets) {
+        const composer = target.composer ? 'yes' : 'no';
+        const title = target.probeError ? `${target.title} (${target.probeError})` : target.title;
+        lines.push(`${target.id}\t${target.url}\t${target.auth}\t${composer}\t${title}`);
+    }
+    return lines.join('\n');
+}
+export function printAttachChatExports(target, cdpUrl = DEFAULT_CDP_URL) {
+    console.log(`export PIBO_CDP_URL=${shellQuote(cdpUrl)}`);
+    console.log(`export PIBO_CDP_TARGET_ID=${shellQuote(target.id)}`);
+    console.log(`export PIBO_CDP_TARGET_WS=${shellQuote(target.webSocketDebuggerUrl ?? '')}`);
+    console.log(`export PIBO_CHAT_URL=${shellQuote(target.url)}`);
+}
+export function normalizeCdpUrlSync(value) {
+    return value.replace(/\/+$/, '');
+}
+async function normalizeCdpUrl(value) {
+    if (value)
+        return normalizeCdpUrlSync(value);
+    return (await discoverCdpUrl()).replace(/\/+$/, '');
+}
+async function fetchChromeTargets(cdpUrl, timeoutMs) {
+    const response = await fetchWithTimeout(`${cdpUrl}/json/list`, timeoutMs);
+    if (!response.ok) {
+        throw new Error(`Chrome target discovery failed: ${response.status} ${response.statusText}`);
+    }
+    const payload = await response.json();
+    if (!Array.isArray(payload))
+        throw new Error('Chrome target discovery returned invalid JSON');
+    return payload;
+}
+async function fetchWithTimeout(url, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function normalizeChromeTarget(target) {
+    return {
+        id: stringValue(target.id),
+        type: stringValue(target.type),
+        title: stringValue(target.title),
+        url: stringValue(target.url),
+        webSocketDebuggerUrl: optionalStringValue(target.webSocketDebuggerUrl),
+        auth: 'unknown',
+        composer: false,
+        textareaCount: 0,
+    };
+}
+async function probeChatTarget(target, timeoutMs) {
+    try {
+        const probe = await evaluateCdp(target.webSocketDebuggerUrl, CHAT_TARGET_PROBE, timeoutMs);
+        return applyProbe(target, probe);
+    }
+    catch (error) {
+        return {
+            ...target,
+            probeError: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function applyProbe(target, probe) {
+    const text = stringValue(probe.text);
+    const textareas = Array.isArray(probe.textareas) ? probe.textareas : [];
+    const composer = textareas.some((textarea) => {
+        if (!isRecord(textarea))
+            return false;
+        return textarea.disabled !== true;
+    });
+    return {
+        ...target,
+        title: stringValue(probe.title) || target.title,
+        auth: classifyAuth(text, composer),
+        composer,
+        textareaCount: textareas.length,
+    };
+}
+function classifyAuth(text, composer) {
+    if (/Unauthenticated|Sign in with Google|Sign in/i.test(text))
+        return 'unauthenticated';
+    if (composer)
+        return 'authenticated';
+    if (/[^\s@]+@[^\s@]+\.[^\s@]+/.test(text))
+        return 'authenticated';
+    return 'unknown';
+}
+function scoreChatTarget(target) {
+    return ((target.auth === 'authenticated' ? 100 : 0) +
+        (target.composer ? 50 : 0) +
+        (target.url.includes('/sessions/') ? 20 : 0) +
+        (target.url.includes('/rooms/') ? 10 : 0));
+}
+async function evaluateCdp(webSocketUrl, expression, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const socket = new WebSocket(webSocketUrl);
+        let nextId = 0;
+        let settled = false;
+        const timer = setTimeout(() => fail(new Error('Timed out waiting for CDP target')), timeoutMs);
+        function settle() {
+            if (settled)
+                return false;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                socket.close();
+            }
+            catch {
+                // The target may fail before the WebSocket reaches OPEN.
+            }
+            return true;
+        }
+        function succeed(value) {
+            if (settle())
+                resolve(value);
+        }
+        function fail(error) {
+            if (settle())
+                reject(error);
+        }
+        function send(method, params) {
+            const id = ++nextId;
+            socket.send(JSON.stringify({ id, method, params }));
+            return id;
+        }
+        socket.addEventListener('open', () => {
+            send('Runtime.evaluate', { expression, returnByValue: true });
+        });
+        socket.addEventListener('message', (event) => {
+            const message = parseJson(String(event.data));
+            if (!isRecord(message) || typeof message.id !== 'number')
+                return;
+            if (isRecord(message.error)) {
+                fail(new Error(JSON.stringify(message.error)));
+                return;
+            }
+            const result = isRecord(message.result) ? message.result : undefined;
+            const runtimeResult = result && isRecord(result.result) ? result.result : undefined;
+            const value = runtimeResult && isRecord(runtimeResult.value) ? runtimeResult.value : {};
+            succeed(value);
+        });
+        socket.addEventListener('error', () => {
+            fail(new Error('CDP WebSocket error'));
+        });
+    });
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : '';
+}
+function optionalStringValue(value) {
+    const text = stringValue(value);
+    return text || undefined;
+}
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}