monomind 1.10.40 → 1.10.41

package/packages/@monomind/cli/dist/src/commands/browse.js

@@ -15,6 +15,13 @@ async function getBrowser() {
 async function ensureConnected(port, targetId) {
     const browser = await getBrowser();
     if (!_client || !_client.isConnected()) {
+        if (_client && _sessionId) {
+            browser.teardownRouteInterception(_sessionId);
+            browser.stopRequestCapture(_sessionId);
+            browser.teardownDialogHandling(_sessionId);
+            browser.teardownConsoleCapture(_sessionId);
+            _client.close();
+        }
         _port = await browser.launchBrowser({ port, headless: false });
         const conn = await browser.connectToTarget(_port, targetId);
         _client = conn.client;
@@ -45,12 +52,46 @@ const openCommand = {
             throw new Error('URL required. Usage: monomind browse open <url>');
         const port = ctx.flags.port ?? 9222;
         const browser = await getBrowser();
+        if (_client) {
+            const prevSid = _sessionId;
+            const prevClient = _client;
+            if (browser.getHarStatus(prevSid).recording) {
+                try {
+                    await browser.stopHarRecording(prevClient, prevSid);
+                }
+                catch { /* ignore */ }
+            }
+            if (browser.getTraceStatus(prevSid)) {
+                try {
+                    await browser.stopTrace(prevClient, prevSid);
+                }
+                catch { /* ignore */ }
+            }
+            if (browser.isProfilingActive(prevSid)) {
+                try {
+                    await browser.stopCpuProfile(prevClient, prevSid);
+                }
+                catch { /* ignore */ }
+            }
+            browser.teardownRouteInterception(prevSid);
+            browser.stopRequestCapture(prevSid);
+            browser.teardownDialogHandling(prevSid);
+            browser.teardownConsoleCapture(prevSid);
+            prevClient.close();
+            _client = null;
+            _sessionId = '';
+            _targetId = '';
+            _refs = new Map();
+        }
         _port = await browser.launchBrowser({ port, headless: ctx.flags.headless });
         const conn = await browser.connectToTarget(_port);
         _client = conn.client;
         _sessionId = conn.sessionId;
         _targetId = conn.target.id;
         _refs = new Map();
+        if (ctx.flags.state && ctx.flags.session) {
+            output.printWarning('Both --state and --session provided; --state takes precedence');
+        }
         if (ctx.flags.state) {
             await browser.loadStateFile(_client, _sessionId, ctx.flags.state);
         }
@@ -198,7 +239,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 };
@@ -283,7 +324,7 @@ const getCommand = {
                     value = result.result?.value ?? '';
                 }
                 else {
-                    value = (await browser.evaluateJs(client, sessionId, 'document.body.innerText'));
+                    value = (await browser.evaluateJs(client, sessionId, 'document.body?.innerText ?? ""'));
                 }
                 break;
             }
@@ -410,21 +451,45 @@ const navigateCommand = {
     description: 'Navigate browser history. Usage: monomind browse navigate back|forward|reload',
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
         const direction = ctx.args[0];
         if (!direction)
             throw new Error('Usage: monomind browse navigate back|forward|reload');
-        switch (direction) {
-            case 'back':
-                await client.send('Runtime.evaluate', { expression: 'history.back()' }, sessionId);
-                break;
-            case 'forward':
-                await client.send('Runtime.evaluate', { expression: 'history.forward()' }, sessionId);
-                break;
-            case 'reload':
-                await client.send('Page.reload', {}, sessionId);
-                break;
-            default:
-                throw new Error(`Unknown direction: ${direction}. Use: back|forward|reload`);
+        if (direction === 'back' || direction === 'forward') {
+            // Pre-register frame-start listener BEFORE JS navigation to avoid the race
+            // where history.back/forward() returns before the browser issues any requests
+            let offFrameStarted = () => { };
+            const frameStartedPromise = new Promise((resolve) => {
+                offFrameStarted = client.on('Page.frameStartedLoading', (_params, sid) => {
+                    if (sid === sessionId) {
+                        const off = offFrameStarted;
+                        offFrameStarted = () => { };
+                        off();
+                        resolve();
+                    }
+                });
+            });
+            try {
+                await client.send('Runtime.evaluate', {
+                    expression: direction === 'back' ? 'history.back()' : 'history.forward()',
+                }, sessionId);
+                let fallbackHandle;
+                const fallbackPromise = new Promise((r) => { fallbackHandle = setTimeout(r, 2000); });
+                await Promise.race([frameStartedPromise, fallbackPromise]);
+                if (fallbackHandle !== undefined)
+                    clearTimeout(fallbackHandle);
+            }
+            finally {
+                offFrameStarted();
+            }
+            await browser.waitForLoad(client, sessionId, 'networkidle');
+        }
+        else if (direction === 'reload') {
+            await client.send('Page.reload', {}, sessionId);
+            await browser.waitForLoad(client, sessionId, 'load');
+        }
+        else {
+            throw new Error(`Unknown direction: ${direction}. Use: back|forward|reload`);
         }
         output.printSuccess(`Navigated: ${direction}`);
         return { success: true };
@@ -474,7 +539,7 @@ const setCommand = {
                 const offlineArg = ctx.args[1];
                 if (offlineArg === undefined)
                     throw new Error('Usage: set offline <true|false>');
-                const enabled = offlineArg !== 'false';
+                const enabled = offlineArg === 'true';
                 await browser.setOfflineMode(client, sessionId, enabled);
                 output.printSuccess(`Offline mode: ${enabled}`);
                 break;
@@ -701,7 +766,33 @@ const closeCommand = {
     description: 'Close the active browser session',
     action: async (_ctx) => {
         if (_client) {
-            _client.close();
+            const browser = await getBrowser();
+            const sid = _sessionId;
+            const client = _client;
+            // Tear down per-session Maps and listeners before closing
+            if (browser.getHarStatus(sid).recording) {
+                try {
+                    await browser.stopHarRecording(client, sid);
+                }
+                catch { /* ignore */ }
+            }
+            if (browser.getTraceStatus(sid)) {
+                try {
+                    await browser.stopTrace(client, sid);
+                }
+                catch { /* ignore */ }
+            }
+            if (browser.isProfilingActive(sid)) {
+                try {
+                    await browser.stopCpuProfile(client, sid);
+                }
+                catch { /* ignore */ }
+            }
+            browser.teardownRouteInterception(sid);
+            browser.stopRequestCapture(sid);
+            browser.teardownDialogHandling(sid);
+            browser.teardownConsoleCapture(sid);
+            client.close();
             _client = null;
             _sessionId = '';
             _targetId = '';
@@ -996,14 +1087,18 @@ const clipboardCommand = {
                 output.printSuccess('Clipboard written');
                 break;
             }
-            case 'copy':
-                await browser.pressKeyCombo(client, sessionId, 'c', 2); // Ctrl modifier
+            case 'copy': {
+                const mod = process.platform === 'darwin' ? 4 : 2; // Meta/Cmd on macOS, Ctrl elsewhere
+                await browser.pressKeyCombo(client, sessionId, 'c', mod);
                 output.printSuccess('Copy sent');
                 break;
-            case 'paste':
-                await browser.pressKeyCombo(client, sessionId, 'v', 2); // Ctrl modifier
+            }
+            case 'paste': {
+                const mod = process.platform === 'darwin' ? 4 : 2;
+                await browser.pressKeyCombo(client, sessionId, 'v', mod);
                 output.printSuccess('Paste sent');
                 break;
+            }
             default:
                 throw new Error('Usage: monomind browse clipboard read|write|copy|paste');
         }
@@ -1090,13 +1185,74 @@ const tabCommand = {
                 const tabId = ctx.args[1];
                 if (!tabId)
                     throw new Error('Usage: monomind browse tab close <tabId>');
-                await browser.closeTab(client, sessionId, tabId);
+                if (tabId === _targetId) {
+                    const sid = _sessionId;
+                    // Stop profiling before closing the tab so CDP commands still reach the live session
+                    if (browser.getHarStatus(sid).recording) {
+                        try {
+                            await browser.stopHarRecording(client, sid);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    if (browser.getTraceStatus(sid)) {
+                        try {
+                            await browser.stopTrace(client, sid);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    if (browser.isProfilingActive(sid)) {
+                        try {
+                            await browser.stopCpuProfile(client, sid);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    browser.teardownRouteInterception(sid);
+                    browser.stopRequestCapture(sid);
+                    browser.teardownDialogHandling(sid);
+                    browser.teardownConsoleCapture(sid);
+                    await browser.closeTab(client, sessionId, tabId);
+                    client.close();
+                    _client = null;
+                    _sessionId = '';
+                    _targetId = '';
+                    _refs = new Map();
+                }
+                else {
+                    await browser.closeTab(client, sessionId, tabId);
+                }
                 output.printSuccess(`Closed tab: ${tabId}`);
                 break;
             }
             default: {
-                // Try to treat arg as tab ID to switch to
-                _sessionId = await browser.activateTab(client, sessionId, action);
+                // Attach to new tab FIRST — only tear down old session if that succeeds
+                const newSid = await browser.activateTab(client, sessionId, action);
+                const oldSid = _sessionId;
+                if (browser.getHarStatus(oldSid).recording) {
+                    try {
+                        await browser.stopHarRecording(client, oldSid);
+                    }
+                    catch { /* ignore */ }
+                }
+                if (browser.getTraceStatus(oldSid)) {
+                    try {
+                        await browser.stopTrace(client, oldSid);
+                    }
+                    catch { /* ignore */ }
+                }
+                if (browser.isProfilingActive(oldSid)) {
+                    try {
+                        await browser.stopCpuProfile(client, oldSid);
+                    }
+                    catch { /* ignore */ }
+                }
+                await browser.disableInterception(client, oldSid).catch(() => { });
+                browser.stopRequestCapture(oldSid);
+                browser.teardownDialogHandling(oldSid);
+                browser.teardownConsoleCapture(oldSid);
+                _sessionId = newSid;
+                _targetId = action;
+                _refs = new Map();
+                await browser.enableSessionDomains(client, _sessionId);
                 output.printSuccess(`Switched to tab: ${action}`);
             }
         }
@@ -1114,11 +1270,12 @@ const consoleLogCommand = {
     action: async (ctx) => {
         const browser = await getBrowser();
         if (ctx.flags.clear) {
-            browser.clearConsoleMessages();
+            browser.clearConsoleMessages(_sessionId);
             output.printSuccess('Console cleared');
             return { success: true };
         }
-        const msgs = browser.getConsoleMessages(_sessionId);
+        const allMsgs = browser.getConsoleMessages(_sessionId);
+        const msgs = ctx.flags['errors-only'] ? allMsgs.filter((m) => m.type === 'error') : allMsgs;
         if (ctx.flags.json) {
             print(JSON.stringify(msgs));
         }
@@ -1141,7 +1298,7 @@ const errorsCommand = {
     action: async (ctx) => {
         const browser = await getBrowser();
         if (ctx.flags.clear) {
-            browser.clearPageErrors();
+            browser.clearPageErrors(_sessionId);
             output.printSuccess('Errors cleared');
             return { success: true };
         }
@@ -1195,6 +1352,8 @@ const storageCommand = {
         if (key && ctx.flags.remove) {
             if (isLocal)
                 await browser.removeLocalStorageKey(client, sessionId, key);
+            else
+                await browser.removeSessionStorageKey(client, sessionId, key);
             output.printSuccess(`Removed ${key}`);
             return { success: true };
         }
@@ -1507,28 +1666,71 @@ const batchCommand = {
             }
             try {
                 const parsedFlags = { _: [] };
-                // Parse --flags from subArgs
+                const consumedIndices = new Set();
+                // Parse --flags from subArgs, tracking which indices are flag names/values
                 for (let i = 0; i < subArgs.length; i++) {
                     if (subArgs[i].startsWith('--')) {
+                        consumedIndices.add(i);
                         const key = subArgs[i].slice(2);
                         const next = subArgs[i + 1];
-                        if (next && !next.startsWith('--')) {
-                            parsedFlags[key] = next;
+                        const optDef = subCmd.options?.find((o) => o.name === key);
+                        const isBooleanFlag = optDef?.type === 'boolean';
+                        if (next && (!next.startsWith('-') || /^-\d/.test(next)) && !isBooleanFlag) {
+                            // Non-boolean flags consume the next token as their value (allow negative numbers like -1)
+                            consumedIndices.add(i + 1);
+                            if (optDef?.type === 'number') {
+                                parsedFlags[key] = Number(next);
+                            }
+                            else {
+                                parsedFlags[key] = next;
+                            }
+                            i++;
+                        }
+                        else if (isBooleanFlag && (next === 'true' || next === 'false')) {
+                            // Explicit boolean value token
+                            consumedIndices.add(i + 1);
+                            parsedFlags[key] = next !== 'false';
                             i++;
                         }
                         else {
                             parsedFlags[key] = true;
                         }
                     }
+                    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);
+                        if (optDef) {
+                            const key = optDef.name;
+                            const next = subArgs[i + 1];
+                            const isBooleanFlag = optDef.type === 'boolean';
+                            if (next && (!next.startsWith('-') || /^-\d/.test(next)) && !isBooleanFlag) {
+                                consumedIndices.add(i + 1);
+                                parsedFlags[key] = optDef.type === 'number' ? Number(next) : next;
+                                i++;
+                            }
+                            else if (isBooleanFlag && (next === 'true' || next === 'false')) {
+                                consumedIndices.add(i + 1);
+                                parsedFlags[key] = next !== 'false';
+                                i++;
+                            }
+                            else {
+                                parsedFlags[key] = true;
+                            }
+                        }
+                    }
                 }
                 const fakeCtx = {
-                    args: subArgs.filter((a) => !a.startsWith('--')),
+                    args: subArgs.filter((_, i) => !consumedIndices.has(i)),
                     flags: parsedFlags,
                     cwd: ctx.cwd,
                     interactive: false,
                 };
-                await subCmd.action(fakeCtx);
-                results.push({ command: cmdStr, success: true });
+                const cmdResult = await subCmd.action(fakeCtx);
+                const succeeded = cmdResult?.success !== false;
+                results.push({ command: cmdStr, success: succeeded, error: succeeded ? undefined : 'Command returned failure' });
+                if (!succeeded && ctx.flags.bail)
+                    break;
             }
             catch (e) {
                 const err = e instanceof Error ? e.message : String(e);
@@ -1581,6 +1783,37 @@ const connectCommand = {
     action: async (ctx) => {
         const port = ctx.flags.port ?? 9222;
         const browser = await getBrowser();
+        if (_client) {
+            const prevSid = _sessionId;
+            const prevClient = _client;
+            if (browser.getHarStatus(prevSid).recording) {
+                try {
+                    await browser.stopHarRecording(prevClient, prevSid);
+                }
+                catch { /* ignore */ }
+            }
+            if (browser.getTraceStatus(prevSid)) {
+                try {
+                    await browser.stopTrace(prevClient, prevSid);
+                }
+                catch { /* ignore */ }
+            }
+            if (browser.isProfilingActive(prevSid)) {
+                try {
+                    await browser.stopCpuProfile(prevClient, prevSid);
+                }
+                catch { /* ignore */ }
+            }
+            browser.teardownRouteInterception(prevSid);
+            browser.stopRequestCapture(prevSid);
+            browser.teardownDialogHandling(prevSid);
+            browser.teardownConsoleCapture(prevSid);
+            prevClient.close();
+            _client = null;
+            _sessionId = '';
+            _targetId = '';
+            _refs = new Map();
+        }
         const conn = await browser.connectToTarget(port, ctx.flags.target);
         _client = conn.client;
         _sessionId = conn.sessionId;

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.10.40",
+  "version": "1.10.41",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",