monomind 1.10.33 → 1.10.34

package/.claude/helpers/intelligence.cjs

@@ -10,11 +10,12 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const DATA_DIR = path.join(process.cwd(), '.monomind', 'data');
+const _CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const DATA_DIR = path.join(_CWD, '.monomind', 'data');
 const STORE_PATH = path.join(DATA_DIR, 'auto-memory-store.json');
 const RANKED_PATH = path.join(DATA_DIR, 'ranked-context.json');
 const PENDING_PATH = path.join(DATA_DIR, 'pending-insights.jsonl');
-const SESSION_DIR = path.join(process.cwd(), '.monomind', 'sessions');
+const SESSION_DIR = path.join(_CWD, '.monomind', 'sessions');
 const SESSION_FILE = path.join(SESSION_DIR, 'current.json');
 
 // ── Safety limits (fixes #1530, #1531) ─────────────────────────────────────

package/.claude/helpers/session.cjs

@@ -12,7 +12,8 @@ const platform = os.platform();
 const homeDir = os.homedir();
 
 function getDataDir() {
-  const localDir = path.join(process.cwd(), '.monomind', 'sessions');
+  const baseDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const localDir = path.join(baseDir, '.monomind', 'sessions');
   if (fs.existsSync(path.dirname(localDir))) {
     return localDir;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.10.33",
+  "version": "1.10.34",
   "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/browser.js

@@ -4,6 +4,8 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { CdpClient, fetchTargets, fetchNewTarget } from './cdp.js';
 import { CHROME_EXECUTABLES } from './types.js';
+import { enableConsoleCapture } from './console-log.js';
+import { setupDialogAutoHandling } from './dialog.js';
 const DEFAULT_PORT = 9222;
 const LAUNCH_TIMEOUT = 10_000;
 const POLL_INTERVAL = 200;
@@ -112,6 +114,9 @@ export async function connectToTarget(port, targetId) {
         client.send('DOM.enable', {}, sessionId),
         client.send('Accessibility.enable', {}, sessionId),
     ]);
+    // Wire up auto-capture listeners so console/errors/dialogs work immediately
+    enableConsoleCapture(client, sessionId);
+    setupDialogAutoHandling(client, sessionId);
     return { client, target, sessionId };
 }
 export async function openUrl(client, sessionId, url) {
@@ -122,7 +127,7 @@ export async function waitForLoad(client, sessionId, condition = 'load', timeout
     if (condition === 'load' || condition === 'domcontentloaded') {
         const event = condition === 'load' ? 'Page.loadEventFired' : 'Page.domContentEventFired';
         await Promise.race([
-            client.once(event),
+            client.once(event, sessionId),
             sleep(timeout).then(() => { throw new Error(`Timeout waiting for ${condition}`); }),
         ]);
         return;
@@ -137,16 +142,23 @@ async function waitForNetworkIdle(client, sessionId, idleMs) {
     return new Promise((resolve) => {
         let pending = 0;
         let timer = null;
+        const settle = () => {
+            offReq();
+            offResp();
+            offFail();
+            resolve();
+        };
         const check = () => {
             if (pending === 0) {
                 if (timer)
                     clearTimeout(timer);
-                timer = setTimeout(resolve, idleMs);
+                timer = setTimeout(settle, idleMs);
             }
             else {
-                if (timer)
+                if (timer) {
                     clearTimeout(timer);
-                timer = null;
+                    timer = null;
+                }
             }
         };
         const offReq = client.on('Network.requestWillBeSent', (_, sid) => {
@@ -168,14 +180,6 @@ async function waitForNetworkIdle(client, sessionId, idleMs) {
             }
         });
         check();
-        // Cleanup after resolution
-        const originalResolve = resolve;
-        resolve = () => {
-            offReq();
-            offResp();
-            offFail();
-            originalResolve();
-        };
     });
 }
 export async function getCurrentUrl(client, sessionId) {

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

@@ -8,7 +8,7 @@ export declare class CdpClient {
     connect(wsUrl: string): Promise<void>;
     send<T = Record<string, unknown>>(method: string, params?: Record<string, unknown>, sessionId?: string): Promise<T>;
     on(event: string, fn: (params: Record<string, unknown>, sessionId?: string) => void): () => void;
-    once(event: string): Promise<Record<string, unknown>>;
+    once(event: string, sessionId?: string): Promise<Record<string, unknown>>;
     close(): void;
     isConnected(): boolean;
 }

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

@@ -74,9 +74,11 @@ export class CdpClient {
         this.eventListeners.get(event).add(fn);
         return () => this.eventListeners.get(event)?.delete(fn);
     }
-    once(event) {
+    once(event, sessionId) {
         return new Promise((resolve) => {
-            const off = this.on(event, (params) => {
+            const off = this.on(event, (params, sid) => {
+                if (sessionId !== undefined && sid !== sessionId)
+                    return;
                 off();
                 resolve(params);
             });

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

@@ -31,7 +31,7 @@ async function waitForLoad(client, sessionId, condition, timeout) {
     }
     const event = condition === 'load' ? 'Page.loadEventFired' : 'Page.domContentEventFired';
     await Promise.race([
-        client.once(event),
+        client.once(event, sessionId),
         sleep(timeout).then(() => { throw new Error(`Timeout waiting for ${condition}`); }),
     ]);
 }

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

@@ -1066,17 +1066,18 @@ const cookiesCommand = {
                 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>');
+                // Support both: cookies set --name n --value v  AND  cookies set <name> <value>
+                const name = ctx.flags.name ?? ctx.args[1];
+                const value = ctx.flags.value ?? ctx.args[2];
+                if (!name || value === undefined) {
+                    throw new Error('Usage: monomind browse cookies set <name> <value> [--domain <d>]');
                 }
+                await browser.setCookies(client, sessionId, [{
+                        name,
+                        value,
+                        domain: ctx.flags.domain,
+                    }]);
+                output.printSuccess(`Cookie set: ${name}`);
                 break;
             }
             case 'clear':

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.10.33",
+  "version": "1.10.34",
   "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",