monomind 1.14.6 → 1.15.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/packages/@monomind/cli/dist/src/browser/action-builder/analyzer.d.ts

@@ -0,0 +1,11 @@
+import type { ActionDef } from './types.js';
+export declare function buildPrompt(task: string, domSnapshot: string): string;
+export declare function parseActionResponse(response: string): ActionDef;
+export declare function analyzeAndBuild(options: {
+    url: string;
+    task: string;
+    client: import('@monoes/monobrowse').CdpClient;
+    sessionId: string;
+    outputDir: string;
+}): Promise<ActionDef>;
+//# sourceMappingURL=analyzer.d.ts.map

package/packages/@monomind/cli/dist/src/browser/action-builder/analyzer.js

@@ -0,0 +1,71 @@
+import { writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+const SYSTEM_PROMPT = `You are a browser automation expert. Given a DOM snippet and a task description, generate a JSON action definition that automates the task.
+
+Rules:
+- Use ONLY these step types: navigate, find, click, type, wait, extract
+- For "find" steps, provide 2-3 selector alternatives in order of preference (CSS, aria-label, XPath)
+- For "type" steps, set humanDelay: true for form inputs
+- Parameters use {{params.name}} syntax
+- The action id format is "custom:<snake_case_name>"
+- Output ONLY a JSON code block, no explanation before or after
+
+JSON schema:
+{
+  "id": "custom:action_name",
+  "platform": "custom",
+  "name": "Human Readable Name",
+  "params": ["param1", "param2"],
+  "steps": [...]
+}`;
+export function buildPrompt(task, domSnapshot) {
+    const truncated = domSnapshot.slice(0, 8000);
+    return `Task: ${task}\n\nDOM snapshot:\n${truncated}\n\nGenerate the action JSON.`;
+}
+export function parseActionResponse(response) {
+    const match = response.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (!match)
+        throw new Error('No JSON block found in Claude response');
+    try {
+        return JSON.parse(match[1].trim());
+    }
+    catch (err) {
+        throw new Error(`Invalid JSON in response: ${err.message}`);
+    }
+}
+export async function analyzeAndBuild(options) {
+    const { url, task, client, sessionId, outputDir } = options;
+    // Navigate to the URL and wait for load
+    await client.send('Page.navigate', { url }, sessionId);
+    await new Promise(r => setTimeout(r, 2500)); // allow page to settle
+    // Capture DOM snapshot — accessibility tree + visible text
+    const domResult = await client.send('DOM.getDocument', { depth: 3, pierce: true }, sessionId);
+    const outerHtml = await client.send('DOM.getOuterHTML', { nodeId: domResult.root.nodeId }, sessionId);
+    // Strip scripts/styles, keep interactive elements
+    const cleanDom = outerHtml.outerHTML
+        .replace(/<script[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[\s\S]*?<\/style>/gi, '')
+        .replace(/\s{2,}/g, ' ')
+        .slice(0, 12000);
+    // Call Claude API
+    const { Anthropic } = await import('@anthropic-ai/sdk');
+    const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+    const message = await anthropic.messages.create({
+        model: 'claude-sonnet-4-6',
+        max_tokens: 2048,
+        system: SYSTEM_PROMPT,
+        messages: [{ role: 'user', content: buildPrompt(task, cleanDom) }],
+    });
+    const responseText = message.content
+        .filter(c => c.type === 'text')
+        .map(c => c.text)
+        .join('');
+    const action = parseActionResponse(responseText);
+    // Write to output directory
+    await mkdir(outputDir, { recursive: true });
+    const filename = action.id.replace(/[^a-z0-9_-]/gi, '_') + '.json';
+    const outPath = join(outputDir, filename);
+    await writeFile(outPath, JSON.stringify(action, null, 2));
+    return action;
+}
+//# sourceMappingURL=analyzer.js.map

package/packages/@monomind/cli/dist/src/browser/action-builder/types.d.ts

@@ -0,0 +1,47 @@
+export type StepType = 'navigate' | 'find' | 'click' | 'type' | 'wait' | 'extract' | 'condition';
+export interface NavigateStep {
+    type: 'navigate';
+    url: string;
+}
+export interface FindStep {
+    type: 'find';
+    selectors: string[];
+    as: string;
+}
+export interface ClickStep {
+    type: 'click';
+    target: string;
+}
+export interface TypeStep {
+    type: 'type';
+    target: string;
+    text: string;
+    humanDelay?: boolean;
+}
+export interface WaitStep {
+    type: 'wait';
+    condition: 'network_idle' | 'selector' | 'duration';
+    timeout?: number;
+    selector?: string;
+}
+export interface ExtractStep {
+    type: 'extract';
+    target: string;
+    as: string;
+    attribute?: string;
+}
+export interface ConditionStep {
+    type: 'condition';
+    expression: string;
+    then: StepDef[];
+    else?: StepDef[];
+}
+export type StepDef = NavigateStep | FindStep | ClickStep | TypeStep | WaitStep | ExtractStep | ConditionStep;
+export interface ActionDef {
+    id: string;
+    platform: string;
+    name: string;
+    params: string[];
+    steps: StepDef[];
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/@monomind/cli/dist/src/browser/action-builder/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,3 @@
+import type { PlatformAdapter } from './index.js';
+export declare const geminiAdapter: PlatformAdapter;
+//# sourceMappingURL=gemini.d.ts.map

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

@@ -0,0 +1,16 @@
+export const geminiAdapter = {
+    platform: 'gemini',
+    baseURL: 'https://gemini.google.com',
+    reservedPaths: ['/app', '/faq', '/privacy', '/terms', '/about'],
+    loginURL: () => 'https://accounts.google.com/signin',
+    async isLoggedIn(page) {
+        const url = await page.url();
+        if (url.includes('accounts.google.com'))
+            return false;
+        return page.evaluate(`!!document.querySelector('bard-sidenav, [data-test-id="bard-sidenav"]')`);
+    },
+    async extractUsername(page) {
+        return page.evaluate(`(document.querySelector('[data-email]')?.getAttribute('data-email') ?? 'unknown')`);
+    },
+};
+//# sourceMappingURL=gemini.js.map