@monoes/monobrowse 1.0.9 → 1.0.12

package/dist/src/cli/commands.js

@@ -2,8 +2,8 @@
  * Browse Command — Native browser automation via Chrome DevTools Protocol
  * Provides ref-based element model and token-efficient accessibility snapshots
  */
-import { output } from './output.js';
 import { createActionCommand } from './action.js';
+import { output } from './output.js';
 import { createPlatformCommand } from './platform.js';
 // Runtime state (single session per CLI process)
 const DEFAULT_PORT = 9222;
@@ -50,7 +50,9 @@ function ensureSignalCleanupHandlers() {
                             try {
                                 process.kill(pid, 'SIGKILL');
                             }
-                            catch { /* already exited */ }
+                            catch {
+                                /* already exited */
+                            }
                         }
                     }
                 }
@@ -78,7 +80,9 @@ async function resolveDefaultPort(browser) {
         // user's debug port and silently swap which browser commands act on —
         // fail loudly instead.
         try {
-            await fetch(`http://127.0.0.1:${persisted.port}/json/version`, { signal: AbortSignal.timeout(1500) });
+            await fetch(`http://127.0.0.1:${persisted.port}/json/version`, {
+                signal: AbortSignal.timeout(1500),
+            });
         }
         catch {
             await browser.clearActivePort();
@@ -89,7 +93,7 @@ async function resolveDefaultPort(browser) {
 }
 async function ensureConnected(port, targetId) {
     const browser = await getBrowser();
-    if (!_client || !_client.isConnected()) {
+    if (!_client?.isConnected()) {
         if (_client && _sessionId) {
             browser.teardownRouteInterception(_sessionId);
             browser.stopRequestCapture(_sessionId);
@@ -146,20 +150,28 @@ async function detectAttentionNeeded(client, sessionId, url) {
     if (ATTENTION_URL_RE.test(url))
         return 'login';
     try {
-        const hasPassword = await client.send('Runtime.evaluate', {
+        const hasPassword = await client
+            .send('Runtime.evaluate', {
             expression: '!!document.querySelector("input[type=password]")',
             returnByValue: true,
-        }, sessionId).then(r => r.result?.value === true).catch(() => false);
+        }, sessionId)
+            .then((r) => r.result?.value === true)
+            .catch(() => false);
         if (hasPassword)
             return 'login';
-        const hasCaptcha = await client.send('Runtime.evaluate', {
+        const hasCaptcha = await client
+            .send('Runtime.evaluate', {
             expression: '!!(document.querySelector("iframe[src*=recaptcha]") || document.querySelector("iframe[src*=hcaptcha]") || document.querySelector(".g-recaptcha") || document.querySelector(".h-captcha") || document.querySelector("[data-sitekey]"))',
             returnByValue: true,
-        }, sessionId).then(r => r.result?.value === true).catch(() => false);
+        }, sessionId)
+            .then((r) => r.result?.value === true)
+            .catch(() => false);
         if (hasCaptcha)
             return 'captcha';
     }
-    catch { /* ignore CDP errors */ }
+    catch {
+        /* ignore CDP errors */
+    }
     return null;
 }
 function waitForEnter() {
@@ -167,12 +179,16 @@ function waitForEnter() {
         // Non-interactive context (MCP server, piped input, CI) — cannot safely read stdin.
         // Auto-continue after a short grace period so automation isn't blocked.
         output.printWarning('Non-interactive mode: auto-continuing in 30s. Switch to headed manually if needed.');
-        return new Promise(resolve => setTimeout(resolve, 30_000));
+        return new Promise((resolve) => setTimeout(resolve, 30_000));
     }
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
         process.stdin.resume();
         process.stdin.setEncoding('utf8');
-        const onData = () => { process.stdin.pause(); process.stdin.off('data', onData); resolve(); };
+        const onData = () => {
+            process.stdin.pause();
+            process.stdin.off('data', onData);
+            resolve();
+        };
         process.stdin.once('data', onData);
     });
 }
@@ -184,7 +200,9 @@ async function switchToHeaded(url, port) {
         try {
             savedCookies = await browser.getCookies(_client, _sessionId);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         browser.teardownRouteInterception(_sessionId);
         browser.stopRequestCapture(_sessionId);
         browser.teardownDialogHandling(_sessionId);
@@ -219,14 +237,18 @@ async function switchToHeaded(url, port) {
         try {
             await browser.setCookies(_client, _sessionId, savedCookies);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     await browser.openUrl(_client, _sessionId, url);
     output.printInfo('Browser window opened. Complete the required action (login / CAPTCHA), then press Enter to continue in headless mode...');
     await waitForEnter();
     // Capture post-auth cookies
     const authCookies = await browser.getCookies(_client, _sessionId).catch(() => []);
-    const authLocalStorage = await browser.getLocalStorage(_client, _sessionId).catch(() => ({}));
+    const authLocalStorage = await browser
+        .getLocalStorage(_client, _sessionId)
+        .catch(() => ({}));
     // Close headed session — actually terminate the underlying Chrome process
     // (Browser.close CDP command, PID-kill fallback), not just our CDP client
     // connection, so the visible authenticated window doesn't linger forever.
@@ -251,13 +273,17 @@ async function switchToHeaded(url, port) {
         try {
             await browser.setCookies(_client, _sessionId, authCookies);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     if (authLocalStorage && Object.keys(authLocalStorage).length) {
         try {
             await browser.setLocalStorage(_client, _sessionId, authLocalStorage);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
 }
 /**
@@ -272,7 +298,7 @@ function imageFormat(value, allowed, fallback) {
     return allowed.includes(value) ? value : fallback;
 }
 function print(msg) {
-    process.stdout.write(msg + '\n');
+    process.stdout.write(`${msg}\n`);
 }
 // ---------------------------------------------------------------------------
 // Sub-commands
@@ -282,7 +308,12 @@ const openCommand = {
     description: 'Open a URL in the browser. Usage: monomind browse open <url>',
     options: [
         { name: 'port', short: 'p', type: 'number', description: 'CDP port', default: 9222 },
-        { name: 'headed', type: 'boolean', description: 'Force visible browser window', default: false },
+        {
+            name: 'headed',
+            type: 'boolean',
+            description: 'Force visible browser window',
+            default: false,
+        },
         { name: 'session', short: 's', type: 'string', description: 'Session name to restore' },
         { name: 'state', type: 'string', description: 'State file to load' },
     ],
@@ -300,19 +331,25 @@ const openCommand = {
                 try {
                     await browser.stopHarRecording(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.getTraceStatus(prevSid)) {
                 try {
                     await browser.stopTrace(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.isProfilingActive(prevSid)) {
                 try {
                     await browser.stopCpuProfile(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             browser.teardownRouteInterception(prevSid);
             browser.stopRequestCapture(prevSid);
@@ -352,7 +389,10 @@ const openCommand = {
             // launched it) instead of overwriting with undefined.
             const existing = await browser.loadActivePortInfo();
             const preserved = existing && existing.port === _port ? existing : undefined;
-            await browser.saveActivePort(_port, { pid: preserved?.pid, userDataDir: preserved?.userDataDir });
+            await browser.saveActivePort(_port, {
+                pid: preserved?.pid,
+                userDataDir: preserved?.userDataDir,
+            });
         }
         ensureSignalCleanupHandlers();
         const conn = await browser.connectToTarget(_port);
@@ -395,15 +435,49 @@ const snapshotCommand = {
     name: 'snapshot',
     description: 'Capture accessibility snapshot with ref-based element handles (@e1, @e2, ...)',
     options: [
-        { name: 'interactive', short: 'i', type: 'boolean', description: 'Interactive elements only (93% token reduction)', default: false },
-        { name: 'compact', short: 'c', type: 'boolean', description: 'Compact output format', default: false },
+        {
+            name: 'interactive',
+            short: 'i',
+            type: 'boolean',
+            description: 'Interactive elements only (93% token reduction)',
+            default: false,
+        },
+        {
+            name: 'compact',
+            short: 'c',
+            type: 'boolean',
+            description: 'Compact output format',
+            default: false,
+        },
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
         { name: 'depth', short: 'd', type: 'number', description: 'Max depth of AX tree to show' },
-        { name: 'selector', short: 's', type: 'string', description: 'Scope snapshot to a CSS selector' },
-        { name: 'save', type: 'string', description: 'Save snapshot text to file (baseline for --diff)' },
-        { name: 'diff', type: 'string', description: 'Compare current snapshot against a saved baseline file' },
-        { name: 'content-boundaries', type: 'boolean', description: 'Wrap output in sentinel markers to prevent page-content injection attacks', default: false },
-        { name: 'max-output', type: 'number', description: 'Truncate output to N characters (prevents context window blowout on large pages)' },
+        {
+            name: 'selector',
+            short: 's',
+            type: 'string',
+            description: 'Scope snapshot to a CSS selector',
+        },
+        {
+            name: 'save',
+            type: 'string',
+            description: 'Save snapshot text to file (baseline for --diff)',
+        },
+        {
+            name: 'diff',
+            type: 'string',
+            description: 'Compare current snapshot against a saved baseline file',
+        },
+        {
+            name: 'content-boundaries',
+            type: 'boolean',
+            description: 'Wrap output in sentinel markers to prevent page-content injection attacks',
+            default: false,
+        },
+        {
+            name: 'max-output',
+            type: 'number',
+            description: 'Truncate output to N characters (prevents context window blowout on large pages)',
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -427,8 +501,8 @@ const snapshotCommand = {
         };
         // --save: write snapshot text to baseline file
         if (ctx.flags.save) {
-            const { writeFile, mkdir } = await import('fs/promises');
-            const { dirname } = await import('path');
+            const { writeFile, mkdir } = await import('node:fs/promises');
+            const { dirname } = await import('node:path');
             const savePath = ctx.flags.save;
             await mkdir(dirname(savePath), { recursive: true }).catch(() => { });
             await writeFile(savePath, result.text, 'utf8');
@@ -437,7 +511,7 @@ const snapshotCommand = {
         }
         // --diff: compare against baseline file
         if (ctx.flags.diff) {
-            const { readFile } = await import('fs/promises');
+            const { readFile } = await import('node:fs/promises');
             const baselinePath = ctx.flags.diff;
             let baseline;
             try {
@@ -459,7 +533,13 @@ const snapshotCommand = {
                     removed.push(l);
             const changed = added.length > 0 || removed.length > 0;
             if (ctx.flags.json) {
-                print(JSON.stringify({ changed, additions: added.length, removals: removed.length, added, removed }));
+                print(JSON.stringify({
+                    changed,
+                    additions: added.length,
+                    removals: removed.length,
+                    added,
+                    removed,
+                }));
             }
             else {
                 if (!changed) {
@@ -473,11 +553,19 @@ const snapshotCommand = {
                         print(`\x1b[31m- ${l}\x1b[0m`);
                 }
             }
-            return { success: true, data: { changed, additions: added.length, removals: removed.length } };
+            return {
+                success: true,
+                data: { changed, additions: added.length, removals: removed.length },
+            };
         }
         if (ctx.flags.json) {
             const refsObj = Object.fromEntries([...result.refs.entries()].map(([k, v]) => [k, v]));
-            print(JSON.stringify({ url: result.url, title: result.title, refs: refsObj, snapshot: result.text }));
+            print(JSON.stringify({
+                url: result.url,
+                title: result.title,
+                refs: refsObj,
+                snapshot: result.text,
+            }));
         }
         else {
             print(`[${result.title}] ${result.url}\n`);
@@ -555,11 +643,19 @@ const waitCommand = {
         { name: 'text', type: 'string', description: 'Wait for text to appear in page' },
         { name: 'not-text', type: 'string', description: 'Wait for text to disappear from page' },
         { name: 'selector', type: 'string', description: 'Wait for CSS selector to appear' },
-        { name: 'load', type: 'string', description: 'Wait for load event: load|networkidle|domcontentloaded' },
+        {
+            name: 'load',
+            type: 'string',
+            description: 'Wait for load event: load|networkidle|domcontentloaded',
+        },
         { name: 'fn', type: 'string', description: 'Wait until JS expression returns truthy' },
         { name: 'ms', type: 'number', description: 'Wait N milliseconds' },
         { name: 'timeout', short: 't', type: 'number', description: 'Timeout in ms', default: 30000 },
-        { name: 'download', type: 'string', description: 'Wait for a file download to complete and save to path (monitors Browser.downloadProgress events)' },
+        {
+            name: 'download',
+            type: 'string',
+            description: 'Wait for a file download to complete and save to path (monitors Browser.downloadProgress events)',
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -574,7 +670,9 @@ const waitCommand = {
         if (ctx.flags.fn) {
             const expr = ctx.flags.fn;
             const rawTimeout = ctx.flags.timeout ?? 30000;
-            const timeout = Number.isFinite(rawTimeout) ? Math.max(100, Math.min(rawTimeout, 300_000)) : 30000; // cap at 5min
+            const timeout = Number.isFinite(rawTimeout)
+                ? Math.max(100, Math.min(rawTimeout, 300_000))
+                : 30000; // cap at 5min
             const interval = 200;
             const deadline = Date.now() + timeout;
             while (Date.now() < deadline) {
@@ -593,7 +691,7 @@ const waitCommand = {
             const interval = 200;
             const deadline = Date.now() + timeout;
             while (Date.now() < deadline) {
-                const text = await browser.evaluateJs(client, sessionId, 'document.body?.innerText ?? ""');
+                const text = (await browser.evaluateJs(client, sessionId, 'document.body?.innerText ?? ""'));
                 if (!text.includes(target)) {
                     output.printSuccess('Text disappeared');
                     return { success: true };
@@ -604,26 +702,39 @@ const waitCommand = {
         }
         if (ctx.flags.download) {
             const savePath = ctx.flags.download;
-            const { mkdir } = await import('fs/promises');
-            const { dirname, join } = await import('path');
-            const { tmpdir } = await import('os');
+            const { mkdir } = await import('node:fs/promises');
+            const { dirname, join } = await import('node:path');
+            const { tmpdir } = await import('node:os');
             const downloadDir = join(tmpdir(), `mm-dl-wait-${Date.now()}`);
             await mkdir(downloadDir, { recursive: true });
-            await client.send('Browser.setDownloadBehavior', {
-                behavior: 'allow', downloadPath: downloadDir, eventsEnabled: true,
-            }, undefined).catch(() => client.send('Page.setDownloadBehavior', { behavior: 'allow', downloadPath: downloadDir }, sessionId).catch(() => { }));
+            await client
+                .send('Browser.setDownloadBehavior', {
+                behavior: 'allow',
+                downloadPath: downloadDir,
+                eventsEnabled: true,
+            }, undefined)
+                .catch(() => client
+                .send('Page.setDownloadBehavior', { behavior: 'allow', downloadPath: downloadDir }, sessionId)
+                .catch(() => { }));
             const MAX_DOWNLOAD_TIMEOUT = 5 * 60 * 1000; // I6: cap at 5 minutes
             const rawTimeout = Math.min(ctx.flags.timeout ?? 30000, MAX_DOWNLOAD_TIMEOUT);
             const finalPath = await new Promise((resolve, reject) => {
                 let guid = '';
                 let settled = false;
                 // C2: capture off() functions to avoid listener leaks
-                const offBegin = client.on('Browser.downloadWillBegin', (params) => { guid = params.guid; });
+                const offBegin = client.on('Browser.downloadWillBegin', (params) => {
+                    guid = params.guid;
+                });
                 let offProgress;
                 // cleanup defined before setTimeout so the timeout callback can call it
                 let tid;
                 let pollTid;
-                const cleanup = () => { clearTimeout(tid); clearInterval(pollTid); offBegin?.(); offProgress?.(); };
+                const cleanup = () => {
+                    clearTimeout(tid);
+                    clearInterval(pollTid);
+                    offBegin?.();
+                    offProgress?.();
+                };
                 const finish = (path) => {
                     if (settled)
                         return;
@@ -641,7 +752,7 @@ const waitCommand = {
                 tid = setTimeout(() => fail(new Error('Download timed out')), rawTimeout);
                 offProgress = client.on('Browser.downloadProgress', async (params) => {
                     if (params.guid === guid && params.state === 'completed') {
-                        const { readdir, rename, rmdir } = await import('fs/promises');
+                        const { readdir, rename, rmdir } = await import('node:fs/promises');
                         const files = await readdir(downloadDir);
                         if (files.length > 0) {
                             const src = join(downloadDir, files[0]);
@@ -671,7 +782,7 @@ const waitCommand = {
                     if (settled || guid)
                         return; // a real CDP event has taken over
                     try {
-                        const { stat } = await import('fs/promises');
+                        const { stat } = await import('node:fs/promises');
                         const st = await stat(savePath);
                         if (st.isFile() && st.size > 0 && st.size === lastSize) {
                             stableReads++;
@@ -709,8 +820,18 @@ const screenshotCommand = {
         { name: 'full', type: 'boolean', description: 'Full page screenshot', default: false },
         { name: 'format', type: 'string', description: 'Format: png|jpeg|webp', default: 'png' },
         { name: 'quality', type: 'number', description: 'Quality 0-100 for jpeg/webp', default: 80 },
-        { name: 'annotate', type: 'boolean', description: 'Overlay numbered labels keyed to @eN refs from last snapshot (viewport-only; do not combine with --full)', default: false },
-        { name: 'hide-scrollbars', type: 'boolean', description: 'Hide native scrollbars via CSS injection before capture', default: false },
+        {
+            name: 'annotate',
+            type: 'boolean',
+            description: 'Overlay numbered labels keyed to @eN refs from last snapshot (viewport-only; do not combine with --full)',
+            default: false,
+        },
+        {
+            name: 'hide-scrollbars',
+            type: 'boolean',
+            description: 'Hide native scrollbars via CSS injection before capture',
+            default: false,
+        },
         { name: 'json', type: 'boolean', description: 'Output JSON with path', default: false },
     ],
     action: async (ctx) => {
@@ -718,10 +839,12 @@ const screenshotCommand = {
         const browser = await getBrowser();
         const hideScrollbars = ctx.flags['hide-scrollbars'];
         if (hideScrollbars) {
-            await client.send('Runtime.evaluate', {
+            await client
+                .send('Runtime.evaluate', {
                 expression: `(function(){var s=document.getElementById('__mm_noscroll__');if(s)return;var el=document.createElement('style');el.id='__mm_noscroll__';el.textContent='*::-webkit-scrollbar{display:none!important}*{scrollbar-width:none!important;-ms-overflow-style:none!important}';document.head.appendChild(el);})()`,
                 returnByValue: false,
-            }, sessionId).catch(() => { });
+            }, sessionId)
+                .catch(() => { });
         }
         const annotate = ctx.flags.annotate;
         // eslint-disable-next-line prefer-const
@@ -738,10 +861,12 @@ const screenshotCommand = {
         }
         finally {
             if (hideScrollbars) {
-                await client.send('Runtime.evaluate', {
+                await client
+                    .send('Runtime.evaluate', {
                     expression: `(function(){var s=document.getElementById('__mm_noscroll__');if(s)s.remove();})()`,
                     returnByValue: false,
-                }, sessionId).catch(() => { });
+                }, sessionId)
+                    .catch(() => { });
             }
         }
         if (ctx.flags.json) {
@@ -756,9 +881,7 @@ const screenshotCommand = {
 const getCommand = {
     name: 'get',
     description: 'Get page info. Usage: monomind browse get url|title|text|html|value|attr|count|box|styles [@ref] [attrName]',
-    options: [
-        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
-    ],
+    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON', default: false }],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
         const browser = await getBrowser();
@@ -811,7 +934,8 @@ const getCommand = {
                     throw new Error('Element not in DOM');
                 const r = await client.send('Runtime.callFunctionOn', {
                     functionDeclaration: 'function() { return this.value ?? null; }',
-                    objectId, returnByValue: true,
+                    objectId,
+                    returnByValue: true,
                 }, sessionId);
                 value = r.result?.value ?? null;
                 break;
@@ -830,7 +954,8 @@ const getCommand = {
                     throw new Error('Element not in DOM');
                 const r = await client.send('Runtime.callFunctionOn', {
                     functionDeclaration: `function() { return this.getAttribute(${JSON.stringify(attrName)}); }`,
-                    objectId, returnByValue: true,
+                    objectId,
+                    returnByValue: true,
                 }, sessionId);
                 value = r.result?.value ?? null;
                 break;
@@ -867,7 +992,8 @@ const getCommand = {
                     throw new Error('Element not in DOM');
                 const r = await client.send('Runtime.callFunctionOn', {
                     functionDeclaration: 'function() { const s = window.getComputedStyle(this); return JSON.stringify(Object.fromEntries([...s].map(k => [k, s.getPropertyValue(k)]))); }',
-                    objectId, returnByValue: true,
+                    objectId,
+                    returnByValue: true,
                 }, sessionId);
                 try {
                     value = JSON.parse(r.result?.value ?? '{}');
@@ -895,7 +1021,12 @@ const scrollCommand = {
     options: [
         { name: 'amount', short: 'a', type: 'number', description: 'Pixels to scroll', default: 300 },
         { name: 'ref', type: 'string', description: 'Element ref to scroll within' },
-        { name: 'selector', short: 's', type: 'string', description: 'CSS selector of element to scroll within' },
+        {
+            name: 'selector',
+            short: 's',
+            type: 'string',
+            description: 'CSS selector of element to scroll within',
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -905,12 +1036,14 @@ const scrollCommand = {
             throw new Error('Usage: monomind browse scroll up|down|left|right [amount]');
         // Support positional amount: scroll down 300
         const positionalAmount = ctx.args[1] !== undefined ? parseInt(ctx.args[1], 10) : undefined;
-        const amount = (positionalAmount && Number.isFinite(positionalAmount)) ? positionalAmount : ctx.flags.amount ?? 300;
+        const amount = positionalAmount && Number.isFinite(positionalAmount)
+            ? positionalAmount
+            : (ctx.flags.amount ?? 300);
         if (ctx.flags.selector) {
             const sel = ctx.flags.selector;
             const dx = direction === 'right' ? amount : direction === 'left' ? -amount : 0;
             const dy = direction === 'down' ? amount : direction === 'up' ? -amount : 0;
-            const posJson = await browser.evaluateJs(client, sessionId, `(function(){var el=document.querySelector(${JSON.stringify(sel)});if(!el)return null;var r=el.getBoundingClientRect();return JSON.stringify({x:r.left+r.width/2,y:r.top+r.height/2});})()`);
+            const posJson = (await browser.evaluateJs(client, sessionId, `(function(){var el=document.querySelector(${JSON.stringify(sel)});if(!el)return null;var r=el.getBoundingClientRect();return JSON.stringify({x:r.left+r.width/2,y:r.top+r.height/2});})()`));
             if (!posJson)
                 throw new Error(`Selector not found: ${sel}`);
             const pos = JSON.parse(posJson);
@@ -958,7 +1091,9 @@ const navigateCommand = {
                     expression: direction === 'back' ? 'history.back()' : 'history.forward()',
                 }, sessionId);
                 let fallbackHandle;
-                const fallbackPromise = new Promise((r) => { fallbackHandle = setTimeout(r, 2000); });
+                const fallbackPromise = new Promise((r) => {
+                    fallbackHandle = setTimeout(r, 2000);
+                });
                 await Promise.race([frameStartedPromise, fallbackPromise]);
                 if (fallbackHandle !== undefined)
                     clearTimeout(fallbackHandle);
@@ -996,10 +1131,13 @@ const setCommand = {
                 const width = parseInt(ctx.args[1], 10);
                 const height = parseInt(ctx.args[2], 10);
                 const dpr = parseFloat(ctx.args[3]) || undefined;
-                if (isNaN(width) || isNaN(height))
+                if (Number.isNaN(width) || Number.isNaN(height))
                     throw new Error('Usage: set viewport <width> <height> [dpr]');
                 await client.send('Emulation.setDeviceMetricsOverride', {
-                    width, height, deviceScaleFactor: dpr ?? 1, mobile: false,
+                    width,
+                    height,
+                    deviceScaleFactor: dpr ?? 1,
+                    mobile: false,
                 }, sessionId);
                 output.printSuccess(`Viewport set to ${width}x${height}${dpr ? ` @${dpr}x` : ''}`);
                 break;
@@ -1016,7 +1154,7 @@ const setCommand = {
                 const lat = parseFloat(ctx.args[1]);
                 const lon = parseFloat(ctx.args[2]);
                 const acc = parseFloat(ctx.args[3]) || 100;
-                if (isNaN(lat) || isNaN(lon))
+                if (Number.isNaN(lat) || Number.isNaN(lon))
                     throw new Error('Usage: set geo <latitude> <longitude> [accuracy]');
                 await browser.setGeolocation(client, sessionId, lat, lon, acc);
                 output.printSuccess(`Geolocation set: ${lat}, ${lon}`);
@@ -1066,7 +1204,11 @@ const stateCommand = {
     name: 'state',
     description: 'Manage browser session state. Usage: monomind browse state save|load|list|rename|clean [name]',
     options: [
-        { name: 'older-than', type: 'number', description: 'For state clean: remove sessions older than N days' },
+        {
+            name: 'older-than',
+            type: 'number',
+            description: 'For state clean: remove sessions older than N days',
+        },
     ],
     action: async (ctx) => {
         const browser = await getBrowser();
@@ -1123,7 +1265,13 @@ const stateCommand = {
                 const title = await browser.getCurrentTitle(c, sid);
                 const cookies = await browser.getCookies(c, sid);
                 const ls = await browser.getAllLocalStorage(c, sid);
-                const info = { url, title, cookies: cookies.length, localStorage: Object.keys(ls).length, refs: _refs.size };
+                const info = {
+                    url,
+                    title,
+                    cookies: cookies.length,
+                    localStorage: Object.keys(ls).length,
+                    refs: _refs.size,
+                };
                 print(JSON.stringify(info, null, 2));
                 return { success: true, data: info };
             }
@@ -1146,14 +1294,14 @@ const stateCommand = {
                 if (!sessions.includes(oldName))
                     throw new Error(`Session not found: ${oldName}`);
                 // W1: validate newName to prevent path traversal
-                const { basename: basenameFn } = await import('path');
+                const { basename: basenameFn } = await import('node:path');
                 const safeName = basenameFn(newName);
                 if (safeName !== newName || safeName.startsWith('.') || safeName.includes('/')) {
                     throw new Error('Invalid session name — must not contain path separators or start with "."');
                 }
-                const { unlink: unlinkRename, readFile, writeFile, mkdir: mkdirRename } = await import('fs/promises');
-                const { join: joinR } = await import('path');
-                const { homedir } = await import('os');
+                const { unlink: unlinkRename, readFile, writeFile, mkdir: mkdirRename, } = await import('node:fs/promises');
+                const { join: joinR } = await import('node:path');
+                const { homedir } = await import('node:os');
                 const sessionDir = joinR(homedir(), '.monomind', 'browser-sessions');
                 const oldPath = joinR(sessionDir, `${oldName}.json`);
                 const newPath = joinR(sessionDir, `${newName}.json`);
@@ -1167,9 +1315,9 @@ const stateCommand = {
             }
             case 'clean': {
                 const days = ctx.flags['older-than'] ?? 7;
-                const { unlink, stat } = await import('fs/promises');
-                const { join: joinC } = await import('path');
-                const { homedir: homedirC } = await import('os');
+                const { unlink, stat } = await import('node:fs/promises');
+                const { join: joinC } = await import('node:path');
+                const { homedir: homedirC } = await import('node:os');
                 const sessionDir = joinC(homedirC(), '.monomind', 'browser-sessions');
                 const sessions = await browser.listSessions();
                 const cutoff = Date.now() - days * 86400 * 1000;
@@ -1200,10 +1348,26 @@ const networkCommand = {
         { name: 'status', type: 'number', description: 'HTTP status for fulfill', default: 200 },
         { name: 'headers', type: 'string', description: 'JSON headers object' },
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
-        { name: 'filter', type: 'string', description: 'Filter requests by URL substring (for network requests)' },
-        { name: 'method', type: 'string', description: 'Filter by HTTP method, e.g. GET, POST (for network requests)' },
-        { name: 'status-code', type: 'number', description: 'Filter by HTTP status code (for network requests)' },
-        { name: 'type', type: 'string', description: 'Filter by resource type: xhr|fetch|document|script|stylesheet|image (for network requests)' },
+        {
+            name: 'filter',
+            type: 'string',
+            description: 'Filter requests by URL substring (for network requests)',
+        },
+        {
+            name: 'method',
+            type: 'string',
+            description: 'Filter by HTTP method, e.g. GET, POST (for network requests)',
+        },
+        {
+            name: 'status-code',
+            type: 'number',
+            description: 'Filter by HTTP status code (for network requests)',
+        },
+        {
+            name: 'type',
+            type: 'string',
+            description: 'Filter by resource type: xhr|fetch|document|script|stylesheet|image (for network requests)',
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -1216,15 +1380,19 @@ const networkCommand = {
                 const pattern = ctx.flags.pattern;
                 if (!pattern)
                     throw new Error('--pattern required for network route');
-                const routes = [{
+                const routes = [
+                    {
                         pattern,
                         action: ctx.flags.abort ? 'abort' : ctx.flags.fulfill ? 'fulfill' : 'continue',
-                        response: ctx.flags.fulfill ? {
-                            status: ctx.flags.status,
-                            body: ctx.flags.fulfill,
-                            headers: ctx.flags.headers ? JSON.parse(ctx.flags.headers) : {},
-                        } : undefined,
-                    }];
+                        response: ctx.flags.fulfill
+                            ? {
+                                status: ctx.flags.status,
+                                body: ctx.flags.fulfill,
+                                headers: ctx.flags.headers ? JSON.parse(ctx.flags.headers) : {},
+                            }
+                            : undefined,
+                    },
+                ];
                 await browser.setupRoutes(client, sessionId, routes);
                 output.printSuccess(`Network route set: ${pattern}`);
                 break;
@@ -1275,7 +1443,8 @@ const networkCommand = {
                 if (filterStatus)
                     reqs = reqs.filter((r) => r.status === filterStatus);
                 if (filterType)
-                    reqs = reqs.filter((r) => r.resourceType === filterType || r.type === filterType);
+                    reqs = reqs.filter((r) => r.resourceType === filterType ||
+                        r.type === filterType);
                 if (ctx.flags.json)
                     print(JSON.stringify({ data: reqs }));
                 else {
@@ -1293,7 +1462,8 @@ const networkCommand = {
                 if (!reqId)
                     throw new Error('Usage: monomind browse network request <requestId>');
                 const reqs = browser.getCapturedRequests(sessionId);
-                const req = reqs.find((r) => r.requestId === reqId || r.id === reqId);
+                const req = reqs.find((r) => r.requestId === reqId ||
+                    r.id === reqId);
                 if (!req) {
                     output.printWarning(`Request not found: ${reqId}`);
                     return { success: false };
@@ -1319,16 +1489,29 @@ const DEFAULT_EVAL_MAX_OUTPUT = 50_000;
 function truncateForOutput(text, maxOutput) {
     if (!(maxOutput > 0) || text.length <= maxOutput)
         return text;
-    return text.slice(0, maxOutput) + `\n[... truncated at ${maxOutput} chars]`;
+    return `${text.slice(0, maxOutput)}\n[... truncated at ${maxOutput} chars]`;
 }
 const evalCommand = {
     name: 'eval',
     description: 'Evaluate JavaScript in page context. Usage: monomind browse eval "document.title"',
     options: [
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
-        { name: 'stdin', type: 'boolean', description: 'Read JS expression from stdin (heredoc-friendly for multiline scripts)', default: false },
-        { name: 'max-output', type: 'number', description: `Truncate printed output to N characters (default ${DEFAULT_EVAL_MAX_OUTPUT}; 0 disables truncation)` },
-        { name: 'timeout', type: 'number', description: 'Max ms to wait for evaluation to settle (default 30000)' },
+        {
+            name: 'stdin',
+            type: 'boolean',
+            description: 'Read JS expression from stdin (heredoc-friendly for multiline scripts)',
+            default: false,
+        },
+        {
+            name: 'max-output',
+            type: 'number',
+            description: `Truncate printed output to N characters (default ${DEFAULT_EVAL_MAX_OUTPUT}; 0 disables truncation)`,
+        },
+        {
+            name: 'timeout',
+            type: 'number',
+            description: 'Max ms to wait for evaluation to settle (default 30000)',
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -1367,19 +1550,25 @@ const closeCommand = {
                 try {
                     await browser.stopHarRecording(client, sid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.getTraceStatus(sid)) {
                 try {
                     await browser.stopTrace(client, sid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.isProfilingActive(sid)) {
                 try {
                     await browser.stopCpuProfile(client, sid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             browser.teardownRouteInterception(sid);
             browser.stopRequestCapture(sid);
@@ -1418,7 +1607,9 @@ const closeCommand = {
                         try {
                             conn.client.close();
                         }
-                        catch { /* already gone */ }
+                        catch {
+                            /* already gone */
+                        }
                     }
                     // closeBrowser has no PID fallback in a fresh process (launchedPids
                     // is per-process) — re-probe so we report what actually happened.
@@ -1428,8 +1619,10 @@ const closeCommand = {
                     const probeDeadline = Date.now() + 3000;
                     while (stillUp && Date.now() < probeDeadline) {
                         try {
-                            await fetch(`http://127.0.0.1:${persisted.port}/json/version`, { signal: AbortSignal.timeout(800) });
-                            await new Promise(r => setTimeout(r, 300));
+                            await fetch(`http://127.0.0.1:${persisted.port}/json/version`, {
+                                signal: AbortSignal.timeout(800),
+                            });
+                            await new Promise((r) => setTimeout(r, 300));
                         }
                         catch {
                             stillUp = false;
@@ -1733,7 +1926,7 @@ const tapCommand = {
             y = Math.round(box.y);
         }
         else {
-            const posJson = await browser.evaluateJs(client, sessionId, `(function(){var el=document.querySelector(${JSON.stringify(arg)});if(!el)return null;var r=el.getBoundingClientRect();return JSON.stringify({x:r.left+r.width/2,y:r.top+r.height/2});})()`);
+            const posJson = (await browser.evaluateJs(client, sessionId, `(function(){var el=document.querySelector(${JSON.stringify(arg)});if(!el)return null;var r=el.getBoundingClientRect();return JSON.stringify({x:r.left+r.width/2,y:r.top+r.height/2});})()`));
             if (!posJson)
                 throw new Error(`Selector not found: ${arg}`);
             const pos = JSON.parse(posJson);
@@ -1750,9 +1943,25 @@ const swipeCommand = {
     name: 'swipe',
     description: 'Swipe gesture (mobile). Usage: monomind browse swipe up|down|left|right [distance] [--x N] [--y N]',
     options: [
-        { name: 'x', type: 'number', description: 'Start X coordinate (default: center)', default: 200 },
-        { name: 'y', type: 'number', description: 'Start Y coordinate (default: center)', default: 400 },
-        { name: 'distance', short: 'd', type: 'number', description: 'Swipe distance in pixels', default: 300 },
+        {
+            name: 'x',
+            type: 'number',
+            description: 'Start X coordinate (default: center)',
+            default: 200,
+        },
+        {
+            name: 'y',
+            type: 'number',
+            description: 'Start Y coordinate (default: center)',
+            default: 400,
+        },
+        {
+            name: 'distance',
+            short: 'd',
+            type: 'number',
+            description: 'Swipe distance in pixels',
+            default: 300,
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -1763,14 +1972,16 @@ const swipeCommand = {
         const startX = ctx.flags.x ?? 200;
         const startY = ctx.flags.y ?? 400;
         const positionalDistance = ctx.args[1] !== undefined ? parseInt(ctx.args[1], 10) : undefined;
-        const distance = (positionalDistance && Number.isFinite(positionalDistance)) ? positionalDistance : ctx.flags.distance ?? 300;
+        const distance = positionalDistance && Number.isFinite(positionalDistance)
+            ? positionalDistance
+            : (ctx.flags.distance ?? 300);
         const dx = direction === 'right' ? distance : direction === 'left' ? -distance : 0;
         const dy = direction === 'down' ? distance : direction === 'up' ? -distance : 0;
         await client.send('Input.dispatchTouchEvent', { type: 'touchStart', touchPoints: [{ x: startX, y: startY }] }, sessionId);
         const steps = 10;
         for (let i = 1; i <= steps; i++) {
-            const x = Math.round(startX + dx * i / steps);
-            const y = Math.round(startY + dy * i / steps);
+            const x = Math.round(startX + (dx * i) / steps);
+            const y = Math.round(startY + (dy * i) / steps);
             await client.send('Input.dispatchTouchEvent', { type: 'touchMove', touchPoints: [{ x, y }] }, sessionId);
             await new Promise((r) => setTimeout(r, 16));
         }
@@ -1835,33 +2046,43 @@ const downloadCommand = {
     name: 'download',
     description: 'Click an element and capture the triggered file download. Usage: monomind browse download @e1 ./output.pdf',
     options: [
-        { name: 'timeout', short: 't', type: 'number', description: 'Max wait for download in ms', default: 30000 },
+        {
+            name: 'timeout',
+            short: 't',
+            type: 'number',
+            description: 'Max wait for download in ms',
+            default: 30000,
+        },
         { name: 'json', type: 'boolean', description: 'Output result as JSON', default: false },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
-        const browser = await getBrowser();
+        const _browser = await getBrowser();
         const refOrSel = ctx.args[0];
         const savePath = ctx.args[1];
         if (!refOrSel || !savePath)
             throw new Error('Usage: monomind browse download @e1|selector <save-path>');
-        const { mkdir } = await import('fs/promises');
-        const { dirname } = await import('path');
-        const { tmpdir } = await import('os');
-        const { join } = await import('path');
+        const { mkdir } = await import('node:fs/promises');
+        const { dirname } = await import('node:path');
+        const { tmpdir } = await import('node:os');
+        const { join } = await import('node:path');
         const downloadDir = join(tmpdir(), `mm-download-${Date.now()}`);
         await mkdir(downloadDir, { recursive: true });
         // Enable Page.downloadWillBegin / Page.downloadProgress events
-        await client.send('Browser.setDownloadBehavior', {
+        await client
+            .send('Browser.setDownloadBehavior', {
             behavior: 'allow',
             downloadPath: downloadDir,
             eventsEnabled: true,
-        }, undefined).catch(() => {
+        }, undefined)
+            .catch(() => {
             // Fallback: older Chrome API (session-scoped)
-            return client.send('Page.setDownloadBehavior', {
+            return client
+                .send('Page.setDownloadBehavior', {
                 behavior: 'allow',
                 downloadPath: downloadDir,
-            }, sessionId).catch(() => { });
+            }, sessionId)
+                .catch(() => { });
         });
         // Track when download completes
         const downloadPromise = new Promise((resolve, reject) => {
@@ -1873,13 +2094,20 @@ const downloadCommand = {
             let offProgress;
             // cleanup defined before setTimeout so the timeout callback can call it
             let timeout;
-            const cleanup = () => { clearTimeout(timeout); offBegin?.(); offProgress?.(); };
-            timeout = setTimeout(() => { cleanup(); reject(new Error('Download timed out')); }, ctx.flags.timeout);
+            const cleanup = () => {
+                clearTimeout(timeout);
+                offBegin?.();
+                offProgress?.();
+            };
+            timeout = setTimeout(() => {
+                cleanup();
+                reject(new Error('Download timed out'));
+            }, ctx.flags.timeout);
             offProgress = client.on('Browser.downloadProgress', async (params) => {
                 if (params.guid === guid && params.state === 'completed') {
                     cleanup();
                     // Find the downloaded file in downloadDir
-                    const { readdir, rename, rmdir } = await import('fs/promises');
+                    const { readdir, rename, rmdir } = await import('node:fs/promises');
                     const files = await readdir(downloadDir);
                     if (files.length > 0) {
                         const src = join(downloadDir, files[0]);
@@ -2071,9 +2299,7 @@ const frameCommand = {
 const tabCommand = {
     name: 'tab',
     description: 'Tab management. Usage: monomind browse tab list|new|close [url]',
-    options: [
-        { name: 'label', type: 'string', description: 'Label for new tab' },
-    ],
+    options: [{ name: 'label', type: 'string', description: 'Label for new tab' }],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
         const browser = await getBrowser();
@@ -2102,19 +2328,25 @@ const tabCommand = {
                         try {
                             await browser.stopHarRecording(client, sid);
                         }
-                        catch { /* ignore */ }
+                        catch {
+                            /* ignore */
+                        }
                     }
                     if (browser.getTraceStatus(sid)) {
                         try {
                             await browser.stopTrace(client, sid);
                         }
-                        catch { /* ignore */ }
+                        catch {
+                            /* ignore */
+                        }
                     }
                     if (browser.isProfilingActive(sid)) {
                         try {
                             await browser.stopCpuProfile(client, sid);
                         }
-                        catch { /* ignore */ }
+                        catch {
+                            /* ignore */
+                        }
                     }
                     browser.teardownRouteInterception(sid);
                     browser.stopRequestCapture(sid);
@@ -2142,19 +2374,25 @@ const tabCommand = {
                     try {
                         await browser.stopHarRecording(client, oldSid);
                     }
-                    catch { /* ignore */ }
+                    catch {
+                        /* ignore */
+                    }
                 }
                 if (browser.getTraceStatus(oldSid)) {
                     try {
                         await browser.stopTrace(client, oldSid);
                     }
-                    catch { /* ignore */ }
+                    catch {
+                        /* ignore */
+                    }
                 }
                 if (browser.isProfilingActive(oldSid)) {
                     try {
                         await browser.stopCpuProfile(client, oldSid);
                     }
-                    catch { /* ignore */ }
+                    catch {
+                        /* ignore */
+                    }
                 }
                 await browser.disableInterception(client, oldSid).catch(() => { });
                 browser.stopRequestCapture(oldSid);
@@ -2192,19 +2430,25 @@ const windowCommand = {
                 try {
                     await browser.stopHarRecording(client, oldSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.getTraceStatus(oldSid)) {
                 try {
                     await browser.stopTrace(client, oldSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.isProfilingActive(oldSid)) {
                 try {
                     await browser.stopCpuProfile(client, oldSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             browser.teardownRouteInterception(oldSid);
             browser.stopRequestCapture(oldSid);
@@ -2366,11 +2610,13 @@ const cookiesCommand = {
                 if (!name || value === undefined) {
                     throw new Error('Usage: monomind browse cookies set <name> <value> [--domain <d>]');
                 }
-                await browser.setCookies(client, sessionId, [{
+                await browser.setCookies(client, sessionId, [
+                    {
                         name,
                         value,
                         domain: ctx.flags.domain,
-                    }]);
+                    },
+                ]);
                 output.printSuccess(`Cookie set: ${name}`);
                 break;
             }
@@ -2406,9 +2652,7 @@ const pdfCommand = {
 const isCommand = {
     name: 'is',
     description: 'Check element state. Usage: monomind browse is visible|enabled|checked @e1',
-    options: [
-        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
-    ],
+    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON', default: false }],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
         const browser = await getBrowser();
@@ -2429,7 +2673,8 @@ const isCommand = {
             case 'checked':
                 result = await browser.isChecked(client, sessionId, ref);
                 break;
-            default: throw new Error(`Unknown check: ${check}. Use: visible|enabled|checked`);
+            default:
+                throw new Error(`Unknown check: ${check}. Use: visible|enabled|checked`);
         }
         if (ctx.flags.json) {
             print(JSON.stringify({ data: { [check]: result } }));
@@ -2467,7 +2712,7 @@ const findCommand = {
         if (locator === 'alttext') {
             // I2: use JS attribute comparison to avoid broken CSS selectors for values with spaces/quotes
             const valJson = JSON.stringify(value);
-            const found = await browser.evaluateJs(client, sessionId, `(function(v){var el=document.querySelector('img[alt]')||null;var all=document.querySelectorAll('[alt]');for(var i=0;i<all.length;i++){if(all[i].getAttribute('alt')===v){all[i].setAttribute('data-mm-located','true');return true;}}return false;})(${valJson})`);
+            const found = (await browser.evaluateJs(client, sessionId, `(function(v){var el=document.querySelector('img[alt]')||null;var all=document.querySelectorAll('[alt]');for(var i=0;i<all.length;i++){if(all[i].getAttribute('alt')===v){all[i].setAttribute('data-mm-located','true');return true;}}return false;})(${valJson})`));
             if (!found) {
                 output.printWarning(`alttext not found: ${value}`);
                 return { success: false };
@@ -2479,7 +2724,7 @@ const findCommand = {
         if (locator === 'title') {
             // I2: use JS attribute comparison to avoid broken CSS selectors for values with spaces/quotes
             const valJson = JSON.stringify(value);
-            const found = await browser.evaluateJs(client, sessionId, `(function(v){var all=document.querySelectorAll('[title]');for(var i=0;i<all.length;i++){if(all[i].getAttribute('title')===v){all[i].setAttribute('data-mm-located','true');return true;}}return false;})(${valJson})`);
+            const found = (await browser.evaluateJs(client, sessionId, `(function(v){var all=document.querySelectorAll('[title]');for(var i=0;i<all.length;i++){if(all[i].getAttribute('title')===v){all[i].setAttribute('data-mm-located','true');return true;}}return false;})(${valJson})`));
             if (!found) {
                 output.printWarning(`title not found: ${value}`);
                 return { success: false };
@@ -2585,7 +2830,13 @@ const diffCommand = {
     name: 'diff',
     description: 'Compare two URLs or snapshots. Usage: monomind browse diff url <url1> <url2> [--interactive] [--json]',
     options: [
-        { name: 'interactive', short: 'i', type: 'boolean', description: 'Snapshot interactive elements only', default: false },
+        {
+            name: 'interactive',
+            short: 'i',
+            type: 'boolean',
+            description: 'Snapshot interactive elements only',
+            default: false,
+        },
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
     ],
     action: async (ctx) => {
@@ -2600,11 +2851,15 @@ const diffCommand = {
             // Capture snapshot at url1
             await browser.openUrl(client, sessionId, url1);
             await browser.waitFor(client, sessionId, { load: 'load', timeout: 15000 });
-            const snap1 = await browser.captureSnapshot(client, sessionId, { interactiveOnly: ctx.flags.interactive });
+            const snap1 = await browser.captureSnapshot(client, sessionId, {
+                interactiveOnly: ctx.flags.interactive,
+            });
             // Capture snapshot at url2
             await browser.openUrl(client, sessionId, url2);
             await browser.waitFor(client, sessionId, { load: 'load', timeout: 15000 });
-            const snap2 = await browser.captureSnapshot(client, sessionId, { interactiveOnly: ctx.flags.interactive });
+            const snap2 = await browser.captureSnapshot(client, sessionId, {
+                interactiveOnly: ctx.flags.interactive,
+            });
             _refs = snap2.refs;
             await browser.saveRefCache(_targetId, snap2.url, _refs);
             // Text diff
@@ -2616,7 +2871,15 @@ const diffCommand = {
             const onlyIn2 = lines2.filter((l) => !set1.has(l));
             const changed = onlyIn1.length > 0 || onlyIn2.length > 0;
             if (ctx.flags.json) {
-                print(JSON.stringify({ changed, url1, url2, onlyIn1, onlyIn2, additions: onlyIn2.length, removals: onlyIn1.length }));
+                print(JSON.stringify({
+                    changed,
+                    url1,
+                    url2,
+                    onlyIn1,
+                    onlyIn2,
+                    additions: onlyIn2.length,
+                    removals: onlyIn1.length,
+                }));
             }
             else {
                 if (!changed) {
@@ -2630,7 +2893,10 @@ const diffCommand = {
                         print(`\x1b[32m+ ${l}\x1b[0m`);
                 }
             }
-            return { success: true, data: { changed, url1, url2, additions: onlyIn2.length, removals: onlyIn1.length } };
+            return {
+                success: true,
+                data: { changed, url1, url2, additions: onlyIn2.length, removals: onlyIn1.length },
+            };
         }
         throw new Error('Usage: monomind browse diff url <url1> <url2>');
     },
@@ -2744,7 +3010,6 @@ export function parseBatchCommandLine(cmdStr) {
             flags[boolFlag[1]] = true;
             rest = rest.slice(boolFlag[0].length);
             consumedAnother = true;
-            continue;
         }
     }
     return { subName: 'eval', subArgs: [rest], flags };
@@ -2803,7 +3068,9 @@ const batchCommand = {
                             parsedFlags[key] = true;
                         }
                     }
-                    else if (subArgs[i].startsWith('-') && subArgs[i].length === 2 && /[a-zA-Z]/.test(subArgs[i][1])) {
+                    else if (subArgs[i].startsWith('-') &&
+                        subArgs[i].length === 2 &&
+                        /[a-zA-Z]/.test(subArgs[i][1])) {
                         consumedIndices.add(i);
                         const shortKey = subArgs[i][1];
                         const optDef = subCmd.options?.find((o) => o.short === shortKey);
@@ -2835,7 +3102,11 @@ const batchCommand = {
                 };
                 const cmdResult = await subCmd.action(fakeCtx);
                 const succeeded = cmdResult?.success !== false;
-                results.push({ command: cmdStr, success: succeeded, error: succeeded ? undefined : 'Command returned failure' });
+                results.push({
+                    command: cmdStr,
+                    success: succeeded,
+                    error: succeeded ? undefined : 'Command returned failure',
+                });
                 if (!succeeded && ctx.flags.bail)
                     break;
             }
@@ -2886,7 +3157,12 @@ const connectCommand = {
     options: [
         { name: 'port', short: 'p', type: 'number', description: 'CDP port', default: 9222 },
         { name: 'target', type: 'string', description: 'Target ID to attach to' },
-        { name: 'auto-connect', type: 'boolean', description: 'Auto-discover running Chrome on ports 9222 and 9229', default: false },
+        {
+            name: 'auto-connect',
+            type: 'boolean',
+            description: 'Auto-discover running Chrome on ports 9222 and 9229',
+            default: false,
+        },
     ],
     action: async (ctx) => {
         let port = ctx.flags.port ?? 9222;
@@ -2902,7 +3178,9 @@ const connectCommand = {
                         break;
                     }
                 }
-                catch { /* port not open */ }
+                catch {
+                    /* port not open */
+                }
             }
             if (!found)
                 throw new Error('No running Chrome instance found. Launch Chrome with --remote-debugging-port or use --port.');
@@ -2915,19 +3193,25 @@ const connectCommand = {
                 try {
                     await browser.stopHarRecording(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.getTraceStatus(prevSid)) {
                 try {
                     await browser.stopTrace(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.isProfilingActive(prevSid)) {
                 try {
                     await browser.stopCpuProfile(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             browser.teardownRouteInterception(prevSid);
             browser.stopRequestCapture(prevSid);
@@ -3030,7 +3314,9 @@ const traceCommand = {
             throw new Error('Usage: monomind browse trace start|stop [path]');
         switch (action) {
             case 'start':
-                await browser.startTrace(client, sessionId, { screenshots: ctx.flags.screenshots });
+                await browser.startTrace(client, sessionId, {
+                    screenshots: ctx.flags.screenshots,
+                });
                 output.printSuccess('Trace started');
                 return { success: true };
             case 'stop': {
@@ -3064,7 +3350,9 @@ const profilerCommand = {
             throw new Error('Usage: monomind browse profiler start|stop|heap [path]');
         switch (action) {
             case 'start':
-                await browser.startCpuProfile(client, sessionId, { samplingInterval: ctx.flags.interval });
+                await browser.startCpuProfile(client, sessionId, {
+                    samplingInterval: ctx.flags.interval,
+                });
                 output.printSuccess('CPU profiler started');
                 return { success: true };
             case 'stop': {
@@ -3155,7 +3443,7 @@ const resizeCommand = {
         const browser = await getBrowser();
         const width = parseInt(ctx.args[0], 10);
         const height = parseInt(ctx.args[1], 10);
-        if (isNaN(width) || isNaN(height))
+        if (Number.isNaN(width) || Number.isNaN(height))
             throw new Error('Usage: monomind browse resize <width> <height>');
         await browser.setViewport(client, sessionId, width, height);
         output.printSuccess(`Resized to ${width}x${height}`);
@@ -3303,7 +3591,10 @@ const browseCommand = {
     ],
     examples: [
         { command: 'monomind browse open https://example.com', description: 'Open a URL' },
-        { command: 'monomind browse snapshot -i', description: 'Interactive-only snapshot (93% token reduction)' },
+        {
+            command: 'monomind browse snapshot -i',
+            description: 'Interactive-only snapshot (93% token reduction)',
+        },
         { command: 'monomind browse click @e3', description: 'Click element by ref' },
         { command: 'monomind browse fill @e1 "user@example.com"', description: 'Fill an input' },
         { command: 'monomind browse press Enter', description: 'Press Enter key' },
@@ -3317,7 +3608,10 @@ const browseCommand = {
         { command: 'monomind browse state save my-session', description: 'Save session state' },
         { command: 'monomind browse navigate back', description: 'Navigate back' },
         { command: 'monomind browse eval "document.title"', description: 'Evaluate JavaScript' },
-        { command: 'monomind browse network route --pattern "https://api.*" --abort', description: 'Abort API calls' },
+        {
+            command: 'monomind browse network route --pattern "https://api.*" --abort',
+            description: 'Abort API calls',
+        },
         { command: 'monomind browse close', description: 'Close browser session' },
     ],
     action: async (_ctx) => {