@jackwener/opencli 1.7.3 → 1.7.5

package/dist/src/cli.js

@@ -5,6 +5,7 @@
  * Dynamic adapter commands are registered via commanderAdapter.ts.
  */
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
@@ -13,20 +14,132 @@ import { findPackageRoot, getBuiltEntryCandidates } from './package-paths.js';
 import { fullName, getRegistry, strategyLabel } from './registry.js';
 import { serializeCommand, formatArgSummary } from './serialization.js';
 import { render as renderOutput } from './output.js';
-import { getBrowserFactory, browserSession } from './runtime.js';
 import { PKG_VERSION } from './version.js';
 import { printCompletionScript } from './completion.js';
 import { loadExternalClis, executeExternalCli, installExternalCli, registerExternalCli, isBinaryInstalled } from './external.js';
 import { registerAllCommands } from './commanderAdapter.js';
-import { EXIT_CODES, getErrorMessage } from './errors.js';
-import { daemonStop } from './commands/daemon.js';
+import { EXIT_CODES, getErrorMessage, BrowserConnectError } from './errors.js';
+import { TargetError } from './browser/target-errors.js';
+import { resolveTargetJs, getTextResolvedJs, getValueResolvedJs, getAttributesResolvedJs, selectResolvedJs, isAutocompleteResolvedJs } from './browser/target-resolver.js';
+import { daemonStatus, daemonStop } from './commands/daemon.js';
 import { log } from './logger.js';
 const CLI_FILE = fileURLToPath(import.meta.url);
