@steipete/oracle 0.4.5 → 0.5.1

package/dist/scripts/test-browser.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env tsx
+/**
+ * Lightweight browser connectivity smoke test.
+ * - Launches Chrome headful with a fixed DevTools port (default 45871 or env ORACLE_BROWSER_PORT/ORACLE_BROWSER_DEBUG_PORT).
+ * - Verifies the DevTools /json/version endpoint responds.
+ * - Prints a WSL-friendly firewall hint if the port is unreachable.
+ */
+import { setTimeout as sleep } from 'node:timers/promises';
+import { launch } from 'chrome-launcher';
+import os from 'node:os';
+import { readFileSync } from 'node:fs';
+const DEFAULT_PORT = 45871;
+const port = normalizePort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT) ?? DEFAULT_PORT;
+const hostHint = resolveWslHost();
+const targetHost = hostHint ?? '127.0.0.1';
+function normalizePort(raw) {
+    if (!raw)
+        return null;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value <= 0 || value > 65535)
+        return null;
+    return value;
+}
+function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    if (process.env.WSL_DISTRO_NAME)
+        return true;
+    return os.release().toLowerCase().includes('microsoft');
+}
+function resolveWslHost() {
+    if (!isWsl())
+        return null;
+    try {
+        const resolv = readFileSync('/etc/resolv.conf', 'utf8');
+        for (const line of resolv.split('\n')) {
+            const match = line.match(/^nameserver\s+([0-9.]+)/);
+            if (match?.[1])
+                return match[1];
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function firewallHint(host, devtoolsPort) {
+    if (!isWsl())
+        return null;
+    return [
+        `DevTools port ${host}:${devtoolsPort} is blocked from WSL.`,
+        '',
+        'PowerShell (admin):',
+        `New-NetFirewallRule -DisplayName 'Chrome DevTools ${devtoolsPort}' -Direction Inbound -Action Allow -Protocol TCP -LocalPort ${devtoolsPort}`,
+        "New-NetFirewallRule -DisplayName 'Chrome DevTools (chrome.exe)' -Direction Inbound -Action Allow -Program 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe' -Protocol TCP",
+        '',
+        'Re-run ./runner pnpm test:browser after adding the rule.',
+    ].join('\n');
+}
+async function fetchVersion(host, devtoolsPort) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5000);
+    try {
+        const res = await fetch(`http://${host}:${devtoolsPort}/json/version`, { signal: controller.signal });
+        if (!res.ok)
+            return false;
+        const json = (await res.json());
+        return Boolean(json.webSocketDebuggerUrl);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function main() {
+    console.log(`[browser-test] launching Chrome on ${targetHost}:${port} (headful)…`);
+    const chrome = await launch({
+        port,
+        chromeFlags: ['--remote-debugging-address=0.0.0.0'],
+    });
+    let ok = await fetchVersion(targetHost, chrome.port);
+    if (!ok) {
+        await sleep(500);
+        ok = await fetchVersion(targetHost, chrome.port);
+    }
+    await chrome.kill();
+    if (ok) {
+        console.log(`[browser-test] PASS: DevTools responding on ${targetHost}:${chrome.port}`);
+        process.exit(0);
+    }
+    const hint = firewallHint(targetHost, chrome.port);
+    console.error(`[browser-test] FAIL: DevTools not reachable at ${targetHost}:${chrome.port}`);
+    if (hint) {
+        console.error(hint);
+    }
+    process.exit(1);
+}
+main().catch((error) => {
+    console.error('[browser-test] Unexpected failure:', error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/scripts/test-remote-chrome.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env npx tsx
+/**
+ * POC: Test connecting to remote Chrome instance
+ *
+ * On remote machine with display, run:
+ *   google-chrome --remote-debugging-port=9222 --remote-debugging-address=0.0.0.0
+ *
+ * Then run this script:
+ *   npx tsx scripts/test-remote-chrome.ts <remote-host> [port]
+ */
+import CDP from 'chrome-remote-interface';
+async function main() {
+    const host = process.argv[2] || 'localhost';
+    const port = parseInt(process.argv[3] || '9222', 10);
+    console.log(`Attempting to connect to Chrome at ${host}:${port}...`);
+    try {
+        // Test connection
+        const client = await CDP({ host, port });
+        console.log('✓ Connected to Chrome DevTools Protocol');
+        const { Network, Page, Runtime } = client;
+        // Enable domains
+        await Promise.all([Network.enable(), Page.enable()]);
+        console.log('✓ Enabled Network and Page domains');
+        // Get browser version info
+        const version = await CDP.Version({ host, port });
+        console.log(`✓ Browser: ${version.Browser}`);
+        console.log(`✓ Protocol: ${version['Protocol-Version']}`);
+        // Navigate to ChatGPT
+        console.log('\nNavigating to ChatGPT...');
+        await Page.navigate({ url: 'https://chatgpt.com/' });
+        await Page.loadEventFired();
+        console.log('✓ Page loaded');
+        // Check current URL
+        const evalResult = await Runtime.evaluate({ expression: 'window.location.href' });
+        console.log(`✓ Current URL: ${evalResult.result.value}`);
+        // Check if logged in (look for specific elements)
+        const checkLogin = await Runtime.evaluate({
+            expression: `
+        // Check for composer textarea (indicates logged in)
+        const composer = document.querySelector('textarea, [contenteditable="true"]');
+        const hasComposer = !!composer;
+
+        // Check for login button (indicates logged out)
+        const loginBtn = document.querySelector('a[href*="login"], button[data-testid*="login"]');
+        const hasLogin = !!loginBtn;
+
+        ({ hasComposer, hasLogin, loggedIn: hasComposer && !hasLogin })
+      `,
+        });
+        console.log(`✓ Login status: ${JSON.stringify(checkLogin.result.value)}`);
+        await client.close();
+        console.log('\n✓ POC successful! Remote Chrome connection works.');
+        console.log('\nTo use Oracle with remote Chrome, you would need to:');
+        console.log('1. Ensure cookies are loaded in remote Chrome');
+        console.log('2. Configure Oracle with --remote-chrome <host:port> to use this instance');
+        console.log('3. Ensure Oracle skips local Chrome launch when --remote-chrome is specified');
+    }
+    catch (error) {
+        console.error('✗ Connection failed:', error instanceof Error ? error.message : error);
+        console.log('\nTroubleshooting:');
+        console.log('1. Ensure Chrome is running on remote machine with:');
+        console.log(`   google-chrome --remote-debugging-port=${port} --remote-debugging-address=0.0.0.0`);
+        console.log('2. Check firewall allows connections to port', port);
+        console.log('3. Verify network connectivity to', host);
+        process.exit(1);
+    }
+}
+void main();

package/dist/src/browser/actions/attachments.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { FILE_INPUT_SELECTOR, GENERIC_FILE_INPUT_SELECTOR, SEND_BUTTON_SELECTOR, UPLOAD_STATUS_SELECTORS, } from '../constants.js';
+import { FILE_INPUT_SELECTORS, SEND_BUTTON_SELECTORS, UPLOAD_STATUS_SELECTORS } from '../constants.js';
 import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
 export async function uploadAttachmentFile(deps, attachment, logger) {
@@ -8,7 +8,7 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
         throw new Error('DOM domain unavailable while uploading attachments.');
     }
     const documentNode = await dom.getDocument();
-    const selectors = [FILE_INPUT_SELECTOR, GENERIC_FILE_INPUT_SELECTOR];
+    const selectors = FILE_INPUT_SELECTORS;
     let targetNodeId;
     for (const selector of selectors) {
         const result = await dom.querySelector({ nodeId: documentNode.root.nodeId, selector });
@@ -33,25 +33,49 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
 export async function waitForAttachmentCompletion(Runtime, timeoutMs, logger) {
     const deadline = Date.now() + timeoutMs;
     const expression = `(() => {
-    const button = document.querySelector('${SEND_BUTTON_SELECTOR}');
-    if (!button) {
-      return { state: 'missing', uploading: false };
+    const sendSelectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
+    let button = null;
+    for (const selector of sendSelectors) {
+      button = document.querySelector(selector);
+      if (button) break;
     }
-    const disabled = button.hasAttribute('disabled') || button.getAttribute('aria-disabled') === 'true';
+    const disabled = button
+      ? button.hasAttribute('disabled') ||
+        button.getAttribute('aria-disabled') === 'true' ||
+        button.getAttribute('data-disabled') === 'true' ||
+        window.getComputedStyle(button).pointerEvents === 'none'
+      : null;
     const uploadingSelectors = ${JSON.stringify(UPLOAD_STATUS_SELECTORS)};
     const uploading = uploadingSelectors.some((selector) => {
       return Array.from(document.querySelectorAll(selector)).some((node) => {
+        const ariaBusy = node.getAttribute?.('aria-busy');
+        const dataState = node.getAttribute?.('data-state');
+        if (ariaBusy === 'true' || dataState === 'loading' || dataState === 'uploading' || dataState === 'pending') {
+          return true;
+        }
         const text = node.textContent?.toLowerCase?.() ?? '';
-        return text.includes('upload') || text.includes('processing');
+        return text.includes('upload') || text.includes('processing') || text.includes('uploading');
       });
     });
-    return { state: disabled ? 'disabled' : 'ready', uploading };
+    const fileSelectors = ${JSON.stringify(FILE_INPUT_SELECTORS)};
+    const filesAttached = fileSelectors.some((selector) =>
+      Array.from(document.querySelectorAll(selector)).some((node) => {
+        const el = node instanceof HTMLInputElement ? node : null;
+        return Boolean(el?.files?.length);
+      }),
+    );
+    return { state: button ? (disabled ? 'disabled' : 'ready') : 'missing', uploading, filesAttached };
   })()`;
     while (Date.now() < deadline) {
         const { result } = await Runtime.evaluate({ expression, returnByValue: true });
         const value = result?.value;
-        if (value && value.state === 'ready' && !value.uploading) {
-            return;
+        if (value && !value.uploading) {
+            if (value.state === 'ready') {
+                return;
+            }
+            if (value.state === 'missing' && value.filesAttached) {
+                return;
+            }
         }
         await delay(250);
     }
@@ -62,13 +86,20 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, logger) {
 async function waitForAttachmentSelection(Runtime, expectedName, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     const expression = `(() => {
-    const selector = ${JSON.stringify(GENERIC_FILE_INPUT_SELECTOR)};
-    const input = document.querySelector(selector);
-    if (!input || !input.files) {
-      return { matched: false, names: [] };
+    const selectors = ${JSON.stringify(FILE_INPUT_SELECTORS)};
+    for (const selector of selectors) {
+      const inputs = Array.from(document.querySelectorAll(selector));
+      for (const input of inputs) {
+        if (!(input instanceof HTMLInputElement) || !input.files) {
+          continue;
+        }
+        const names = Array.from(input.files ?? []).map((file) => file?.name ?? '');
+        if (names.some((name) => name === ${JSON.stringify(expectedName)})) {
+          return { matched: true, names };
+        }
+      }
     }
-    const names = Array.from(input.files).map((file) => file?.name ?? '');
-    return { matched: names.some((name) => name === ${JSON.stringify(expectedName)}), names };
+    return { matched: false, names: [] };
   })()`;
     while (Date.now() < deadline) {
         const { result } = await Runtime.evaluate({ expression, returnByValue: true });

package/dist/src/browser/actions/promptComposer.js

@@ -1,6 +1,13 @@
-import { INPUT_SELECTORS, PROMPT_PRIMARY_SELECTOR, PROMPT_FALLBACK_SELECTOR, SEND_BUTTON_SELECTOR, CONVERSATION_TURN_SELECTOR, } from '../constants.js';
+import { INPUT_SELECTORS, PROMPT_PRIMARY_SELECTOR, PROMPT_FALLBACK_SELECTOR, SEND_BUTTON_SELECTORS, CONVERSATION_TURN_SELECTOR, } from '../constants.js';
 import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
+const ENTER_KEY_EVENT = {
+    key: 'Enter',
+    code: 'Enter',
+    windowsVirtualKeyCode: 13,
+    nativeVirtualKeyCode: 13,
+};
+const ENTER_KEY_TEXT = '\r';
 export async function submitPrompt(deps, prompt, logger) {
     const { runtime, input } = deps;
     const encodedPrompt = JSON.stringify(prompt);
@@ -52,6 +59,9 @@ export async function submitPrompt(deps, prompt, logger) {
         throw new Error('Failed to focus prompt textarea');
     }
     await input.insertText({ text: prompt });
+    // Some pages (notably ChatGPT when subscriptions/widgets load) need a brief settle
+    // before the send button becomes enabled; give it a short breather to avoid races.
+    await delay(500);
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
     const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
     const verification = await runtime.evaluate({
@@ -86,18 +96,14 @@ export async function submitPrompt(deps, prompt, logger) {
     const clicked = await attemptSendButton(runtime);
     if (!clicked) {
         await input.dispatchKeyEvent({
-            type: 'rawKeyDown',
-            key: 'Enter',
-            code: 'Enter',
-            windowsVirtualKeyCode: 13,
-            nativeVirtualKeyCode: 13,
+            type: 'keyDown',
+            ...ENTER_KEY_EVENT,
+            text: ENTER_KEY_TEXT,
+            unmodifiedText: ENTER_KEY_TEXT,
         });
         await input.dispatchKeyEvent({
             type: 'keyUp',
-            key: 'Enter',
-            code: 'Enter',
-            windowsVirtualKeyCode: 13,
-            nativeVirtualKeyCode: 13,
+            ...ENTER_KEY_EVENT,
         });
         logger('Submitted prompt via Enter key');
     }
@@ -105,19 +111,28 @@ export async function submitPrompt(deps, prompt, logger) {
         logger('Clicked send button');
     }
     await verifyPromptCommitted(runtime, prompt, 30_000, logger);
+    await clickAnswerNowIfPresent(runtime, logger);
 }
 async function attemptSendButton(Runtime) {
     const script = `(() => {
-    const button = document.querySelector('${SEND_BUTTON_SELECTOR}');
-    if (!button) {
-      return 'missing';
+    const selectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
+    let button = null;
+    for (const selector of selectors) {
+      button = document.querySelector(selector);
+      if (button) break;
     }
+    if (!button) return 'missing';
     const ariaDisabled = button.getAttribute('aria-disabled');
-    const disabled = button.hasAttribute('disabled') || ariaDisabled === 'true';
-    if (disabled || window.getComputedStyle(button).display === 'none') {
-      return 'disabled';
-    }
-    button.click();
+    const dataDisabled = button.getAttribute('data-disabled');
+    const style = window.getComputedStyle(button);
+    const disabled =
+      button.hasAttribute('disabled') ||
+      ariaDisabled === 'true' ||
+      dataDisabled === 'true' ||
+      style.pointerEvents === 'none' ||
+      style.display === 'none';
+    if (disabled) return 'disabled';
+    (button as HTMLElement).click();
     return 'clicked';
   })()`;
     const deadline = Date.now() + 2_000;
@@ -133,6 +148,40 @@ async function attemptSendButton(Runtime) {
     }
     return false;
 }
+async function clickAnswerNowIfPresent(Runtime, logger) {
+    const script = `(() => {
+    const matchesText = (el) => (el?.textContent || '').trim().toLowerCase() === 'answer now';
+    const candidate = Array.from(document.querySelectorAll('button,span')).find(matchesText);
+    if (!candidate) return 'missing';
+    const button = candidate.closest('button') ?? candidate;
+    const style = window.getComputedStyle(button);
+    const disabled =
+      button.hasAttribute('disabled') ||
+      button.getAttribute('aria-disabled') === 'true' ||
+      style.pointerEvents === 'none' ||
+      style.display === 'none';
+    if (disabled) return 'disabled';
+    (button).dispatchEvent(new MouseEvent('pointerdown', { bubbles: true, cancelable: true }));
+    (button).dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true }));
+    (button).dispatchEvent(new MouseEvent('pointerup', { bubbles: true, cancelable: true }));
+    (button).dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true }));
+    (button).dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+    return 'clicked';
+  })()`;
+    const deadline = Date.now() + 3_000;
+    while (Date.now() < deadline) {
+        const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
+        const status = result.value;
+        if (status === 'clicked') {
+            logger?.('Clicked "Answer now" gate');
+            await delay(500);
+            return;
+        }
+        if (status === 'missing')
+            return;
+        await delay(100);
+    }
+}
 async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger) {
     const deadline = Date.now() + timeoutMs;
     const encodedPrompt = JSON.stringify(prompt.trim());

package/dist/src/browser/actions/remoteFileTransfer.js

@@ -1,6 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { FILE_INPUT_SELECTOR, GENERIC_FILE_INPUT_SELECTOR } from '../constants.js';
+import { FILE_INPUT_SELECTORS } from '../constants.js';
 import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
 /**
@@ -25,9 +25,8 @@ export async function uploadAttachmentViaDataTransfer(deps, attachment, logger)
     logger(`Transferring ${fileName} (${fileContent.length} bytes) to remote browser...`);
     // Find file input element
     const documentNode = await dom.getDocument();
-    const selectors = [FILE_INPUT_SELECTOR, GENERIC_FILE_INPUT_SELECTOR];
     let fileInputSelector;
-    for (const selector of selectors) {
+    for (const selector of FILE_INPUT_SELECTORS) {
         const result = await dom.querySelector({ nodeId: documentNode.root.nodeId, selector });
         if (result.nodeId) {
             fileInputSelector = selector;
@@ -74,7 +73,40 @@ export async function uploadAttachmentViaDataTransfer(deps, attachment, logger)
       // Create DataTransfer and assign to input
       const dataTransfer = new DataTransfer();
       dataTransfer.items.add(file);
-      fileInput.files = dataTransfer.files;
+      let assigned = false;
+
+      const proto = Object.getPrototypeOf(fileInput);
+      const descriptor = proto ? Object.getOwnPropertyDescriptor(proto, 'files') : null;
+      if (descriptor?.set) {
+        try {
+          descriptor.set.call(fileInput, dataTransfer.files);
+          assigned = true;
+        } catch {
+          assigned = false;
+        }
+      }
+      if (!assigned) {
+        try {
+          Object.defineProperty(fileInput, 'files', {
+            configurable: true,
+            get: () => dataTransfer.files,
+          });
+          assigned = true;
+        } catch {
+          assigned = false;
+        }
+      }
+      if (!assigned) {
+        try {
+          fileInput.files = dataTransfer.files;
+          assigned = true;
+        } catch {
+          assigned = false;
+        }
+      }
+      if (!assigned) {
+        return { success: false, error: 'Unable to assign FileList to input' };
+      }
 
       // Trigger both input and change events for better compatibility
       fileInput.dispatchEvent(new Event('input', { bubbles: true }));

package/dist/src/browser/chromeCookies.js

@@ -2,14 +2,17 @@ import path from 'node:path';
 import os from 'node:os';
 import fs from 'node:fs/promises';
 import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import chromeCookies from 'chrome-cookies-secure';
 import { COOKIE_URLS } from './constants.js';
-import './keytarShim.js';
 import { ensureCookiesDirForFallback } from './windowsCookies.js';
 const COOKIE_READ_TIMEOUT_MS = readDuration('ORACLE_COOKIE_LOAD_TIMEOUT_MS', 5_000);
 const KEYCHAIN_PROBE_TIMEOUT_MS = readDuration('ORACLE_KEYCHAIN_PROBE_TIMEOUT_MS', 3_000);
 const MAC_KEYCHAIN_LABELS = loadKeychainLabels();
 export async function loadChromeCookies({ targetUrl, profile, explicitCookiePath, filterNames, }) {
+    if (process.platform === 'win32') {
+        throw new Error('Cookie sync is disabled on Windows; use --browser-manual-login (persistent profile) or inline cookies instead.');
+    }
     const urlsToCheck = Array.from(new Set([stripQuery(targetUrl), ...COOKIE_URLS]));
     const merged = new Map();
     const cookieFile = await resolveCookieFilePath({ explicitPath: explicitCookiePath, profile });
@@ -49,13 +52,26 @@ export async function loadChromeCookies({ targetUrl, profile, explicitCookiePath
     return Array.from(merged.values());
 }
 async function ensureMacKeychainReadable() {
-    if (process.platform !== 'darwin') {
+    if (process.platform === 'win32') {
         return;
     }
-    // chrome-cookies-secure can hang forever when macOS Keychain rejects access (e.g., SSH/no GUI).
-    // Probe the keychain ourselves with a timeout so callers fail fast instead of blocking the run.
-    const keytarModule = await import('keytar');
-    const keytar = (keytarModule.default ?? keytarModule);
+    // chrome-cookies-secure can hang forever when the platform keyring rejects access (e.g., SSH/no GUI).
+    // Probe the keyring ourselves with a timeout so callers fail fast instead of blocking the run.
+    let keytar = null;
+    let keytarPath = null;
+    try {
+        const require = createRequire(import.meta.url);
+        keytarPath = require.resolve('keytar');
+        const keytarModule = await import('keytar');
+        keytar = (keytarModule.default ?? keytarModule);
+    }
+    catch (error) {
+        const base = error instanceof Error ? error.message : String(error);
+        const rebuildHint = keytarPath
+            ? ` You may need to rebuild keytar: PYTHON=/usr/bin/python3 /Users/steipete/Projects/oracle/runner npx node-gyp rebuild (run inside ${path.dirname(keytarPath)}).`
+            : '';
+        throw new Error(`Failed to load keytar for secure cookie copy (${base}). Install keyring deps (macOS Keychain / libsecret) or rerun with --render --copy to paste into ChatGPT manually.${rebuildHint}`);
+    }
     const password = await settleWithTimeout(findKeychainPassword(keytar, MAC_KEYCHAIN_LABELS), KEYCHAIN_PROBE_TIMEOUT_MS, `Timed out reading macOS Keychain while looking up Chrome Safe Storage (after ${KEYCHAIN_PROBE_TIMEOUT_MS} ms). Unlock the login keychain or start oracle serve from a GUI session.`);
     if (!password) {
         throw new Error('macOS Keychain denied access to Chrome cookies. Unlock the login keychain or run oracle serve from a GUI session, then retry.');
@@ -204,6 +220,23 @@ async function defaultProfileRoot() {
         candidates.push(path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome'), path.join(os.homedir(), 'Library', 'Application Support', 'Microsoft Edge'), path.join(os.homedir(), 'Library', 'Application Support', 'Chromium'));
     }
     else if (process.platform === 'linux') {
+        if (isWsl()) {
+            const windowsHomes = [process.env.USERPROFILE, process.env.WIN_HOME, process.env.HOME?.replace('/home', '/mnt/c/Users')]
+                .filter((p) => Boolean(p))
+                .map((p) => p.replace(/\\/g, '/'));
+            const wslCandidates = [];
+            for (const home of windowsHomes) {
+                const normalized = home.startsWith('/mnt/') ? home : `/mnt/c/Users/${path.basename(home)}`;
+                wslCandidates.push(path.join(normalized, 'AppData', 'Local', 'Google', 'Chrome', 'User Data'), path.join(normalized, 'AppData', 'Local', 'Microsoft', 'Edge', 'User Data'));
+            }
+            // Ensure we don't pick a non-user Default profile ahead of real ones.
+            for (const candidate of wslCandidates) {
+                const hasProfile = existsSync(path.join(candidate, 'Default'));
+                if (hasProfile) {
+                    candidates.push(candidate);
+                }
+            }
+        }
         candidates.push(path.join(os.homedir(), '.config', 'google-chrome'), path.join(os.homedir(), '.config', 'microsoft-edge'), path.join(os.homedir(), '.config', 'chromium'), 
         // Snap Chromium profiles
         path.join(os.homedir(), 'snap', 'chromium', 'common', 'chromium'), path.join(os.homedir(), 'snap', 'chromium', 'current', 'chromium'));
@@ -241,6 +274,11 @@ function readDuration(envKey, fallback) {
     const parsed = Number.parseInt(raw, 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
+function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    return Boolean(process.env.WSL_DISTRO_NAME || os.release().toLowerCase().includes('microsoft'));
+}
 function loadKeychainLabels() {
     const defaults = [
         { service: 'Chrome Safe Storage', account: 'Chrome' },