npm - monomind - Versions diffs - 1.14.6 → 1.15.0 - Mend

monomind 1.14.6 → 1.15.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (314) hide show

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.14.6",
+  "version": "1.15.0",
   "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",
@@ -20,6 +20,10 @@
     "bin/**",
     "packages/@monomind/cli/bin/**",
     "packages/@monomind/cli/dist/**/*.js",
+    "packages/@monomind/cli/dist/**/*.mjs",
+    "packages/@monomind/cli/dist/**/*.html",
+    "packages/@monomind/cli/dist/**/*.json",
+    "packages/@monomind/cli/dist/**/*.svg",
     "packages/@monomind/cli/dist/**/*.d.ts",
     "!packages/@monomind/cli/dist/**/*.map",
     "packages/@monomind/cli/bundled-graph/**",
@@ -56,7 +60,9 @@
   },
   "dependencies": {
     "semver": "^7.6.0",
-    "@monoes/monograph": "^1.1.0"
+    "@monoes/monograph": "^1.2.1",
+    "@monoes/monobrowse": "^1.0.0",
+    "@monoes/monoplaybook": "^1.0.0"
   },
   "overrides": {
     "hono": ">=4.12.21",

package/packages/@monomind/cli/bin/cli.js CHANGED Viewed

@@ -214,7 +214,9 @@ if (isMCPMode) {
   const { CLI } = await import('../dist/src/index.js');
   const cli = new CLI();
-  cli.run().catch((error) => {
+  cli.run().then(() => {
+    process.exit(process.exitCode ?? 0);
+  }).catch((error) => {
     console.error('Fatal error:', safeMsg(error && error.message));
     process.exit(1);
   });

package/packages/@monomind/cli/dist/dashboard/server.js ADDED Viewed

@@ -0,0 +1,137 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDashboard = startDashboard;
+exports.getDashboard = getDashboard;
+var node_http_1 = require("node:http");
+var node_fs_1 = require("node:fs");
+var node_path_1 = require("node:path");
+var node_url_1 = require("node:url");
+var node_module_1 = require("node:module");
+var _require = (0, node_module_1.createRequire)(import.meta.url);
+var __dirname = (0, node_path_1.dirname)((0, node_url_1.fileURLToPath)(import.meta.url));
+var DEFAULT_PORT = parseInt((_a = process.env['MONOBROWSE_DASHBOARD_PORT']) !== null && _a !== void 0 ? _a : '4242', 10);
+var MAX_RUN_HISTORY = 50;
+var instance = null;
+function startDashboard(port) {
+    var _a;
+    if (port === void 0) { port = DEFAULT_PORT; }
+    if (instance)
+        return instance;
+    var runHistory = [];
+    var stopRequests = new Set();
+    var clients = new Set(); // WebSocket or SSE response
+    // Try to load ws, fall back to SSE
+    var WebSocketServer = null;
+    try {
+        var wsModule = _require('ws');
+        WebSocketServer = (_a = wsModule.WebSocketServer) !== null && _a !== void 0 ? _a : wsModule.Server;
+    }
+    catch (_b) {
+        // ws not available — fall back to SSE
+    }
+    // ui.html must be copied to dist/ alongside server.js during build
+    var uiHtml;
+    try {
+        uiHtml = (0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, 'ui.html'), 'utf-8');
+    }
+    catch (_c) {
+        uiHtml = "<!DOCTYPE html><html><head><title>monobrowse dashboard</title></head><body style=\"background:#0f0f1a;color:#ccc;font-family:system-ui;padding:20px\"><h1>monobrowse dashboard</h1><p>Dashboard UI not found. Run the build to include ui.html.</p><script>const es=new EventSource('/events');es.onmessage=e=>console.log(JSON.parse(e.data));</script></body></html>";
+    }
+    var server = (0, node_http_1.createServer)(function (req, res) {
+        var _a;
+        var url = (_a = req.url) !== null && _a !== void 0 ? _a : '/';
+        if (url === '/' && req.method === 'GET') {
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(uiHtml);
+            return;
+        }
+        if (url === '/runs' && req.method === 'GET') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(runHistory));
+            return;
+        }
+        if (url.startsWith('/stop/') && req.method === 'POST') {
+            var runId = url.slice(6);
+            stopRequests.add(runId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, runId: runId }));
+            return;
+        }
+        if (url === '/events' && (req.method === 'GET' || req.method === 'HEAD') && !WebSocketServer) {
+            // SSE endpoint (fallback when ws not available).
+            // No CORS header — the dashboard is served from 127.0.0.1:4242 and no cross-origin
+            // access is needed. A wildcard ACAO would let any web page subscribe to workflow events.
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+            });
+            res.write("data: ".concat(JSON.stringify({ type: 'connected' }), "\n\n"));
+            clients.add(res);
+            req.on('close', function () { return clients.delete(res); });
+            return;
+        }
+        res.writeHead(404);
+        res.end('Not found');
+    });
+    if (WebSocketServer) {
+        var wss = new WebSocketServer({ server: server });
+        wss.on('connection', function (ws) {
+            clients.add(ws);
+            ws.send(JSON.stringify({ type: 'history', runs: runHistory }));
+            ws.on('close', function () { return clients.delete(ws); });
+        });
+    }
+    server.on('error', function (err) {
+        if (err.code === 'EADDRINUSE') {
+            console.error("Dashboard port ".concat(port, " is already in use. Set MONOBROWSE_DASHBOARD_PORT to use a different port."));
+        }
+        else {
+            console.error("Dashboard server error: ".concat(err.message));
+        }
+        instance = null;
+        process.exit(1);
+    });
+    server.listen(port, '127.0.0.1');
+    function broadcast(event) {
+        var msg = JSON.stringify(event);
+        for (var _i = 0, clients_1 = clients; _i < clients_1.length; _i++) {
+            var client = clients_1[_i];
+            try {
+                if (typeof client.send === 'function') {
+                    client.send(msg); // WebSocket
+                }
+                else {
+                    client.write("data: ".concat(msg, "\n\n")); // SSE
+                }
+            }
+            catch (_a) {
+                clients.delete(client);
+            }
+        }
+    }
+    function addRunRecord(record) {
+        var idx = runHistory.findIndex(function (r) { return r.id === record.id; });
+        if (idx >= 0) {
+            runHistory[idx] = record;
+        }
+        else {
+            runHistory.unshift(record);
+            if (runHistory.length > MAX_RUN_HISTORY)
+                runHistory.pop();
+        }
+    }
+    function isStopRequested(runId) {
+        return stopRequests.has(runId);
+    }
+    function close() {
+        server.close();
+        instance = null;
+    }
+    instance = { broadcast: broadcast, addRunRecord: addRunRecord, isStopRequested: isStopRequested, close: close, port: port };
+    return instance;
+}
+function getDashboard() {
+    return instance;
+}