+const DEFAULT_BROWSER_WORKSPACE = 'browser:default';
+const BROWSER_TAB_OPTION_DESCRIPTION = 'Target tab/page identity returned by "browser open", "browser tab new", or "browser tab list"';
+function getBrowserCacheDir() {
+    return process.env.OPENCLI_CACHE_DIR || path.join(os.homedir(), '.opencli', 'cache');
+}
+function getBrowserTargetStatePath(scope = DEFAULT_BROWSER_WORKSPACE) {
+    const safeWorkspace = scope.replace(/[^a-zA-Z0-9_-]+/g, '_');
+    return path.join(getBrowserCacheDir(), 'browser-state', `${safeWorkspace}.json`);
+}
+function loadBrowserTargetState(scope = DEFAULT_BROWSER_WORKSPACE) {
+    try {
+        const raw = fs.readFileSync(getBrowserTargetStatePath(scope), 'utf-8');
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function saveBrowserTargetState(defaultPage, scope = DEFAULT_BROWSER_WORKSPACE) {
+    const target = getBrowserTargetStatePath(scope);
+    if (!defaultPage) {
+        fs.rmSync(target, { force: true });
+        return;
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, JSON.stringify({ defaultPage, updatedAt: new Date().toISOString() }), 'utf-8');
+}
+function hasBrowserTabTarget(tabs, targetPage) {
+    return tabs.some((tab) => {
+        return typeof tab === 'object'
+            && tab !== null
+            && 'page' in tab
+            && typeof tab.page === 'string'
+            && tab.page === targetPage;
+    });
+}
+async function resolveBrowserTargetInSession(page, targetPage, opts) {
+    const candidate = targetPage.trim();
+    if (!candidate)
+        return undefined;
+    let tabs;
+    try {
+        tabs = await page.tabs();
+    }
+    catch (err) {
+        if (opts.source === 'saved') {
+            saveBrowserTargetState(undefined, opts.scope);
+            return undefined;
+        }
+        throw new Error(`Target tab ${candidate} could not be validated in the current browser session. ` +
+            'The Browser Bridge workspace may have restarted; re-run "opencli browser tab list" and choose a current target.', { cause: err });
+    }
+    if (Array.isArray(tabs) && hasBrowserTabTarget(tabs, candidate)) {
+        return candidate;
+    }
+    if (opts.source === 'saved') {
+        saveBrowserTargetState(undefined, opts.scope);
+        return undefined;
+    }
+    throw new Error(`Target tab ${candidate} is not part of the current browser session. ` +
+        'The Browser Bridge workspace may have restarted; re-run "opencli browser tab list" and choose a current target.');
+}
+async function resolveStoredBrowserTarget(page, scope = DEFAULT_BROWSER_WORKSPACE) {
+    const defaultPage = loadBrowserTargetState(scope)?.defaultPage?.trim();
+    if (!defaultPage)
+        return undefined;
+    return resolveBrowserTargetInSession(page, defaultPage, { scope, source: 'saved' });
+}
 /** Create a browser page for browser commands. Uses a dedicated browser workspace for session persistence. */
-async function getBrowserPage() {
+async function getBrowserPage(targetPage) {
     const { BrowserBridge } = await import('./browser/index.js');
     const bridge = new BrowserBridge();
-    return bridge.connect({ timeout: 30, workspace: 'browser:default' });
+    const envTimeout = process.env.OPENCLI_BROWSER_TIMEOUT;
+    const idleTimeout = envTimeout ? parseInt(envTimeout, 10) : undefined;
+    const page = await bridge.connect({
+        timeout: 30,
+        workspace: DEFAULT_BROWSER_WORKSPACE,
+        ...(idleTimeout && idleTimeout > 0 && { idleTimeout }),
+    });
+    const resolvedTargetPage = targetPage
+        ? await resolveBrowserTargetInSession(page, targetPage, { scope: DEFAULT_BROWSER_WORKSPACE, source: 'explicit' })
+        : await resolveStoredBrowserTarget(page, DEFAULT_BROWSER_WORKSPACE);
+    if (resolvedTargetPage) {
+        if (!page.setActivePage) {
+            throw new Error('This browser session does not support explicit tab targeting');
+        }
+        page.setActivePage(resolvedTargetPage);
+    }
+    return page;
+}
+function addBrowserTabOption(command) {
+    return command.option('--tab <targetId>', BROWSER_TAB_OPTION_DESCRIPTION);
+}
+function getBrowserTargetId(command) {
+    if (!command)
+        return undefined;
+    const opts = command.optsWithGlobals ? command.optsWithGlobals() : command.opts();
+    return typeof opts.tab === 'string' && opts.tab.trim() ? opts.tab.trim() : undefined;
+}
+function resolveBrowserTabTarget(targetId, opts) {
+    if (typeof targetId === 'string' && targetId.trim())
+        return targetId.trim();
+    if (typeof opts?.tab === 'string' && opts.tab.trim())
+        return opts.tab.trim();
+    return undefined;
+}
+function parsePositiveIntOption(val, label, fallback) {
+    if (val === undefined)
+        return fallback;
+    const parsed = parseInt(val, 10);
+    if (Number.isNaN(parsed) || parsed <= 0) {
+        console.error(`[cli] Invalid ${label}="${val}", using default ${fallback}`);
+        return fallback;
+    }
+    return parsed;
 }
 function applyVerbose(opts) {
     if (opts.verbose)
@@ -129,119 +242,6 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         console.log(renderVerifyReport(r));
         process.exitCode = r.ok ? EXIT_CODES.SUCCESS : EXIT_CODES.GENERIC_ERROR;
     });
-    // ── Built-in: explore / synthesize / generate / cascade ───────────────────
-    program
-        .command('explore')
-        .alias('probe')
-        .description('Explore a website: discover APIs, stores, and recommend strategies')
-        .argument('<url>')
-        .option('--site <name>')
-        .option('--goal <text>')
-        .option('--wait <s>', '', '3')
-        .option('--auto', 'Enable interactive fuzzing')
-        .option('--click <labels>', 'Comma-separated labels to click before fuzzing')
-        .option('-v, --verbose', 'Debug output')
-        .action(async (url, opts) => {
-        applyVerbose(opts);
-        const { exploreUrl, renderExploreSummary } = await import('./explore.js');
-        const clickLabels = opts.click
-            ? opts.click.split(',').map((s) => s.trim())
-            : undefined;
-        const workspace = `explore:${inferHost(url, opts.site)}`;
-        const result = await exploreUrl(url, {
-            BrowserFactory: getBrowserFactory(),
-            site: opts.site,
-            goal: opts.goal,
-            waitSeconds: parseFloat(opts.wait),
-            auto: opts.auto,
-            clickLabels,
-            workspace,
-        });
-        console.log(renderExploreSummary(result));
-    });
-    program
-        .command('synthesize')
-        .description('Synthesize CLIs from explore')
-        .argument('<target>')
-        .option('--top <n>', '', '3')
-        .option('-v, --verbose', 'Debug output')
-        .action(async (target, opts) => {
-        applyVerbose(opts);
-        const { synthesizeFromExplore, renderSynthesizeSummary } = await import('./synthesize.js');
-        console.log(renderSynthesizeSummary(synthesizeFromExplore(target, { top: parseInt(opts.top) })));
-    });
-    program
-        .command('generate')
-        .description('One-shot: explore → synthesize → verify → register')
-        .argument('<url>')
-        .option('--goal <text>')
-        .option('--site <name>')
-        .option('--format <fmt>', 'Output format: table, json', 'table')
-        .option('--no-register', 'Verify the generated adapter without registering it')
-        .option('-v, --verbose', 'Debug output')
-        .action(async (url, opts) => {
-        applyVerbose(opts);
-        const { generateVerifiedFromUrl, renderGenerateVerifiedSummary } = await import('./generate-verified.js');
-        const workspace = `generate:${inferHost(url, opts.site)}`;
-        const r = await generateVerifiedFromUrl({
-            url,
-            BrowserFactory: getBrowserFactory(),
-            goal: opts.goal,
-            site: opts.site,
-            workspace,
-            noRegister: opts.register === false,
-        });
-        if (opts.format === 'json')
-            console.log(JSON.stringify(r, null, 2));
-        else
-            console.log(renderGenerateVerifiedSummary(r));
-        process.exitCode = r.status === 'success' ? EXIT_CODES.SUCCESS : EXIT_CODES.GENERIC_ERROR;
-    });
-    // ── Built-in: record ─────────────────────────────────────────────────────
-    program
-        .command('record')
-        .description('Record API calls from a live browser session → generate YAML candidates')
-        .argument('<url>', 'URL to open and record')
-        .option('--site <name>', 'Site name (inferred from URL if omitted)')
-        .option('--out <dir>', 'Output directory for candidates')
-        .option('--poll <ms>', 'Poll interval in milliseconds', '2000')
-        .option('--timeout <ms>', 'Auto-stop after N milliseconds (default: 60000)', '60000')
-        .option('-v, --verbose', 'Debug output')
-        .action(async (url, opts) => {
-        applyVerbose(opts);
-        const { recordSession, renderRecordSummary } = await import('./record.js');
-        const result = await recordSession({
-            BrowserFactory: getBrowserFactory(),
-            url,
-            site: opts.site,
-            outDir: opts.out,
-            pollMs: parseInt(opts.poll, 10),
-            timeoutMs: parseInt(opts.timeout, 10),
-        });
-        console.log(renderRecordSummary(result));
-        process.exitCode = result.candidateCount > 0 ? EXIT_CODES.SUCCESS : EXIT_CODES.EMPTY_RESULT;
-    });
-    program
-        .command('cascade')
-        .description('Strategy cascade: find simplest working strategy')
-        .argument('<url>')
-        .option('--site <name>')
-        .option('-v, --verbose', 'Debug output')
-        .action(async (url, opts) => {
-        applyVerbose(opts);
-        const { cascadeProbe, renderCascadeResult } = await import('./cascade.js');
-        const workspace = `cascade:${inferHost(url, opts.site)}`;
-        const result = await browserSession(getBrowserFactory(), async (page) => {
-            try {
-                const siteUrl = new URL(url);
-                await page.goto(`${siteUrl.protocol}//${siteUrl.host}`);
-                await page.wait(2);
-            }
-            catch { }
-            return cascadeProbe(page, url);
-        }, { workspace });
-        console.log(renderCascadeResult(result));
-    });
     // ── Built-in: browser (browser control for Claude Code skill) ───────────────
     //
     // Make websites accessible for AI agents.
@@ -249,35 +249,115 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     const browser = program
         .command('browser')
         .description('Browser control — navigate, click, type, extract, wait (no LLM needed)');
+    /** Resolve a ref/CSS target via the unified resolver, throwing TargetError on failure. */
+    async function resolveRef(page, ref) {
+        const resolution = await page.evaluate(resolveTargetJs(ref));
+        if (!resolution.ok) {
+            throw new TargetError(resolution);
+        }
+    }
     /** Wrap browser actions with error handling and optional --json output */
     function browserAction(fn) {
         return async (...args) => {
             try {
-                const page = await getBrowserPage();
+                const command = args.at(-1) instanceof Command ? args.at(-1) : undefined;
+                const targetPage = getBrowserTargetId(command);
+                const page = await getBrowserPage(targetPage);
                 await fn(page, ...args);
             }
             catch (err) {
-                const msg = getErrorMessage(err);
-                if (msg.includes('Extension not connected') || msg.includes('Daemon')) {
-                    log.error(`Browser not connected. Run 'opencli doctor' to diagnose.`);
+                if (err instanceof BrowserConnectError) {
+                    log.error(err.message);
+                    if (err.hint)
+                        log.error(`Hint: ${err.hint}`);
                 }
-                else if (msg.includes('attach failed') || msg.includes('chrome-extension://')) {
-                    log.error(`Browser attach failed — another extension may be interfering. Try disabling 1Password.`);
+                else if (err instanceof TargetError) {
+                    log.error(`[${err.code}] ${err.message}`);
+                    if (err.hint)
+                        log.error(`Hint: ${err.hint}`);
+                    if (err.candidates?.length) {
+                        log.error('Candidates:');
+                        err.candidates.forEach((c, i) => log.error(`  ${i + 1}. ${c}`));
+                    }
                 }
                 else {
-                    log.error(msg);
+                    const msg = getErrorMessage(err);
+                    if (msg.includes('attach failed') || msg.includes('chrome-extension://')) {
+                        log.error(`Browser attach failed — another extension may be interfering. Try disabling 1Password.`);
+                    }
+                    else {
+                        log.error(msg);
+                    }
                 }
                 process.exitCode = EXIT_CODES.GENERIC_ERROR;
             }
         };
     }
+    const browserTab = browser
+        .command('tab')
+        .description('Tab management — list, create, and close tabs in the automation window');
+    browserTab.command('list')
+        .description('List tabs in the automation window with target IDs')
+        .action(browserAction(async (page) => {
+        const tabs = await page.tabs();
+        console.log(JSON.stringify(tabs, null, 2));
+    }));
+    browserTab.command('new')
+        .argument('[url]', 'Optional URL to open in the new tab')
+        .description('Create a new tab and print its target ID')
+        .action(browserAction(async (page, url) => {
+        if (!page.newTab) {
+            throw new Error('This browser session does not support creating tabs');
+        }
+        const createdPage = await page.newTab(url);
+        console.log(JSON.stringify({
+            page: createdPage,
+            url: url ?? null,
+        }, null, 2));
+    }));
+    addBrowserTabOption(browserTab.command('select')
+        .argument('[targetId]', 'Target tab/page identity returned by "browser open", "browser tab new", or "browser tab list"')
+        .description('Select a tab by target ID and make it the default browser tab'))
+        .action(browserAction(async (page, targetId, opts) => {
+        const resolvedTarget = resolveBrowserTabTarget(targetId, opts);
+        if (!resolvedTarget) {
+            throw new Error('Target tab required. Pass it as an argument or --tab <targetId>.');
+        }
+        await page.selectTab(resolvedTarget);
+        saveBrowserTargetState(resolvedTarget, DEFAULT_BROWSER_WORKSPACE);
+        console.log(JSON.stringify({ selected: resolvedTarget }, null, 2));
+    }));
+    addBrowserTabOption(browserTab.command('close')
+        .argument('[targetId]', 'Target tab/page identity returned by "browser open", "browser tab new", or "browser tab list"')
+        .description('Close a tab by target ID'))
+        .action(browserAction(async (page, targetId, opts) => {
+        const resolvedTarget = resolveBrowserTabTarget(targetId, opts);
+        if (!page.closeTab) {
+            throw new Error('This browser session does not support closing tabs');
+        }
+        if (!resolvedTarget) {
+            throw new Error('Target tab required. Pass it as an argument or --tab <targetId>.');
+        }
+        const validatedTarget = await resolveBrowserTargetInSession(page, resolvedTarget, {
+            scope: DEFAULT_BROWSER_WORKSPACE,
+            source: 'explicit',
+        });
+        if (!validatedTarget) {
+            throw new Error(`Target tab ${resolvedTarget} is not part of the current browser session.`);
+        }
+        await page.closeTab(validatedTarget);
+        if (loadBrowserTargetState(DEFAULT_BROWSER_WORKSPACE)?.defaultPage === validatedTarget) {
+            saveBrowserTargetState(undefined, DEFAULT_BROWSER_WORKSPACE);
+        }
+        console.log(JSON.stringify({ closed: validatedTarget }, null, 2));
+    }));
     // ── Navigation ──
     /** Network interceptor JS — injected on every open/navigate to capture fetch/XHR */
     const NETWORK_INTERCEPTOR_JS = `(function(){if(window.__opencli_net)return;window.__opencli_net=[];var M=200,B=50000,F=window.fetch;window.fetch=async function(){var r=await F.apply(this,arguments);try{var ct=r.headers.get('content-type')||'';if(ct.includes('json')||ct.includes('text')){var c=r.clone(),t=await c.text();if(window.__opencli_net.length<M){var b=null;if(t.length<=B)try{b=JSON.parse(t)}catch(e){b=t}window.__opencli_net.push({url:r.url||(arguments[0]&&arguments[0].url)||String(arguments[0]),method:(arguments[1]&&arguments[1].method)||'GET',status:r.status,size:t.length,ct:ct,body:b})}}}catch(e){}return r};var X=XMLHttpRequest.prototype,O=X.open,S=X.send;X.open=function(m,u){this._om=m;this._ou=u;return O.apply(this,arguments)};X.send=function(){var x=this;x.addEventListener('load',function(){try{var ct=x.getResponseHeader('content-type')||'';if((ct.includes('json')||ct.includes('text'))&&window.__opencli_net.length<M){var t=x.responseText,b=null;if(t&&t.length<=B)try{b=JSON.parse(t)}catch(e){b=t}window.__opencli_net.push({url:x._ou,method:x._om||'GET',status:x.status,size:t?t.length:0,ct:ct,body:b})}}catch(e){}});return S.apply(this,arguments)}})()`;
-    browser.command('open').argument('<url>').description('Open URL in automation window')
+    addBrowserTabOption(browser.command('open').argument('<url>').description('Open URL in automation window'))
         .action(browserAction(async (page, url) => {
         // Start session-level capture before navigation (catches initial requests)
-        const hasSessionCapture = await page.startNetworkCapture?.().then(() => true).catch(() => false);
+        const hasSessionCapture = await page.startNetworkCapture?.() ?? false;
         await page.goto(url);
         await page.wait(2);
         // Fallback: inject JS interceptor when session capture is unavailable
@@ -287,15 +367,18 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             }
             catch { /* non-fatal */ }
         }
-        console.log(`Navigated to: ${await page.getCurrentUrl?.() ?? url}`);
+        console.log(JSON.stringify({
+            url: await page.getCurrentUrl?.() ?? url,
+            ...(page.getActivePage?.() ? { page: page.getActivePage?.() } : {}),
+        }, null, 2));
     }));
-    browser.command('back').description('Go back in browser history')
+    addBrowserTabOption(browser.command('back').description('Go back in browser history'))
         .action(browserAction(async (page) => {
         await page.evaluate('history.back()');
         await page.wait(2);
         console.log('Navigated back');
     }));
-    browser.command('scroll').argument('<direction>', 'up or down').option('--amount <pixels>', 'Pixels to scroll', '500')
+    addBrowserTabOption(browser.command('scroll').argument('<direction>', 'up or down').option('--amount <pixels>', 'Pixels to scroll', '500'))
         .description('Scroll page')
         .action(browserAction(async (page, direction, opts) => {
         if (direction !== 'up' && direction !== 'down') {
@@ -307,14 +390,19 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         console.log(`Scrolled ${direction}`);
     }));
     // ── Inspect ──
-    browser.command('state').description('Page state: URL, title, interactive elements with [N] indices')
+    addBrowserTabOption(browser.command('state').description('Page state: URL, title, interactive elements with [N] indices'))
         .action(browserAction(async (page) => {
         const snapshot = await page.snapshot({ viewportExpand: 2000 });
         const url = await page.getCurrentUrl?.() ?? '';
         console.log(`URL: ${url}\n`);
         console.log(typeof snapshot === 'string' ? snapshot : JSON.stringify(snapshot, null, 2));
     }));
-    browser.command('screenshot').argument('[path]', 'Save to file (base64 if omitted)')
+    addBrowserTabOption(browser.command('frames').description('List cross-origin iframe targets in snapshot order'))
+        .action(browserAction(async (page) => {
+        const frames = await page.frames?.() ?? [];
+        console.log(JSON.stringify(frames, null, 2));
+    }));
+    addBrowserTabOption(browser.command('screenshot').argument('[path]', 'Save to file (base64 if omitted)'))
         .description('Take screenshot')
         .action(browserAction(async (page, path) => {
         if (path) {
@@ -327,59 +415,53 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     }));
     // ── Get commands (structured data extraction) ──
     const get = browser.command('get').description('Get page properties');
-    get.command('title').description('Page title')
+    addBrowserTabOption(get.command('title').description('Page title'))
         .action(browserAction(async (page) => {
         console.log(await page.evaluate('document.title'));
     }));
-    get.command('url').description('Current page URL')
+    addBrowserTabOption(get.command('url').description('Current page URL'))
         .action(browserAction(async (page) => {
         console.log(await page.getCurrentUrl?.() ?? await page.evaluate('location.href'));
     }));
-    get.command('text').argument('<index>', 'Element index').description('Element text content')
+    addBrowserTabOption(get.command('text').argument('<index>', 'Element index').description('Element text content'))
         .action(browserAction(async (page, index) => {
-        const text = await page.evaluate(`((idx) => document.querySelector('[data-opencli-ref="' + idx + '"]')?.textContent?.trim())(${JSON.stringify(String(index))})`);
+        await resolveRef(page, String(index));
+        const text = await page.evaluate(getTextResolvedJs());
         console.log(text ?? '(empty)');
     }));
-    get.command('value').argument('<index>', 'Element index').description('Input/textarea value')
+    addBrowserTabOption(get.command('value').argument('<index>', 'Element index').description('Input/textarea value'))
         .action(browserAction(async (page, index) => {
-        const val = await page.evaluate(`((idx) => document.querySelector('[data-opencli-ref="' + idx + '"]')?.value)(${JSON.stringify(String(index))})`);
+        await resolveRef(page, String(index));
+        const val = await page.evaluate(getValueResolvedJs());
         console.log(val ?? '(empty)');
     }));
-    get.command('html').option('--selector <css>', 'CSS selector scope').description('Page HTML (or scoped)')
+    addBrowserTabOption(get.command('html').option('--selector <css>', 'CSS selector scope').description('Page HTML (or scoped)'))
         .action(browserAction(async (page, opts) => {
         const sel = opts.selector ? JSON.stringify(opts.selector) : 'null';
         const html = await page.evaluate(`(${sel} ? document.querySelector(${sel})?.outerHTML : document.documentElement.outerHTML)?.slice(0, 50000)`);
         console.log(html ?? '(empty)');
     }));
-    get.command('attributes').argument('<index>', 'Element index').description('Element attributes')
+    addBrowserTabOption(get.command('attributes').argument('<index>', 'Element index').description('Element attributes'))
         .action(browserAction(async (page, index) => {
-        const attrs = await page.evaluate(`((idx) => JSON.stringify(Object.fromEntries([...document.querySelector('[data-opencli-ref="' + idx + '"]')?.attributes].map(a=>[a.name,a.value]))))(${JSON.stringify(String(index))})`);
+        await resolveRef(page, String(index));
+        const attrs = await page.evaluate(getAttributesResolvedJs());
         console.log(attrs ?? '{}');
     }));
     // ── Interact ──
-    browser.command('click').argument('<index>', 'Element index from state').description('Click element by index')
+    addBrowserTabOption(browser.command('click').argument('<index>', 'Element index from state').description('Click element by index'))
         .action(browserAction(async (page, index) => {
         await page.click(index);
         console.log(`Clicked element [${index}]`);
     }));
-    browser.command('type').argument('<index>', 'Element index').argument('<text>', 'Text to type')
+    addBrowserTabOption(browser.command('type').argument('<index>', 'Element index').argument('<text>', 'Text to type'))
         .description('Click element, then type text')
         .action(browserAction(async (page, index, text) => {
         await page.click(index);
         await page.wait(0.3);
         await page.typeText(index, text);
         // Detect autocomplete/combobox fields and wait for dropdown suggestions
-        const safeIndex = JSON.stringify(String(index));
-        const isAutocomplete = await page.evaluate(`
-        (() => {
-          const el = document.querySelector('[data-opencli-ref="' + ${safeIndex} + '"]');
-          if (!el) return false;
-          const role = el.getAttribute('role');
-          const ac = el.getAttribute('aria-autocomplete');
-          const list = el.getAttribute('list');
-          return role === 'combobox' || ac === 'list' || ac === 'both' || !!list;
-        })()
-      `);
+        // __resolved is already set by typeText's resolver call
+        const isAutocomplete = await page.evaluate(isAutocompleteResolvedJs());
         if (isAutocomplete) {
             await page.wait(0.4);
             console.log(`Typed "${text}" into autocomplete [${index}] — use state to see suggestions`);
@@ -388,23 +470,11 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             console.log(`Typed "${text}" into element [${index}]`);
         }
     }));
-    browser.command('select').argument('<index>', 'Element index of <select>').argument('<option>', 'Option text')
+    addBrowserTabOption(browser.command('select').argument('<index>', 'Element index of <select>').argument('<option>', 'Option text'))
         .description('Select dropdown option')
         .action(browserAction(async (page, index, option) => {
-        const safeIdx = JSON.stringify(String(index));
-        const result = await page.evaluate(`
-        (function() {
-          var sel = document.querySelector('[data-opencli-ref="' + ${safeIdx} + '"]');
-          if (!sel || sel.tagName !== 'SELECT') return { error: 'Not a <select>' };
-          var match = Array.from(sel.options).find(o => o.text.trim() === ${JSON.stringify(option)} || o.value === ${JSON.stringify(option)});
-          if (!match) return { error: 'Option not found', available: Array.from(sel.options).map(o => o.text.trim()) };
-          var setter = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, 'value')?.set;
-          if (setter) setter.call(sel, match.value); else sel.value = match.value;
-          sel.dispatchEvent(new Event('input', {bubbles:true}));
-          sel.dispatchEvent(new Event('change', {bubbles:true}));
-          return { selected: match.text };
-        })()
-      `);
+        await resolveRef(page, String(index));
+        const result = await page.evaluate(selectResolvedJs(option));
         if (result?.error) {
             console.error(`Error: ${result.error}${result.available ? ` — Available: ${result.available.join(', ')}` : ''}`);
             process.exitCode = EXIT_CODES.GENERIC_ERROR;
@@ -413,14 +483,14 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             console.log(`Selected "${result?.selected}" in element [${index}]`);
         }
     }));
-    browser.command('keys').argument('<key>', 'Key to press (Enter, Escape, Tab, Control+a)')
+    addBrowserTabOption(browser.command('keys').argument('<key>', 'Key to press (Enter, Escape, Tab, Control+a)'))
         .description('Press keyboard key')
         .action(browserAction(async (page, key) => {
         await page.pressKey(key);
         console.log(`Pressed: ${key}`);
     }));
     // ── Wait commands ──
-    browser.command('wait')
+    addBrowserTabOption(browser.command('wait'))
         .argument('<type>', 'selector, text, or time')
         .argument('[value]', 'CSS selector, text string, or seconds')
         .option('--timeout <ms>', 'Timeout in milliseconds', '10000')
@@ -456,16 +526,34 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         }
     }));
     // ── Extract ──
