@monoes/monomindcli 1.10.30 → 1.10.31

package/dist/src/commands/browse.js

@@ -318,13 +318,13 @@ const navigateCommand = {
 };
 const setCommand = {
     name: 'set',
-    description: 'Configure browser settings. Usage: monomind browse set viewport 375 812',
+    description: 'Configure browser settings. Usage: monomind browse set viewport|device|geo|offline|media|credentials|useragent <args>',
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
         const browser = await getBrowser();
         const setting = ctx.args[0];
         if (!setting)
-            throw new Error('Usage: monomind browse set viewport <width> <height>');
+            throw new Error('Usage: monomind browse set viewport|device|geo|offline|media|credentials|useragent <args>');
         switch (setting) {
             case 'viewport': {
                 const width = parseInt(ctx.args[1], 10);
@@ -335,6 +335,47 @@ const setCommand = {
                 output.printSuccess(`Viewport set to ${width}x${height}`);
                 break;
             }
+            case 'device': {
+                const deviceName = ctx.args[1];
+                if (!deviceName)
+                    throw new Error(`Usage: set device <name>. Available: ${browser.listDevices().join(', ')}`);
+                await browser.emulateDevice(client, sessionId, deviceName);
+                output.printSuccess(`Emulating device: ${deviceName}`);
+                break;
+            }
+            case 'geo': {
+                const lat = parseFloat(ctx.args[1]);
+                const lon = parseFloat(ctx.args[2]);
+                const acc = parseFloat(ctx.args[3]) || 100;
+                if (isNaN(lat) || 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}`);
+                break;
+            }
+            case 'offline': {
+                const enabled = ctx.args[1] !== 'false';
+                await browser.setOfflineMode(client, sessionId, enabled);
+                output.printSuccess(`Offline mode: ${enabled}`);
+                break;
+            }
+            case 'media': {
+                const scheme = ctx.args[1];
+                if (!scheme)
+                    throw new Error('Usage: set media dark|light|no-preference');
+                await browser.setColorScheme(client, sessionId, scheme);
+                output.printSuccess(`Color scheme: ${scheme}`);
+                break;
+            }
+            case 'credentials': {
+                const username = ctx.args[1];
+                const password = ctx.args[2];
+                if (!username || !password)
+                    throw new Error('Usage: set credentials <username> <password>');
+                await browser.setBasicAuth(client, sessionId, username, password);
+                output.printSuccess('Basic auth credentials set');
+                break;
+            }
             case 'useragent': {
                 const ua = ctx.args[1];
                 if (!ua)
@@ -344,7 +385,7 @@ const setCommand = {
                 break;
             }
             default:
-                throw new Error(`Unknown setting: ${setting}. Use: viewport|useragent`);
+                throw new Error(`Unknown setting: ${setting}. Use: viewport|device|geo|offline|media|credentials|useragent`);
         }
         return { success: true };
     },
@@ -500,6 +541,826 @@ const closeCommand = {
     },
 };
 // ---------------------------------------------------------------------------
+// Additional subcommands
+// ---------------------------------------------------------------------------
+const dblclickCommand = {
+    name: 'dblclick',
+    description: 'Double-click an element. Usage: monomind browse dblclick @e1',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const refArg = ctx.args[0];
+        if (!refArg)
+            throw new Error('Usage: monomind browse dblclick @e1');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        await browser.clickElement(client, sessionId, ref, { clickCount: 2 });
+        output.printSuccess(`Double-clicked: ${ref.role} "${ref.name}"`);
+        return { success: true };
+    },
+};
+const focusCommand = {
+    name: 'focus',
+    description: 'Focus an element. Usage: monomind browse focus @e1',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const refArg = ctx.args[0];
+        if (!refArg)
+            throw new Error('Usage: monomind browse focus @e1');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        await browser.focusElement(client, sessionId, ref);
+        output.printSuccess(`Focused: ${ref.role} "${ref.name}"`);
+        return { success: true };
+    },
+};
+const typeCommand = {
+    name: 'type',
+    description: 'Type text into element (appends, does not clear). Usage: monomind browse type @e1 "text"',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const refArg = ctx.args[0];
+        const value = ctx.args[1];
+        if (!refArg || value === undefined)
+            throw new Error('Usage: monomind browse type @e1 "value"');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        await browser.typeIntoElement(client, sessionId, ref, value);
+        output.printSuccess(`Typed into: ${ref.role} "${ref.name}"`);
+        return { success: true };
+    },
+};
+const keyboardCommand = {
+    name: 'keyboard',
+    description: 'Keyboard commands. Usage: monomind browse keyboard type "text" | inserttext "text"',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        const text = ctx.args[1];
+        if (!action || !text)
+            throw new Error('Usage: monomind browse keyboard type|inserttext "text"');
+        await browser.typeText(client, sessionId, text);
+        output.printSuccess(`Keyboard ${action}: ${text.length} chars`);
+        return { success: true };
+    },
+};
+const keydownCommand = {
+    name: 'keydown',
+    description: 'Hold key down. Usage: monomind browse keydown Shift',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const key = ctx.args[0];
+        if (!key)
+            throw new Error('Usage: monomind browse keydown <key>');
+        await browser.keyDown(client, sessionId, key);
+        output.printSuccess(`Key down: ${key}`);
+        return { success: true };
+    },
+};
+const keyupCommand = {
+    name: 'keyup',
+    description: 'Release held key. Usage: monomind browse keyup Shift',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const key = ctx.args[0];
+        if (!key)
+            throw new Error('Usage: monomind browse keyup <key>');
+        await browser.keyUp(client, sessionId, key);
+        output.printSuccess(`Key up: ${key}`);
+        return { success: true };
+    },
+};
+const hoverCommand = {
+    name: 'hover',
+    description: 'Hover over an element. Usage: monomind browse hover @e1',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const refArg = ctx.args[0];
+        if (!refArg)
+            throw new Error('Usage: monomind browse hover @e1');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        await browser.hoverElement(client, sessionId, ref);
+        output.printSuccess(`Hovered: ${ref.role} "${ref.name}"`);
+        return { success: true };
+    },
+};
+const selectCommand = {
+    name: 'select',
+    description: 'Select a dropdown option. Usage: monomind browse select @e1 "Option text"',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const refArg = ctx.args[0];
+        const value = ctx.args[1];
+        if (!refArg || !value)
+            throw new Error('Usage: monomind browse select @e1 "value"');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        await browser.selectOption(client, sessionId, ref, value);
+        output.printSuccess(`Selected: "${value}"`);
+        return { success: true };
+    },
+};
+const checkCommand = {
+    name: 'check',
+    description: 'Check a checkbox. Usage: monomind browse check @e1',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const refArg = ctx.args[0];
+        if (!refArg)
+            throw new Error('Usage: monomind browse check @e1');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        await browser.checkElement(client, sessionId, ref, true);
+        output.printSuccess(`Checked: ${ref.role} "${ref.name}"`);
+        return { success: true };
+    },
+};
+const uncheckCommand = {
+    name: 'uncheck',
+    description: 'Uncheck a checkbox. Usage: monomind browse uncheck @e1',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const refArg = ctx.args[0];
+        if (!refArg)
+            throw new Error('Usage: monomind browse uncheck @e1');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        await browser.checkElement(client, sessionId, ref, false);
+        output.printSuccess(`Unchecked: ${ref.role} "${ref.name}"`);
+        return { success: true };
+    },
+};
+const scrollIntoViewCommand = {
+    name: 'scrollintoview',
+    description: 'Scroll element into view. Usage: monomind browse scrollintoview @e1',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const refArg = ctx.args[0];
+        if (!refArg)
+            throw new Error('Usage: monomind browse scrollintoview @e1');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        await browser.scrollIntoView(client, sessionId, ref);
+        output.printSuccess(`Scrolled into view: ${ref.role} "${ref.name}"`);
+        return { success: true };
+    },
+};
+const dragCommand = {
+    name: 'drag',
+    description: 'Drag element to another element. Usage: monomind browse drag @e1 @e2',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const srcArg = ctx.args[0];
+        const tgtArg = ctx.args[1];
+        if (!srcArg || !tgtArg)
+            throw new Error('Usage: monomind browse drag @e1 @e2');
+        const srcKey = srcArg.startsWith('@') ? srcArg.slice(1) : srcArg;
+        const tgtKey = tgtArg.startsWith('@') ? tgtArg.slice(1) : tgtArg;
+        const src = await browser.resolveRef(client, sessionId, _refs, srcKey);
+        const tgt = await browser.resolveRef(client, sessionId, _refs, tgtKey);
+        await browser.dragAndDrop(client, sessionId, src, tgt);
+        output.printSuccess(`Dragged @${srcKey} to @${tgtKey}`);
+        return { success: true };
+    },
+};
+const uploadCommand = {
+    name: 'upload',
+    description: 'Upload files to a file input. Usage: monomind browse upload @e1 ./file.pdf',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const refArg = ctx.args[0];
+        const files = ctx.args.slice(1);
+        if (!refArg || files.length === 0)
+            throw new Error('Usage: monomind browse upload @e1 <file1> [file2...]');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        await browser.uploadFile(client, sessionId, ref, files);
+        output.printSuccess(`Uploaded ${files.length} file(s) to @${refKey}`);
+        return { success: true };
+    },
+};
+const mouseCommand = {
+    name: 'mouse',
+    description: 'Fine-grained mouse control. Usage: monomind browse mouse move|down|up|wheel <args>',
+    options: [
+        { name: 'button', type: 'string', description: 'Button: left|right|middle', default: 'left' },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        switch (action) {
+            case 'move': {
+                const x = parseFloat(ctx.args[1]);
+                const y = parseFloat(ctx.args[2]);
+                await browser.mouseMove(client, sessionId, x, y);
+                output.printSuccess(`Mouse moved to (${x}, ${y})`);
+                break;
+            }
+            case 'down': {
+                const x = parseFloat(ctx.args[1]) || 0;
+                const y = parseFloat(ctx.args[2]) || 0;
+                const button = ctx.flags.button ?? 'left';
+                await browser.mouseDown(client, sessionId, x, y, button);
+                output.printSuccess(`Mouse down at (${x}, ${y})`);
+                break;
+            }
+            case 'up': {
+                const x = parseFloat(ctx.args[1]) || 0;
+                const y = parseFloat(ctx.args[2]) || 0;
+                const button = ctx.flags.button ?? 'left';
+                await browser.mouseUp(client, sessionId, x, y, button);
+                output.printSuccess(`Mouse up at (${x}, ${y})`);
+                break;
+            }
+            case 'wheel': {
+                const x = parseFloat(ctx.args[1]) || 0;
+                const y = parseFloat(ctx.args[2]) || 0;
+                const dy = parseFloat(ctx.args[3]) || 0;
+                const dx = parseFloat(ctx.args[4]) || 0;
+                await browser.mouseWheel(client, sessionId, x, y, dy, dx);
+                output.printSuccess(`Mouse wheel (${dx}, ${dy})`);
+                break;
+            }
+            default:
+                throw new Error('Usage: monomind browse mouse move|down|up|wheel <args>');
+        }
+        return { success: true };
+    },
+};
+const clipboardCommand = {
+    name: 'clipboard',
+    description: 'Clipboard operations. Usage: monomind browse clipboard read|write|copy|paste',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        switch (action) {
+            case 'read': {
+                const text = await browser.readClipboard(client, sessionId);
+                print(text);
+                return { success: true, data: { text } };
+            }
+            case 'write': {
+                const text = ctx.args[1];
+                if (!text)
+                    throw new Error('Usage: monomind browse clipboard write "text"');
+                await browser.writeClipboard(client, sessionId, text);
+                output.printSuccess('Clipboard written');
+                break;
+            }
+            case 'copy':
+                await browser.pressKey(client, sessionId, 'c');
+                output.printSuccess('Copy sent (Ctrl+C equivalent)');
+                break;
+            case 'paste':
+                await browser.pressKey(client, sessionId, 'v');
+                output.printSuccess('Paste sent (Ctrl+V equivalent)');
+                break;
+            default:
+                throw new Error('Usage: monomind browse clipboard read|write|copy|paste');
+        }
+        return { success: true };
+    },
+};
+const dialogCommand = {
+    name: 'dialog',
+    description: 'Handle browser dialogs. Usage: monomind browse dialog accept|dismiss|status',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        switch (action) {
+            case 'accept': {
+                const text = ctx.args[1];
+                await browser.acceptDialog(client, sessionId, text);
+                output.printSuccess('Dialog accepted');
+                break;
+            }
+            case 'dismiss':
+                await browser.dismissDialog(client, sessionId);
+                output.printSuccess('Dialog dismissed');
+                break;
+            case 'status': {
+                const info = browser.getDialogStatus();
+                if (info) {
+                    print(`Dialog open: type=${info.type} message="${info.message}"`);
+                }
+                else {
+                    print('No dialog open');
+                }
+                return { success: true, data: { dialog: info } };
+            }
+            default:
+                throw new Error('Usage: monomind browse dialog accept|dismiss|status');
+        }
+        return { success: true };
+    },
+};
+const frameCommand = {
+    name: 'frame',
+    description: 'Switch to iframe or back to main. Usage: monomind browse frame "#frame-id" | frame main',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const target = ctx.args[0];
+        if (!target)
+            throw new Error('Usage: monomind browse frame <selector>|main');
+        if (target === 'main') {
+            output.printSuccess('Switched to main frame');
+        }
+        else {
+            const frameSrc = await browser.switchToFrame(client, sessionId, target);
+            output.printSuccess(`Switched to frame: ${frameSrc ?? target}`);
+        }
+        return { success: true };
+    },
+};
+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' },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        switch (action ?? 'list') {
+            case 'list': {
+                const tabs = await browser.listTabs(_port);
+                for (const t of tabs)
+                    print(`  ${t.id}: ${t.title} (${t.url})`);
+                return { success: true, data: { tabs } };
+            }
+            case 'new': {
+                const url = ctx.args[1];
+                const tab = await browser.newTab(_port, url);
+                output.printSuccess(`New tab: ${tab.id} ${url ?? ''}`);
+                return { success: true, data: { tab } };
+            }
+            case 'close': {
+                const tabId = ctx.args[1];
+                if (!tabId)
+                    throw new Error('Usage: monomind browse tab close <tabId>');
+                await browser.closeTab(client, sessionId, tabId);
+                output.printSuccess(`Closed tab: ${tabId}`);
+                break;
+            }
+            default: {
+                // Try to treat arg as tab ID to switch to
+                await browser.activateTab(client, sessionId, action);
+                output.printSuccess(`Switched to tab: ${action}`);
+            }
+        }
+        return { success: true };
+    },
+};
+const consoleLogCommand = {
+    name: 'console',
+    description: 'View captured console messages. Usage: monomind browse console [--clear] [--json]',
+    options: [
+        { name: 'clear', type: 'boolean', description: 'Clear console messages', default: false },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+        { name: 'errors-only', type: 'boolean', description: 'Show only errors', default: false },
+    ],
+    action: async (ctx) => {
+        const browser = await getBrowser();
+        if (ctx.flags.clear) {
+            browser.clearConsoleMessages();
+            output.printSuccess('Console cleared');
+            return { success: true };
+        }
+        const msgs = browser.getConsoleMessages();
+        if (ctx.flags.json) {
+            print(JSON.stringify(msgs));
+        }
+        else {
+            for (const m of msgs) {
+                const prefix = m.type === 'error' ? '[ERROR]' : m.type === 'warn' ? '[WARN]' : '[LOG]';
+                print(`${prefix} ${m.text}`);
+            }
+        }
+        return { success: true, data: { messages: msgs } };
+    },
+};
+const errorsCommand = {
+    name: 'errors',
+    description: 'View page errors (uncaught JS exceptions). Usage: monomind browse errors [--clear]',
+    options: [
+        { name: 'clear', type: 'boolean', description: 'Clear errors', default: false },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const browser = await getBrowser();
+        if (ctx.flags.clear) {
+            browser.clearPageErrors();
+            output.printSuccess('Errors cleared');
+            return { success: true };
+        }
+        const errs = browser.getPageErrors();
+        if (ctx.flags.json) {
+            print(JSON.stringify(errs));
+        }
+        else if (errs.length === 0) {
+            output.printSuccess('No page errors');
+        }
+        else {
+            for (const e of errs)
+                print(`[ERROR] ${e.text} (${e.url}:${e.lineNumber})`);
+        }
+        return { success: true, data: { errors: errs } };
+    },
+};
+const storageCommand = {
+    name: 'storage',
+    description: 'localStorage/sessionStorage management. Usage: monomind browse storage local|session [key] [--set val] [--clear]',
+    options: [
+        { name: 'set', type: 'string', description: 'Value to set for key' },
+        { name: 'clear', type: 'boolean', description: 'Clear all storage', default: false },
+        { name: 'remove', type: 'boolean', description: 'Remove a specific key', 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 storageType = ctx.args[0];
+        const key = ctx.args[1];
+        if (!storageType)
+            throw new Error('Usage: monomind browse storage local|session [key]');
+        const isLocal = storageType === 'local';
+        if (ctx.flags.clear) {
+            if (isLocal)
+                await browser.clearLocalStorage(client, sessionId);
+            else
+                await browser.clearSessionStorage(client, sessionId);
+            output.printSuccess(`${storageType}Storage cleared`);
+            return { success: true };
+        }
+        if (key && ctx.flags.set !== undefined) {
+            if (isLocal)
+                await browser.setLocalStorageKey(client, sessionId, key, ctx.flags.set);
+            else
+                await browser.setSessionStorageKey(client, sessionId, key, ctx.flags.set);
+            output.printSuccess(`Set ${key}`);
+            return { success: true };
+        }
+        if (key && ctx.flags.remove) {
+            if (isLocal)
+                await browser.removeLocalStorageKey(client, sessionId, key);
+            output.printSuccess(`Removed ${key}`);
+            return { success: true };
+        }
+        if (key) {
+            const val = isLocal
+                ? await browser.getLocalStorageKey(client, sessionId, key)
+                : await browser.getSessionStorageKey(client, sessionId, key);
+            if (ctx.flags.json)
+                print(JSON.stringify({ data: val }));
+            else
+                print(val ?? '(null)');
+            return { success: true, data: { value: val } };
+        }
+        const all = isLocal
+            ? await browser.getAllLocalStorage(client, sessionId)
+            : await browser.getAllSessionStorage(client, sessionId);
+        if (ctx.flags.json)
+            print(JSON.stringify(all));
+        else {
+            for (const [k, v] of Object.entries(all))
+                print(`  ${k}: ${v}`);
+        }
+        return { success: true, data: { storage: all } };
+    },
+};
+const cookiesCommand = {
+    name: 'cookies',
+    description: 'Cookie management. Usage: monomind browse cookies [list|set|clear]',
+    options: [
+        { name: 'name', type: 'string', description: 'Cookie name' },
+        { name: 'value', type: 'string', description: 'Cookie value' },
+        { name: 'domain', type: 'string', description: 'Cookie domain' },
+        { name: 'curl', type: 'string', description: 'Import cookies from cURL dump file' },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0] ?? 'list';
+        switch (action) {
+            case 'list': {
+                const cookies = await browser.getCookies(client, sessionId);
+                print(JSON.stringify(cookies, null, 2));
+                return { success: true, data: { cookies } };
+            }
+            case 'set': {
+                if (ctx.flags.name && ctx.flags.value) {
+                    await browser.setCookies(client, sessionId, [{
+                            name: ctx.flags.name,
+                            value: ctx.flags.value,
+                            domain: ctx.flags.domain,
+                        }]);
+                    output.printSuccess(`Cookie set: ${ctx.flags.name}`);
+                }
+                else {
+                    throw new Error('Usage: monomind browse cookies set --name <n> --value <v>');
+                }
+                break;
+            }
+            case 'clear':
+                await browser.clearCookies(client, sessionId);
+                output.printSuccess('Cookies cleared');
+                break;
+            default:
+                throw new Error('Usage: monomind browse cookies list|set|clear');
+        }
+        return { success: true };
+    },
+};
+const pdfCommand = {
+    name: 'pdf',
+    description: 'Save page as PDF. Usage: monomind browse pdf [path]',
+    options: [
+        { name: 'landscape', type: 'boolean', description: 'Landscape orientation', default: false },
+        { name: 'background', type: 'boolean', description: 'Print background', default: true },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const path = await browser.capturePdf(client, sessionId, {
+            path: ctx.args[0],
+            landscape: ctx.flags.landscape,
+            printBackground: ctx.flags.background,
+        });
+        output.printSuccess(`PDF saved: ${path}`);
+        return { success: true, data: { path } };
+    },
+};
+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 },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const check = ctx.args[0];
+        const refArg = ctx.args[1];
+        if (!check || !refArg)
+            throw new Error('Usage: monomind browse is visible|enabled|checked @e1');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        let result;
+        switch (check) {
+            case 'visible':
+                result = await browser.isVisible(client, sessionId, ref);
+                break;
+            case 'enabled':
+                result = await browser.isEnabled(client, sessionId, ref);
+                break;
+            case 'checked':
+                result = await browser.isChecked(client, sessionId, ref);
+                break;
+            default: throw new Error(`Unknown check: ${check}. Use: visible|enabled|checked`);
+        }
+        if (ctx.flags.json) {
+            print(JSON.stringify({ data: { [check]: result } }));
+        }
+        else {
+            print(result ? 'true' : 'false');
+        }
+        return { success: true, data: { [check]: result } };
+    },
+};
+const findCommand = {
+    name: 'find',
+    description: 'Find elements by semantic locators. Usage: monomind browse find role|text|label|testid <value> [action]',
+    options: [
+        { name: 'name', type: 'string', description: 'Filter by accessible name' },
+        { name: 'exact', type: 'boolean', description: 'Require exact match', default: false },
+        { name: 'nth', type: 'number', description: 'Find nth match' },
+        { name: 'last', type: 'boolean', description: 'Find last match', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const locator = ctx.args[0];
+        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]');
+        const opts = {
+            name: ctx.flags.name,
+            exact: ctx.flags.exact,
+            nth: ctx.flags.nth,
+            last: ctx.flags.last,
+        };
+        let ref = null;
+        switch (locator) {
+            case 'role':
+                ref = await browser.findByRole(client, sessionId, _refs, value, opts);
+                break;
+            case 'text':
+                ref = await browser.findByText(client, sessionId, _refs, value, opts);
+                break;
+            case 'label':
+                ref = await browser.findByLabel(client, sessionId, _refs, value, opts);
+                break;
+            case 'testid': {
+                const sel = await browser.findByTestId(client, sessionId, value);
+                if (!sel) {
+                    output.printWarning(`testid not found: ${value}`);
+                    return { success: false };
+                }
+                output.printSuccess(`Found testid selector: ${sel}`);
+                return { success: true, data: { selector: sel } };
+            }
+            default:
+                throw new Error(`Unknown locator: ${locator}. Use: role|text|label|testid`);
+        }
+        if (!ref) {
+            output.printWarning(`No element found: ${locator}="${value}"`);
+            return { success: false };
+        }
+        output.printSuccess(`Found: ${ref.role} "${ref.name}" [@${ref.ref}]`);
+        if (action) {
+            switch (action) {
+                case 'click':
+                    await browser.clickElement(client, sessionId, ref);
+                    break;
+                case 'fill': {
+                    const fillValue = ctx.args[3];
+                    await browser.fillElement(client, sessionId, ref, fillValue ?? '');
+                    break;
+                }
+                case 'type': {
+                    const typeValue = ctx.args[3];
+                    await browser.typeIntoElement(client, sessionId, ref, typeValue ?? '');
+                    break;
+                }
+                case 'hover':
+                    await browser.hoverElement(client, sessionId, ref);
+                    break;
+                case 'focus':
+                    await browser.focusElement(client, sessionId, ref);
+                    break;
+                case 'check':
+                    await browser.checkElement(client, sessionId, ref, true);
+                    break;
+                case 'uncheck':
+                    await browser.checkElement(client, sessionId, ref, false);
+                    break;
+                case 'text': {
+                    const objectId = await browser.getObjectIdForRef(client, sessionId, ref);
+                    if (objectId) {
+                        const r = await client.send('Runtime.callFunctionOn', {
+                            functionDeclaration: 'function() { return this.innerText || this.textContent || ""; }',
+                            objectId,
+                            returnByValue: true,
+                        }, sessionId);
+                        print(r.result?.value ?? '');
+                    }
+                    break;
+                }
+            }
+        }
+        return { success: true, data: { ref } };
+    },
+};
+const highlightCommand = {
+    name: 'highlight',
+    description: 'Highlight an element for 2 seconds. Usage: monomind browse highlight @e1',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const refArg = ctx.args[0];
+        if (!refArg)
+            throw new Error('Usage: monomind browse highlight @e1');
+        const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+        const ref = await browser.resolveRef(client, sessionId, _refs, refKey);
+        await browser.highlightElement(client, sessionId, ref);
+        output.printSuccess(`Highlighted: ${ref.role} "${ref.name}"`);
+        return { success: true };
+    },
+};
+const pushstateCommand = {
+    name: 'pushstate',
+    description: 'SPA navigation via pushState. Usage: monomind browse pushstate /path',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const url = ctx.args[0];
+        if (!url)
+            throw new Error('Usage: monomind browse pushstate <url>');
+        await browser.pushState(client, sessionId, url);
+        output.printSuccess(`pushState: ${url}`);
+        return { success: true };
+    },
+};
+const batchCommand = {
+    name: 'batch',
+    description: 'Execute multiple commands. Usage: monomind browse batch "open url" "snapshot -i" "click @e1"',
+    options: [
+        { name: 'bail', type: 'boolean', description: 'Stop on first error', default: false },
+        { name: 'json', type: 'boolean', description: 'Input from JSON stdin', default: false },
+    ],
+    action: async (ctx) => {
+        const commands = ctx.args;
+        if (commands.length === 0)
+            throw new Error('Usage: monomind browse batch "cmd1" "cmd2" ...');
+        const results = [];
+        for (const cmdStr of commands) {
+            const parts = cmdStr.trim().split(/\s+/);
+            const subName = parts[0];
+            const subArgs = parts.slice(1);
+            const subCmd = browseCommand.subcommands?.find((s) => s.name === subName);
+            if (!subCmd?.action) {
+                const err = `Unknown command: ${subName}`;
+                results.push({ command: cmdStr, success: false, error: err });
+                if (ctx.flags.bail)
+                    break;
+                continue;
+            }
+            try {
+                const parsedFlags = { _: [] };
+                // Parse --flags from subArgs
+                for (let i = 0; i < subArgs.length; i++) {
+                    if (subArgs[i].startsWith('--')) {
+                        const key = subArgs[i].slice(2);
+                        const next = subArgs[i + 1];
+                        if (next && !next.startsWith('--')) {
+                            parsedFlags[key] = next;
+                            i++;
+                        }
+                        else {
+                            parsedFlags[key] = true;
+                        }
+                    }
+                }
+                const fakeCtx = {
+                    args: subArgs.filter((a) => !a.startsWith('--')),
+                    flags: parsedFlags,
+                    cwd: ctx.cwd,
+                    interactive: false,
+                };
+                await subCmd.action(fakeCtx);
+                results.push({ command: cmdStr, success: true });
+            }
+            catch (e) {
+                const err = e instanceof Error ? e.message : String(e);
+                results.push({ command: cmdStr, success: false, error: err });
+                output.printWarning(`Batch error in "${cmdStr}": ${err}`);
+                if (ctx.flags.bail)
+                    break;
+            }
+        }
+        const failed = results.filter((r) => !r.success).length;
+        output.printInfo(`Batch: ${results.length - failed}/${results.length} succeeded`);
+        return { success: failed === 0, data: { results } };
+    },
+};
+const addinitscriptCommand = {
+    name: 'addinitscript',
+    description: 'Add script to run before page navigation. Usage: monomind browse addinitscript "window.x=1"',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const script = ctx.args[0];
+        if (!script)
+            throw new Error('Usage: monomind browse addinitscript "<js>"');
+        const id = await browser.addInitScript(client, sessionId, script);
+        output.printSuccess(`Init script added: ${id}`);
+        return { success: true, data: { identifier: id } };
+    },
+};
+const removeinitscriptCommand = {
+    name: 'removeinitscript',
+    description: 'Remove a previously added init script. Usage: monomind browse removeinitscript <id>',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const id = ctx.args[0];
+        if (!id)
+            throw new Error('Usage: monomind browse removeinitscript <identifier>');
+        await browser.removeInitScript(client, sessionId, id);
+        output.printSuccess(`Init script removed: ${id}`);
+        return { success: true };
+    },
+};
+// ---------------------------------------------------------------------------
 // Root browse command
 // ---------------------------------------------------------------------------
 const browseCommand = {
@@ -509,8 +1370,23 @@ const browseCommand = {
         openCommand,
         snapshotCommand,
         clickCommand,
+        dblclickCommand,
         fillCommand,
+        typeCommand,
         pressCommand,
+        keyboardCommand,
+        keydownCommand,
+        keyupCommand,
+        hoverCommand,
+        focusCommand,
+        selectCommand,
+        checkCommand,
+        uncheckCommand,
+        scrollIntoViewCommand,
+        dragCommand,
+        uploadCommand,
+        mouseCommand,
+        clipboardCommand,
         waitCommand,
         screenshotCommand,
         getCommand,
@@ -520,6 +1396,21 @@ const browseCommand = {
         stateCommand,
         networkCommand,
         evalCommand,
+        dialogCommand,
+        frameCommand,
+        tabCommand,
+        consoleLogCommand,
+        errorsCommand,
+        storageCommand,
+        cookiesCommand,
+        pdfCommand,
+        isCommand,
+        findCommand,
+        highlightCommand,
+        pushstateCommand,
+        batchCommand,
+        addinitscriptCommand,
+        removeinitscriptCommand,
         closeCommand,
     ],
     options: [
@@ -551,21 +1442,51 @@ const browseCommand = {
         output.printInfo('Usage: monomind browse <subcommand> [options]');
         output.printInfo('');
         output.printInfo('Subcommands:');
-        output.printInfo('  open       Open a URL');
-        output.printInfo('  snapshot   Capture accessibility snapshot with refs');
-        output.printInfo('  click      Click an element by ref');
-        output.printInfo('  fill       Fill an input element');
-        output.printInfo('  press      Press a keyboard key');
-        output.printInfo('  wait       Wait for a condition');
-        output.printInfo('  screenshot Take a screenshot');
-        output.printInfo('  get        Get page info (url, title, text, html)');
-        output.printInfo('  scroll     Scroll the page');
-        output.printInfo('  navigate   Navigate history (back/forward/reload)');
-        output.printInfo('  set        Configure viewport or user agent');
-        output.printInfo('  state      Save/load/list session state');
-        output.printInfo('  network    Network interception and cookies');
-        output.printInfo('  eval       Evaluate JavaScript');
-        output.printInfo('  close      Close the browser session');
+        output.printInfo('  open           Open a URL');
+        output.printInfo('  snapshot       Capture accessibility snapshot with refs');
+        output.printInfo('  click          Click an element by ref');
+        output.printInfo('  dblclick       Double-click an element');
+        output.printInfo('  fill           Fill an input (clears first)');
+        output.printInfo('  type           Type into element (appends)');
+        output.printInfo('  press          Press a keyboard key');
+        output.printInfo('  keyboard       Insert text directly');
+        output.printInfo('  keydown        Hold a key down');
+        output.printInfo('  keyup          Release a held key');
+        output.printInfo('  hover          Hover over element');
+        output.printInfo('  focus          Focus an element');
+        output.printInfo('  select         Select a dropdown option');
+        output.printInfo('  check          Check a checkbox');
+        output.printInfo('  uncheck        Uncheck a checkbox');
+        output.printInfo('  scrollintoview Scroll element into view');
+        output.printInfo('  drag           Drag element to another element');
+        output.printInfo('  upload         Upload file(s) to file input');
+        output.printInfo('  mouse          Fine-grained mouse control');
+        output.printInfo('  clipboard      Read/write clipboard');
+        output.printInfo('  wait           Wait for a condition');
+        output.printInfo('  screenshot     Take a screenshot');
+        output.printInfo('  get            Get page info (url, title, text, html)');
+        output.printInfo('  scroll         Scroll the page');
+        output.printInfo('  navigate       Navigate history (back/forward/reload)');
+        output.printInfo('  set            Configure viewport, device, user agent');
+        output.printInfo('  state          Save/load/list session state');
+        output.printInfo('  network        Network interception and cookies');
+        output.printInfo('  eval           Evaluate JavaScript');
+        output.printInfo('  dialog         Handle browser dialogs');
+        output.printInfo('  frame          Switch to iframe');
+        output.printInfo('  tab            Tab management');
+        output.printInfo('  console        View captured console messages');
+        output.printInfo('  errors         View page JS errors');
+        output.printInfo('  storage        localStorage/sessionStorage management');
+        output.printInfo('  cookies        Cookie management');
+        output.printInfo('  pdf            Save page as PDF');
+        output.printInfo('  is             Check element state (visible/enabled/checked)');
+        output.printInfo('  find           Find elements by semantic locators');
+        output.printInfo('  highlight      Highlight an element visually');
+        output.printInfo('  pushstate      SPA navigation via pushState');
+        output.printInfo('  batch          Execute multiple commands');
+        output.printInfo('  addinitscript  Add script to run before page navigation');
+        output.printInfo('  removeinitscript Remove a previously added init script');
+        output.printInfo('  close          Close the browser session');
         return { success: true };
     },
 };