monomind 1.10.39 → 1.10.41

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

@@ -6,20 +6,20 @@ export async function listTabs(port) {
 export async function newTab(port, url = 'about:blank') {
     return fetchNewTarget(port, url);
 }
-export async function closeTab(client, sessionId, targetId) {
-    await client.send('Target.closeTarget', { targetId }, sessionId);
+export async function closeTab(client, _sessionId, targetId) {
+    await client.send('Target.closeTarget', { targetId });
 }
-export async function activateTab(client, sessionId, targetId) {
-    await client.send('Target.activateTarget', { targetId }, sessionId);
+export async function activateTab(client, oldSessionId, targetId) {
+    if (oldSessionId) {
+        await client.send('Target.detachFromTarget', { sessionId: oldSessionId }).catch(() => { });
+    }
+    await client.send('Target.activateTarget', { targetId });
+    const result = await client.send('Target.attachToTarget', { targetId, flatten: true });
+    return result.sessionId;
 }
-export async function switchToFrame(client, sessionId, frameSelector) {
-    const result = await client.send('Runtime.evaluate', {
-        expression: `
-      const frame = document.querySelector(${JSON.stringify(frameSelector)});
-      frame ? frame.src || frame.name || null : null
-    `,
-        returnByValue: true,
-    }, sessionId);
-    return result.result?.value ?? null;
+export async function switchToFrame(_client, _sessionId, _frameSelector) {
+    throw new Error('switchToFrame is not yet implemented. ' +
+        'For same-origin frames, CDP commands already apply to the whole page. ' +
+        'For cross-origin (OOPIF) frames, call Target.attachToTarget with the frame target ID.');
 }
 //# sourceMappingURL=tabs.js.map

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

@@ -50,8 +50,13 @@ export async function stopTrace(client, sessionId, outputPath) {
         throw new Error('No active trace for this session');
     try {
         const [completePromise, cancelOnce] = client.onceWithOff('Tracing.tracingComplete', sessionId);
-        let timedOut = false;
-        const timeoutPromise = new Promise((_, reject) => setTimeout(() => { timedOut = true; cancelOnce(); reject(new Error('Timeout waiting for Tracing.tracingComplete')); }, 30_000));
+        let timeoutHandle;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                cancelOnce();
+                reject(new Error('Timeout waiting for Tracing.tracingComplete'));
+            }, 30_000);
+        });
         try {
             await client.send('Tracing.end', {}, sessionId);
             await Promise.race([completePromise, timeoutPromise]);
@@ -60,8 +65,9 @@ export async function stopTrace(client, sessionId, outputPath) {
             cancelOnce();
             throw err;
         }
-        if (timedOut)
-            throw new Error('Timeout waiting for Tracing.tracingComplete');
+        finally {
+            clearTimeout(timeoutHandle);
+        }
     }
     finally {
         state.offData();

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

@@ -32,7 +32,10 @@ async function waitForLoad(client, sessionId, condition, timeout) {
     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)
@@ -40,11 +43,13 @@ async function waitForLoad(client, sessionId, condition, timeout) {
     }
     finally {
         cancelOnce();
+        clearTimeout(timeoutHandle);
     }
 }
 async function waitForNetworkIdle(client, sessionId, idleMs, timeout) {
     return new Promise((resolve, reject) => {
         let pending = 0;
+        const inflight = new Set();
         let idleTimer = null;
         const cleanup = () => {
             if (idleTimer) {
@@ -55,6 +60,7 @@ async function waitForNetworkIdle(client, sessionId, idleMs, timeout) {
             offReq();
             offResp();
             offFail();
+            offCache();
         };
         const killTimer = setTimeout(() => {
             cleanup();
@@ -74,24 +80,28 @@ 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) {
+        const decrement = (params, sid) => {
+            if (sid !== sessionId)
+                return;
+            const id = params.requestId;
+            if (inflight.delete(id)) {
                 pending = Math.max(0, pending - 1);
                 check();
             }
-        });
-        const offFail = client.on('Network.loadingFailed', (_, sid) => {
-            if (sid === sessionId) {
-                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);
         check();
     });
 }
@@ -107,7 +117,7 @@ async function waitForUrl(client, sessionId, pattern, deadline) {
 }
 async function waitForText(client, sessionId, text, deadline) {
     while (Date.now() < deadline) {
-        const bodyText = await evaluateJs(client, sessionId, 'document.body.innerText');
+        const bodyText = await evaluateJs(client, sessionId, 'document.body?.innerText ?? ""');
         if (bodyText.includes(text))
             return;
         await sleep(POLL_INTERVAL);
@@ -128,7 +138,7 @@ function globToRegex(pattern) {
         .replace(/[-[\]{}()+?.,\\^$|#\s]/g, '\\$&')
         .replace(/\*\*/g, '.*')
         .replace(/\*/g, '[^/]*');
-    return new RegExp(escaped);
+    return new RegExp(`^${escaped}$`);
 }
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));

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 };
@@ -471,7 +536,10 @@ const setCommand = {
                 break;
             }
             case 'offline': {
-                const enabled = ctx.args[1] !== 'false';
+                const offlineArg = ctx.args[1];
+                if (offlineArg === undefined)
+                    throw new Error('Usage: set offline <true|false>');
+                const enabled = offlineArg === 'true';
                 await browser.setOfflineMode(client, sessionId, enabled);
                 output.printSuccess(`Offline mode: ${enabled}`);
                 break;
@@ -698,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 = '';
@@ -993,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');
         }
@@ -1087,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
-                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}`);
             }
         }
@@ -1111,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();
+        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));
         }
@@ -1138,11 +1298,11 @@ 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 };
         }
-        const errs = browser.getPageErrors();
+        const errs = browser.getPageErrors(_sessionId);
         if (ctx.flags.json) {
             print(JSON.stringify(errs));
         }
@@ -1192,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 };
         }
@@ -1448,6 +1610,36 @@ const pushstateCommand = {
         return { success: true };
     },
 };
+function tokenizeBatchCommand(input) {
+    const tokens = [];
+    let current = '';
+    let inQuote = null;
+    for (const ch of input.trim()) {
+        if (inQuote) {
+            if (ch === inQuote) {
+                inQuote = null;
+            }
+            else {
+                current += ch;
+            }
+        }
+        else if (ch === '"' || ch === "'") {
+            inQuote = ch;
+        }
+        else if (/\s/.test(ch)) {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
 const batchCommand = {
     name: 'batch',
     description: 'Execute multiple commands. Usage: monomind browse batch "open url" "snapshot -i" "click @e1"',
@@ -1461,7 +1653,7 @@ const batchCommand = {
             throw new Error('Usage: monomind browse batch "cmd1" "cmd2" ...');
         const results = [];
         for (const cmdStr of commands) {
-            const parts = cmdStr.trim().split(/\s+/);
+            const parts = tokenizeBatchCommand(cmdStr);
             const subName = parts[0];
             const subArgs = parts.slice(1);
             const subCmd = browseCommand.subcommands?.find((s) => s.name === subName);
@@ -1474,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);
@@ -1548,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.39",
+  "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",