package/packages/@monomind/cli/dist/src/__tests__/browse-adapters.test.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=browse-adapters.test.d.ts.map

package/packages/@monomind/cli/dist/src/__tests__/browse-adapters.test.js ADDED Viewed

@@ -0,0 +1,51 @@
+// src/__tests__/browse-adapters.test.ts
+import { describe, it, expect, vi } from 'vitest';
+import { getAdapter, adapters } from '@monoes/monobrowse';
+function mockPage(isLoggedIn, username = 'testuser') {
+    return {
+        evaluate: vi.fn().mockImplementation((expr) => {
+            if (expr.includes('querySelector'))
+                return Promise.resolve(isLoggedIn ? true : false);
+            return Promise.resolve(username);
+        }),
+        url: vi.fn().mockResolvedValue('https://example.com'),
+    };
+}
+describe('adapter registry', () => {
+    it('has all 6 platforms', () => {
+        expect(adapters.size).toBe(6);
+        for (const p of ['linkedin', 'instagram', 'x', 'gemini', 'google', 'microsoft']) {
+            expect(adapters.has(p)).toBe(true);
+        }
+    });
+    it('getAdapter throws for unknown platform', () => {
+        expect(() => getAdapter('myspace')).toThrow('Unknown platform');
+    });
+});
+describe('each adapter', () => {
+    const platforms = ['linkedin', 'instagram', 'x', 'gemini', 'google', 'microsoft'];
+    for (const platform of platforms) {
+        describe(platform, () => {
+            const adapter = getAdapter(platform);
+            it('has required fields', () => {
+                expect(typeof adapter.platform).toBe('string');
+                expect(adapter.baseURL).toMatch(/^https?:\/\//);
+                expect(Array.isArray(adapter.reservedPaths)).toBe(true);
+                expect(adapter.reservedPaths.length).toBeGreaterThan(0);
+                expect(typeof adapter.loginURL()).toBe('string');
+            });
+            it('isLoggedIn returns boolean', async () => {
+                const page = mockPage(true);
+                const result = await adapter.isLoggedIn(page);
+                expect(typeof result).toBe('boolean');
+            });
+            it('extractUsername returns string', async () => {
+                const page = mockPage(true);
+                page.evaluate = vi.fn().mockResolvedValue('johndoe');
+                const username = await adapter.extractUsername(page);
+                expect(typeof username).toBe('string');
+            });
+        });
+    }
+});
+//# sourceMappingURL=browse-adapters.test.js.map

package/packages/@monomind/cli/dist/src/__tests__/browse-analyzer.test.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=browse-analyzer.test.d.ts.map

package/packages/@monomind/cli/dist/src/__tests__/browse-analyzer.test.js ADDED Viewed

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Shared mock instance so tests can override `create` per-test
+const mockCreate = vi.fn().mockResolvedValue({
+    content: [{
+            type: 'text',
+            text: JSON.stringify({
+                id: 'linkedin:comment_post',
+                platform: 'linkedin',
+                name: 'Comment on Post',
+                params: ['post_url', 'text'],
+                steps: [
+                    { type: 'navigate', url: '{{params.post_url}}' },
+                    { type: 'find', selectors: ['.comment-box'], as: 'box' },
+                    { type: 'click', target: '{{box}}' },
+                    { type: 'type', target: '{{box}}', text: '{{params.text}}', humanDelay: true },
+                    { type: 'wait', condition: 'network_idle', timeout: 3000 },
+                ],
+            }),
+        }],
+});
+// Mock Anthropic SDK before importing analyzer
+vi.mock('@anthropic-ai/sdk', () => {
+    const MockAnthropic = vi.fn(function () {
+        this.messages = { create: mockCreate };
+    });
+    return { default: MockAnthropic };
+});
+function mockPage(url = 'https://linkedin.com/feed', title = 'LinkedIn') {
+    return {
+        url: vi.fn().mockResolvedValue(url),
+        evaluate: vi.fn().mockImplementation((expr) => {
+            if (expr === 'document.title')
+                return Promise.resolve(title);
+            return Promise.resolve('[]'); // empty elements for DOM capture
+        }),
+    };
+}
+describe('analyzePageForAction', () => {
+    let analyzePageForAction;
+    beforeEach(async () => {
+        mockCreate.mockClear();
+        const mod = await import('@monoes/monobrowse');
+        analyzePageForAction = mod.analyzePageForAction;
+    });
+    it('returns a valid ActionDef from mocked Claude response', async () => {
+        const page = mockPage();
+        // Pass a dummy key via options (Anthropic SDK is mocked — no real call is made)
+        const result = await analyzePageForAction(page, 'comment on a LinkedIn post', { apiKey: 'sk-test' });
+        expect(result.id).toBe('linkedin:comment_post');
+        expect(result.steps).toHaveLength(5);
+        expect(result.params).toContain('text');
+    });
+    it('throws on invalid JSON from Claude', async () => {
+        mockCreate.mockResolvedValueOnce({
+            content: [{ type: 'text', text: 'not json at all' }],
+        });
+        const page = mockPage();
+        await expect(analyzePageForAction(page, 'test', { apiKey: 'sk-test' })).rejects.toThrow('invalid JSON');
+    });
+    it('throws when ActionDef is missing id', async () => {
+        mockCreate.mockResolvedValueOnce({
+            content: [{ type: 'text', text: JSON.stringify({ steps: [] }) }],
+        });
+        const page = mockPage();
+        await expect(analyzePageForAction(page, 'test', { apiKey: 'sk-test' })).rejects.toThrow('invalid ActionDef');
+    });
+});
+//# sourceMappingURL=browse-analyzer.test.js.map

package/packages/@monomind/cli/dist/src/__tests__/browse-builtin-handlers.test.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=browse-builtin-handlers.test.d.ts.map

package/packages/@monomind/cli/dist/src/__tests__/browse-builtin-handlers.test.js ADDED Viewed

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// Mock fs/promises before importing the module under test
+vi.mock('node:fs/promises', () => ({
+    writeFile: vi.fn().mockResolvedValue(undefined),
+    readFile: vi.fn().mockRejectedValue(new Error('no file')),
+    mkdir: vi.fn().mockResolvedValue(undefined),
+    chmod: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn().mockReturnValue(false),
+}));
+// Mock the browser module so gemini_image CDP path returns null immediately
+vi.mock('../browser/index.js', () => ({
+    connectToTarget: vi.fn().mockRejectedValue(new Error('no browser')),
+    setCookies: vi.fn(),
+    openUrl: vi.fn(),
+    findByRole: vi.fn(),
+    findBySelector: vi.fn(),
+    clickElement: vi.fn(),
+    fillElement: vi.fn(),
+    pressKey: vi.fn(),
+    evaluateJs: vi.fn(),
+    getCookies: vi.fn().mockResolvedValue([]),
+    getCurrentUrl: vi.fn().mockResolvedValue(''),
+    captureScreenshot: vi.fn().mockResolvedValue(null),
+}));
+import { createBuiltinHandlers } from '@monoes/monobrowse';
+import * as fsMock from 'node:fs/promises';
+function makeItem(data = {}) {
+    return { data };
+}
+describe('createBuiltinHandlers', () => {
+    it('returns a Map with the expected handler keys', () => {
+        const handlers = createBuiltinHandlers();
+        expect(handlers).toBeInstanceOf(Map);
+        expect(handlers.has('action.http')).toBe(true);
+        expect(handlers.has('action.save_file')).toBe(true);
+        expect(handlers.has('action.log')).toBe(true);
+        expect(handlers.has('action.gemini_image')).toBe(true);
+    });
+});
+describe('action.save_file', () => {
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // existsSync stays false — no sessions file
+        handlers = createBuiltinHandlers();
+    });
+    it('writes a file for a safe relative path', async () => {
+        const handler = handlers.get('action.save_file');
+        const items = [makeItem({ hello: 'world' })];
+        const result = await handler(items, { path: 'output.txt' });
+        expect(fsMock.writeFile).toHaveBeenCalled();
+        expect(result[0].data.savedPath).toMatch(/output\.txt$/);
+    });
+    it('throws "Path traversal blocked" for a path that escapes cwd', async () => {
+        const handler = handlers.get('action.save_file');
+        const items = [makeItem()];
+        await expect(handler(items, { path: '../../etc/passwd' })).rejects.toThrow('Path traversal blocked');
+    });
+    it('writes binary content when item.binaryBase64 is set', async () => {
+        const handler = handlers.get('action.save_file');
+        const binaryItem = { data: {}, binaryBase64: Buffer.from('abc').toString('base64') };
+        const result = await handler([binaryItem], { path: 'img.png' });
+        expect(fsMock.writeFile).toHaveBeenCalled();
+        const [, content] = vi.mocked(fsMock.writeFile).mock.calls[0];
+        expect(Buffer.isBuffer(content)).toBe(true);
+        expect(result[0].data.savedPath).toMatch(/img\.png$/);
+    });
+    it('uses config.content when no field is provided', async () => {
+        const handler = handlers.get('action.save_file');
+        const items = [makeItem()];
+        const result = await handler(items, { path: 'out.txt', content: 'hello content' });
+        const [, written] = vi.mocked(fsMock.writeFile).mock.calls[0];
+        expect(written).toBe('hello content');
+        expect(result[0].data.savedPath).toMatch(/out\.txt$/);
+    });
+});
+describe('action.gemini_image', () => {
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = createBuiltinHandlers();
+    });
+    it('falls back to mock mode when browser and API key are unavailable', async () => {
+        const handler = handlers.get('action.gemini_image');
+        // No GEMINI_API_KEY set, browser import throws — mock mode
+        delete process.env['GEMINI_API_KEY'];
+        delete process.env['GOOGLE_API_KEY'];
+        const items = [makeItem({ prompt: 'a beautiful sunset' })];
+        const result = await handler(items, { prompt: 'a beautiful sunset', cdpPort: 19999 });
+        expect(result[0].data.mockMode).toBe(true);
+        expect(result[0].data.prompt).toBe('a beautiful sunset');
+    });
+    it('throws "Path traversal blocked" for outputPath outside cwd', async () => {
+        const handler = handlers.get('action.gemini_image');
+        delete process.env['GEMINI_API_KEY'];
+        delete process.env['GOOGLE_API_KEY'];
+        const items = [makeItem()];
+        await expect(handler(items, { prompt: 'test', outputPath: '../../evil.png', cdpPort: 19999 })).rejects.toThrow('Path traversal blocked');
+    });
+});
+describe('action.http', () => {
+    let handlers;
+    const originalFetch = globalThis.fetch;
+    beforeEach(() => {
+        handlers = createBuiltinHandlers();
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it('fetches a URL and stores response in item.data.response', async () => {
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            text: async () => JSON.stringify({ success: true }),
+        });
+        globalThis.fetch = mockFetch;
+        const handler = handlers.get('action.http');
+        const items = [makeItem()];
+        const result = await handler(items, { url: 'https://example.com/api', method: 'GET' });
+        expect(mockFetch).toHaveBeenCalledWith('https://example.com/api', expect.objectContaining({ method: 'GET' }));
+        expect(result[0].data.response.statusCode).toBe(200);
+        expect(result[0].data.response.json).toEqual({ success: true });
+    });
+    it('uses a custom responseField when specified', async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 201,
+            text: async () => 'created',
+        });
+        const handler = handlers.get('action.http');
+        const items = [makeItem()];
+        const result = await handler(items, { url: 'https://example.com', responseField: 'myResult' });
+        expect(result[0].data.myResult).toBeDefined();
+        expect(result[0].data.myResult.statusCode).toBe(201);
+    });
+});
+//# sourceMappingURL=browse-builtin-handlers.test.js.map