-    browser.command('eval').argument('<js>', 'JavaScript code').description('Execute JS in page context, return result')
-        .action(browserAction(async (page, js) => {
-        const result = await page.evaluate(js);
+    addBrowserTabOption(browser.command('eval')
+        .argument('<js>', 'JavaScript code')
+        .option('--frame <index>', 'Cross-origin iframe index from "browser frames"')
+        .description('Execute JS in page context, return result'))
+        .action(browserAction(async (page, js, opts) => {
+        let result;
+        if (opts.frame !== undefined) {
+            const frameIndex = Number.parseInt(opts.frame, 10);
+            if (!Number.isInteger(frameIndex) || frameIndex < 0) {
+                console.error(`Invalid frame index "${opts.frame}". Use a 0-based index from "browser frames".`);
+                process.exitCode = EXIT_CODES.USAGE_ERROR;
+                return;
+            }
+            if (!page.evaluateInFrame) {
+                throw new Error('This browser session does not support frame-targeted evaluation');
+            }
+            result = await page.evaluateInFrame(js, frameIndex);
+        }
+        else {
+            result = await page.evaluate(js);
+        }
         if (typeof result === 'string')
             console.log(result);
         else
             console.log(JSON.stringify(result, null, 2));
     }));
     // ── Network (API discovery) ──
-    browser.command('network')
+    addBrowserTabOption(browser.command('network'))
         .option('--detail <index>', 'Show full response body of request at index')
         .option('--all', 'Show all requests including static resources')
         .description('Show captured network requests (auto-captured since last open)')
@@ -1003,6 +1091,10 @@ cli({
     });
     // ── Built-in: daemon ──────────────────────────────────────────────────────
     const daemonCmd = program.command('daemon').description('Manage the opencli daemon');
+    daemonCmd
+        .command('status')
+        .description('Show daemon status')
+        .action(async () => { await daemonStatus(); });
     daemonCmd
         .command('stop')
         .description('Stop the daemon')
@@ -1063,10 +1155,14 @@ cli({
         .command('serve')
         .description('Start Anthropic-compatible API proxy for Antigravity')
         .option('--port <port>', 'Server port (default: 8082)', '8082')
+        .option('--timeout <seconds>', 'Maximum time to wait for a reply (default: 120s)')
         .action(async (opts) => {
         // @ts-expect-error JS adapter — no type declarations
         const { startServe } = await import('../clis/antigravity/serve.js');
-        await startServe({ port: parseInt(opts.port) });
+        await startServe({
+            port: parseInt(opts.port, 10),
+            timeout: opts.timeout ? parsePositiveIntOption(opts.timeout, '--timeout', 120) : undefined,
+        });
     });
     // ── Dynamic adapter commands ──────────────────────────────────────────────
     const siteGroups = new Map();
@@ -1124,14 +1220,3 @@ export function resolveBrowserVerifyInvocation(opts = {}) {
         ...(platform === 'win32' ? { shell: true } : {}),
     };
 }
-/** Infer a workspace-friendly hostname from a URL, with site override. */
-function inferHost(url, site) {
-    if (site)
-        return site;
-    try {
-        return new URL(url).host;
-    }
-    catch {
-        return 'default';
-    }
-}