@monoes/monomindcli 1.10.34 → 1.10.35

package/dist/src/commands/browse.js

@@ -71,6 +71,8 @@ const snapshotCommand = {
         { 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' },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -78,6 +80,8 @@ const snapshotCommand = {
         const result = await browser.captureSnapshot(client, sessionId, {
             interactiveOnly: ctx.flags.interactive,
             compact: ctx.flags.compact,
+            maxDepth: ctx.flags.depth,
+            selector: ctx.flags.selector,
         });
         _refs = result.refs;
         if (ctx.flags.json) {
@@ -158,8 +162,10 @@ const waitCommand = {
     options: [
         { name: 'url', type: 'string', description: 'Wait for URL matching glob pattern' },
         { 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: '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 },
     ],
@@ -171,6 +177,36 @@ const waitCommand = {
             output.printSuccess(`Waited ${ctx.flags.ms}ms`);
             return { success: true };
         }
+        if (ctx.flags.fn) {
+            const expr = ctx.flags.fn;
+            const timeout = ctx.flags.timeout ?? 30000;
+            const interval = 200;
+            const deadline = Date.now() + timeout;
+            while (Date.now() < deadline) {
+                const result = await browser.evaluateJs(client, sessionId, expr);
+                if (result) {
+                    output.printSuccess('Wait function returned truthy');
+                    return { success: true };
+                }
+                await new Promise((r) => setTimeout(r, interval));
+            }
+            throw new Error(`Timeout waiting for --fn: ${expr}`);
+        }
+        if (ctx.flags['not-text']) {
+            const target = ctx.flags['not-text'];
+            const timeout = ctx.flags.timeout ?? 30000;
+            const interval = 200;
+            const deadline = Date.now() + timeout;
+            while (Date.now() < deadline) {
+                const text = await browser.evaluateJs(client, sessionId, 'document.body.innerText');
+                if (!text.includes(target)) {
+                    output.printSuccess('Text disappeared');
+                    return { success: true };
+                }
+                await new Promise((r) => setTimeout(r, interval));
+            }
+            throw new Error(`Timeout waiting for text to disappear: "${target}"`);
+        }
         await browser.waitFor(client, sessionId, {
             url: ctx.flags.url,
             text: ctx.flags.text,
@@ -211,7 +247,7 @@ const screenshotCommand = {
 };
 const getCommand = {
     name: 'get',
-    description: 'Get page info. Usage: monomind browse get url|title|text|html [@ref]',
+    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 },
     ],
@@ -220,7 +256,7 @@ const getCommand = {
         const browser = await getBrowser();
         const what = ctx.args[0];
         if (!what)
-            throw new Error('Usage: monomind browse get url|title|text|html');
+            throw new Error('Usage: monomind browse get url|title|text|html|value|attr|count|box|styles');
         let value;
         switch (what) {
             case 'url':
@@ -254,14 +290,92 @@ const getCommand = {
             case 'html':
                 value = (await browser.evaluateJs(client, sessionId, 'document.documentElement.outerHTML'));
                 break;
+            case 'value': {
+                const refArg = ctx.args[1];
+                if (!refArg)
+                    throw new Error('Usage: monomind browse get value @ref');
+                const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+                const ref = _refs.get(refKey);
+                if (!ref)
+                    throw new Error(`Ref @${refKey} not found`);
+                const objectId = await browser.getObjectIdForRef(client, sessionId, ref);
+                if (!objectId)
+                    throw new Error('Element not in DOM');
+                const r = await client.send('Runtime.callFunctionOn', {
+                    functionDeclaration: 'function() { return this.value ?? null; }',
+                    objectId, returnByValue: true,
+                }, sessionId);
+                value = r.result?.value ?? null;
+                break;
+            }
+            case 'attr': {
+                const refArg = ctx.args[1];
+                const attrName = ctx.args[2];
+                if (!refArg || !attrName)
+                    throw new Error('Usage: monomind browse get attr @ref <attrName>');
+                const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+                const ref = _refs.get(refKey);
+                if (!ref)
+                    throw new Error(`Ref @${refKey} not found`);
+                const objectId = await browser.getObjectIdForRef(client, sessionId, ref);
+                if (!objectId)
+                    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,
+                }, sessionId);
+                value = r.result?.value ?? null;
+                break;
+            }
+            case 'count': {
+                const selector = ctx.args[1];
+                if (!selector)
+                    throw new Error('Usage: monomind browse get count <cssSelector>');
+                value = await browser.evaluateJs(client, sessionId, `document.querySelectorAll(${JSON.stringify(selector)}).length`);
+                break;
+            }
+            case 'box': {
+                const refArg = ctx.args[1];
+                if (!refArg)
+                    throw new Error('Usage: monomind browse get box @ref');
+                const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+                const ref = _refs.get(refKey);
+                if (!ref)
+                    throw new Error(`Ref @${refKey} not found`);
+                value = await browser.getElementBox(client, sessionId, ref);
+                break;
+            }
+            case 'styles': {
+                const refArg = ctx.args[1];
+                if (!refArg)
+                    throw new Error('Usage: monomind browse get styles @ref');
+                const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+                const ref = _refs.get(refKey);
+                if (!ref)
+                    throw new Error(`Ref @${refKey} not found`);
+                const objectId = await browser.getObjectIdForRef(client, sessionId, ref);
+                if (!objectId)
+                    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,
+                }, sessionId);
+                try {
+                    value = JSON.parse(r.result?.value ?? '{}');
+                }
+                catch {
+                    value = {};
+                }
+                break;
+            }
             default:
-                throw new Error(`Unknown: ${what}. Use: url|title|text|html`);
+                throw new Error(`Unknown: ${what}. Use: url|title|text|html|value|attr|count|box|styles`);
         }
         if (ctx.flags.json) {
             print(JSON.stringify({ data: { [what]: value } }));
         }
         else {
-            print(value);
+            print(typeof value === 'object' ? JSON.stringify(value, null, 2) : String(value ?? ''));
         }
         return { success: true, data: { [what]: value } };
     },
@@ -329,10 +443,13 @@ const setCommand = {
             case 'viewport': {
                 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))
-                    throw new Error('Usage: set viewport <width> <height>');
-                await browser.setViewport(client, sessionId, width, height);
-                output.printSuccess(`Viewport set to ${width}x${height}`);
+                    throw new Error('Usage: set viewport <width> <height> [dpr]');
+                await client.send('Emulation.setDeviceMetricsOverride', {
+                    width, height, deviceScaleFactor: dpr ?? 1, mobile: false,
+                }, sessionId);
+                output.printSuccess(`Viewport set to ${width}x${height}${dpr ? ` @${dpr}x` : ''}`);
                 break;
             }
             case 'device': {
@@ -442,8 +559,27 @@ const stateCommand = {
                 output.printSuccess(`State loaded from ${target}`);
                 return { success: true };
             }
+            case 'show': {
+                const { client: c, sessionId: sid } = await ensureConnected(_port);
+                const url = await browser.getCurrentUrl(c, sid);
+                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 };
+                print(JSON.stringify(info, null, 2));
+                return { success: true, data: info };
+            }
+            case 'clear': {
+                const { client: c, sessionId: sid } = await ensureConnected(_port);
+                await browser.clearCookies(c, sid);
+                await browser.clearLocalStorage(c, sid);
+                await browser.clearSessionStorage(c, sid);
+                _refs = new Map();
+                output.printSuccess('Browser state cleared (cookies, localStorage, sessionStorage, refs)');
+                return { success: true };
+            }
             default:
-                throw new Error(`Unknown action: ${action}. Use: save|load|list`);
+                throw new Error(`Unknown action: ${action}. Use: save|load|list|show|clear`);
         }
     },
 };