package/packages/@monomind/cli/dist/src/__tests__/browse-cdp.test.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=browse-cdp.test.d.ts.map

package/packages/@monomind/cli/dist/src/__tests__/browse-cdp.test.js ADDED Viewed

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// ---------------------------------------------------------------------------
+// Fake WebSocket — mimics the Node.js EventEmitter-style API that 'ws' uses
+// ---------------------------------------------------------------------------
+class FakeWS {
+    readyState = 1; // OPEN
+    sent = [];
+    _handlers = {};
+    on(event, fn) {
+        if (!this._handlers[event])
+            this._handlers[event] = [];
+        this._handlers[event].push(fn);
+        return this;
+    }
+    send(data, cb) {
+        this.sent.push(data);
+        cb?.();
+    }
+    close() {
+        this.emit('close');
+    }
+    emit(event, ...args) {
+        for (const fn of this._handlers[event] ?? [])
+            fn(...args);
+    }
+    /** Simulate a message arriving from the browser */
+    simulateMessage(obj) {
+        this.emit('message', JSON.stringify(obj));
+    }
+}
+// ---------------------------------------------------------------------------
+// Module-level reference so test helpers can access the last FakeWS instance
+// ---------------------------------------------------------------------------
+let fakeWsInstance = null;
+// We need WebSocket to be constructable.  Use vi.fn() and expose a class-like
+// constructor that captures the instance.
+function FakeWebSocket(_url) {
+    fakeWsInstance = new FakeWS();
+    Object.assign(this, fakeWsInstance);
+    // Proxy the FakeWS methods onto `this`
+    for (const key of Object.getOwnPropertyNames(FakeWS.prototype)) {
+        if (key !== 'constructor') {
+            this[key] = fakeWsInstance[key].bind(fakeWsInstance);
+        }
+    }
+    // Also expose sent and emit directly on `this`
+    Object.defineProperty(this, 'sent', {
+        get: () => fakeWsInstance.sent,
+        configurable: true,
+    });
+}
+vi.mock('ws', () => ({
+    WebSocket: FakeWebSocket,
+}));
+import { CdpClient } from '@monoes/monobrowse';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function openClient() {
+    const client = new CdpClient();
+    client.connect('ws://localhost:9222/devtools/page/abc');
+    const ws = fakeWsInstance;
+    ws.emit('open');
+    return { client, ws };
+}
+async function connectedClient() {
+    const { client, ws } = openClient();
+    await Promise.resolve();
+    return { client, ws };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('CdpClient', () => {
+    beforeEach(() => {
+        fakeWsInstance = null;
+        vi.clearAllMocks();
+    });
+    it('connects and resolves when the WebSocket opens', async () => {
+        const client = new CdpClient();
+        const p = client.connect('ws://localhost:9222/devtools/page/abc');
+        fakeWsInstance.emit('open');
+        await expect(p).resolves.toBeUndefined();
+        expect(client.isConnected()).toBe(true);
+    });
+    it('rejects when the WebSocket emits an error before opening', async () => {
+        const client = new CdpClient();
+        const p = client.connect('ws://localhost:9222/devtools/page/abc');
+        const err = new Error('ECONNREFUSED');
+        fakeWsInstance.emit('error', err);
+        await expect(p).rejects.toThrow('ECONNREFUSED');
+    });
+    it('sends a command and resolves with the response result', async () => {
+        const { client, ws } = await connectedClient();
+        const sendPromise = client.send('Runtime.evaluate', { expression: '1+1' });
+        const sent = JSON.parse(ws.sent[0]);
+        expect(sent.method).toBe('Runtime.evaluate');
+        ws.simulateMessage({ id: sent.id, result: { value: 2 } });
+        const result = await sendPromise;
+        expect(result.value).toBe(2);
+    });
+    it('rejects a command when the response contains a CDP error', async () => {
+        const { client, ws } = await connectedClient();
+        const sendPromise = client.send('DOM.getDocument');
+        const sent = JSON.parse(ws.sent[0]);
+        ws.simulateMessage({ id: sent.id, error: { code: -32000, message: 'Not found' } });
+        await expect(sendPromise).rejects.toThrow('CDP error -32000: Not found');
+    });
+    it('rejects when not connected', async () => {
+        const client = new CdpClient();
+        await expect(client.send('Page.navigate')).rejects.toThrow('CDP not connected');
+    });
+    it('enforces 1000 in-flight command cap', async () => {
+        const { client, ws } = await connectedClient();
+        // Override send to avoid callbacks so commands stay pending
+        vi.spyOn(ws, 'send').mockImplementation((data) => {
+            ws.sent.push(data);
+        });
+        // Fill up to 1000 pending
+        for (let i = 0; i < 1000; i++) {
+            client.send('Page.dummy').catch(() => { });
+        }
+        // 1001st command should be rejected immediately
+        await expect(client.send('Page.overflow')).rejects.toThrow('queue full');
+    });
+    it('rejects all pending commands when the connection closes', async () => {
+        const { client, ws } = await connectedClient();
+        vi.spyOn(ws, 'send').mockImplementation((data) => {
+            ws.sent.push(data);
+            // no callback — keeps command in-flight
+        });
+        const pendingPromise = client.send('Page.navigate');
+        ws.emit('close');
+        await expect(pendingPromise).rejects.toThrow('CDP connection closed');
+        expect(client.isConnected()).toBe(false);
+    });
+    it('fires event listeners when a CDP event arrives', async () => {
+        const { client, ws } = await connectedClient();
+        const listener = vi.fn();
+        client.on('Page.loadEventFired', listener);
+        ws.simulateMessage({ method: 'Page.loadEventFired', params: { timestamp: 1.23 } });
+        expect(listener).toHaveBeenCalledWith({ timestamp: 1.23 }, undefined);
+    });
+    it('enforces 100 listener cap per event', async () => {
+        const { client } = await connectedClient();
+        for (let i = 0; i < 100; i++) {
+            client.on('Page.frameNavigated', vi.fn());
+        }
+        expect(() => client.on('Page.frameNavigated', vi.fn())).toThrow('CDP event listener limit reached');
+    });
+    it('close() rejects pending commands and disconnects', async () => {
+        const { client, ws } = await connectedClient();
+        vi.spyOn(ws, 'send').mockImplementation((data) => {
+            ws.sent.push(data);
+        });
+        const p = client.send('Network.enable');
+        client.close();
+        await expect(p).rejects.toThrow('CDP connection closed');
+        expect(client.isConnected()).toBe(false);
+    });
+    it('once() resolves on the first matching event', async () => {
+        const { client, ws } = await connectedClient();
+        const oncePromise = client.once('Page.loadEventFired');
+        ws.simulateMessage({ method: 'Page.loadEventFired', params: { timestamp: 99 } });
+        const params = await oncePromise;
+        expect(params).toEqual({ timestamp: 99 });
+    });
+});
+//# sourceMappingURL=browse-cdp.test.js.map

package/packages/@monomind/cli/dist/src/__tests__/browse-dashboard.test.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=browse-dashboard.test.d.ts.map