monomind 1.18.4 → 1.18.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.18.4",
+  "version": "1.18.6",
   "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",
@@ -25,6 +25,8 @@
     "packages/@monomind/cli/dist/**/*.json",
     "packages/@monomind/cli/dist/**/*.svg",
     "packages/@monomind/cli/dist/**/*.d.ts",
+    "!packages/@monomind/cli/dist/**/*.test.js",
+    "!packages/@monomind/cli/dist/**/__tests__/**",
     "!packages/@monomind/cli/dist/**/*.map",
     "packages/@monomind/cli/bundled-graph/**",
     "packages/@monomind/cli/scripts/**/*.mjs",
@@ -50,7 +52,7 @@
     "semver": "^7.6.0",
     "zod": "^3.22.0",
     "@monoes/monobrowse": "^1.0.0",
-    "@monoes/monograph": "1.2.9"
+    "@monoes/monograph": "1.2.10"
   },
   "overrides": {
     "hono": ">=4.12.21",

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.18.4",
+  "version": "1.18.6",
   "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",
@@ -66,6 +66,9 @@
   },
   "files": [
     "dist",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/__tests__/**",
     "bin",
     ".claude",
     "scripts",
@@ -88,7 +91,8 @@
     "@noble/ed25519": "^2.1.0",
     "@monoes/monograph": "workspace:*",
     "@monoes/monobrowse": "^1.0.1",
-    "@monomind/security": "workspace:*"
+    "zod": "^3.25.0",
+    "yaml": "^2.8.0"
   },
   "optionalDependencies": {
     "sql.js": "^1.14.1",
@@ -98,7 +102,8 @@
     "@monomind/hooks": "*",
     "@monomind/guidance": "*",
     "@monomind/mcp": "*",
-    "@monomind/routing": "*"
+    "@monomind/routing": "*",
+    "@monomind/security": "workspace:*"
   },
   "publishConfig": {
     "access": "public",

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

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

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

@@ -1,51 +0,0 @@
-// 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

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

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

@@ -1,68 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { EventEmitter } from 'events';
-// Mock child_process.spawn so tests don't invoke the real claude CLI
-vi.mock('child_process', async (importOriginal) => {
-    const actual = await importOriginal();
-    return { ...actual, spawn: vi.fn() };
-});
-async function makeSpawnMock(stdout, exitCode = 0) {
-    const { spawn } = vi.mocked(await import('child_process'));
-    spawn.mockImplementationOnce(() => {
-        const proc = new EventEmitter();
-        proc.stdout = new EventEmitter();
-        proc.stderr = new EventEmitter();
-        proc.kill = vi.fn();
-        setTimeout(() => {
-            proc.stdout.emit('data', Buffer.from(stdout));
-            proc.emit('close', exitCode);
-        }, 0);
-        return proc;
-    });
-}
-const VALID_ACTION_DEF = {
-    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 },
-    ],
-};
-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('[]');
-        }),
-    };
-}
-describe('analyzePageForAction', () => {
-    let analyzePageForAction;
-    beforeEach(async () => {
-        vi.resetModules();
-        const mod = await import('@monoes/monobrowse');
-        analyzePageForAction = mod.analyzePageForAction;
-    }, 20000); // monolean: re-importing the workspace package can exceed the 10s default under full-suite parallel load
-    it('returns a valid ActionDef from mocked claude --print response', async () => {
-        await makeSpawnMock(JSON.stringify(VALID_ACTION_DEF));
-        const result = await analyzePageForAction(mockPage(), 'comment on a LinkedIn post');
-        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 () => {
-        await makeSpawnMock('not json at all');
-        await expect(analyzePageForAction(mockPage(), 'test')).rejects.toThrow('invalid JSON');
-    });
-    it('throws when ActionDef is missing id', async () => {
-        await makeSpawnMock(JSON.stringify({ steps: [] }));
-        await expect(analyzePageForAction(mockPage(), 'test')).rejects.toThrow('invalid ActionDef');
-    });
-});
-//# sourceMappingURL=browse-analyzer.test.js.map

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

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

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

@@ -1,139 +0,0 @@
-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

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

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

@@ -1,169 +0,0 @@
-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

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

package/packages/@monomind/cli/dist/src/__tests__/browse-dashboard.test.js

@@ -1,179 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { startDashboard, getDashboard } from '@monoes/monobrowse';
-import { WebSocket } from 'ws';
-const PORT = 14242; // Use non-conflicting test port
-const SSE_PORT = 14243; // Separate port for SSE streaming tests
-afterEach(() => {
-    getDashboard()?.close();
-});
-function makeEvent(overrides = {}) {
-    return {
-        runId: 'run-1',
-        playbookId: 'wf-1',
-        playbookName: 'Test WF',
-        nodeId: 'node-1',
-        nodeName: 'Test Node',
-        eventType: 'step_completed',
-        timestamp: Date.now(),
-        ...overrides,
-    };
-}
-describe('startDashboard', () => {
-    it('returns a dashboard server instance', async () => {
-        const dash = startDashboard(PORT);
-        expect(dash).toBeDefined();
-        expect(dash.port).toBe(PORT);
-    });
-    it('returns the same instance on repeated calls', async () => {
-        const a = startDashboard(PORT);
-        const b = startDashboard(PORT);
-        expect(a).toBe(b);
-    });
-    it('serves HTML at GET /', async () => {
-        startDashboard(PORT);
-        const res = await fetch(`http://localhost:${PORT}/`);
-        expect(res.status).toBe(200);
-        expect(res.headers.get('content-type')).toContain('text/html');
-        const body = await res.text();
-        expect(body).toContain('monomind');
-    });
-    it('GET /runs returns JSON array', async () => {
-        const dash = startDashboard(PORT);
-        const run = { id: 'r1', playbookId: 'wf', playbookName: 'WF', status: 'completed', startedAt: Date.now(), itemsProcessed: 1, itemsTotal: 1 };
-        dash.addRunRecord(run);
-        const res = await fetch(`http://localhost:${PORT}/runs`);
-        expect(res.status).toBe(200);
-        const body = await res.json();
-        expect(body.some(r => r.id === 'r1')).toBe(true);
-    });
-    it('POST /stop/:runId marks run as stop-requested', async () => {
-        const dash = startDashboard(PORT);
-        const res = await fetch(`http://localhost:${PORT}/stop/run-abc`, { method: 'POST' });
-        expect(res.status).toBe(200);
-        expect(dash.isStopRequested('run-abc')).toBe(true);
-    });
-    it('isStopRequested returns false for unknown runId', () => {
-        const dash = startDashboard(PORT);
-        expect(dash.isStopRequested('nonexistent')).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// SSE / WebSocket streaming tests
-//
-// The dashboard uses WebSocket (via 'ws') when the package is available, and
-// falls back to Server-Sent Events when it is not.  Since 'ws' IS installed in
-// this repo the server runs in WebSocket mode.  We test the streaming path
-// (broadcast + ?dir= filter) through the WebSocket interface so the tests are
-// consistent regardless of environment.
-// ---------------------------------------------------------------------------
-/**
- * Open a WebSocket to the dashboard, wait for the initial 'history' message,
- * then return a helper that collects subsequent messages.
- */
-function connectWs(port, dir) {
-    return new Promise((resolve, reject) => {
-        const url = dir ? `ws://127.0.0.1:${port}/?dir=${encodeURIComponent(dir)}` : `ws://127.0.0.1:${port}/`;
-        const ws = new WebSocket(url);
-        const messages = [];
-        ws.on('open', () => {
-            // history message arrives; resolve after we have it
-            ws.on('message', (data) => {
-                const parsed = JSON.parse(data.toString());
-                messages.push(parsed);
-                if (messages.length === 1 && parsed.type === 'history') {
-                    resolve({ ws, messages, close: () => ws.close() });
-                }
-            });
-        });
-        ws.on('error', reject);
-        setTimeout(() => reject(new Error('WS connect timeout')), 3000);
-    });
-}
-describe('broadcast via WebSocket', () => {
-    it('delivers events to connected clients', async () => {
-        const dash = startDashboard(PORT);
-        // Wait a tick for the server to be ready
-        await new Promise(r => setTimeout(r, 50));
-        const { ws, messages, close } = await connectWs(PORT);
-        try {
-            // Wait for initial history message, then broadcast
-            dash.broadcast(makeEvent({ eventType: 'step_completed', nodeId: 'node-broadcast-1' }));
-            await new Promise(r => setTimeout(r, 100));
-            const events = messages.filter((m) => m.eventType !== undefined);
-            expect(events.length).toBeGreaterThan(0);
-            expect(events[0].nodeId).toBe('node-broadcast-1');
-        }
-        finally {
-            close();
-        }
-    });
-    it('?dir= filter — client with matching dir receives event', async () => {
-        const dash = startDashboard(PORT);
-        await new Promise(r => setTimeout(r, 50));
-        const dirA = '/projects/alpha';
-        const { messages, close } = await connectWs(PORT, dirA);
-        try {
-            dash.broadcast(makeEvent({ projectDir: dirA, nodeId: 'node-alpha' }));
-            await new Promise(r => setTimeout(r, 100));
-            const events = messages.filter((m) => m.eventType !== undefined);
-            expect(events.length).toBeGreaterThan(0);
-            expect(events[0].nodeId).toBe('node-alpha');
-        }
-        finally {
-            close();
-        }
-    });
-    it('?dir= filter — client with non-matching dir does NOT receive event', async () => {
-        const dash = startDashboard(PORT);
-        await new Promise(r => setTimeout(r, 50));
-        const { messages, close } = await connectWs(PORT, '/projects/beta');
-        try {
-            dash.broadcast(makeEvent({ projectDir: '/projects/alpha', nodeId: 'node-alpha-only' }));
-            await new Promise(r => setTimeout(r, 100));
-            const events = messages.filter((m) => m.eventType !== undefined);
-            expect(events.length).toBe(0);
-        }
-        finally {
-            close();
-        }
-    });
-    it('client without ?dir= receives all broadcasts', async () => {
-        const dash = startDashboard(PORT);
-        await new Promise(r => setTimeout(r, 50));
-        const { messages, close } = await connectWs(PORT);
-        try {
-            dash.broadcast(makeEvent({ projectDir: '/projects/alpha', nodeId: 'all-1' }));
-            dash.broadcast(makeEvent({ projectDir: '/projects/beta', nodeId: 'all-2' }));
-            await new Promise(r => setTimeout(r, 150));
-            const events = messages.filter((m) => m.eventType !== undefined);
-            expect(events.length).toBeGreaterThanOrEqual(2);
-        }
-        finally {
-            close();
-        }
-    });
-});
-describe('GET /events SSE endpoint', () => {
-    it('returns text/event-stream content-type when ws is unavailable', async () => {
-        // The dashboard is already started in ws mode on PORT.
-        // We verify the /events endpoint returns 404 in ws mode (ws is installed),
-        // which confirms the conditional branching works correctly.
-        const dash = startDashboard(PORT);
-        await new Promise(r => setTimeout(r, 50));
-        const res = await fetch(`http://127.0.0.1:${PORT}/events`, {
-            headers: { Accept: 'text/event-stream' },
-        });
-        // In ws mode the SSE endpoint is not registered — server returns 404
-        // In SSE-only mode it would return 200 with text/event-stream
-        // We test what the current mode actually does
-        if (res.status === 200) {
-            expect(res.headers.get('content-type')).toContain('text/event-stream');
-            await res.body?.cancel();
-        }
-        else {
-            // ws mode: SSE not registered
-            expect(res.status).toBe(404);
-        }
-    });
-});
-//# sourceMappingURL=browse-dashboard.test.js.map

package/packages/@monomind/cli/dist/src/__tests__/browse-engine.test.d.ts

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

package/packages/@monomind/cli/dist/src/__tests__/browse-engine.test.js

@@ -1,122 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { runPlaybook } from '@monoes/monobrowse';
-const triggerNode = { id: 'trigger', type: 'trigger.manual', config: {} };
-describe('runPlaybook', () => {
-    it('runs a single-node trigger workflow', async () => {
-        const def = {
-            id: 'wf-1', name: 'Test', nodes: [triggerNode], connections: [],
-        };
-        const record = await runPlaybook(def);
-        expect(record.status).toBe('completed');
-        expect(record.playbookId).toBe('wf-1');
-    });
-    it('rejects cyclic workflow', async () => {
-        const def = {
-            id: 'cyclic', name: 'Cyclic',
-            nodes: [
-                { id: 'a', type: 'core.set', config: {} },
-                { id: 'b', type: 'core.set', config: {} },
-            ],
-            connections: [{ from: 'a', to: 'b' }, { from: 'b', to: 'a' }],
-        };
-        await expect(runPlaybook(def)).rejects.toThrow('cycle');
-    });
-    it('calls node handlers for action nodes', async () => {
-        const handler = vi.fn().mockResolvedValue([{ data: { result: 'ok' } }]);
-        const def = {
-            id: 'wf-2', name: 'Action Test',
-            nodes: [
-                triggerNode,
-                { id: 'act', type: 'action.linkedin.comment_post', config: { text: 'hi' } },
-            ],
-            connections: [{ from: 'trigger', to: 'act' }],
-        };
-        const handlers = new Map([['action.linkedin.comment_post', handler]]);
-        const record = await runPlaybook(def, { handlers });
-        expect(handler).toHaveBeenCalled();
-        expect(record.status).toBe('completed');
-    });
-    it('emits step events in order', async () => {
-        const events = [];
-        const def = { id: 'wf-3', name: 'Events', nodes: [triggerNode], connections: [] };
-        await runPlaybook(def, { onEvent: e => events.push(e.eventType) });
-        expect(events[0]).toBe('run_started');
-        expect(events[events.length - 1]).toBe('run_completed');
-    });
-    it('skips failed node when onError is skip', async () => {
-        const handler = vi.fn().mockRejectedValue(new Error('fail'));
-        const def = {
-            id: 'wf-4', name: 'Skip',
-            nodes: [
-                triggerNode,
-                { id: 'bad', type: 'action.x.fail', config: {}, onError: 'skip' },
-            ],
-            connections: [{ from: 'trigger', to: 'bad' }],
-        };
-        const handlers = new Map([['action.x.fail', handler]]);
-        const record = await runPlaybook(def, { handlers });
-        expect(record.status).toBe('completed');
-    });
-    it('stops on node failure when onError is stop (default)', async () => {
-        const handler = vi.fn().mockRejectedValue(new Error('boom'));
-        const def = {
-            id: 'wf-5', name: 'Stop',
-            nodes: [
-                triggerNode,
-                { id: 'bad', type: 'action.x.fail', config: {} },
-            ],
-            connections: [{ from: 'trigger', to: 'bad' }],
-        };
-        const handlers = new Map([['action.x.fail', handler]]);
-        const record = await runPlaybook(def, { handlers });
-        expect(record.status).toBe('failed');
-        expect(record.error).toContain('boom');
-    });
-    it('stops when AbortSignal is aborted', async () => {
-        const controller = new AbortController();
-        controller.abort();
-        const def = { id: 'wf-6', name: 'Abort', nodes: [triggerNode], connections: [] };
-        const record = await runPlaybook(def, { signal: controller.signal });
-        expect(record.status).toBe('stopped');
-    });
-    it('core.set transforms item fields', async () => {
-        const def = {
-            id: 'wf-7', name: 'Set',
-            nodes: [
-                { id: 'trigger', type: 'trigger.manual', config: { items: [{ data: { x: 1 } }] } },
-                { id: 'setNode', type: 'core.set', config: { y: 'hardcoded' } },
-            ],
-            connections: [{ from: 'trigger', to: 'setNode' }],
-        };
-        const events = [];
-        const record = await runPlaybook(def, { onEvent: e => events.push(e) });
-        expect(record.status).toBe('completed');
-    });
-    it('throws for unregistered action handler', async () => {
-        const def = {
-            id: 'wf-8', name: 'NoHandler',
-            nodes: [
-                triggerNode,
-                { id: 'act', type: 'action.missing.thing', config: {} },
-            ],
-            connections: [{ from: 'trigger', to: 'act' }],
-        };
-        const record = await runPlaybook(def);
-        expect(record.status).toBe('failed');
-        expect(record.error).toContain('No handler registered');
-    });
-    it('core.filter keeps matching items', async () => {
-        const def = {
-            id: 'wf-filter', name: 'Filter',
-            nodes: [
-                { id: 'trigger', type: 'trigger.manual', config: { items: [{ data: { x: 1 } }, { data: { x: 2 } }, { data: { x: 3 } }] } },
-                { id: 'filter', type: 'core.filter', config: { expression: '{{$json.x}}' } },
-            ],
-            connections: [{ from: 'trigger', to: 'filter' }],
-        };
-        const record = await runPlaybook(def);
-        expect(record.status).toBe('completed');
-        expect(record.itemsProcessed).toBeGreaterThan(0);
-    });
-});
-//# sourceMappingURL=browse-engine.test.js.map

package/packages/@monomind/cli/dist/src/__tests__/browse-expression.test.d.ts

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

package/packages/@monomind/cli/dist/src/__tests__/browse-expression.test.js

@@ -1,54 +0,0 @@
-import { describe, it, expect, afterEach, vi } from 'vitest';
-import { resolveExpression, resolveConfig } from '@monoes/monobrowse';
-const item = { data: { url: 'https://linkedin.com/post/123', comment: 'Great post!' } };
-const nodeOutputs = {
-    'trigger': [{ data: { url: 'https://linkedin.com/post/123' } }],
-};
-const params = { text: 'Hello world', post_url: 'https://linkedin.com/post/123' };
-describe('resolveExpression', () => {
-    it('resolves $json fields', () => {
-        expect(resolveExpression('{{$json.url}}', item, nodeOutputs, params)).toBe('https://linkedin.com/post/123');
-    });
-    it('resolves $env variables', () => {
-        vi.stubEnv('TEST_VAR', 'test-value');
-        expect(resolveExpression('{{$env.TEST_VAR}}', item, nodeOutputs, params)).toBe('test-value');
-    });
-    it('resolves params', () => {
-        expect(resolveExpression('{{params.text}}', item, nodeOutputs, params)).toBe('Hello world');
-    });
-    it('resolves node output references', () => {
-        expect(resolveExpression('{{$node.trigger.url}}', item, nodeOutputs, params)).toBe('https://linkedin.com/post/123');
-    });
-    it('resolves $node bracket notation', () => {
-        expect(resolveExpression('{{$node["trigger"].url}}', item, nodeOutputs, params)).toBe('https://linkedin.com/post/123');
-    });
-    it('returns raw string if no template markers', () => {
-        expect(resolveExpression('plain text', item, nodeOutputs, params)).toBe('plain text');
-    });
-    it('throws on unresolved expression', () => {
-        expect(() => resolveExpression('{{$json.missing}}', item, nodeOutputs, params)).toThrow('Unresolved');
-    });
-    it('replaces duplicate placeholders in a single template', () => {
-        const doubled = { data: { x: 'hello' } };
-        expect(resolveExpression('{{$json.x}} and {{$json.x}}', doubled, {}, {})).toBe('hello and hello');
-    });
-    it('throws when $node output array is empty', () => {
-        expect(() => resolveExpression('{{$node.empty.field}}', item, { empty: [] }, params)).toThrow('Unresolved');
-    });
-    it('throws when $node bracket field is missing', () => {
-        expect(() => resolveExpression('{{$node["trigger"].missing}}', item, nodeOutputs, params)).toThrow('Unresolved');
-    });
-});
-afterEach(() => {
-    vi.unstubAllEnvs();
-});
-describe('resolveConfig', () => {
-    it('resolves all string values in a config object', () => {
-        const config = { post_url: '{{$json.url}}', text: '{{params.text}}', count: 3 };
-        const result = resolveConfig(config, item, nodeOutputs, params);
-        expect(result.post_url).toBe('https://linkedin.com/post/123');
-        expect(result.text).toBe('Hello world');
-        expect(result.count).toBe(3);
-    });
-});
-//# sourceMappingURL=browse-expression.test.js.map

package/packages/@monomind/cli/dist/src/__tests__/browse-store.test.d.ts

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

package/packages/@monomind/cli/dist/src/__tests__/browse-store.test.js

@@ -1,99 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { readPlaybook, writePlaybookRun, listPlaybookRuns, readAction, clearRunStore } from '@monoes/monobrowse';
-import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-const TMP = join(tmpdir(), 'browse-store-test-' + Date.now());
-beforeEach(() => {
-    clearRunStore();
-    mkdirSync(join(TMP, 'playbooks'), { recursive: true });
-    mkdirSync(join(TMP, 'actions'), { recursive: true });
-});
-afterEach(() => {
-    rmSync(TMP, { recursive: true, force: true });
-});
-describe('readPlaybook', () => {
-    it('parses a valid playbook JSON file', async () => {
-        const pb = {
-            id: 'test-pb',
-            name: 'Test Playbook',
-            nodes: [{ id: 'trigger', type: 'trigger.manual', config: {} }],
-            connections: [],
-        };
-        const p = join(TMP, 'playbooks', 'test.json');
-        writeFileSync(p, JSON.stringify(pb));
-        const result = await readPlaybook(p);
-        expect(result.id).toBe('test-pb');
-        expect(result.nodes).toHaveLength(1);
-    });
-    it('throws on missing file', async () => {
-        await expect(readPlaybook(join(TMP, 'nonexistent.json'))).rejects.toThrow();
-    });
-    it('throws on invalid JSON', async () => {
-        const p = join(TMP, 'playbooks', 'bad.json');
-        writeFileSync(p, 'not json');
-        await expect(readPlaybook(p)).rejects.toThrow();
-    });
-    it('throws if nodes array is missing', async () => {
-        const p = join(TMP, 'playbooks', 'no-nodes.json');
-        writeFileSync(p, JSON.stringify({ id: 'x', name: 'y', connections: [] }));
-        await expect(readPlaybook(p)).rejects.toThrow('nodes');
-    });
-});
-describe('readAction', () => {
-    it('parses a valid action JSON file', async () => {
-        const action = {
-            id: 'linkedin:comment_post',
-            platform: 'linkedin',
-            name: 'Comment on Post',
-            params: ['post_url', 'text'],
-            steps: [],
-        };
-        const p = join(TMP, 'actions', 'comment.json');
-        writeFileSync(p, JSON.stringify(action));
-        const result = await readAction(p);
-        expect(result.id).toBe('linkedin:comment_post');
-        expect(result.params).toContain('post_url');
-    });
-    it('throws on missing action file', async () => {
-        await expect(readAction(join(TMP, 'actions', 'nonexistent.json'))).rejects.toThrow();
-    });
-    it('throws on invalid action JSON', async () => {
-        const p = join(TMP, 'actions', 'bad.json');
-        writeFileSync(p, 'not json');
-        await expect(readAction(p)).rejects.toThrow();
-    });
-    it('throws if action steps array is missing', async () => {
-        const p = join(TMP, 'actions', 'no-steps.json');
-        writeFileSync(p, JSON.stringify({ id: 'x', platform: 'y', name: 'z', params: [] }));
-        await expect(readAction(p)).rejects.toThrow('steps');
-    });
-});
-describe('writePlaybookRun + listPlaybookRuns', () => {
-    it('stores and retrieves run records', async () => {
-        const record = {
-            id: 'run-1',
-            playbookId: 'pb-1',
-            playbookName: 'Test PB',
-            status: 'completed',
-            startedAt: Date.now(),
-            completedAt: Date.now() + 1000,
-            itemsProcessed: 5,
-            itemsTotal: 5,
-        };
-        await writePlaybookRun(record);
-        const runs = await listPlaybookRuns();
-        const found = runs.find(r => r.id === 'run-1');
-        expect(found).toBeDefined();
-        expect(found?.status).toBe('completed');
-    });
-    it('filters runs by playbookId', async () => {
-        const r1 = { id: 'r1', playbookId: 'pb-a', playbookName: 'A', status: 'completed', startedAt: 1, itemsProcessed: 1, itemsTotal: 1 };
-        const r2 = { id: 'r2', playbookId: 'pb-b', playbookName: 'B', status: 'failed', startedAt: 2, itemsProcessed: 0, itemsTotal: 1 };
-        await writePlaybookRun(r1);
-        await writePlaybookRun(r2);
-        const runs = await listPlaybookRuns('pb-a');
-        expect(runs.every(r => r.playbookId === 'pb-a')).toBe(true);
-    });
-});
-//# sourceMappingURL=browse-store.test.js.map

package/packages/@monomind/cli/dist/src/__tests__/browse-workflow-types.test.d.ts

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

package/packages/@monomind/cli/dist/src/__tests__/browse-workflow-types.test.js

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest';
-describe('PlaybookDef', () => {
-    it('accepts a valid playbook definition', () => {
-        const wf = {
-            id: 'my-playbook',
-            name: 'My Playbook',
-            nodes: [
-                { id: 'n1', type: 'trigger.manual', config: {} },
-                { id: 'n2', type: 'action.linkedin.comment_post', config: { post_url: '{{$json.url}}', text: 'hi' } },
-            ],
-            connections: [{ from: 'n1', to: 'n2' }],
-        };
-        expect(wf.nodes).toHaveLength(2);
-        expect(wf.connections[0].from).toBe('n1');
-    });
-    it('accepts a valid ActionDef with steps', () => {
-        const action = {
-            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', '[aria-label="Add a comment"]'], as: 'box' },
-                { type: 'click', target: '{{box}}' },
-                { type: 'type', target: '{{box}}', text: '{{params.text}}', humanDelay: true },
-                { type: 'wait', condition: 'network_idle', timeout: 3000 },
-            ],
-        };
-        expect(action.steps).toHaveLength(5);
-    });
-});
-//# sourceMappingURL=browse-workflow-types.test.js.map