omnikey-cli 1.0.24 → 1.0.25

package/backend-dist/agent/agentServer.js

@@ -45,7 +45,7 @@ const subscription_1 = require("../models/subscription");
 const subscriptionUsage_1 = require("../models/subscriptionUsage");
 const agentPrompts_1 = require("./agentPrompts");
 const featureRoutes_1 = require("../featureRoutes");
-const web_search_provider_1 = require("../web-search-provider");
+const web_search_provider_1 = require("../web-search/web-search-provider");
 const agentAuth_1 = require("./agentAuth");
 const utils_1 = require("./utils");
 const ai_client_1 = require("../ai-client");

package/backend-dist/agent/utils.js

@@ -4,7 +4,7 @@ exports.buildAvailableTools = buildAvailableTools;
 exports.createUserContent = createUserContent;
 exports.sendFinalAnswer = sendFinalAnswer;
 exports.pushToSessionHistory = pushToSessionHistory;
-const web_search_provider_1 = require("../web-search-provider");
+const web_search_provider_1 = require("../web-search/web-search-provider");
 const ai_client_1 = require("../ai-client");
 const config_1 = require("../config");
 /**

package/backend-dist/web-search/browser-playwright.js

@@ -0,0 +1,613 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnyBrowserRunning = isAnyBrowserRunning;
+exports.isBrowserOpenWithUrl = isBrowserOpenWithUrl;
+exports.fetchWithPlaywright = fetchWithPlaywright;
+const axios_1 = __importDefault(require("axios"));
+// Utility: Promise with timeout
+async function withTimeout(promise, ms, label, log) {
+    let timeoutId;
+    return Promise.race([
+        promise,
+        new Promise((resolve) => {
+            timeoutId = setTimeout(() => {
+                log.warn('browser-playwright: fetch timed out', { label, ms });
+                resolve(null);
+            }, ms);
+        }),
+    ]).then((result) => {
+        clearTimeout(timeoutId);
+        return result;
+    });
+}
+/**
+ * Playwright-based web fetching using the user's installed browser profile.
+ *
+ * Key design decisions:
+ *   1. Detects which Chromium browsers are currently RUNNING and tries those
+ *      first — the active browser is where the authenticated session lives.
+ *   2. Discovers the actual profile directory dynamically (Default, Profile 1,
+ *      Profile 2 …) rather than hardcoding "Default".
+ *   3. Checks multiple executable locations (system /Applications and
+ *      user ~/Applications).
+ *   4. Firefox is intentionally excluded from Playwright — headless Firefox
+ *      on macOS has a known RenderCompositorSWGL rendering bug that causes
+ *      30-second timeouts. Cookies from Firefox are still extracted separately
+ *      by browser-cookies.ts for the plain-HTTP fallback.
+ *
+ * macOS only. Returns null on other platforms.
+ */
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const playwright_core_1 = __importDefault(require("playwright-core"));
+const home = os.homedir();
+const BROWSER_CATALOGUE = [
+    {
+        name: 'Chrome',
+        executablePaths: [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            `${home}/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`,
+        ],
+        userDataDir: path.join(home, 'Library/Application Support/Google/Chrome'),
+    },
+    {
+        name: 'Brave',
+        executablePaths: [
+            '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+            `${home}/Applications/Brave Browser.app/Contents/MacOS/Brave Browser`,
+        ],
+        userDataDir: path.join(home, 'Library/Application Support/BraveSoftware/Brave-Browser'),
+    },
+    {
+        name: 'Edge',
+        executablePaths: [
+            '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+            `${home}/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge`,
+        ],
+        userDataDir: path.join(home, 'Library/Application Support/Microsoft Edge'),
+    },
+    {
+        name: 'Arc',
+        executablePaths: [
+            '/Applications/Arc.app/Contents/MacOS/Arc',
+            `${home}/Applications/Arc.app/Contents/MacOS/Arc`,
+        ],
+        userDataDir: path.join(home, 'Library/Application Support/Arc/User Data'),
+    },
+    {
+        name: 'Vivaldi',
+        executablePaths: [
+            '/Applications/Vivaldi.app/Contents/MacOS/Vivaldi',
+            `${home}/Applications/Vivaldi.app/Contents/MacOS/Vivaldi`,
+        ],
+        userDataDir: path.join(home, 'Library/Application Support/Vivaldi'),
+    },
+    {
+        name: 'Opera',
+        executablePaths: [
+            '/Applications/Opera.app/Contents/MacOS/Opera',
+            `${home}/Applications/Opera.app/Contents/MacOS/Opera`,
+        ],
+        userDataDir: path.join(home, 'Library/Application Support/com.operasoftware.Opera'),
+    },
+    {
+        name: 'Chromium',
+        executablePaths: [
+            '/Applications/Chromium.app/Contents/MacOS/Chromium',
+            `${home}/Applications/Chromium.app/Contents/MacOS/Chromium`,
+        ],
+        userDataDir: path.join(home, 'Library/Application Support/Chromium'),
+    },
+];
+// ─── Running browser detection ────────────────────────────────────────────────
+/**
+ * Returns the names of browsers that are currently running.
+ * Used to sort the browser list so the active browser (with a live session)
+ * is tried first.
+ */
+function getRunningBrowserNames() {
+    const running = new Set();
+    try {
+        // ps -axco command lists only the process name (no path, no args)
+        const output = (0, child_process_1.execSync)('ps -axco command', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const lines = output.toLowerCase().split('\n');
+        const processMap = {
+            'google chrome': 'Chrome',
+            'brave browser': 'Brave',
+            'microsoft edge': 'Edge',
+            arc: 'Arc',
+            vivaldi: 'Vivaldi',
+            opera: 'Opera',
+            chromium: 'Chromium',
+            safari: 'Safari',
+        };
+        for (const [processName, browserName] of Object.entries(processMap)) {
+            if (processName === 'safari') {
+                // Only match the main Safari process exactly (case-insensitive, trimmed)
+                if (lines.some((l) => l.trim() === 'safari')) {
+                    running.add(browserName);
+                }
+            }
+            else {
+                // For other browsers, allow exact match or substring match
+                if (lines.some((l) => l.trim() === processName || l.includes(processName))) {
+                    running.add(browserName);
+                }
+            }
+        }
+    }
+    catch {
+        // ps failed — proceed without running-browser info
+    }
+    return running;
+}
+// ─── Strategy -1: CDP via DevToolsActivePort ─────────────────────────────────
+//
+// When Chrome is launched with --remote-debugging-port (or --remote-debugging-port=0
+// to let it pick a free port), it writes a DevToolsActivePort file to the user data
+// directory containing the actual port. Connecting via CDP gives us direct access
+// to the live, JS-rendered tab content without AppleScript permissions or cookie
+// decryption. This is the fastest and most reliable path when available.
+async function fetchWithCDP(url, browsersWithUrl, log) {
+    const targetBase = url.split('?')[0]; // strip query for prefix match
+    // Collect candidate ports:
+    //   1. DevToolsActivePort file (written when Chrome was started with --remote-debugging-port)
+    //   2. Well-known default ports developers commonly use
+    const candidatePorts = [];
+    for (const candidate of BROWSER_CATALOGUE) {
+        if (!browsersWithUrl.has(candidate.name))
+            continue;
+        if (candidate.name === 'Safari')
+            continue; // CDP is Chromium-only
+        const portFile = path.join(candidate.userDataDir, 'DevToolsActivePort');
+        if (fs.existsSync(portFile)) {
+            try {
+                const raw = fs.readFileSync(portFile, 'utf8');
+                const port = parseInt(raw.split('\n')[0].trim(), 10);
+                if (!isNaN(port) && port > 0 && !candidatePorts.includes(port)) {
+                    candidatePorts.push(port);
+                }
+            }
+            catch { }
+        }
+    }
+    // Always probe the most common debug ports — many developers run Chrome with
+    // --remote-debugging-port=9222 and these checks are cheap (instant refusal if closed).
+    for (const p of [9222, 9229, 9333]) {
+        if (!candidatePorts.includes(p))
+            candidatePorts.push(p);
+    }
+    for (const port of candidatePorts) {
+        // Quick HTTP probe: /json/version returns immediately if the debug endpoint is up.
+        let endpointUp = false;
+        try {
+            const probe = await axios_1.default.get(`http://localhost:${port}/json/version`, { timeout: 800 });
+            endpointUp = probe.status === 200;
+        }
+        catch {
+            // Port not listening — skip without logging noise
+            continue;
+        }
+        if (!endpointUp)
+            continue;
+        log.info('browser-playwright: CDP — debug endpoint found, connecting', { port });
+        let cdpBrowser = null;
+        try {
+            cdpBrowser = await playwright_core_1.default.chromium.connectOverCDP(`http://localhost:${port}`, {
+                timeout: 5000,
+            });
+            let matchedPage = null;
+            for (const context of cdpBrowser.contexts()) {
+                for (const page of context.pages()) {
+                    if (page.url().startsWith(targetBase)) {
+                        matchedPage = page;
+                        break;
+                    }
+                }
+                if (matchedPage)
+                    break;
+            }
+            if (!matchedPage) {
+                log.debug('browser-playwright: CDP — no tab found matching URL', { port, url });
+                continue;
+            }
+            log.info('browser-playwright: CDP — tab found, extracting content', {
+                port,
+                tabUrl: matchedPage.url(),
+            });
+            try {
+                await matchedPage.waitForFunction(() => (document.body?.innerText ?? '').trim().length > 200, { timeout: 5000 });
+            }
+            catch {
+                // Best-effort — extract whatever is rendered so far
+            }
+            const content = await matchedPage.evaluate(() => document.body.innerText ?? document.body.textContent ?? '');
+            log.info('browser-playwright: CDP — content extracted', {
+                port,
+                contentLength: content.trim().length,
+            });
+            const trimmed = content.trim();
+            return trimmed ? { content: trimmed, finalUrl: matchedPage.url() } : null;
+        }
+        catch (err) {
+            log.warn('browser-playwright: CDP — connection failed', {
+                port,
+                error: err instanceof Error ? err.message.split('\n')[0] : String(err),
+            });
+        }
+        finally {
+            if (cdpBrowser) {
+                try {
+                    await cdpBrowser.close();
+                }
+                catch { }
+            }
+        }
+    }
+    return null;
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Returns true if any supported Chromium browser is currently running.
+ */
+function isAnyBrowserRunning() {
+    return getRunningBrowserNames().size > 0;
+}
+const BROWSER_APPLESCRIPT = {
+    Chrome: { appName: 'Google Chrome', jsVerb: 'execute javascript' },
+    Brave: { appName: 'Brave Browser', jsVerb: 'execute javascript' },
+    Edge: { appName: 'Microsoft Edge', jsVerb: 'execute javascript' },
+    Arc: { appName: 'Arc', jsVerb: 'execute javascript' },
+    Vivaldi: { appName: 'Vivaldi', jsVerb: 'execute javascript' },
+    Opera: { appName: 'Opera', jsVerb: 'execute javascript' },
+    Chromium: { appName: 'Chromium', jsVerb: 'execute javascript' },
+    Safari: { appName: 'Safari', jsVerb: 'do JavaScript' },
+};
+// ─── Tab detection ────────────────────────────────────────────────────────────
+/**
+ * Returns the names of running browsers that are confirmed to have the given
+ * URL's hostname open in a tab, via AppleScript.
+ * Only browsers where AppleScript succeeds AND the hostname is found are included.
+ * Browsers where AppleScript fails are silently skipped (not assumed to have it open).
+ */
+function getBrowsersWithUrlOpen(url, log) {
+    const confirmed = new Set();
+    let targetHostname;
+    try {
+        targetHostname = new URL(url).hostname;
+    }
+    catch {
+        return confirmed;
+    }
+    const runningBrowsers = getRunningBrowserNames();
+    if (runningBrowsers.size === 0)
+        return confirmed;
+    for (const browserName of runningBrowsers) {
+        const info = BROWSER_APPLESCRIPT[browserName];
+        if (!info)
+            continue;
+        try {
+            const script = `tell application "${info.appName}" to get URL of every tab of every window`;
+            const output = (0, child_process_1.execSync)(`osascript -e '${script}'`, {
+                encoding: 'utf8',
+                timeout: 5000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const found = output
+                .split(/[,\n]/)
+                .map((u) => u.trim())
+                .some((u) => {
+                try {
+                    return new URL(u).hostname === targetHostname;
+                }
+                catch {
+                    return false;
+                }
+            });
+            log.debug('browser-playwright: tab check', { browser: browserName, targetHostname, found });
+            if (found)
+                confirmed.add(browserName);
+        }
+        catch {
+            log.debug('browser-playwright: AppleScript tab check failed — skipping browser', {
+                browser: browserName,
+            });
+        }
+    }
+    return confirmed;
+}
+/**
+ * Returns true if the given URL's hostname is confirmed open in any running
+ * browser tab via AppleScript. Returns false if the check cannot be performed
+ * or if no browser has the URL open.
+ */
+function isBrowserOpenWithUrl(url, log) {
+    return getBrowsersWithUrlOpen(url, log).size > 0;
+}
+// ─── Strategy 0: Live-tab AppleScript extraction ──────────────────────────────
+//
+// When the user already has the URL open in a browser we can pull the rendered
+// page text directly via AppleScript — no cookie decryption, no profile copying,
+// no headless browser launch needed.  This is the most reliable strategy for
+// authenticated pages because the live tab already holds the valid session.
+/**
+ * Writes an AppleScript to a temp file, executes it with `osascript`, then
+ * deletes the file. Using a temp file avoids heredoc parsing issues that arise
+ * when multi-line scripts are passed inline to execSync.
+ *
+ * On failure, the thrown Error includes the osascript stderr so callers can
+ * log the actual reason (e.g. "Allow JavaScript from Apple Events is not enabled").
+ */
+function runAppleScript(script, timeoutMs) {
+    const tmpPath = path.join(os.tmpdir(), `omnikey-as-${Date.now()}-${Math.random().toString(36).slice(2)}.applescript`);
+    fs.writeFileSync(tmpPath, script, 'utf8');
+    try {
+        return (0, child_process_1.execSync)(`osascript "${tmpPath}"`, {
+            encoding: 'utf8',
+            timeout: timeoutMs,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch (err) {
+        // Enrich the error with osascript's stderr so callers get the real reason.
+        const stderr = err?.stderr?.toString?.().trim() ?? '';
+        const base = err instanceof Error ? err.message : String(err);
+        const enriched = new Error(stderr ? `${base}\n${stderr}` : base);
+        throw enriched;
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch { }
+    }
+}
+/**
+ * Finds the window/tab index of `url` inside `appName` via AppleScript.
+ * Returns { winIdx, tabIdx } (1-based) or null if not found.
+ */
+function findTabLocation(appName, url) {
+    // Strip query-string for the prefix match so deep links still resolve.
+    const urlBase = url.split('?')[0].replace(/"/g, ''); // remove double-quotes to avoid breaking AppleScript string
+    const script = [
+        `tell application "${appName}"`,
+        `  repeat with wIdx from 1 to count of windows`,
+        `    repeat with tIdx from 1 to count of tabs of window wIdx`,
+        `      if URL of tab tIdx of window wIdx starts with "${urlBase}" then`,
+        `        return (wIdx as string) & ":" & (tIdx as string)`,
+        `      end if`,
+        `    end repeat`,
+        `  end repeat`,
+        `  return ""`,
+        `end tell`,
+    ].join('\n');
+    try {
+        const result = runAppleScript(script, 5000).trim();
+        if (!result)
+            return null;
+        const [w, t] = result.split(':').map(Number);
+        if (!w || !t || isNaN(w) || isNaN(t))
+            return null;
+        return { winIdx: w, tabIdx: t };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Attempts to extract the rendered text of `url` directly from an open browser
+ * tab using AppleScript JS execution. Only tries browsers confirmed to have the
+ * URL open. Returns null if the URL is not open or extraction fails.
+ */
+async function fetchFromRunningBrowserTab(url, browsersWithUrl, log) {
+    if (process.platform !== 'darwin' || browsersWithUrl.size === 0)
+        return null;
+    for (const browserName of browsersWithUrl) {
+        const info = BROWSER_APPLESCRIPT[browserName];
+        if (!info)
+            continue;
+        const location = findTabLocation(info.appName, url);
+        if (!location) {
+            log.debug('browser-playwright: tab location not found', { browser: browserName, url });
+            continue;
+        }
+        const { winIdx, tabIdx } = location;
+        log.info('browser-playwright: extracting content from live tab', {
+            browser: browserName,
+            winIdx,
+            tabIdx,
+            url,
+        });
+        // ── Attempt A: execute JavaScript to get the JS-rendered innerText ────────
+        // Requires "Allow JavaScript from Apple Events" in Chrome (View → Developer)
+        // or Safari (Develop → Allow JavaScript from Apple Events).
+        //
+        // Chrome ONLY allows execute javascript on the ACTIVE tab of a window, even
+        // with "Allow JavaScript from Apple Events" enabled. We must set the active
+        // tab index first, then use the `tell tab` block form (not the `in tab` form)
+        // which is more reliably dispatched by Chrome's Apple Event handler.
+        const extractJsScript = browserName === 'Safari'
+            ? [
+                `tell application "${info.appName}"`,
+                `  ${info.jsVerb} "document.body.innerText || document.body.textContent || ''" in tab ${tabIdx} of window ${winIdx}`,
+                `end tell`,
+            ].join('\n')
+            : [
+                `tell application "${info.appName}"`,
+                `  set active tab index of window ${winIdx} to ${tabIdx}`,
+                `  tell tab ${tabIdx} of window ${winIdx}`,
+                `    execute javascript "document.body.innerText || document.body.textContent || ''"`,
+                `  end tell`,
+                `end tell`,
+            ].join('\n');
+        try {
+            const content = runAppleScript(extractJsScript, 10000).trim();
+            if (content && content.length > 100) {
+                log.info('browser-playwright: live tab JS content extracted', {
+                    browser: browserName,
+                    url,
+                    contentLength: content.length,
+                });
+                return content;
+            }
+            log.debug('browser-playwright: live tab JS content too short or empty', {
+                browser: browserName,
+                url,
+                contentLength: content.length,
+            });
+        }
+        catch (err) {
+            // The first line of err.message is "Command failed: osascript ...".
+            // The second line (from stderr) is the real reason, e.g.:
+            //   "Google Chrome got an error: Allow JavaScript from Apple Events is not enabled"
+            const lines = (err instanceof Error ? err.message : String(err)).split('\n');
+            const detail = lines.find((l) => l.trim() && !l.startsWith('Command failed')) ?? lines[0];
+            log.warn('browser-playwright: live tab JS extraction failed — falling back to page source', {
+                browser: browserName,
+                url,
+                reason: detail.trim(),
+            });
+        }
+        // ── Attempt B: get source of tab (Safari only) ───────────────────────────
+        // Chrome-family does NOT expose a `source` property on tab objects via
+        // AppleScript — the only content-extraction path is `execute javascript`
+        // (Attempt A), which requires "Allow JavaScript from Apple Events".
+        // Safari exposes `source` on `document` objects (not `tab`), so we compute
+        // the global document index by counting tabs across all windows in order.
+        if (browserName !== 'Safari') {
+            log.info('browser-playwright: live tab JS execution failed — ensure "Allow JavaScript from Apple Events" is enabled (Chrome: View → Developer → Allow JavaScript from Apple Events) and restart Chrome after enabling it', {
+                browser: browserName,
+                url,
+            });
+            continue;
+        }
+        const getSourceScript = [
+            `tell application "${info.appName}"`,
+            `  set docIdx to 0`,
+            `  repeat with w from 1 to count of windows`,
+            `    repeat with t from 1 to count of tabs of window w`,
+            `      set docIdx to docIdx + 1`,
+            `      if w = ${winIdx} and t = ${tabIdx} then`,
+            `        return source of document docIdx`,
+            `      end if`,
+            `    end repeat`,
+            `  end repeat`,
+            `  return ""`,
+            `end tell`,
+        ].join('\n');
+        try {
+            const html = runAppleScript(getSourceScript, 10000).trim();
+            if (html && html.length > 200) {
+                const text = html
+                    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+                    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+                    .replace(/<[^>]+>/g, ' ')
+                    .replace(/\s+/g, ' ')
+                    .trim();
+                if (text.length > 100) {
+                    log.info('browser-playwright: live tab page source extracted', {
+                        browser: browserName,
+                        url,
+                        contentLength: text.length,
+                    });
+                    return text;
+                }
+            }
+            log.debug('browser-playwright: live tab page source too short or empty', {
+                browser: browserName,
+                url,
+            });
+        }
+        catch (err) {
+            const lines = (err instanceof Error ? err.message : String(err)).split('\n');
+            const detail = lines.find((l) => l.trim() && !l.startsWith('Command failed')) ?? lines[0];
+            log.warn('browser-playwright: live tab page source extraction failed', {
+                browser: browserName,
+                url,
+                reason: detail.trim(),
+            });
+        }
+    }
+    return null;
+}
+/**
+ * Fetches a URL using the user's browser session.
+ *
+ * Only browsers that are confirmed (via AppleScript) to have the URL open are
+ * tried — this avoids wasting time on browsers or profiles that don't hold the
+ * active session.
+ *
+ * Strategies in order:
+ *  0. Live-tab extraction — reads content directly from the open tab via
+ *     AppleScript JS execution. No cookie decryption required.
+ *  1. Cookie injection — decrypts cookies and injects into a fresh headless
+ *     Chromium context (handles cookie-based auth when live tab unavailable).
+ *  2. Profile copy — copies Local Storage + IndexedDB to a temp dir (handles
+ *     localStorage/sessionStorage token auth flows).
+ *  3. Safari Playwright — WebKit with injected Safari cookies (Safari only).
+ */
+async function fetchWithPlaywright(url, log) {
+    // Determine which browsers have the URL open right now.
+    const browsersWithUrl = getBrowsersWithUrlOpen(url, log);
+    log.info('browser-playwright: browsers with URL open', {
+        url,
+        browsers: [...browsersWithUrl],
+    });
+    // ── Strategy -1: CDP via DevToolsActivePort ──────────────────────────────
+    // Fastest path — connects directly to the live browser's JS-rendered tab.
+    // Only works when Chrome was launched with --remote-debugging-port.
+    if (browsersWithUrl.size > 0) {
+        const cdpResult = await fetchWithCDP(url, browsersWithUrl, log);
+        if (cdpResult) {
+            return cdpResult.content;
+        }
+    }
+    // ── Strategy 0: extract from the live tab directly ────────────────────────
+    const liveContent = await fetchFromRunningBrowserTab(url, browsersWithUrl, log);
+    if (liveContent) {
+        return liveContent;
+    }
+    log.warn('browser-playwright: all strategies exhausted', { url });
+    return null;
+}

package/backend-dist/web-search/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./web-search-provider"), exports);

package/backend-dist/web-search/llm-auth-check.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPageAuthenticated = isPageAuthenticated;
+const ai_client_1 = require("../ai-client");
+const ai_client_2 = require("../ai-client");
+const SYSTEM_PROMPT = 'You are an expert at detecting whether a web page is showing the real requested content. ' +
+    'Given a URL and the visible text content of a web page, answer "yes" if EITHER: ' +
+    '(1) The URL looks like a public resource that does not require authentication — such as documentation sites, ' +
+    'public wikis, news articles, open-source repos, package registries, developer references, or any URL whose ' +
+    'hostname/path strongly suggests publicly accessible content (e.g. docs.*, developer.*, wikipedia.org, github.com public repos, ' +
+    'stackoverflow.com, npmjs.com, medium.com, reddit.com, youtube.com, etc.). ' +
+    '(2) The page is showing the actual content that an authenticated user would see at that URL. ' +
+    'Answer "no" if the page is: a login/sign-in page, an access denied or unauthorized page, a redirect away from the requested URL, ' +
+    'a generic 404/not-found or error page that could be an auth redirect in disguise (e.g. shows a not-found message but ' +
+    'the URL was a valid authenticated route), or any page that does not correspond to the requested resource. ' +
+    'When in doubt about whether a URL is public, lean towards "yes". Reply with only one word: "yes" or "no".';
+const PUBLIC_URL_PATTERNS = [
+    /^https?:\/\/(www\.)?github\.com\/(?!.*\/settings|.*\/account)/,
+    /^https?:\/\/(www\.)?stackoverflow\.com/,
+    /^https?:\/\/(www\.)?wikipedia\.org/,
+    /^https?:\/\/docs\./,
+    /^https?:\/\/developer\./,
+    /^https?:\/\/(www\.)?npmjs\.com/,
+    /^https?:\/\/(www\.)?pypi\.org/,
+    /^https?:\/\/(www\.)?medium\.com/,
+    /^https?:\/\/(www\.)?reddit\.com/,
+    /^https?:\/\/(www\.)?youtube\.com/,
+    /^https?:\/\/(www\.)?news\.ycombinator\.com/,
+    // Package registries & language docs
+    /^https?:\/\/(www\.)?crates\.io/,
+    /^https?:\/\/(www\.)?rubygems\.org/,
+    /^https?:\/\/(www\.)?packagist\.org/,
+    /^https?:\/\/(www\.)?pkg\.go\.dev/,
+    /^https?:\/\/(www\.)?hex\.pm/,
+    /^https?:\/\/(www\.)?nuget\.org/,
+    /^https?:\/\/(www\.)?maven\.apache\.org/,
+    /^https?:\/\/central\.sonatype\.com/,
+    // Official language & runtime docs
+    /^https?:\/\/(www\.)?python\.org/,
+    /^https?:\/\/(www\.)?rust-lang\.org/,
+    /^https?:\/\/(www\.)?golang\.org/,
+    /^https?:\/\/(www\.)?go\.dev/,
+    /^https?:\/\/(www\.)?ruby-lang\.org/,
+    /^https?:\/\/(www\.)?php\.net/,
+    /^https?:\/\/(www\.)?kotlinlang\.org/,
+    /^https?:\/\/(www\.)?swift\.org/,
+    /^https?:\/\/learn\.microsoft\.com/,
+    /^https?:\/\/msdn\.microsoft\.com/,
+    /^https?:\/\/devblogs\.microsoft\.com/,
+    /^https?:\/\/(www\.)?w3\.org/,
+    /^https?:\/\/(www\.)?w3schools\.com/,
+    /^https?:\/\/(www\.)?mdn\./,
+    /^https?:\/\/developer\.mozilla\.org/,
+    // Source code & open-source platforms
+    /^https?:\/\/(www\.)?gitlab\.com\/(?!.*\/-\/settings)/,
+    /^https?:\/\/(www\.)?bitbucket\.org\/(?!.*\/admin)/,
+    /^https?:\/\/(www\.)?sourceforge\.net/,
+    /^https?:\/\/(www\.)?codepen\.io/,
+    /^https?:\/\/(www\.)?jsfiddle\.net/,
+    /^https?:\/\/(www\.)?codesandbox\.io/,
+    // Q&A, forums & community sites
+    /^https?:\/\/(www\.)?stackexchange\.com/,
+    /^https?:\/\/(www\.)?superuser\.com/,
+    /^https?:\/\/(www\.)?serverfault\.com/,
+    /^https?:\/\/(www\.)?askubuntu\.com/,
+    /^https?:\/\/(www\.)?quora\.com/,
+    /^https?:\/\/(www\.)?dev\.to/,
+    /^https?:\/\/(www\.)?hashnode\.com/,
+    /^https?:\/\/(www\.)?lobste\.rs/,
+    // News & tech media
+    /^https?:\/\/(www\.)?techcrunch\.com/,
+    /^https?:\/\/(www\.)?theverge\.com/,
+    /^https?:\/\/(www\.)?wired\.com/,
+    /^https?:\/\/(www\.)?arstechnica\.com/,
+    /^https?:\/\/(www\.)?thenextweb\.com/,
+    /^https?:\/\/(www\.)?infoq\.com/,
+    /^https?:\/\/(www\.)?smashingmagazine\.com/,
+    /^https?:\/\/(www\.)?css-tricks\.com/,
+    // Reference & encyclopedias
+    /^https?:\/\/[a-z-]+\.wikipedia\.org/,
+    /^https?:\/\/(www\.)?wikidata\.org/,
+    /^https?:\/\/(www\.)?wikimedia\.org/,
+    /^https?:\/\/(www\.)?archive\.org/,
+    // Cloud provider public docs
+    /^https?:\/\/cloud\.google\.com\/(?!.*\/console)/,
+    /^https?:\/\/aws\.amazon\.com\/(?!(.*\/console|.*\/signin))/,
+    /^https?:\/\/(www\.)?azure\.microsoft\.com/,
+    /^https?:\/\/registry\./,
+];
+const AUTH_PATH_PATTERN = /[/?#](login|log-in|signin|sign-in|signup|sign-up|register|auth|authenticate|oauth|sso|saml|forgot-password|reset-password|verify|two-factor|2fa|mfa)([/?#]|$)/i;
+function isPublicUrl(url) {
+    if (AUTH_PATH_PATTERN.test(url))
+        return false;
+    return PUBLIC_URL_PATTERNS.some((pattern) => pattern.test(url));
+}
+async function isPageAuthenticated(content, url, log, finalUrl) {
+    if (finalUrl) {
+        const normalize = (u) => u.replace(/#.*$/, '').replace(/\/$/, '');
+        if (normalize(finalUrl) !== normalize(url)) {
+            log.info('llm-auth-check: redirect detected, treating as not authenticated', {
+                requestUrl: url,
+                finalUrl,
+            });
+            return false;
+        }
+    }
+    if (isPublicUrl(url)) {
+        log.info('llm-auth-check: public URL, skipping auth check', { url });
+        return true;
+    }
+    const model = (0, ai_client_2.getDefaultModel)(ai_client_1.aiClient.getProvider(), 'fast');
+    const messages = [
+        { role: 'system', content: SYSTEM_PROMPT },
+        { role: 'user', content: `URL: ${url}\n\nPage content:\n${content}` },
+    ];
+    try {
+        const result = await ai_client_1.aiClient.complete(model, messages, { temperature: 0, maxTokens: 1 });
+        const answer = result.content.trim().toLowerCase();
+        log.info('llm-auth-check: LLM response', { url, answer });
+        return answer === 'yes';
+    }
+    catch (err) {
+        log.error('llm-auth-check: LLM call failed', { url, error: String(err) });
+        // If LLM call fails, default to not authorized
+        return false;
+    }
+}

package/backend-dist/{web-search-provider.js → web-search/web-search-provider.js}

@@ -7,7 +7,9 @@ exports.MAX_TOOL_CONTENT_CHARS = exports.MAX_WEB_FETCH_BYTES = exports.WEB_SEARC
 exports.executeWebSearch = executeWebSearch;
 exports.executeTool = executeTool;
 const axios_1 = __importDefault(require("axios"));
-const config_1 = require("./config");
+const config_1 = require("../config");
+const browser_playwright_1 = require("./browser-playwright");
+const llm_auth_check_1 = require("./llm-auth-check");
 exports.WEB_FETCH_TOOL = {
     name: 'web_fetch',
     description: "Fetch the text content of any publicly accessible URL. Use this to retrieve documentation, error references, API guides, release notes, or any web resource that would help answer the user's question.",
@@ -134,27 +136,107 @@ async function executeWebSearch(query, log) {
     log.info('web_search: using DuckDuckGo (free fallback)', { query });
     return formatSearchResults(await searchWithDuckDuckGo(query));
 }
+function stripHtml(raw) {
+    return raw
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+const BASE_FETCH_HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (compatible; OmniKeyAgent/1.0)',
+};
+// ── Step 1: plain HTTP fetch ──────────────────────────────────────────────────
+async function fetchPlainHttp(url, log) {
+    try {
+        const response = await axios_1.default.get(url, {
+            timeout: 15000,
+            responseType: 'text',
+            maxContentLength: exports.MAX_WEB_FETCH_BYTES,
+            headers: BASE_FETCH_HEADERS,
+        });
+        const finalUrl = response.request?.res?.responseUrl ?? url;
+        return { html: String(response.data), authBlocked: false, finalUrl };
+    }
+    catch (err) {
+        const status = axios_1.default.isAxiosError(err) ? err.response?.status : undefined;
+        log.warn('Initial fetch failed', {
+            url,
+            error: err instanceof Error ? err.message : String(err),
+            status,
+        });
+        // If a browser is running, any failure could be auth-related —
+        // sites use redirects, 302s, custom error pages, or soft-blocks
+        // rather than a clean 401/403, so checking status codes alone is
+        // unreliable. Fall through to the browser-session path instead.
+        if (isSelfHostedMacOS && (0, browser_playwright_1.isBrowserOpenWithUrl)(url, log)) {
+            return { html: null, authBlocked: true, finalUrl: url };
+        }
+        if (status === 401 || status === 403) {
+            return { html: null, authBlocked: true, finalUrl: url };
+        }
+        throw err;
+    }
+}
+// ── Step 2: LLM auth check on plain response ──────────────────────────────────
+async function checkPlainResponseAuth(plainText, url, log, finalUrl) {
+    const authenticated = await (0, llm_auth_check_1.isPageAuthenticated)(plainText.slice(0, 5000), url, log, finalUrl);
+    if (!authenticated) {
+        log.info('web_fetch: plain response failed auth check — trying active-tab strategy', { url });
+    }
+    return authenticated;
+}
+// ── Step 3: active-tab extraction (self-hosted macOS only) ───────────────────
+async function fetchFromActiveTab(url, log) {
+    log.info('web_fetch: falling back to active-tab extraction', { url });
+    return (0, browser_playwright_1.fetchWithPlaywright)(url, log);
+}
+const isSelfHostedMacOS = config_1.config.isSelfHosted && config_1.config.terminalPlatform === 'macos';
+async function executeWebFetch(url, log) {
+    log.info('Executing web_fetch tool', { url });
+    // ── Step 1: plain HTTP request ────────────────────────────────────────────
+    const { html, authBlocked, finalUrl } = await fetchPlainHttp(url, log);
+    const plainText = html ? stripHtml(html) : '';
+    if (!isSelfHostedMacOS) {
+        if (authBlocked) {
+            log.warn('Error: page requires authentication. Run OmniKey in self-hosted mode on macOS to enable browser-session access.');
+        }
+        return plainText.slice(0, exports.MAX_TOOL_CONTENT_CHARS) || 'No content retrieved';
+    }
+    // ── Step 2 (self-hosted macOS only): LLM auth check on plain response ─────
+    let looksUnauthenticated = false;
+    if (!authBlocked && plainText) {
+        log.info('web_fetch: performing LLM auth check on plain HTTP response', { url });
+        const authenticated = await checkPlainResponseAuth(plainText, url, log, finalUrl);
+        if (authenticated) {
+            return plainText.slice(0, exports.MAX_TOOL_CONTENT_CHARS) || 'No content retrieved';
+        }
+        looksUnauthenticated = true;
+    }
+    // ── Step 3 (self-hosted macOS only): active-tab extraction ───────────────
+    // Only attempted when there is evidence authentication is required.
+    const needsAuth = authBlocked || looksUnauthenticated;
+    if (needsAuth) {
+        log.info('web_fetch: evidence of authentication requirement, attempting active-tab extraction', { url });
+        const activeTabText = await fetchFromActiveTab(url, log);
+        if (activeTabText) {
+            return activeTabText.slice(0, exports.MAX_TOOL_CONTENT_CHARS);
+        }
+    }
+    // All strategies exhausted.
+    if (authBlocked) {
+        log.warn('Error: page requires authentication. Open the page in Chrome and ensure "Allow JavaScript from Apple Events" is enabled (View → Developer → Allow JavaScript from Apple Events).');
+    }
+    return plainText.slice(0, exports.MAX_TOOL_CONTENT_CHARS) || 'No content retrieved';
+}
 async function executeTool(name, args, log) {
     if (name === 'web_fetch') {
         const url = args.url;
         if (!url)
             return 'Error: url parameter is required';
         try {
-            log.info('Executing web_fetch tool', { url });
-            const response = await axios_1.default.get(url, {
-                timeout: 15000,
-                responseType: 'text',
-                maxContentLength: exports.MAX_WEB_FETCH_BYTES,
-                headers: { 'User-Agent': 'Mozilla/5.0 (compatible; OmniKeyAgent/1.0)' },
-            });
-            const text = String(response.data)
-                .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
-                .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
-                .replace(/<[^>]+>/g, ' ')
-                .replace(/\s+/g, ' ')
-                .trim()
-                .slice(0, exports.MAX_TOOL_CONTENT_CHARS);
-            return text || 'No content retrieved';
+            return await executeWebFetch(url, log);
         }
         catch (err) {
             log.warn('web_fetch tool failed', {

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "1.0.24",
+  "version": "1.0.25",
   "description": "CLI for onboarding users to Omnikey AI and configuring OPENAI_API_KEY. Use Yarn for install/build.",
   "engines": {
     "node": ">=14.0.0",
@@ -44,7 +44,8 @@
     "sqlite3": "^5.1.6",
     "winston": "^3.19.0",
     "ws": "^8.18.0",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "playwright-core": "^1.50.0"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.9",