@@ -456,13 +592,14 @@ const networkCommand = {
         { name: 'fulfill', type: 'string', description: 'JSON response body' },
         { 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 },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
         const browser = await getBrowser();
         const action = ctx.args[0];
         if (!action)
-            throw new Error('Usage: monomind browse network route|cookies|headers');
+            throw new Error('Usage: monomind browse network route|unroute|cookies|headers|requests');
         switch (action) {
             case 'route': {
                 const pattern = ctx.flags.pattern;
@@ -481,6 +618,10 @@ const networkCommand = {
                 output.printSuccess(`Network route set: ${pattern}`);
                 break;
             }
+            case 'unroute':
+                await browser.disableInterception(client, sessionId);
+                output.printSuccess('Network interception disabled');
+                break;
             case 'cookies': {
                 const cookies = await browser.getCookies(client, sessionId);
                 print(JSON.stringify(cookies, null, 2));
@@ -494,8 +635,38 @@ const networkCommand = {
                 output.printSuccess('Extra headers set');
                 break;
             }
+            case 'capture': {
+                const subAction = ctx.args[1] ?? 'start';
+                if (subAction === 'start') {
+                    browser.startRequestCapture(client, sessionId);
+                    output.printSuccess('Request capture started');
+                }
+                else if (subAction === 'stop') {
+                    browser.stopRequestCapture(sessionId);
+                    output.printSuccess('Request capture stopped');
+                }
+                else if (subAction === 'clear') {
+                    browser.clearCapturedRequests(sessionId);
+                    output.printSuccess('Captured requests cleared');
+                }
+                break;
+            }
+            case 'requests': {
+                const reqs = browser.getCapturedRequests(sessionId);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: reqs }));
+                else {
+                    if (reqs.length === 0) {
+                        output.printInfo('No captured requests. Run: network capture start');
+                    }
+                    else
+                        for (const r of reqs)
+                            print(`  ${r.method ?? 'GET'} ${r.status ?? '-'} ${r.url}`);
+                }
+                return { success: true, data: { requests: reqs } };
+            }
             default:
-                throw new Error(`Unknown: ${action}. Use: route|cookies|headers`);
+                throw new Error(`Unknown: ${action}. Use: route|unroute|cookies|headers|capture|requests`);
         }
         return { success: true };
     },
