@jackwener/opencli 1.7.8 → 1.7.10

package/dist/src/cli.js

@@ -29,11 +29,55 @@ import { parseFilter, shapeMatchesFilter } from './browser/shape-filter.js';
 import { buildHtmlTreeJs } from './browser/html-tree.js';
 import { buildExtractHtmlJs, runExtractFromHtml } from './browser/extract.js';
 import { analyzeSite } from './browser/analyze.js';
-import { daemonStatus, daemonStop } from './commands/daemon.js';
+import { daemonRestart, daemonStatus, daemonStop } from './commands/daemon.js';
 import { log } from './logger.js';
+import { bindTab, BrowserCommandError, fetchDaemonStatus, sendCommand } from './browser/daemon-client.js';
+import { aliasForContextId, loadProfileConfig, renameProfile, resolveProfileContextId, setDefaultProfile } from './browser/profile.js';
+import { formatDaemonVersion, isDaemonStale } from './browser/daemon-version.js';
 const CLI_FILE = fileURLToPath(import.meta.url);
 const DEFAULT_BROWSER_WORKSPACE = 'browser:default';
+const DEFAULT_BOUND_WORKSPACE = 'bound:default';
 const BROWSER_TAB_OPTION_DESCRIPTION = 'Target tab/page identity returned by "browser open", "browser tab new", or "browser tab list"';
