monomind 1.10.39 → 1.10.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.10.39",
+  "version": "1.10.41",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/dist/src/browser/actions.js

@@ -1,3 +1,4 @@
+import { resolve } from 'path';
 import { getObjectIdForRef, getElementBox } from './snapshot.js';
 export async function clickElement(client, sessionId, ref, options = {}) {
     const box = await getElementBox(client, sessionId, ref);
@@ -11,6 +12,7 @@ export async function clickElement(client, sessionId, ref, options = {}) {
         await client.send('Runtime.callFunctionOn', {
             functionDeclaration: 'function() { this.click(); }',
             objectId,
+            returnByValue: true,
         }, sessionId);
         return;
     }
@@ -21,10 +23,11 @@ export async function clickPoint(client, sessionId, x, y, options = {}) {
     const clickCount = options.clickCount ?? 1;
     const modifiers = options.modifiers ?? 0;
     const shared = { x, y, button, modifiers };
+    const buttonsMask = button === 'right' ? 2 : button === 'middle' ? 4 : 1;
     for (let i = 0; i < clickCount; i++) {
         const count = i + 1;
-        await client.send('Input.dispatchMouseEvent', { ...shared, type: 'mousePressed', buttons: 1, clickCount: count }, sessionId);
-        await client.send('Input.dispatchMouseEvent', { ...shared, type: 'mouseReleased', buttons: 0, clickCount: count }, sessionId);
+        await client.send('Input.dispatchMouseEvent', { ...shared, type: 'mousePressed', buttons: buttonsMask, clickCount: count }, sessionId);
+        await client.send('Input.dispatchMouseEvent', { ...shared, type: 'mouseReleased', buttons: i < clickCount - 1 ? buttonsMask : 0, clickCount: count }, sessionId);
     }
 }
 export async function fillElement(client, sessionId, ref, value) {
@@ -36,7 +39,7 @@ export async function fillElement(client, sessionId, ref, value) {
     // Select all and replace
     const objectId = await getObjectIdForRef(client, sessionId, ref);
     if (objectId) {
-        await client.send('Runtime.callFunctionOn', {
+        const fillSelectResult = await client.send('Runtime.callFunctionOn', {
             functionDeclaration: `function() {
         this.focus();
         if (this.tagName === 'INPUT' || this.tagName === 'TEXTAREA') {
@@ -49,8 +52,19 @@ export async function fillElement(client, sessionId, ref, value) {
         }
       }`,
             objectId,
+            returnByValue: true,
         }, sessionId);
+        if (fillSelectResult.exceptionDetails) {
+            throw new Error(`fillElement select-all failed: ${fillSelectResult.exceptionDetails.exception?.description ?? fillSelectResult.exceptionDetails.text}`);
+        }
+    }
+    else if (box) {
+        // Fallback for elements without a resolvable objectId: keyboard select-all clears existing content
+        const mod = process.platform === 'darwin' ? 4 : 2;
+        await pressKeyCombo(client, sessionId, 'a', mod);
     }
+    if (!objectId && !box)
+        throw new Error(`Cannot fill ref @${ref.ref}: element not found in DOM`);
     // Type the value character by character for natural input
     await typeText(client, sessionId, value);
 }
@@ -64,15 +78,16 @@ export async function pressKeyCombo(client, sessionId, key, modifiers) {
     await client.send('Input.dispatchKeyEvent', { type: 'keyUp', ...keyInfo, modifiers }, sessionId);
 }
 export async function pressKey(client, sessionId, key) {
-    const keyInfo = resolveKey(key);
+    const { text, ...keyInfo } = resolveKey(key);
+    // rawKeyDown does not insert text; the explicit char event handles insertion
     await client.send('Input.dispatchKeyEvent', {
-        type: 'keyDown',
+        type: 'rawKeyDown',
         ...keyInfo,
     }, sessionId);
-    if (keyInfo.text) {
+    if (text) {
         await client.send('Input.dispatchKeyEvent', {
             type: 'char',
-            text: keyInfo.text,
+            text,
         }, sessionId);
     }
     await client.send('Input.dispatchKeyEvent', {
@@ -97,12 +112,74 @@ function resolveKey(key) {
         PageDown: { key: 'PageDown', code: 'PageDown', windowsVirtualKeyCode: 34 },
         Space: { key: ' ', code: 'Space', text: ' ', windowsVirtualKeyCode: 32 },
         ' ': { key: ' ', code: 'Space', text: ' ', windowsVirtualKeyCode: 32 },
+        Shift: { key: 'Shift', code: 'ShiftLeft', windowsVirtualKeyCode: 16 },
+        Control: { key: 'Control', code: 'ControlLeft', windowsVirtualKeyCode: 17 },
+        Alt: { key: 'Alt', code: 'AltLeft', windowsVirtualKeyCode: 18 },
+        Meta: { key: 'Meta', code: 'MetaLeft', windowsVirtualKeyCode: 91 },
+        F1: { key: 'F1', code: 'F1', windowsVirtualKeyCode: 112 },
+        F2: { key: 'F2', code: 'F2', windowsVirtualKeyCode: 113 },
+        F3: { key: 'F3', code: 'F3', windowsVirtualKeyCode: 114 },
+        F4: { key: 'F4', code: 'F4', windowsVirtualKeyCode: 115 },
+        F5: { key: 'F5', code: 'F5', windowsVirtualKeyCode: 116 },
+        F6: { key: 'F6', code: 'F6', windowsVirtualKeyCode: 117 },
+        F7: { key: 'F7', code: 'F7', windowsVirtualKeyCode: 118 },
+        F8: { key: 'F8', code: 'F8', windowsVirtualKeyCode: 119 },
+        F9: { key: 'F9', code: 'F9', windowsVirtualKeyCode: 120 },
+        F10: { key: 'F10', code: 'F10', windowsVirtualKeyCode: 121 },
+        F11: { key: 'F11', code: 'F11', windowsVirtualKeyCode: 122 },
+        F12: { key: 'F12', code: 'F12', windowsVirtualKeyCode: 123 },
     };
     if (keyMap[key])
         return keyMap[key];
     // Single printable character — windowsVirtualKeyCode required for rawKeyDown shortcut dispatch
     if (key.length === 1) {
-        return { key, code: `Key${key.toUpperCase()}`, text: key, windowsVirtualKeyCode: key.toUpperCase().charCodeAt(0) };
+        const charCode = key.charCodeAt(0);
+        if (charCode >= 48 && charCode <= 57) {
+            return { key, code: `Digit${key}`, text: key, windowsVirtualKeyCode: charCode };
+        }
+        if ((charCode >= 65 && charCode <= 90) || (charCode >= 97 && charCode <= 122)) {
+            return { key, code: `Key${key.toUpperCase()}`, text: key, windowsVirtualKeyCode: key.toUpperCase().charCodeAt(0) };
+        }
+        // Symbol keys: map to the physical key's code and Windows virtual key code
+        const symbolMap = {
+            '!': { code: 'Digit1', windowsVirtualKeyCode: 49 },
+            '@': { code: 'Digit2', windowsVirtualKeyCode: 50 },
+            '#': { code: 'Digit3', windowsVirtualKeyCode: 51 },
+            '$': { code: 'Digit4', windowsVirtualKeyCode: 52 },
+            '%': { code: 'Digit5', windowsVirtualKeyCode: 53 },
+            '^': { code: 'Digit6', windowsVirtualKeyCode: 54 },
+            '&': { code: 'Digit7', windowsVirtualKeyCode: 55 },
+            '*': { code: 'Digit8', windowsVirtualKeyCode: 56 },
+            '(': { code: 'Digit9', windowsVirtualKeyCode: 57 },
+            ')': { code: 'Digit0', windowsVirtualKeyCode: 48 },
+            '-': { code: 'Minus', windowsVirtualKeyCode: 189 },
+            '_': { code: 'Minus', windowsVirtualKeyCode: 189 },
+            '=': { code: 'Equal', windowsVirtualKeyCode: 187 },
+            '+': { code: 'Equal', windowsVirtualKeyCode: 187 },
+            '[': { code: 'BracketLeft', windowsVirtualKeyCode: 219 },
+            '{': { code: 'BracketLeft', windowsVirtualKeyCode: 219 },
+            ']': { code: 'BracketRight', windowsVirtualKeyCode: 221 },
+            '}': { code: 'BracketRight', windowsVirtualKeyCode: 221 },
+            '\\': { code: 'Backslash', windowsVirtualKeyCode: 220 },
+            '|': { code: 'Backslash', windowsVirtualKeyCode: 220 },
+            ';': { code: 'Semicolon', windowsVirtualKeyCode: 186 },
+            ':': { code: 'Semicolon', windowsVirtualKeyCode: 186 },
+            "'": { code: 'Quote', windowsVirtualKeyCode: 222 },
+            '"': { code: 'Quote', windowsVirtualKeyCode: 222 },
+            '`': { code: 'Backquote', windowsVirtualKeyCode: 192 },
+            '~': { code: 'Backquote', windowsVirtualKeyCode: 192 },
+            ',': { code: 'Comma', windowsVirtualKeyCode: 188 },
+            '<': { code: 'Comma', windowsVirtualKeyCode: 188 },
+            '.': { code: 'Period', windowsVirtualKeyCode: 190 },
+            '>': { code: 'Period', windowsVirtualKeyCode: 190 },
+            '/': { code: 'Slash', windowsVirtualKeyCode: 191 },
+            '?': { code: 'Slash', windowsVirtualKeyCode: 191 },
+        };
+        const sym = symbolMap[key];
+        if (sym)
+            return { key, code: sym.code, text: key, windowsVirtualKeyCode: sym.windowsVirtualKeyCode };
+        // Unknown/non-ASCII character — omit code since no valid DOM KeyboardEvent.code exists
+        return { key, code: '', text: key };
     }
     return { key, code: key };
 }
@@ -113,10 +190,10 @@ export async function scrollElement(client, sessionId, direction, amount = 300,
     let deltaY = 0;
     if (ref) {
         const box = await getElementBox(client, sessionId, ref);
-        if (box) {
-            x = box.x;
-            y = box.y;
-        }
+        if (!box)
+            throw new Error(`Cannot scroll: ref @${ref.ref} not found in DOM`);
+        x = box.x;
+        y = box.y;
     }
     else {
         // Center of viewport
@@ -164,7 +241,7 @@ export async function selectOption(client, sessionId, ref, value) {
     const objectId = await getObjectIdForRef(client, sessionId, ref);
     if (!objectId)
         throw new Error(`Cannot select: ref @${ref.ref} not found in DOM`);
-    await client.send('Runtime.callFunctionOn', {
+    const selectResult = await client.send('Runtime.callFunctionOn', {
         functionDeclaration: `function(value) {
       if (this.tagName !== 'SELECT') throw new Error('Not a select element');
       for (const opt of this.options) {
@@ -178,13 +255,17 @@ export async function selectOption(client, sessionId, ref, value) {
     }`,
         objectId,
         arguments: [{ value }],
+        returnByValue: true,
     }, sessionId);
+    if (selectResult.exceptionDetails) {
+        throw new Error(`selectOption failed: ${selectResult.exceptionDetails.exception?.description ?? selectResult.exceptionDetails.text}`);
+    }
 }
 export async function checkElement(client, sessionId, ref, checked = true) {
     const objectId = await getObjectIdForRef(client, sessionId, ref);
     if (!objectId)
         throw new Error(`Cannot check: ref @${ref.ref} not found in DOM`);
-    await client.send('Runtime.callFunctionOn', {
+    const checkResult = await client.send('Runtime.callFunctionOn', {
         functionDeclaration: `function(checked) {
       if (this.checked !== checked) {
         this.click();
@@ -192,7 +273,11 @@ export async function checkElement(client, sessionId, ref, checked = true) {
     }`,
         objectId,
         arguments: [{ value: checked }],
+        returnByValue: true,
     }, sessionId);
+    if (checkResult.exceptionDetails) {
+        throw new Error(`checkElement failed: ${checkResult.exceptionDetails.exception?.description ?? checkResult.exceptionDetails.text}`);
+    }
 }
 export async function focusElement(client, sessionId, ref) {
     const objectId = await getObjectIdForRef(client, sessionId, ref);
@@ -200,30 +285,36 @@ export async function focusElement(client, sessionId, ref) {
         await client.send('Runtime.callFunctionOn', {
             functionDeclaration: 'function() { this.focus(); }',
             objectId,
+            returnByValue: true,
         }, sessionId);
         return;
     }
     const box = await getElementBox(client, sessionId, ref);
-    if (box)
+    if (box) {
         await clickPoint(client, sessionId, box.x, box.y);
+    }
+    else {
+        throw new Error(`Cannot focus ref @${ref.ref}: element not found in DOM`);
+    }
 }
 export async function typeIntoElement(client, sessionId, ref, text) {
     await focusElement(client, sessionId, ref);
     await typeText(client, sessionId, text);
 }
 export async function keyDown(client, sessionId, key) {
-    const keyInfo = resolveKey(key);
-    await client.send('Input.dispatchKeyEvent', { type: 'keyDown', ...keyInfo }, sessionId);
+    const { text: _text, ...keyInfo } = resolveKey(key);
+    await client.send('Input.dispatchKeyEvent', { type: 'rawKeyDown', ...keyInfo }, sessionId);
 }
 export async function keyUp(client, sessionId, key) {
-    const keyInfo = resolveKey(key);
+    const { text: _text, ...keyInfo } = resolveKey(key);
     await client.send('Input.dispatchKeyEvent', { type: 'keyUp', ...keyInfo }, sessionId);
 }
 export async function mouseMove(client, sessionId, x, y) {
     await client.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y }, sessionId);
 }
 export async function mouseDown(client, sessionId, x, y, button = 'left') {
-    await client.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button, buttons: 1, clickCount: 1 }, sessionId);
+    const buttonsMask = button === 'right' ? 2 : button === 'middle' ? 4 : 1;
+    await client.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button, buttons: buttonsMask, clickCount: 1 }, sessionId);
 }
 export async function mouseUp(client, sessionId, x, y, button = 'left') {
     await client.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button, buttons: 0, clickCount: 1 }, sessionId);
@@ -251,7 +342,7 @@ export async function uploadFile(client, sessionId, ref, filePaths) {
     if (!ref.backendDOMNodeId)
         throw new Error(`Cannot upload: ref @${ref.ref} has no DOM node`);
     await client.send('DOM.setFileInputFiles', {
-        files: filePaths,
+        files: filePaths.map((f) => resolve(f)),
         backendNodeId: ref.backendDOMNodeId,
     }, sessionId);
 }
@@ -268,7 +359,8 @@ export async function pushState(client, sessionId, url) {
     (function() {
       const url = ${JSON.stringify(url)};
       if (window.next && window.next.router) {
-        window.next.router.push(url);
+        window.next.router.push(url).catch(function() {});
+        return;
       } else {
         history.pushState({}, '', url);
         window.dispatchEvent(new PopStateEvent('popstate'));
@@ -292,7 +384,7 @@ export async function evaluateJs(client, sessionId, expression) {
         awaitPromise: true,
     }, sessionId);
     if (result.exceptionDetails) {
-        throw new Error(`JS evaluation error: ${result.exceptionDetails.text}`);
+        throw new Error(`JS evaluation error: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`);
     }
     return result.result?.value;
 }

package/packages/@monomind/cli/dist/src/browser/batch.d.ts

@@ -2,6 +2,4 @@ export interface BatchCommand {
     command: string;
     args: string[];
 }
-export declare function parseBatchCommands(input: string[]): Promise<BatchCommand[]>;
-export declare function parseBatchJson(json: string): Promise<BatchCommand[]>;
 //# sourceMappingURL=batch.d.ts.map

package/packages/@monomind/cli/dist/src/browser/batch.js

@@ -1,11 +1,2 @@
-export async function parseBatchCommands(input) {
-    return input.map((raw) => {
-        const parts = raw.trim().split(/\s+/);
-        return { command: parts[0], args: parts.slice(1) };
-    });
-}
-export async function parseBatchJson(json) {
-    const parsed = JSON.parse(json);
-    return parsed.map(([command, ...args]) => ({ command, args }));
-}
+export {};
 //# sourceMappingURL=batch.js.map

package/packages/@monomind/cli/dist/src/browser/browser.d.ts

@@ -2,6 +2,7 @@ import { CdpClient } from './cdp.js';
 import type { BrowserConfig, CdpTarget } from './types.js';
 export declare function isPortOpen(port: number): Promise<boolean>;
 export declare function launchBrowser(config?: BrowserConfig): Promise<number>;
+export declare function enableSessionDomains(client: CdpClient, sessionId: string): Promise<void>;
 export declare function connectToTarget(port: number, targetId?: string): Promise<{
     client: CdpClient;
     target: CdpTarget;

package/packages/@monomind/cli/dist/src/browser/browser.js

@@ -83,6 +83,18 @@ export async function launchBrowser(config = {}) {
     }
     throw new Error(`Chrome failed to start on port ${port} within ${LAUNCH_TIMEOUT}ms`);
 }
+export async function enableSessionDomains(client, sessionId) {
+    await Promise.all([
+        client.send('Page.enable', {}, sessionId),
+        client.send('Runtime.enable', {}, sessionId),
+        client.send('Network.enable', {}, sessionId),
+        client.send('DOM.enable', {}, sessionId),
+        client.send('Accessibility.enable', {}, sessionId),
+    ]);
+    setupConsoleCapture(client, sessionId);
+    await enableConsoleCapture(client, sessionId);
+    setupDialogAutoHandling(client, sessionId);
+}
 export async function connectToTarget(port, targetId) {
     const targets = await fetchTargets(port);
     const pageTargets = targets.filter((t) => t.type === 'page');
@@ -102,34 +114,33 @@ export async function connectToTarget(port, targetId) {
     const wsUrl = target.webSocketDebuggerUrl ?? `ws://127.0.0.1:${port}/devtools/page/${target.id}`;
     const client = new CdpClient();
     await client.connect(wsUrl);
-    // Enable required domains
     const { sessionId } = await client.send('Target.attachToTarget', {
         targetId: target.id,
         flatten: true,
     });
-    await Promise.all([
-        client.send('Page.enable', {}, sessionId),
-        client.send('Runtime.enable', {}, sessionId),
-        client.send('Network.enable', {}, sessionId),
-        client.send('DOM.enable', {}, sessionId),
-        client.send('Accessibility.enable', {}, sessionId),
-    ]);
-    // Wire up auto-capture listeners so console/errors/dialogs work immediately
-    setupConsoleCapture(client, sessionId);
-    await enableConsoleCapture(client, sessionId);
-    setupDialogAutoHandling(client, sessionId);
+    await enableSessionDomains(client, sessionId);
     return { client, target, sessionId };
 }
 export async function openUrl(client, sessionId, url) {
     await client.send('Page.navigate', { url }, sessionId);
-    await waitForLoad(client, sessionId, 'networkidle');
+    await waitForNetworkIdle(client, sessionId, 500, 30_000);
 }
 export async function waitForLoad(client, sessionId, condition = 'load', timeout = 30_000) {
     if (condition === 'load' || condition === 'domcontentloaded') {
+        // Guard against race where the page loads before the listener is registered
+        const readyExpr = condition === 'load' ? 'document.readyState === "complete"' : 'document.readyState !== "loading"';
+        const readyCheck = await client.send('Runtime.evaluate', {
+            expression: readyExpr, returnByValue: true,
+        }, sessionId).catch(() => ({ result: { value: false } }));
+        if (readyCheck.result?.value)
+            return;
         const event = condition === 'load' ? 'Page.loadEventFired' : 'Page.domContentEventFired';
         const [eventPromise, cancelOnce] = client.onceWithOff(event, sessionId);
         let timedOut = false;
-        const timeoutPromise = sleep(timeout).then(() => { timedOut = true; });
+        let timeoutHandle;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutHandle = setTimeout(() => { timedOut = true; resolve(); }, timeout);
+        });
         try {
             await Promise.race([eventPromise, timeoutPromise]);
             if (timedOut)
@@ -137,6 +148,7 @@ export async function waitForLoad(client, sessionId, condition = 'load', timeout
         }
         finally {
             cancelOnce();
+            clearTimeout(timeoutHandle);
         }
         return;
     }
@@ -146,6 +158,7 @@ export async function waitForLoad(client, sessionId, condition = 'load', timeout
 async function waitForNetworkIdle(client, sessionId, idleMs, timeout) {
     return new Promise((resolve, reject) => {
         let pending = 0;
+        const inflight = new Set();
         let idleTimer = null;
         const killTimer = setTimeout(() => {
             cleanup();
@@ -160,6 +173,8 @@ async function waitForNetworkIdle(client, sessionId, idleMs, timeout) {
             offReq();
             offResp();
             offFail();
+            offCache();
+            offResp2();
         };
         const settle = () => {
             cleanup();
@@ -178,23 +193,35 @@ async function waitForNetworkIdle(client, sessionId, idleMs, timeout) {
                 }
             }
         };
-        const offReq = client.on('Network.requestWillBeSent', (_, sid) => {
-            if (sid === sessionId) {
+        const offReq = client.on('Network.requestWillBeSent', (params, sid) => {
+            if (sid !== sessionId)
+                return;
+            const id = params.requestId;
+            if (!inflight.has(id)) {
+                inflight.add(id);
                 pending++;
                 check();
             }
         });
-        const offResp = client.on('Network.loadingFinished', (_, sid) => {
-            if (sid === sessionId) {
-                pending = Math.max(0, pending - 1);
-                check();
-            }
-        });
-        const offFail = client.on('Network.loadingFailed', (_, sid) => {
-            if (sid === sessionId) {
+        const decrement = (params, sid) => {
+            if (sid !== sessionId)
+                return;
+            const id = params.requestId;
+            if (inflight.delete(id)) {
                 pending = Math.max(0, pending - 1);
                 check();
             }
+        };
+        const offResp = client.on('Network.loadingFinished', decrement);
+        const offFail = client.on('Network.loadingFailed', decrement);
+        const offCache = client.on('Network.requestServedFromCache', decrement);
+        // Guard against requests that never fire loadingFinished/loadingFailed (e.g. data: URLs)
+        // Skip 3xx redirect responses — the request continues under the same requestId
+        const offResp2 = client.on('Network.responseReceived', (params, sid) => {
+            const p = params;
+            if (p.response.status >= 300 && p.response.status < 400)
+                return;
+            decrement(params, sid);
         });
         check();
     });

package/packages/@monomind/cli/dist/src/browser/cdp.js

@@ -13,8 +13,16 @@ export class CdpClient {
                 resolve();
             });
             this.ws.on('error', (err) => {
-                if (!this.connected)
+                if (!this.connected) {
                     reject(err);
+                }
+                else {
+                    // Post-connect: flush all pending commands — 'close' may not fire on all platforms
+                    this.connected = false;
+                    for (const { reject: r } of this.pendingCommands.values())
+                        r(err);
+                    this.pendingCommands.clear();
+                }
             });
             this.ws.on('close', () => {
                 this.connected = false;
@@ -68,7 +76,12 @@ export class CdpClient {
                 resolve: (r) => resolve((r.result ?? {})),
                 reject,
             });
-            this.ws.send(JSON.stringify(cmd));
+            this.ws.send(JSON.stringify(cmd), (err) => {
+                if (err) {
+                    this.pendingCommands.delete(id);
+                    reject(err);
+                }
+            });
         });
     }
     on(event, fn) {
@@ -95,9 +108,13 @@ export class CdpClient {
         return [promise, () => off()];
     }
     close() {
+        this.connected = false;
+        for (const { reject: r } of this.pendingCommands.values())
+            r(new Error('CDP connection closed'));
+        this.pendingCommands.clear();
         this.ws?.close();
         this.ws = null;
-        this.connected = false;
+        this.eventListeners.clear();
     }
     isConnected() {
         return this.connected;
@@ -110,7 +127,7 @@ export async function fetchTargets(port) {
     return res.json();
 }
 export async function fetchNewTarget(port, url) {
-    const res = await fetch(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(url)}`);
+    const res = await fetch(`http://127.0.0.1:${port}/json/new?${url}`);
     if (!res.ok)
         throw new Error(`Failed to create target: ${res.statusText}`);
     return res.json();

package/packages/@monomind/cli/dist/src/browser/console-log.d.ts

@@ -19,4 +19,5 @@ export declare function getConsoleMessages(sessionId?: string): ConsoleMessage[]
 export declare function clearConsoleMessages(sessionId?: string): void;
 export declare function getPageErrors(sessionId?: string): PageError[];
 export declare function clearPageErrors(sessionId?: string): void;
+export declare function teardownConsoleCapture(sessionId: string): void;
 //# sourceMappingURL=console-log.d.ts.map

package/packages/@monomind/cli/dist/src/browser/console-log.js

@@ -17,6 +17,7 @@ export function setupConsoleCapture(client, sessionId) {
     if (prevOffs) {
         for (const off of prevOffs)
             off();
+        _consoleListeners.delete(sessionId);
     }
     _consoleMessages.set(sessionId, []);
     _pageErrors.set(sessionId, []);
@@ -25,8 +26,9 @@ export function setupConsoleCapture(client, sessionId) {
             return;
         const args = params.args ?? [];
         const text = args.map((a) => a.description ?? String(a.value ?? '')).join(' ');
+        const rawType = params.type === 'warning' ? 'warn' : params.type;
         messagesFor(sessionId).push({
-            type: params.type ?? 'log',
+            type: rawType ?? 'log',
             text,
             timestamp: Date.now(),
         });
@@ -35,8 +37,10 @@ export function setupConsoleCapture(client, sessionId) {
         if (sid !== sessionId)
             return;
         const entry = params.entry;
+        // CDP uses 'warning' but ConsoleMessage type uses 'warn'
+        const rawLevel = entry.level === 'warning' ? 'warn' : entry.level;
         messagesFor(sessionId).push({
-            type: entry.level ?? 'log',
+            type: rawLevel ?? 'log',
             text: entry.text ?? '',
             timestamp: Date.now(),
             url: entry.url,
@@ -47,8 +51,9 @@ export function setupConsoleCapture(client, sessionId) {
         if (sid !== sessionId)
             return;
         const detail = params.exceptionDetails;
+        const message = detail.exception?.description ?? detail.text ?? 'Unknown error';
         errorsFor(sessionId).push({
-            text: detail.text ?? 'Unknown error',
+            text: message,
             url: detail.url,
             lineNumber: detail.lineNumber,
             columnNumber: detail.columnNumber,
@@ -58,6 +63,7 @@ export function setupConsoleCapture(client, sessionId) {
     _consoleListeners.set(sessionId, [off1, off2, off3]);
 }
 export async function enableConsoleCapture(client, sessionId) {
+    await client.send('Runtime.enable', {}, sessionId);
     await client.send('Log.enable', {}, sessionId);
 }
 export function getConsoleMessages(sessionId) {
@@ -85,4 +91,14 @@ export function clearPageErrors(sessionId) {
     }
     _pageErrors.clear();
 }
+export function teardownConsoleCapture(sessionId) {
+    const offs = _consoleListeners.get(sessionId);
+    if (offs) {
+        for (const off of offs)
+            off();
+        _consoleListeners.delete(sessionId);
+    }
+    _consoleMessages.delete(sessionId);
+    _pageErrors.delete(sessionId);
+}
 //# sourceMappingURL=console-log.js.map

package/packages/@monomind/cli/dist/src/browser/dialog.js

@@ -13,8 +13,11 @@ export function setupDialogAutoHandling(client, sessionId, autoAccept = true) {
             defaultPrompt: params.defaultPrompt,
         };
         _pendingDialogs.set(sessionId, info);
-        if (autoAccept && (info.type === 'alert' || info.type === 'beforeunload')) {
-            await client.send('Page.handleJavaScriptDialog', { accept: true }, sessionId);
+        if (autoAccept) {
+            try {
+                await client.send('Page.handleJavaScriptDialog', { accept: true }, sessionId);
+            }
+            catch { /* dialog may have already been dismissed */ }
             _pendingDialogs.set(sessionId, null);
         }
     });