@@ -1148,7 +1319,7 @@ const isCommand = {
 };
 const findCommand = {
     name: 'find',
-    description: 'Find elements by semantic locators. Usage: monomind browse find role|text|label|testid <value> [action]',
+    description: 'Find elements by semantic locators. Usage: monomind browse find role|text|label|placeholder|testid|selector <value> [action]',
     options: [
         { name: 'name', type: 'string', description: 'Filter by accessible name' },
         { name: 'exact', type: 'boolean', description: 'Require exact match', default: false },
@@ -1162,7 +1333,7 @@ const findCommand = {
         const value = ctx.args[1];
         const action = ctx.args[2];
         if (!locator || !value)
-            throw new Error('Usage: monomind browse find role|text|label|testid <value> [action]');
+            throw new Error('Usage: monomind browse find role|text|label|placeholder|testid|selector <value> [action]');
         const opts = {
             name: ctx.flags.name,
             exact: ctx.flags.exact,
@@ -1180,6 +1351,18 @@ const findCommand = {
             case 'label':
                 ref = await browser.findByLabel(client, sessionId, _refs, value, opts);
                 break;
+            case 'placeholder':
+                ref = await browser.findByPlaceholder(client, sessionId, _refs, value, opts);
+                break;
+            case 'selector': {
+                const html = await browser.findBySelector(client, sessionId, value, opts);
+                if (!html) {
+                    output.printWarning(`selector not found: ${value}`);
+                    return { success: false };
+                }
+                output.printSuccess(`Found: ${value}`);
+                return { success: true, data: { html } };
+            }
             case 'testid': {
                 const sel = await browser.findByTestId(client, sessionId, value);
                 if (!sel) {
@@ -1190,7 +1373,7 @@ const findCommand = {
                 return { success: true, data: { selector: sel } };
             }
             default:
-                throw new Error(`Unknown locator: ${locator}. Use: role|text|label|testid`);
+                throw new Error(`Unknown locator: ${locator}. Use: role|text|label|placeholder|testid|selector`);
         }
         if (!ref) {
             output.printWarning(`No element found: ${locator}="${value}"`);
@@ -1361,6 +1544,218 @@ const removeinitscriptCommand = {
         return { success: true };
     },
 };
+const connectCommand = {
+    name: 'connect',
+    description: 'Connect to existing Chrome instance. Usage: monomind browse connect [--port 9222] [--target <id>]',
+    options: [
+        { name: 'port', short: 'p', type: 'number', description: 'CDP port', default: 9222 },
+        { name: 'target', type: 'string', description: 'Target ID to attach to' },
+    ],
+    action: async (ctx) => {
+        const port = ctx.flags.port ?? 9222;
+        const browser = await getBrowser();
+        const conn = await browser.connectToTarget(port, ctx.flags.target);
+        _client = conn.client;
+        _sessionId = conn.sessionId;
+        _targetId = conn.target.id;
+        _port = port;
+        _refs = new Map();
+        const url = await browser.getCurrentUrl(_client, _sessionId);
+        const title = await browser.getCurrentTitle(_client, _sessionId);
+        output.printSuccess(`Connected: ${title} (${url})`);
+        return { success: true, data: { targetId: _targetId, url, title } };
+    },
+};
+const recordCommand = {
+    name: 'record',
+    description: 'Screen recording. Usage: monomind browse record start|stop|status [path]',
+    options: [
+        { name: 'format', type: 'string', description: 'jpeg|png', default: 'jpeg' },
+        { name: 'quality', type: 'number', description: 'Quality 0-100', default: 80 },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        if (!action)
+            throw new Error('Usage: monomind browse record start|stop|status');
+        switch (action) {
+            case 'start':
+                await browser.startRecording(client, sessionId, {
+                    format: ctx.flags.format,
+                    quality: ctx.flags.quality,
+                });
+                output.printSuccess('Recording started');
+                return { success: true };
+            case 'stop': {
+                const path = await browser.stopRecording(client, sessionId, ctx.args[1]);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: { path } }));
+                else
+                    output.printSuccess(`Recording saved: ${path}`);
+                return { success: true, data: { path } };
+            }
+            case 'status': {
+                const status = browser.getRecordingStatus(sessionId);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: status }));
+                else
+                    print(`Recording: ${status.recording} | Frames: ${status.frames}`);
+                return { success: true, data: status };
+            }
+            default:
+                throw new Error('Usage: monomind browse record start|stop|status [path]');
+        }
+    },
+};
+const traceCommand = {
+    name: 'trace',
+    description: 'CDP performance trace. Usage: monomind browse trace start|stop [path]',
+    options: [
+        { name: 'screenshots', type: 'boolean', description: 'Include screenshots', default: false },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        if (!action)
+            throw new Error('Usage: monomind browse trace start|stop [path]');
+        switch (action) {
+            case 'start':
+                await browser.startTrace(client, sessionId, { screenshots: ctx.flags.screenshots });
+                output.printSuccess('Trace started');
+                return { success: true };
+            case 'stop': {
+                const path = await browser.stopTrace(client, sessionId, ctx.args[1]);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: { path } }));
+                else
+                    output.printSuccess(`Trace saved: ${path}`);
+                return { success: true, data: { path } };
+            }
+            case 'status':
+                print(browser.getTraceStatus(sessionId) ? 'Tracing active' : 'Not tracing');
+                return { success: true };
+            default:
+                throw new Error('Usage: monomind browse trace start|stop|status [path]');
+        }
+    },
+};
+const profilerCommand = {
+    name: 'profiler',
+    description: 'CPU profiler. Usage: monomind browse profiler start|stop|heap [path]',
+    options: [
+        { name: 'interval', type: 'number', description: 'Sampling interval µs', default: 1000 },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        if (!action)
+            throw new Error('Usage: monomind browse profiler start|stop|heap [path]');
+        switch (action) {
+            case 'start':
+                await browser.startCpuProfile(client, sessionId, { samplingInterval: ctx.flags.interval });
+                output.printSuccess('CPU profiler started');
+                return { success: true };
+            case 'stop': {
+                const path = await browser.stopCpuProfile(client, sessionId, ctx.args[1]);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: { path } }));
+                else
+                    output.printSuccess(`Profile saved: ${path}`);
+                return { success: true, data: { path } };
+            }
+            case 'heap': {
+                const path = await browser.startHeapSnapshot(client, sessionId, ctx.args[1]);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: { path } }));
+                else
+                    output.printSuccess(`Heap snapshot saved: ${path}`);
+                return { success: true, data: { path } };
+            }
+            default:
+                throw new Error('Usage: monomind browse profiler start|stop|heap [path]');
+        }
+    },
+};
+const vitalsCommand = {
+    name: 'vitals',
+    description: 'Collect Core Web Vitals. Usage: monomind browse vitals [--wait 2000]',
+    options: [
+        { name: 'wait', type: 'number', description: 'Wait ms for observers', default: 2000 },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const vitals = await browser.collectVitals(client, sessionId, ctx.flags.wait);
+        if (ctx.flags.json) {
+            print(JSON.stringify({ data: vitals }));
+        }
+        else {
+            print(browser.formatVitals(vitals));
+        }
+        return { success: true, data: vitals };
+    },
+};
+const harCommand = {
+    name: 'har',
+    description: 'HAR network recording. Usage: monomind browse har start|stop|status [path]',
+    options: [
+        { name: 'bodies', type: 'boolean', description: 'Capture response bodies', default: false },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        if (!action)
+            throw new Error('Usage: monomind browse har start|stop|status [path]');
+        switch (action) {
+            case 'start':
+                await browser.startHarRecording(client, sessionId);
+                output.printSuccess('HAR recording started');
+                return { success: true };
+            case 'stop': {
+                const path = await browser.stopHarRecording(client, sessionId, ctx.args[1], ctx.flags.bodies);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: { path } }));
+                else
+                    output.printSuccess(`HAR saved: ${path}`);
+                return { success: true, data: { path } };
+            }
+            case 'status': {
+                const status = browser.getHarStatus(sessionId);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: status }));
+                else
+                    print(`Recording: ${status.recording} | Requests: ${status.requestCount}`);
+                return { success: true, data: status };
+            }
+            default:
+                throw new Error('Usage: monomind browse har start|stop|status [path]');
+        }
+    },
+};
+const resizeCommand = {
+    name: 'resize',
+    description: 'Resize browser window. Usage: monomind browse resize <width> <height>',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const width = parseInt(ctx.args[0], 10);
+        const height = parseInt(ctx.args[1], 10);
+        if (isNaN(width) || 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}`);
+        return { success: true, data: { width, height } };
+    },
+};
 // ---------------------------------------------------------------------------
 // Root browse command
 // ---------------------------------------------------------------------------
@@ -1412,6 +1807,13 @@ const browseCommand = {
         batchCommand,
         addinitscriptCommand,
         removeinitscriptCommand,
+        connectCommand,
+        recordCommand,
+        traceCommand,
+        profilerCommand,
+        vitalsCommand,
+        harCommand,
+        resizeCommand,
         closeCommand,
     ],
     options: [