+const FOLLOW_POLL_MS = 1_000;
+function parseDurationMs(raw, flagName) {
+    if (raw === undefined || raw === null || raw === '')
+        return null;
+    const str = String(raw).trim();
+    const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(str);
+    if (!match)
+        return { error: `--${flagName} must be a duration like 500ms, 30s, 2m, got "${str}"` };
+    const value = Number.parseFloat(match[1]);
+    const unit = match[2] ?? 'ms';
+    const multiplier = unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : unit === 's' ? 1_000 : 1;
+    return Math.round(value * multiplier);
+}
+function timestampFromRaw(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : Date.now();
+}
+function toIsoTimestamp(timestamp) {
+    if (typeof timestamp !== 'number' || !Number.isFinite(timestamp) || timestamp <= 0)
+        return undefined;
+    return new Date(timestamp).toISOString();
+}
+function filterByTimeWindow(items, opts, now = Date.now()) {
+    const sinceTs = opts.sinceMs != null ? now - opts.sinceMs : undefined;
+    const untilTs = opts.untilMs != null ? now - opts.untilMs : undefined;
+    return items.filter((item) => {
+        const ts = item.timestamp ?? now;
+        if (sinceTs !== undefined && ts < sinceTs)
+            return false;
+        if (untilTs !== undefined && ts > untilTs)
+            return false;
+        return true;
+    });
+}
+export function selectFreshByTimestamp(items, lastSeenTs) {
+    const fresh = items.filter((item) => Number(item.timestamp ?? 0) > lastSeenTs);
+    const nextSeenTs = fresh.length > 0
+        ? Math.max(lastSeenTs, ...fresh.map((item) => Number(item.timestamp ?? 0)).filter(Number.isFinite))
+        : lastSeenTs;
+    return { fresh, lastSeenTs: nextSeenTs };
+}
 /**
  * Normalize raw capture entries (from daemon/CDP `readNetworkCapture` or
  * the JS interceptor's `window.__opencli_net`) into a consistent shape.
@@ -69,13 +113,15 @@ async function captureNetworkItems(page) {
                     body,
                     bodyFullSize: fullSize,
                     bodyTruncated: truncated,
+                    timestamp: timestampFromRaw(e.timestamp),
                 };
             });
         }
     }
     const raw = await page.evaluate(`(function(){ var out = window.__opencli_net || []; window.__opencli_net = []; return JSON.stringify(out); })()`);
     try {
-        return JSON.parse(raw);
+        const parsed = JSON.parse(raw);
+        return parsed.map((item) => ({ ...item, timestamp: timestampFromRaw(item.timestamp) }));
     }
     catch {
         if (process.env.OPENCLI_VERBOSE)
@@ -85,9 +131,12 @@ async function captureNetworkItems(page) {
 }
 /** Drop static-resource / telemetry noise so agents see only API-shaped traffic. */
 function filterNetworkItems(items) {
-    return items.filter((r) => (r.ct?.includes('json') || r.ct?.includes('xml') || r.ct?.includes('text/plain')) &&
-        !/\.(js|css|png|jpg|gif|svg|woff|ico|map)(\?|$)/i.test(r.url) &&
-        !/analytics|tracking|telemetry|beacon|pixel|gtag|fbevents/i.test(r.url));
+    return items.filter((r) => {
+        const ct = r.ct?.toLowerCase() ?? '';
+        return ((ct.includes('json') || ct.includes('xml') || ct.includes('text/plain') || ct.includes('javascript')) &&
+            !/\.(js|css|png|jpg|gif|svg|woff|ico|map)(\?|$)/i.test(r.url) &&
+            !/analytics|tracking|telemetry|beacon|pixel|gtag|fbevents/i.test(r.url));
+    });
 }
 /** Exit codes by network error code — usage errors vs runtime failures. */
 const NETWORK_ERROR_EXIT = {
@@ -253,6 +302,9 @@ async function resolveBrowserTargetInSession(page, targetPage, opts) {
     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.');
 }
+function getBrowserScope(workspace, contextId) {
+    return contextId ? `${contextId}:${workspace}` : workspace;
+}
 async function resolveStoredBrowserTarget(page, scope = DEFAULT_BROWSER_WORKSPACE) {
     const defaultPage = loadBrowserTargetState(scope)?.defaultPage?.trim();
     if (!defaultPage)
@@ -260,19 +312,21 @@ async function resolveStoredBrowserTarget(page, scope = DEFAULT_BROWSER_WORKSPAC
     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(targetPage) {
+async function getBrowserPage(targetPage, workspace = DEFAULT_BROWSER_WORKSPACE, contextId) {
     const { BrowserBridge } = await import('./browser/index.js');
     const bridge = new BrowserBridge();
     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,
+        workspace,
+        ...(contextId && { contextId }),
         ...(idleTimeout && idleTimeout > 0 && { idleTimeout }),
     });
+    const targetScope = getBrowserScope(workspace, contextId);
     const resolvedTargetPage = targetPage
-        ? await resolveBrowserTargetInSession(page, targetPage, { scope: DEFAULT_BROWSER_WORKSPACE, source: 'explicit' })
-        : await resolveStoredBrowserTarget(page, DEFAULT_BROWSER_WORKSPACE);
+        ? await resolveBrowserTargetInSession(page, targetPage, { scope: targetScope, source: 'explicit' })
+        : await resolveStoredBrowserTarget(page, targetScope);
     if (resolvedTargetPage) {
         if (!page.setActivePage) {
             throw new Error('This browser session does not support explicit tab targeting');
@@ -290,11 +344,38 @@ function getBrowserTargetId(command) {
     const opts = command.optsWithGlobals ? command.optsWithGlobals() : command.opts();
     return typeof opts.tab === 'string' && opts.tab.trim() ? opts.tab.trim() : undefined;
 }
+function getCommandOption(command, option) {
+    let current = command;
+    while (current) {
+        const opts = current.opts();
+        if (Object.prototype.hasOwnProperty.call(opts, option) && opts[option] !== undefined)
+            return opts[option];
+        current = current.parent;
+    }
+    return undefined;
+}
+function getBrowserWorkspace(command) {
+    const raw = getCommandOption(command, 'workspace');
+    return typeof raw === 'string' && raw.trim() ? raw.trim() : DEFAULT_BROWSER_WORKSPACE;
+}
+function getBrowserContextId(command) {
+    const raw = getCommandOption(command, 'profile');
+    return resolveProfileContextId(typeof raw === 'string' && raw.trim() ? raw.trim() : undefined);
+}
+function getPageWorkspace(page) {
+    const workspace = page.workspace;
+    return typeof workspace === 'string' && workspace.trim() ? workspace.trim() : DEFAULT_BROWSER_WORKSPACE;
+}
+function getPageScope(page) {
+    const contextId = page.contextId;
+    return getBrowserScope(getPageWorkspace(page), typeof contextId === 'string' && contextId.trim() ? contextId.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();
+    const tab = opts instanceof Command ? opts.opts().tab : opts?.tab;
+    if (typeof tab === 'string' && tab.trim())
+        return tab.trim();
     return undefined;
 }
 function parsePositiveIntOption(val, label, fallback) {
@@ -319,17 +400,17 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         .name('opencli')
         .description('Make any website your CLI. Zero setup. AI-powered.')
         .version(PKG_VERSION)
+        .option('--profile <name>', 'Chrome profile/context alias for Browser Bridge commands')
         .enablePositionalOptions();
     // ── Built-in: list ────────────────────────────────────────────────────────
     program
         .command('list')
         .description('List all available CLI commands')
         .option('-f, --format <fmt>', 'Output format: table, json, yaml, md, csv', 'table')
-        .option('--json', 'JSON output (deprecated)')
         .action((opts) => {
         const registry = getRegistry();
         const commands = [...new Set(registry.values())].sort((a, b) => fullName(a).localeCompare(fullName(b)));
-        const fmt = opts.json && opts.format === 'table' ? 'json' : opts.format;
+        const fmt = opts.format;
         const isStructured = fmt === 'json' || fmt === 'yaml';
         if (fmt !== 'table') {
             const rows = isStructured
@@ -414,6 +495,7 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     // All commands wrapped in browserAction() for consistent error handling.
     const browser = program
         .command('browser')
+        .option('--workspace <name>', 'Browser workspace to use (default: browser:default; bound tabs use bound:<name>)')
         .description('Browser control — navigate, click, type, extract, wait (no LLM needed)');
     /**
      * Resolve a `<target>` (numeric ref or CSS selector) via the unified resolver.
@@ -466,7 +548,9 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             try {
                 const command = args.at(-1) instanceof Command ? args.at(-1) : undefined;
                 const targetPage = getBrowserTargetId(command);
-                const page = await getBrowserPage(targetPage);
+                const workspace = getBrowserWorkspace(command);
+                const contextId = getBrowserContextId(command);
+                const page = await getBrowserPage(targetPage, workspace, contextId);
                 await fn(page, ...args);
             }
             catch (err) {
@@ -475,6 +559,20 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
                     if (err.hint)
                         log.error(`Hint: ${err.hint}`);
                 }
+                else if (err instanceof BrowserCommandError) {
+                    if (err.code) {
+                        console.log(JSON.stringify({
+                            error: {
+                                code: err.code,
+                                message: err.message,
+                                ...(err.hint ? { hint: err.hint } : {}),
+                            },
+                        }, null, 2));
+                    }
+                    log.error(err.message);
+                    if (err.hint)
+                        log.error(`Hint: ${err.hint}`);
+                }
                 else if (err instanceof TargetError) {
                     // Agent-facing structured envelope on stdout + short human line on stderr.
                     emitTargetError(err);
@@ -495,6 +593,105 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             }
         };
     }
+    browser.command('bind')
+        .option('--domain <host>', 'Only bind a current/visible tab whose hostname matches this domain')
+        .option('--path-prefix <path>', 'Only bind a current/visible tab whose pathname starts with this prefix')
+        .option('--workspace <name>', 'Bound workspace name (must start with bound:)')
+        .description('Bind a bound:* workspace to the current Chrome tab/window')
+        .action(async (optsOrCommand, maybeCommand) => {
+        const command = optsOrCommand instanceof Command ? optsOrCommand : maybeCommand;
+        const opts = command?.opts() ?? optsOrCommand ?? {};
+        const rawWorkspace = getCommandOption(command, 'workspace');
+        const workspace = typeof rawWorkspace === 'string' && rawWorkspace.trim()
+            ? rawWorkspace.trim()
+            : DEFAULT_BOUND_WORKSPACE;
+        if (!workspace.startsWith('bound:')) {
+            console.log(JSON.stringify({
+                error: {
+                    code: 'invalid_bind_workspace',
+                    message: `--workspace must start with "bound:", got "${workspace}"`,
+                    hint: 'Use the default bound:default or pass --workspace bound:<name>.',
+                },
+            }, null, 2));
+            process.exitCode = EXIT_CODES.USAGE_ERROR;
+            return;
+        }
+        try {
+            const { BrowserBridge } = await import('./browser/index.js');
+            const bridge = new BrowserBridge();
+            const contextId = getBrowserContextId(command);
+            await bridge.connect({ timeout: 30, workspace, ...(contextId && { contextId }) });
+            const data = await bindTab(workspace, {
+                ...(contextId && { contextId }),
+                ...(typeof opts.domain === 'string' && opts.domain.trim() ? { matchDomain: opts.domain.trim() } : {}),
+                ...(typeof opts.pathPrefix === 'string' && opts.pathPrefix.trim() ? { matchPathPrefix: opts.pathPrefix.trim() } : {}),
+            });
+            saveBrowserTargetState(undefined, getBrowserScope(workspace, contextId));
+            console.log(JSON.stringify({ workspace, ...((data && typeof data === 'object') ? data : { data }) }, null, 2));
+        }
+        catch (err) {
+            if (err instanceof BrowserCommandError && err.code) {
+                console.log(JSON.stringify({
+                    error: {
+                        code: err.code,
+                        message: err.message,
+                        ...(err.hint ? { hint: err.hint } : {}),
+                    },
+                }, null, 2));
+            }
+            log.error(err instanceof Error ? err.message : String(err));
+            if (err instanceof BrowserCommandError && err.hint)
+                log.error(`Hint: ${err.hint}`);
+            process.exitCode = err instanceof BrowserCommandError && err.code === 'invalid_bind_workspace'
+                ? EXIT_CODES.USAGE_ERROR
+                : EXIT_CODES.GENERIC_ERROR;
+        }
+    });
+    browser.command('unbind')
+        .option('--workspace <name>', 'Bound workspace name to detach')
+        .description('Detach a bound:* workspace without closing the user tab/window')
+        .action(async (optsOrCommand, maybeCommand) => {
+        const command = optsOrCommand instanceof Command ? optsOrCommand : maybeCommand;
+        const rawWorkspace = getCommandOption(command, 'workspace');
+        const workspace = typeof rawWorkspace === 'string' && rawWorkspace.trim()
+            ? rawWorkspace.trim()
+            : DEFAULT_BOUND_WORKSPACE;
+        if (!workspace.startsWith('bound:')) {
+            console.log(JSON.stringify({
+                error: {
+                    code: 'invalid_bind_workspace',
+                    message: `--workspace must start with "bound:", got "${workspace}"`,
+                    hint: 'Use the default bound:default or pass --workspace bound:<name>.',
+                },
+            }, null, 2));
+            process.exitCode = EXIT_CODES.USAGE_ERROR;
+            return;
+        }
+        try {
+            const { BrowserBridge } = await import('./browser/index.js');
+            const bridge = new BrowserBridge();
+            const contextId = getBrowserContextId(command);
+            await bridge.connect({ timeout: 30, workspace, ...(contextId && { contextId }) });
+            await sendCommand('close-window', { workspace, ...(contextId && { contextId }) });
+            saveBrowserTargetState(undefined, getBrowserScope(workspace, contextId));
+            console.log(JSON.stringify({ unbound: true, workspace }, null, 2));
+        }
+        catch (err) {
+            if (err instanceof BrowserCommandError && err.code) {
+                console.log(JSON.stringify({
+                    error: {
+                        code: err.code,
+                        message: err.message,
+                        ...(err.hint ? { hint: err.hint } : {}),
+                    },
+                }, null, 2));
+            }
+            log.error(err instanceof Error ? err.message : String(err));
+            if (err instanceof BrowserCommandError && err.hint)
+                log.error(`Hint: ${err.hint}`);
+            process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        }
+    });
     const browserTab = browser
         .command('tab')
         .description('Tab management — list, create, and close tabs in the automation window');
@@ -526,7 +723,7 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             throw new Error('Target tab required. Pass it as an argument or --tab <targetId>.');
         }
         await page.selectTab(resolvedTarget);
-        saveBrowserTargetState(resolvedTarget, DEFAULT_BROWSER_WORKSPACE);
+        saveBrowserTargetState(resolvedTarget, getPageScope(page));
         console.log(JSON.stringify({ selected: resolvedTarget }, null, 2));
     }));
     addBrowserTabOption(browserTab.command('close')
@@ -541,15 +738,16 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             throw new Error('Target tab required. Pass it as an argument or --tab <targetId>.');
         }
         const validatedTarget = await resolveBrowserTargetInSession(page, resolvedTarget, {
-            scope: DEFAULT_BROWSER_WORKSPACE,
+            scope: getPageScope(page),
             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);
+        const scope = getPageScope(page);
+        if (loadBrowserTargetState(scope)?.defaultPage === validatedTarget) {
+            saveBrowserTargetState(undefined, scope);
         }
         console.log(JSON.stringify({ closed: validatedTarget }, null, 2));
     }));
@@ -564,12 +762,17 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
      * silently dropping the body. Per-entry cap is 1 MiB and the ring is
      * capped at 200 entries, bounding worst-case in-page memory.
      */
-    const NETWORK_INTERCEPTOR_JS = `(function(){if(window.__opencli_net)return;window.__opencli_net=[];var M=200,B=1048576,F=window.fetch;function capture(url,method,status,text,ct){if(window.__opencli_net.length>=M)return;var full=text?text.length:0,trunc=full>B,stored=trunc?text.slice(0,B):text,body=null;if(stored){if(trunc){body=stored}else{try{body=JSON.parse(stored)}catch(e){body=stored}}}var e={url:url,method:method||'GET',status:status,size:full,ct:ct,body:body};if(trunc){e.bodyTruncated=true;e.bodyFullSize=full}window.__opencli_net.push(e)}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();capture(r.url||(arguments[0]&&arguments[0].url)||String(arguments[0]),(arguments[1]&&arguments[1].method)||'GET',r.status,t,ct)}}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')){capture(x._ou,x._om||'GET',x.status,x.responseText||'',ct)}}catch(e){}});return S.apply(this,arguments)}})()`;
-    addBrowserTabOption(browser.command('open').argument('<url>').description('Open URL in automation window'))
-        .action(browserAction(async (page, url) => {
+    const NETWORK_INTERCEPTOR_JS = `(function(){if(window.__opencli_net)return;window.__opencli_net=[];var M=200,B=1048576,F=window.fetch;function capture(url,method,status,text,ct){if(window.__opencli_net.length>=M)return;var full=text?text.length:0,trunc=full>B,stored=trunc?text.slice(0,B):text,body=null;if(stored){if(trunc){body=stored}else{try{body=JSON.parse(stored)}catch(e){body=stored}}}var e={url:url,method:method||'GET',status:status,size:full,ct:ct,body:body,timestamp:Date.now()};if(trunc){e.bodyTruncated=true;e.bodyFullSize=full}window.__opencli_net.push(e)}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();capture(r.url||(arguments[0]&&arguments[0].url)||String(arguments[0]),(arguments[1]&&arguments[1].method)||'GET',r.status,t,ct)}}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')){capture(x._ou,x._om||'GET',x.status,x.responseText||'',ct)}}catch(e){}});return S.apply(this,arguments)}})()`;
+    addBrowserTabOption(browser.command('open').argument('<url>').option('--allow-navigate-bound', 'Allow navigating a bound user tab', false).description('Open URL in automation window'))
+        .action(browserAction(async (page, url, opts) => {
         // Start session-level capture before navigation (catches initial requests)
         const hasSessionCapture = await page.startNetworkCapture?.() ?? false;
-        await page.goto(url);
+        if (opts.allowNavigateBound === true) {
+            await page.goto(url, { allowBoundNavigation: true });
+        }
+        else {
+            await page.goto(url);
+        }
         await page.wait(2);
         // Fallback: inject JS interceptor when session capture is unavailable
         if (!hasSessionCapture) {
@@ -583,8 +786,19 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             ...(page.getActivePage?.() ? { page: page.getActivePage?.() } : {}),
         }, null, 2));
     }));
-    addBrowserTabOption(browser.command('back').description('Go back in browser history'))
-        .action(browserAction(async (page) => {
+    addBrowserTabOption(browser.command('back').option('--allow-navigate-bound', 'Allow history navigation in a bound user tab', false).description('Go back in browser history'))
+        .action(browserAction(async (page, opts) => {
+        if (getPageWorkspace(page).startsWith('bound:') && opts.allowNavigateBound !== true) {
+            console.log(JSON.stringify({
+                error: {
+                    code: 'bound_navigation_blocked',
+                    message: `Workspace "${getPageWorkspace(page)}" is bound to a user tab; history navigation is blocked by default.`,
+                    hint: 'Pass --allow-navigate-bound only if you intentionally want to navigate the bound tab.',
+                },
+            }, null, 2));
+            process.exitCode = EXIT_CODES.GENERIC_ERROR;
+            return;
+        }
         await page.evaluate('history.back()');
         await page.wait(2);
         console.log('Navigated back');
@@ -624,6 +838,69 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             console.log(await page.screenshot({ format: 'png' }));
         }
     }));
+    addBrowserTabOption(browser.command('console'))
+        .option('--level <level>', 'Console level: all, error, warning, log, info, debug', 'all')
+        .option('--since <duration>', 'Only include messages from the last duration (for example: 30s, 2m)')
+        .option('--until <duration>', 'Only include messages older than the duration from now')
+        .option('--follow', 'Continuously print new console messages as JSON lines', false)
+        .description('Read recent browser console messages')
+        .action(browserAction(async (page, opts) => {
+        const sinceMs = parseDurationMs(opts.since, 'since');
+        const untilMs = parseDurationMs(opts.until, 'until');
+        if (sinceMs && typeof sinceMs === 'object') {
+            console.log(JSON.stringify({ error: { code: 'invalid_since', message: sinceMs.error } }, null, 2));
+            process.exitCode = EXIT_CODES.USAGE_ERROR;
+            return;
+        }
+        if (untilMs && typeof untilMs === 'object') {
+            console.log(JSON.stringify({ error: { code: 'invalid_until', message: untilMs.error } }, null, 2));
+            process.exitCode = EXIT_CODES.USAGE_ERROR;
+            return;
+        }
+        const normalize = (messages) => messages.map((message) => {
+            if (message && typeof message === 'object') {
+                const record = message;
+                return {
+                    ...record,
+                    timestamp: timestampFromRaw(record.timestamp),
+                };
+            }
+            return { type: 'log', text: String(message), timestamp: Date.now() };
+        });
+        const filter = (messages) => filterByTimeWindow(messages, { sinceMs, untilMs }).filter((message) => {
+            if (opts.level === 'all')
+                return true;
+            const type = String(message.type ?? message.level ?? '').toLowerCase();
+            return opts.level === 'error'
+                ? type === 'error' || type === 'warning'
+                : type === String(opts.level).toLowerCase();
+        });
+        if (opts.follow) {
+            let lastSeenTs = 0;
+            while (true) {
+                const messages = filter(normalize(await page.consoleMessages('all')));
+                const next = selectFreshByTimestamp(messages, lastSeenTs);
+                for (const message of next.fresh) {
+                    console.log(JSON.stringify({
+                        ...message,
+                        timestamp: toIsoTimestamp(message.timestamp),
+                    }));
+                }
+                lastSeenTs = next.lastSeenTs;
+                await new Promise((resolve) => setTimeout(resolve, FOLLOW_POLL_MS));
+            }
+        }
+        const messages = filter(normalize(await page.consoleMessages(opts.level)));
+        console.log(JSON.stringify({
+            workspace: getPageWorkspace(page),
+            captured_at: new Date().toISOString(),
+            count: messages.length,
+            messages: messages.map((message) => ({
+                ...message,
+                timestamp: toIsoTimestamp(message.timestamp),
+            })),
+        }, null, 2));
+    }));
     // ── Analyze (site recon, agent-native) ──
     //
     // Mechanizes the `site-recon.md` decision tree into one CLI call. The agent
@@ -1196,14 +1473,28 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         .option('--all', 'Include static resources (js/css/images/telemetry)')
         .option('--raw', 'Emit full bodies for every entry (skip shape preview)')
         .option('--filter <fields>', 'Comma-separated field names; keep only entries whose body shape has ALL names as path segments')
+        .option('--since <duration>', 'Only include entries from the last duration (for example: 30s, 2m)')
+        .option('--until <duration>', 'Only include entries older than the duration from now')
+        .option('--follow', 'Continuously print new matching entries as JSON lines', false)
+        .option('--failed', 'Only include failed HTTP requests (status 0 or >= 400)', false)
         .option('--max-body <chars>', 'With --detail: cap the emitted body at N chars (0 = unlimited, default)', '0')
         .option('--ttl <ms>', 'Cache TTL in ms for --detail lookups', String(DEFAULT_TTL_MS))
         .description('Capture network requests as shape previews; retrieve full bodies by key')
         .action(browserAction(async (page, opts) => {
         const ttlMs = parsePositiveIntOption(opts.ttl, 'ttl', DEFAULT_TTL_MS);
-        const workspace = DEFAULT_BROWSER_WORKSPACE;
+        const workspace = getPageWorkspace(page);
         const hasDetail = typeof opts.detail === 'string' && opts.detail.length > 0;
         const hasFilter = typeof opts.filter === 'string';
+        const sinceMs = parseDurationMs(opts.since, 'since');
+        const untilMs = parseDurationMs(opts.until, 'until');
+        if (sinceMs && typeof sinceMs === 'object') {
+            emitNetworkError('invalid_since', sinceMs.error);
+            return;
+        }
+        if (untilMs && typeof untilMs === 'object') {
+            emitNetworkError('invalid_until', untilMs.error);
+            return;
+        }
         // --detail and --filter do different things (one request by key vs. narrow
         // the list by shape), don't compose, and combining them has no sensible
         // semantic. Reject up front with a structured error instead of silently
@@ -1221,6 +1512,10 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             }
             filterFields = parsed.fields;
         }
+        if (hasDetail && opts.follow) {
+            emitNetworkError('invalid_args', '--follow cannot be used with --detail.');
+            return;
+        }
         // --detail short-circuits: read from cache only, no live capture needed.
         if (hasDetail) {
             const res = loadNetworkCache(workspace, { ttlMs });
@@ -1267,6 +1562,7 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
                 status: entry.status,
                 ct: entry.ct,
                 size: entry.size,
+                ...(typeof entry.timestamp === 'number' ? { timestamp: toIsoTimestamp(entry.timestamp) } : {}),
                 shape: inferShape(entry.body),
                 body: outputBody,
             };
@@ -1280,6 +1576,38 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             console.log(JSON.stringify(detailEnvelope, null, 2));
             return;
         }
+        if (opts.follow) {
+            if (!await page.startNetworkCapture?.()) {
+                try {
+                    await page.evaluate(NETWORK_INTERCEPTOR_JS);
+                }
+                catch { /* non-fatal */ }
+            }
+            while (true) {
+                const rawItems = await captureNetworkItems(page).catch((err) => {
+                    emitNetworkError('capture_failed', `Could not read network capture: ${err.message}`);
+                    return [];
+                });
+                let items = opts.all ? rawItems : filterNetworkItems(rawItems);
+                items = filterByTimeWindow(items, { sinceMs, untilMs });
+                if (opts.failed)
+                    items = items.filter((item) => item.status === 0 || item.status >= 400);
+                const keyed = assignKeys(items);
+                for (const item of keyed) {
+                    console.log(JSON.stringify({
+                        key: item.key,
+                        timestamp: toIsoTimestamp(item.timestamp),
+                        method: item.method,
+                        status: item.status,
+                        url: item.url,
+                        ct: item.ct,
+                        size: item.size,
+                        ...(item.bodyTruncated ? { body_truncated: true } : {}),
+                    }));
+                }
+                await new Promise((resolve) => setTimeout(resolve, FOLLOW_POLL_MS));
+            }
+        }
         // Fresh capture path.
         let rawItems;
         try {
@@ -1289,7 +1617,10 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             emitNetworkError('capture_failed', `Could not read network capture: ${err.message}`);
             return;
         }
-        const items = opts.all ? rawItems : filterNetworkItems(rawItems);
+        let items = opts.all ? rawItems : filterNetworkItems(rawItems);
+        items = filterByTimeWindow(items, { sinceMs, untilMs });
+        if (opts.failed)
+            items = items.filter((item) => item.status === 0 || item.status >= 400);
         const filteredOut = rawItems.length - items.length;
         const keyed = assignKeys(items);
         const cacheEntries = keyed.map((it) => ({
@@ -1300,6 +1631,7 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             size: it.size,
             ct: it.ct,
             body: it.body,
+            ...(typeof it.timestamp === 'number' ? { timestamp: it.timestamp } : {}),
             ...(it.bodyTruncated ? { body_truncated: true } : {}),
             ...(it.bodyTruncated && typeof it.bodyFullSize === 'number'
                 ? { body_full_size: it.bodyFullSize }
@@ -1342,12 +1674,16 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             envelope.body_truncated_hint = 'Some bodies exceeded the capture limit; their `shape` reflects only the captured prefix.';
         }
         if (opts.raw) {
-            envelope.entries = visible.map((s) => s.entry);
+            envelope.entries = visible.map((s) => ({
+                ...s.entry,
+                ...(typeof s.entry.timestamp === 'number' ? { timestamp: toIsoTimestamp(s.entry.timestamp) } : {}),
+            }));
         }
         else {
             envelope.entries = visible.map((s) => ({
                 key: s.entry.key,
                 method: s.entry.method,
+                ...(typeof s.entry.timestamp === 'number' ? { timestamp: toIsoTimestamp(s.entry.timestamp) } : {}),
                 status: s.entry.status,
                 url: s.entry.url,
                 ct: s.entry.ct,
@@ -1412,10 +1748,10 @@ cli({
     { name: 'limit', type: 'int', default: 10, help: 'Number of items' },
   ],
   columns: [], // TODO: field names for table output (e.g. ['title', 'score', 'url'])
-  func: async (page, kwargs) => {
+  func: async (kwargs) => {
     // TODO: implement data fetching
     // Prefer API calls (fetch) over browser automation
-    // page is available if browser: true
+    // If you set browser: true, change this to: async (page, kwargs) => { ... }
     return [];
   },
 });
@@ -1437,6 +1773,7 @@ cli({
         .option('--update-fixture', 'Overwrite an existing fixture with one derived from current output')
         .option('--no-fixture', 'Ignore any fixture file for this run (no value-level validation)')
         .option('--strict-memory', 'Fail (not just warn) when ~/.opencli/sites/<site>/endpoints.json or notes.md is missing')
+        .option('--trace <mode>', 'Trace capture for the adapter subprocess: off, on, retain-on-failure', 'off')
         .description('Execute an adapter and validate output; uses fixture at ~/.opencli/sites/<site>/verify/<cmd>.json when present')
         .action(async (name, opts = {}) => {
         try {
@@ -1474,10 +1811,11 @@ cli({
             const cliArgs = expandFixtureArgs(fixtureArgs);
             if (cliArgs.length === 0 && hasLimitArg)
                 cliArgs.push('--limit', '3');
-            const argDisplay = cliArgs.join(' ');
+            const traceArgs = opts.trace && opts.trace !== 'off' ? ['--trace', opts.trace] : [];
+            const argDisplay = [...cliArgs, ...traceArgs].join(' ');
             const invocation = resolveBrowserVerifyInvocation();
             // Always request JSON so we can validate structurally.
-            const execArgs = [...invocation.args, site, command, ...cliArgs, '--format', 'json'];
+            const execArgs = [...invocation.args, site, command, ...cliArgs, ...traceArgs, '--format', 'json'];
             let rawJson;
             try {
                 rawJson = execFileSync(invocation.binary, execArgs, {
@@ -1884,6 +2222,83 @@ cli({
             ? `✅ Reset "${site}". Now using official baseline.`
             : `✅ Removed custom site "${site}".`));
     });
+    // ── Built-in: browser profile selection ──────────────────────────────────
+    const profileCmd = program.command('profile').description('Manage Browser Bridge Chrome profiles');
+    profileCmd
+        .command('list')
+        .description('List Chrome profiles connected through the Browser Bridge extension')
+        .action(async () => {
+        const status = await fetchDaemonStatus();
+        const config = loadProfileConfig();
+        const profiles = status?.profiles ?? [];
+        if (!status) {
+            console.log(styleText('yellow', 'Daemon is not running. Run opencli doctor after opening Chrome.'));
+            return;
+        }
+        if (isDaemonStale(status, PKG_VERSION) || !Array.isArray(status.profiles)) {
+            console.log(styleText('yellow', `Daemon ${formatDaemonVersion(status)} is stale for CLI v${PKG_VERSION}.`));
+            console.log(styleText('dim', 'Run: opencli daemon restart'));
+            return;
+        }
+        if (profiles.length === 0) {
+            console.log(styleText('yellow', 'No Browser Bridge profiles connected.'));
+            console.log(styleText('dim', 'Open a Chrome profile with the OpenCLI extension installed, then run opencli profile list again.'));
+            return;
+        }
+        const knownContextIds = new Set(profiles.map((profile) => profile.contextId));
+        console.log(styleText('bold', 'Connected Browser Bridge profiles'));
+        console.log();
+        for (const profile of profiles) {
+            const alias = aliasForContextId(config, profile.contextId);
+            const defaultMark = config.defaultContextId === profile.contextId ? styleText('green', ' default') : '';
+            const aliasText = alias ? ` ${styleText('cyan', alias)}` : '';
+            const version = profile.extensionVersion ? ` v${profile.extensionVersion}` : ' version unknown';
+            console.log(`  ${profile.contextId}${aliasText}${defaultMark} — connected${version}`);
+        }
+        const disconnectedAliases = Object.entries(config.aliases)
+            .filter(([, contextId]) => !knownContextIds.has(contextId));
+        if (disconnectedAliases.length > 0 || (config.defaultContextId && !knownContextIds.has(config.defaultContextId))) {
+            console.log();
+            console.log(styleText('dim', 'Disconnected saved profiles:'));
+            const shown = new Set();
+            for (const [alias, contextId] of disconnectedAliases) {
+                shown.add(contextId);
+                console.log(styleText('dim', `  ${contextId} ${alias} — not connected`));
+            }
+            if (config.defaultContextId && !shown.has(config.defaultContextId) && !knownContextIds.has(config.defaultContextId)) {
+                console.log(styleText('dim', `  ${config.defaultContextId} — default, not connected`));
+            }
+        }
+    });
+    profileCmd
+        .command('rename')
+        .description('Assign a local alias to a connected Browser Bridge profile')
+        .argument('<contextId>', 'Profile contextId from opencli profile list')
+        .argument('<alias>', 'Local alias, e.g. work or personal')
+        .action((contextId, alias) => {
+        try {
+            renameProfile(contextId, alias);
+            console.log(`Profile ${contextId} is now aliased as ${styleText('cyan', alias)}.`);
+        }
+        catch (err) {
+            console.error(styleText('red', `Error: ${getErrorMessage(err)}`));
+            process.exitCode = EXIT_CODES.USAGE_ERROR;
+        }
+    });
+    profileCmd
+        .command('use')
+        .description('Set the default Browser Bridge profile for future commands')
+        .argument('<profile>', 'Profile alias or contextId')
+        .action((profile) => {
+        try {
+            const config = setDefaultProfile(profile);
+            console.log(`Default Browser Bridge profile: ${styleText('cyan', config.defaultContextId ?? profile)}`);
+        }
+        catch (err) {
+            console.error(styleText('red', `Error: ${getErrorMessage(err)}`));
+            process.exitCode = EXIT_CODES.USAGE_ERROR;
+        }
+    });
     // ── Built-in: daemon ──────────────────────────────────────────────────────
     const daemonCmd = program.command('daemon').description('Manage the opencli daemon');
     daemonCmd
@@ -1894,9 +2309,16 @@ cli({
         .command('stop')
         .description('Stop the daemon')
         .action(async () => { await daemonStop(); });
+    daemonCmd
+        .command('restart')
+        .description('Restart the daemon')
+        .action(async () => { await daemonRestart(); });
     // ── External CLIs ─────────────────────────────────────────────────────────
     const externalClis = loadExternalClis();
-    program
+    const externalCmd = program
+        .command('external')
+        .description('Manage external CLI passthrough commands');
+    externalCmd
         .command('install')
         .description('Install an external CLI')
         .argument('<name>', 'Name of the external CLI')
@@ -1909,7 +2331,7 @@ cli({
         }
         installExternalCli(ext);
     });
-    program
+    externalCmd
         .command('register')
         .description('Register an external CLI')
         .argument('<name>', 'Name of the CLI')
@@ -1919,6 +2341,26 @@ cli({
         .action((name, opts) => {
         registerExternalCli(name, { binary: opts.binary, install: opts.install, description: opts.desc });
     });
+    externalCmd
+        .command('list')
+        .description('List registered external CLIs')
+        .option('-f, --format <fmt>', 'Output format: table, json, yaml, md, csv', 'table')
+        .action((opts) => {
+        const rows = loadExternalClis().map((ext) => ({
+            name: ext.name,
+            binary: ext.binary,
+            installed: isBinaryInstalled(ext.binary),
+            description: ext.description ?? '',
+            homepage: ext.homepage ?? '',
+            tags: ext.tags?.join(', ') ?? '',
+        }));
+        renderOutput(rows, {
+            fmt: opts.format,
+            columns: ['name', 'binary', 'installed', 'description', 'homepage', 'tags'],
+            title: 'opencli/external/list',
+            source: 'opencli external list',
+        });
+    });
     function passthroughExternal(name, parsedArgs) {
         const args = parsedArgs ?? (() => {
             const idx = process.argv.indexOf(name);
@@ -1965,12 +2407,12 @@ cli({
     registerAllCommands(program, siteGroups);
     // ── Unknown command fallback ──────────────────────────────────────────────
     // Security: do NOT auto-discover and register arbitrary system binaries.
-    // Only explicitly registered external CLIs (via `opencli register`) are allowed.
+    // Only explicitly registered external CLIs are allowed.
     program.on('command:*', (operands) => {
         const binary = operands[0];
         console.error(styleText('red', `error: unknown command '${binary}'`));
         if (isBinaryInstalled(binary)) {
-            console.error(styleText('dim', `  Tip: '${binary}' exists on your PATH. Use 'opencli register ${binary}' to add it as an external CLI.`));
+            console.error(styleText('dim', `  Tip: '${binary}' exists on your PATH. Use 'opencli external register ${binary}' to add it as an external CLI.`));
         }
         program.outputHelp();
         process.exitCode = EXIT_CODES.USAGE_ERROR;