@moda-ai/cli 1.0.2 → 1.0.4

package/dist/__tests__/api-client.test.d.ts

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

package/dist/__tests__/api-client.test.js

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock config before importing api-client
+vi.mock('../config.js', () => ({
+    MODA_API_KEY: 'moda_sk_test_key',
+    MODA_BASE_URL: 'https://test.modaflows.com',
+}));
+import { callDataAPI, ApiError } from '../api-client.js';
+describe('callDataAPI', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('constructs correct URL', async () => {
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ data: 'test' }),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await callDataAPI('/overview?days_back=7');
+        expect(mockFetch).toHaveBeenCalledWith('https://test.modaflows.com/api/v1/data/overview?days_back=7', expect.objectContaining({
+            headers: expect.objectContaining({
+                'x-api-key': 'moda_sk_test_key',
+            }),
+        }));
+    });
+    it('throws ApiError on non-ok response', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: false,
+            status: 401,
+            text: () => Promise.resolve('Unauthorized'),
+        }));
+        await expect(callDataAPI('/overview')).rejects.toThrow('API error (401): Unauthorized');
+        await vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: false,
+            status: 401,
+            text: () => Promise.resolve('Unauthorized'),
+        }));
+        try {
+            await callDataAPI('/overview');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ApiError);
+            expect(e.statusCode).toBe(401);
+        }
+    });
+    it('retries on 500 errors', async () => {
+        const mockFetch = vi.fn()
+            .mockResolvedValueOnce({ ok: false, status: 500, text: () => Promise.resolve('Internal Server Error') })
+            .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ data: 'ok' }) });
+        vi.stubGlobal('fetch', mockFetch);
+        const result = await callDataAPI('/overview');
+        expect(result).toEqual({ data: 'ok' });
+        expect(mockFetch).toHaveBeenCalledTimes(2);
+    });
+    it('does not retry on 4xx errors (except 429)', async () => {
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 403,
+            text: () => Promise.resolve('Forbidden'),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await expect(callDataAPI('/overview')).rejects.toThrow('API error (403)');
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+    });
+    it('returns parsed JSON on success', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ conversations: { total: 100 } }),
+        }));
+        const result = await callDataAPI('/overview');
+        expect(result).toEqual({ conversations: { total: 100 } });
+    });
+});
+//# sourceMappingURL=api-client.test.js.map

package/dist/__tests__/cli.test.d.ts

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

package/dist/__tests__/cli.test.js

@@ -0,0 +1,109 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock api-client (same pattern as handlers.test.ts)
+vi.mock('../api-client.js', () => ({
+    callDataAPI: vi.fn().mockResolvedValue({ mock: true }),
+}));
+// Mock config to prevent process.exit
+vi.mock('../config.js', () => ({
+    validateConfig: vi.fn(),
+    MODA_API_KEY: 'test-key',
+    MODA_BASE_URL: 'https://test.example.com',
+    PORT: 3003,
+}));
+// Import after mocks
+import { parseArgs, flagsToArgs } from '../cli.js';
+import { callDataAPI } from '../api-client.js';
+const mockCallDataAPI = vi.mocked(callDataAPI);
+describe('parseArgs', () => {
+    it('extracts command from argv', () => {
+        const result = parseArgs(['node', 'cli.js', 'overview']);
+        expect(result.command).toBe('overview');
+        expect(result.positional).toBeUndefined();
+        expect(result.flags).toEqual({});
+    });
+    it('extracts positional argument', () => {
+        const result = parseArgs(['node', 'cli.js', 'cluster-conversations', 'node-123']);
+        expect(result.command).toBe('cluster-conversations');
+        expect(result.positional).toBe('node-123');
+    });
+    it('parses --key=value flags', () => {
+        const result = parseArgs(['node', 'cli.js', 'overview', '--days-back=30']);
+        expect(result.flags).toEqual({ 'days-back': '30' });
+    });
+    it('parses --key value flags', () => {
+        const result = parseArgs(['node', 'cli.js', 'overview', '--days-back', '30']);
+        expect(result.flags).toEqual({ 'days-back': '30' });
+    });
+    it('parses mixed flag formats', () => {
+        const result = parseArgs(['node', 'cli.js', 'conversations', '--search=error', '--limit', '5']);
+        expect(result.flags).toEqual({ search: 'error', limit: '5' });
+    });
+    it('handles boolean flags (no value)', () => {
+        const result = parseArgs(['node', 'cli.js', '--help']);
+        expect(result.command).toBe('--help');
+    });
+    it('returns empty command for no args', () => {
+        const result = parseArgs(['node', 'cli.js']);
+        expect(result.command).toBe('');
+    });
+    it('handles positional before flags', () => {
+        const result = parseArgs(['node', 'cli.js', 'context', 'conv-abc', '--window=3']);
+        expect(result.command).toBe('context');
+        expect(result.positional).toBe('conv-abc');
+        expect(result.flags).toEqual({ window: '3' });
+    });
+});
+describe('flagsToArgs', () => {
+    it('converts kebab-case to snake_case', () => {
+        const result = flagsToArgs({ 'days-back': '30', 'time-range': '7d' });
+        expect(result).toEqual({ days_back: 30, time_range: '7d' });
+    });
+    it('parses numeric values', () => {
+        const result = flagsToArgs({ limit: '10', offset: '0' });
+        expect(result).toEqual({ limit: 10, offset: 0 });
+    });
+    it('keeps string values as strings', () => {
+        const result = flagsToArgs({ search: 'error message' });
+        expect(result).toEqual({ search: 'error message' });
+    });
+    it('includes positional key/value', () => {
+        const result = flagsToArgs({ limit: '5' }, 'node_id', 'node-123');
+        expect(result).toEqual({ node_id: 'node-123', limit: 5 });
+    });
+});
+describe('CLI command dispatch', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    // We test the commands by dynamically importing and calling runCommand.
+    // Since runCommand is not exported, we test indirectly via the module's behavior.
+    // The key thing to test is that each command constructs the correct API URL.
+    // This is tested at the integration level via handlers.test.ts already.
+    // Here we focus on the arg parsing + flag conversion that is unique to the CLI.
+    it('overview command builds correct args from flags', () => {
+        const args = flagsToArgs({ 'days-back': '14' });
+        expect(args).toEqual({ days_back: 14 });
+    });
+    it('cluster-conversations builds args with positional node_id', () => {
+        const args = flagsToArgs({ limit: '5', offset: '0' }, 'node_id', 'cluster-abc');
+        expect(args).toEqual({ node_id: 'cluster-abc', limit: 5, offset: 0 });
+    });
+    it('conversations builds args with multiple flags', () => {
+        const args = flagsToArgs({ search: 'error', 'user-id': 'user-1', 'time-range': '7d', limit: '10', offset: '0' });
+        expect(args).toEqual({ search: 'error', user_id: 'user-1', time_range: '7d', limit: 10, offset: 0 });
+    });
+    it('context builds args with positional conversation_id', () => {
+        const args = flagsToArgs({ 'msg-index': '5', window: '3' }, 'conversation_id', 'conv-xyz');
+        expect(args).toEqual({ conversation_id: 'conv-xyz', msg_index: 5, window: 3 });
+    });
+    it('tool-failure-detail builds args with positional tool_name', () => {
+        const args = flagsToArgs({ subtype: 'timeout', 'days-back': '14' }, 'tool_name', 'search');
+        expect(args).toEqual({ tool_name: 'search', subtype: 'timeout', days_back: 14 });
+    });
+    it('offset=0 is preserved (not dropped as falsy)', () => {
+        const args = flagsToArgs({ offset: '0' });
+        expect(args.offset).toBe(0);
+        expect(args.offset).not.toBeUndefined();
+    });
+});
+//# sourceMappingURL=cli.test.js.map

package/dist/__tests__/e2e.test.d.ts

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

package/dist/__tests__/e2e.test.js

@@ -0,0 +1,239 @@
+import { spawn } from 'node:child_process';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SERVER_PATH = resolve(__dirname, '../../dist/index.js');
+const MODA_API_KEY = process.env.MODA_API_KEY;
+// --- JSON-RPC Helper ---
+let nextId = 1;
+function sendJsonRpc(server, method, params) {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+        let buffer = '';
+        const onData = (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            // Keep the last (potentially incomplete) line in the buffer
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.id === id) {
+                        server.stdout.removeListener('data', onData);
+                        resolve(parsed);
+                    }
+                }
+                catch {
+                    // Not valid JSON, skip
+                }
+            }
+        };
+        server.stdout.on('data', onData);
+        const message = JSON.stringify({
+            jsonrpc: '2.0',
+            method,
+            ...(params && { params }),
+            id,
+        });
+        server.stdin.write(message + '\n');
+        // Timeout after 30s
+        setTimeout(() => {
+            server.stdout.removeListener('data', onData);
+            reject(new Error(`sendJsonRpc timed out waiting for response id=${id}`));
+        }, 30_000);
+    });
+}
+// --- Shared State for Chained Tests ---
+let capturedNodeId;
+let capturedConversationId;
+let capturedToolName;
+// --- Test Suite ---
+describe.skipIf(!MODA_API_KEY)('E2E: MCP Server against live backend', { timeout: 30_000 }, () => {
+    let mcpServer;
+    beforeAll(async () => {
+        // Spawn the MCP server process
+        mcpServer = spawn('node', [SERVER_PATH], {
+            env: { ...process.env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Wait for the server startup message on stderr
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error('Server startup timeout')), 10_000);
+            mcpServer.stderr.on('data', (data) => {
+                if (data.toString().includes('running on stdio')) {
+                    clearTimeout(timeout);
+                    resolve();
+                }
+            });
+            mcpServer.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+        // MCP protocol: send initialize request
+        const initResponse = await sendJsonRpc(mcpServer, 'initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'e2e-test', version: '1.0.0' },
+        });
+        expect(initResponse.result).toBeDefined();
+        // MCP protocol: send initialized notification (no id, no response)
+        mcpServer.stdin.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n');
+    });
+    afterAll(() => {
+        mcpServer?.kill();
+    });
+    // --- Phase 1: Overview ---
+    it('moda_get_overview returns valid overview data', async () => {
+        const response = await sendJsonRpc(mcpServer, 'tools/call', {
+            name: 'moda_get_overview',
+            arguments: { days_back: 7 },
+        });
+        expect(response.result).toBeDefined();
+        expect(response.result.content).toHaveLength(1);
+        expect(response.result.content[0].type).toBe('text');
+        const data = JSON.parse(response.result.content[0].text);
+        expect(data).toHaveProperty('conversations');
+        expect(data).toHaveProperty('frustrations');
+        expect(data).toHaveProperty('tool_failures');
+        expect(data).toHaveProperty('top_clusters');
+        expect(data).toHaveProperty('recent_activity');
+    });
+    // --- Phase 2: Independent Tools ---
+    it('moda_get_clusters returns cluster hierarchy', async () => {
+        const response = await sendJsonRpc(mcpServer, 'tools/call', {
+            name: 'moda_get_clusters',
+            arguments: {},
+        });
+        expect(response.result).toBeDefined();
+        const data = JSON.parse(response.result.content[0].text);
+        expect(data).toHaveProperty('clusters');
+        expect(Array.isArray(data.clusters)).toBe(true);
+        if (data.clusters.length > 0) {
+            const cluster = data.clusters[0];
+            expect(cluster).toHaveProperty('node_id');
+            expect(cluster).toHaveProperty('label');
+            // Capture for Phase 3
+            capturedNodeId = cluster.node_id;
+        }
+    });
+    it('moda_search_conversations returns conversations list', async () => {
+        const response = await sendJsonRpc(mcpServer, 'tools/call', {
+            name: 'moda_search_conversations',
+            arguments: {},
+        });
+        expect(response.result).toBeDefined();
+        const data = JSON.parse(response.result.content[0].text);
+        expect(data).toHaveProperty('conversations');
+        expect(Array.isArray(data.conversations)).toBe(true);
+        expect(data).toHaveProperty('pagination');
+        if (data.conversations.length > 0) {
+            const convo = data.conversations[0];
+            expect(convo).toHaveProperty('conversation_id');
+            expect(convo).toHaveProperty('summary');
+            // Capture for Phase 3
+            capturedConversationId = convo.conversation_id;
+        }
+    });
+    it('moda_get_frustrations returns frustration data', async () => {
+        const response = await sendJsonRpc(mcpServer, 'tools/call', {
+            name: 'moda_get_frustrations',
+            arguments: { days_back: 7 },
+        });
+        expect(response.result).toBeDefined();
+        const data = JSON.parse(response.result.content[0].text);
+        expect(data).toHaveProperty('summary');
+        expect(data).toHaveProperty('frustrations');
+        expect(Array.isArray(data.frustrations)).toBe(true);
+        if (data.frustrations.length > 0) {
+            expect(data.frustrations[0]).toHaveProperty('conversation_id');
+        }
+    });
+    it('moda_get_tool_failures returns failure overview', async () => {
+        const response = await sendJsonRpc(mcpServer, 'tools/call', {
+            name: 'moda_get_tool_failures',
+            arguments: { days_back: 7 },
+        });
+        expect(response.result).toBeDefined();
+        const data = JSON.parse(response.result.content[0].text);
+        expect(data).toHaveProperty('summary');
+        expect(data).toHaveProperty('tools');
+        expect(Array.isArray(data.tools)).toBe(true);
+        if (data.tools.length > 0) {
+            const tool = data.tools[0];
+            expect(tool).toHaveProperty('tool_name');
+            expect(tool).toHaveProperty('failure_count');
+            // Capture for Phase 3
+            capturedToolName = tool.tool_name;
+        }
+    });
+    // --- Phase 3: Chained Tools ---
+    it('moda_get_cluster_conversations returns conversations for a cluster', async () => {
+        if (!capturedNodeId) {
+            console.warn('Skipping: no node_id captured from moda_get_clusters (empty data)');
+            return;
+        }
+        const response = await sendJsonRpc(mcpServer, 'tools/call', {
+            name: 'moda_get_cluster_conversations',
+            arguments: { node_id: capturedNodeId },
+        });
+        expect(response.result).toBeDefined();
+        const data = JSON.parse(response.result.content[0].text);
+        expect(data).toHaveProperty('cluster');
+        expect(data).toHaveProperty('conversations');
+        expect(Array.isArray(data.conversations)).toBe(true);
+        expect(data).toHaveProperty('pagination');
+        if (data.conversations.length > 0) {
+            expect(data.conversations[0]).toHaveProperty('conversation_id');
+        }
+    });
+    it('moda_get_conversation_context returns message context', async () => {
+        if (!capturedConversationId) {
+            console.warn('Skipping: no conversation_id captured from moda_search_conversations (empty data)');
+            return;
+        }
+        const response = await sendJsonRpc(mcpServer, 'tools/call', {
+            name: 'moda_get_conversation_context',
+            arguments: { conversation_id: capturedConversationId },
+        });
+        expect(response.result).toBeDefined();
+        const data = JSON.parse(response.result.content[0].text);
+        expect(data).toHaveProperty('conversation_id');
+        expect(data).toHaveProperty('summary');
+        expect(data).toHaveProperty('context');
+        expect(data.context).toHaveProperty('messages');
+        expect(Array.isArray(data.context.messages)).toBe(true);
+    });
+    it('moda_get_tool_failure_detail returns failure details', async () => {
+        if (!capturedToolName) {
+            console.warn('Skipping: no tool_name captured from moda_get_tool_failures (empty data)');
+            return;
+        }
+        const response = await sendJsonRpc(mcpServer, 'tools/call', {
+            name: 'moda_get_tool_failure_detail',
+            arguments: { tool_name: capturedToolName },
+        });
+        expect(response.result).toBeDefined();
+        const data = JSON.parse(response.result.content[0].text);
+        expect(data).toHaveProperty('tool_name');
+        expect(typeof data.tool_name).toBe('string');
+        expect(data).toHaveProperty('subtypes');
+        expect(Array.isArray(data.subtypes)).toBe(true);
+        expect(data).toHaveProperty('examples');
+        expect(Array.isArray(data.examples)).toBe(true);
+    });
+    // --- Error Handling ---
+    it('returns error for invalid arguments (Zod validation)', async () => {
+        const response = await sendJsonRpc(mcpServer, 'tools/call', {
+            name: 'moda_get_overview',
+            arguments: { days_back: 999 },
+        });
+        // The MCP SDK wraps handler errors into an error response
+        expect(response.error).toBeDefined();
+        expect(response.error.message).toContain('Invalid arguments');
+    });
+});
+//# sourceMappingURL=e2e.test.js.map

package/dist/__tests__/handlers.test.d.ts

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

package/dist/__tests__/handlers.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock api-client
+vi.mock('../api-client.js', () => ({
+    callDataAPI: vi.fn().mockResolvedValue({ mock: true }),
+}));
+import { handleToolCall } from '../handlers.js';
+import { callDataAPI } from '../api-client.js';
+const mockCallDataAPI = vi.mocked(callDataAPI);
+describe('handleToolCall', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('moda_get_overview calls correct endpoint', async () => {
+        await handleToolCall('moda_get_overview', { days_back: 14 });
+        expect(mockCallDataAPI).toHaveBeenCalledWith('/overview?days_back=14');
+    });
+    it('moda_get_overview with no args omits query string', async () => {
+        await handleToolCall('moda_get_overview', {});
+        expect(mockCallDataAPI).toHaveBeenCalledWith('/overview');
+    });
+    it('moda_get_clusters passes parent_id and time_range', async () => {
+        await handleToolCall('moda_get_clusters', { parent_id: 'node-1', time_range: '7d' });
+        expect(mockCallDataAPI).toHaveBeenCalledWith(expect.stringContaining('parent_id=node-1'));
+        expect(mockCallDataAPI).toHaveBeenCalledWith(expect.stringContaining('time_range=7d'));
+    });
+    it('moda_get_cluster_conversations includes offset=0', async () => {
+        await handleToolCall('moda_get_cluster_conversations', { node_id: 'c-1', offset: 0 });
+        const calledUrl = mockCallDataAPI.mock.calls[0][0];
+        expect(calledUrl).toContain('offset=0');
+    });
+    it('moda_search_conversations includes offset=0', async () => {
+        await handleToolCall('moda_search_conversations', { offset: 0 });
+        const calledUrl = mockCallDataAPI.mock.calls[0][0];
+        expect(calledUrl).toContain('offset=0');
+    });
+    it('moda_get_frustrations includes offset=0', async () => {
+        await handleToolCall('moda_get_frustrations', { offset: 0 });
+        const calledUrl = mockCallDataAPI.mock.calls[0][0];
+        expect(calledUrl).toContain('offset=0');
+    });
+    it('moda_get_tool_failure_detail includes offset=0', async () => {
+        await handleToolCall('moda_get_tool_failure_detail', { tool_name: 'search', offset: 0 });
+        const calledUrl = mockCallDataAPI.mock.calls[0][0];
+        expect(calledUrl).toContain('offset=0');
+    });
+    it('moda_get_conversation_context uses conversation_id in path', async () => {
+        await handleToolCall('moda_get_conversation_context', { conversation_id: 'conv-abc' });
+        expect(mockCallDataAPI).toHaveBeenCalledWith(expect.stringContaining('/conversations/conv-abc/context'));
+    });
+    it('moda_get_tool_failures calls correct endpoint', async () => {
+        await handleToolCall('moda_get_tool_failures', { days_back: 30 });
+        expect(mockCallDataAPI).toHaveBeenCalledWith('/tool-failures?days_back=30');
+    });
+    it('moda_get_tool_failure_detail uses tool_name in path', async () => {
+        await handleToolCall('moda_get_tool_failure_detail', { tool_name: 'compose' });
+        expect(mockCallDataAPI).toHaveBeenCalledWith(expect.stringContaining('/tool-failures/compose'));
+    });
+    it('throws on unknown tool', async () => {
+        await expect(handleToolCall('unknown_tool', {})).rejects.toThrow('Unknown tool: unknown_tool');
+    });
+    it('throws on invalid arguments', async () => {
+        await expect(handleToolCall('moda_get_overview', { days_back: 'invalid' })).rejects.toThrow('Invalid arguments');
+    });
+    it('returns content array with JSON text', async () => {
+        const result = await handleToolCall('moda_get_overview', {});
+        expect(result.content).toHaveLength(1);
+        expect(result.content[0].type).toBe('text');
+        expect(JSON.parse(result.content[0].text)).toEqual({ mock: true });
+    });
+});
+//# sourceMappingURL=handlers.test.js.map

package/dist/__tests__/integration.test.d.ts

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

package/dist/__tests__/integration.test.js

@@ -0,0 +1,114 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const ROOT = resolve(__dirname, '../..');
+let mockServer;
+function sendJsonRpc(proc, method, params, id = 1) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error('Timeout waiting for response')), 10000);
+        let buffer = '';
+        const onData = (data) => {
+            buffer += data.toString();
+            const lines = buffer.split('\n');
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.id === id) {
+                        clearTimeout(timeout);
+                        proc.stdout.off('data', onData);
+                        resolve(parsed);
+                    }
+                }
+                catch { /* incomplete JSON */ }
+            }
+        };
+        proc.stdout.on('data', onData);
+        const request = JSON.stringify({ jsonrpc: '2.0', method, params, id });
+        proc.stdin.write(request + '\n');
+    });
+}
+beforeAll(async () => {
+    // Start mock server
+    mockServer = spawn('node', [resolve(ROOT, 'mock-server.js')], { stdio: ['pipe', 'pipe', 'pipe'] });
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error('Mock server did not start in time')), 10000);
+        // mock-server.js uses console.log which goes to stdout
+        mockServer.stdout.on('data', (data) => {
+            if (data.toString().includes('Mock Data API server running')) {
+                clearTimeout(timeout);
+                resolve();
+            }
+        });
+        mockServer.stderr.on('data', (data) => {
+            if (data.toString().includes('Mock Data API server running')) {
+                clearTimeout(timeout);
+                resolve();
+            }
+        });
+    });
+}, 15000);
+afterAll(() => {
+    mockServer?.kill();
+});
+describe('MCP Server Integration', () => {
+    it('lists 8 tools', async () => {
+        const mcpServer = spawn('node', [resolve(ROOT, 'dist/index.js')], {
+            env: { ...process.env, MODA_API_KEY: 'moda_sk_test', MODA_BASE_URL: 'http://localhost:3002' },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        try {
+            // Wait for server to start
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => reject(new Error('MCP server did not start in time')), 10000);
+                mcpServer.stderr.on('data', (data) => {
+                    if (data.toString().includes('running on stdio')) {
+                        clearTimeout(timeout);
+                        resolve();
+                    }
+                });
+            });
+            const response = await sendJsonRpc(mcpServer, 'tools/list');
+            expect(response.result.tools).toHaveLength(8);
+            const toolNames = response.result.tools.map((t) => t.name);
+            expect(toolNames).toContain('moda_get_overview');
+            expect(toolNames).toContain('moda_get_frustrations');
+            expect(toolNames).toContain('moda_get_tool_failures');
+        }
+        finally {
+            mcpServer.kill();
+        }
+    }, 20000);
+    it('calls moda_get_overview and returns data', async () => {
+        const mcpServer = spawn('node', [resolve(ROOT, 'dist/index.js')], {
+            env: { ...process.env, MODA_API_KEY: 'moda_sk_test', MODA_BASE_URL: 'http://localhost:3002' },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        try {
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => reject(new Error('MCP server did not start in time')), 10000);
+                mcpServer.stderr.on('data', (data) => {
+                    if (data.toString().includes('running on stdio')) {
+                        clearTimeout(timeout);
+                        resolve();
+                    }
+                });
+            });
+            const response = await sendJsonRpc(mcpServer, 'tools/call', {
+                name: 'moda_get_overview',
+                arguments: { days_back: 7 },
+            });
+            expect(response.result.content).toHaveLength(1);
+            expect(response.result.content[0].type).toBe('text');
+            const data = JSON.parse(response.result.content[0].text);
+            expect(data.conversations.total).toBe(1011);
+        }
+        finally {
+            mcpServer.kill();
+        }
+    }, 20000);
+});
+//# sourceMappingURL=integration.test.js.map

package/dist/__tests__/schemas.test.d.ts

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

package/dist/__tests__/schemas.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, ContextSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, } from '../schemas.js';
+describe('OverviewSchema', () => {
+    it('accepts valid days_back', () => {
+        expect(OverviewSchema.parse({ days_back: 30 })).toEqual({ days_back: 30 });
+    });
+    it('accepts empty object with defaults', () => {
+        expect(OverviewSchema.parse({})).toEqual({});
+    });
+    it('rejects days_back > 90', () => {
+        expect(() => OverviewSchema.parse({ days_back: 91 })).toThrow();
+    });
+    it('rejects days_back < 1', () => {
+        expect(() => OverviewSchema.parse({ days_back: 0 })).toThrow();
+    });
+});
+describe('ClustersSchema', () => {
+    it('accepts all backend time_range values', () => {
+        for (const val of ['all', '1h', '3d', '7d', '24h', '30d', '90d']) {
+            expect(ClustersSchema.parse({ time_range: val }).time_range).toBe(val);
+        }
+    });
+    it('rejects invalid time_range', () => {
+        expect(() => ClustersSchema.parse({ time_range: '2d' })).toThrow();
+    });
+});
+describe('ConversationsSchema', () => {
+    it('accepts 3d time_range (previously missing)', () => {
+        expect(ConversationsSchema.parse({ time_range: '3d' }).time_range).toBe('3d');
+    });
+    it('accepts all valid time_range values', () => {
+        for (const val of ['all', '1h', '3d', '24h', '7d', '30d', '90d']) {
+            expect(ConversationsSchema.parse({ time_range: val }).time_range).toBe(val);
+        }
+    });
+});
+describe('FrustrationsSchema', () => {
+    it('accepts limit up to 20', () => {
+        expect(FrustrationsSchema.parse({ limit: 20 }).limit).toBe(20);
+    });
+    it('rejects limit > 20 (previously allowed 100)', () => {
+        expect(() => FrustrationsSchema.parse({ limit: 21 })).toThrow();
+    });
+});
+describe('ToolFailureDetailSchema', () => {
+    it('accepts limit up to 20', () => {
+        expect(ToolFailureDetailSchema.parse({ tool_name: 'search', limit: 20 }).limit).toBe(20);
+    });
+    it('rejects limit > 20 (previously allowed 100)', () => {
+        expect(() => ToolFailureDetailSchema.parse({ tool_name: 'search', limit: 21 })).toThrow();
+    });
+    it('requires tool_name', () => {
+        expect(() => ToolFailureDetailSchema.parse({})).toThrow();
+    });
+});
+describe('ClusterConversationsSchema', () => {
+    it('requires node_id', () => {
+        expect(() => ClusterConversationsSchema.parse({})).toThrow();
+    });
+    it('accepts valid input', () => {
+        const result = ClusterConversationsSchema.parse({ node_id: 'cluster-1', limit: 10, offset: 0 });
+        expect(result.node_id).toBe('cluster-1');
+    });
+});
+describe('ContextSchema', () => {
+    it('requires conversation_id', () => {
+        expect(() => ContextSchema.parse({})).toThrow();
+    });
+    it('accepts msg_index of 0', () => {
+        expect(ContextSchema.parse({ conversation_id: 'conv-1', msg_index: 0 }).msg_index).toBe(0);
+    });
+    it('rejects window > 5', () => {
+        expect(() => ContextSchema.parse({ conversation_id: 'conv-1', window: 6 })).toThrow();
+    });
+});
+describe('ToolFailuresSchema', () => {
+    it('accepts valid days_back', () => {
+        expect(ToolFailuresSchema.parse({ days_back: 14 }).days_back).toBe(14);
+    });
+});
+//# sourceMappingURL=schemas.test.js.map

package/dist/auth.d.ts

@@ -1,4 +1,4 @@
 export declare function loadToken(): string | null;
-export declare function login(): Promise<string>;
+export declare function login(screen?: 'login' | 'signup'): Promise<string>;
 export declare function authFetch(path: string, options?: RequestInit): Promise<Response>;
 //# sourceMappingURL=auth.d.ts.map

package/dist/auth.js

@@ -56,7 +56,7 @@ const SUCCESS_HTML = `<!DOCTYPE html>
 </div>
 <script>setTimeout(()=>window.close(),2000)</script>
 </body></html>`;
-export async function login() {
+export async function login(screen = 'login') {
     const verifier = generateVerifier();
     const challenge = generateChallenge(verifier);
     return new Promise((resolve, reject) => {
@@ -148,6 +148,9 @@ export async function login() {
             authUrl.searchParams.set('scope', 'openid profile email');
             authUrl.searchParams.set('code_challenge', challenge);
             authUrl.searchParams.set('code_challenge_method', 'S256');
+            if (screen === 'signup') {
+                authUrl.searchParams.set('screen_hint', 'signup');
+            }
             try {
                 const open = (await import('open')).default;
                 await open(authUrl.toString());

package/dist/cli.js

@@ -254,9 +254,7 @@ async function main() {
 // the path of the entry-point script. Comparing them lets tests import parseArgs /
 // flagsToArgs without triggering the CLI bootstrap.
 import { fileURLToPath } from 'url';
-import { realpathSync } from 'fs';
-const isMain = process.argv[1] &&
-    fileURLToPath(import.meta.url) === realpathSync(process.argv[1]);
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
 if (isMain) {
     main().catch((error) => {
         if (error instanceof z.ZodError) {

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "1.0.2";
+export declare const VERSION = "1.0.0";
 export declare const MODA_API_KEY: string | undefined;
 export declare const MODA_BASE_URL: string;
 export declare const PORT: number;

package/dist/config.js

@@ -1,5 +1,5 @@
 // src/config.ts
-export const VERSION = '1.0.2';
+export const VERSION = '1.0.0';
 export const MODA_API_KEY = process.env.MODA_API_KEY;
 export const MODA_BASE_URL = process.env.MODA_BASE_URL || 'https://modaflows.com';
 export const PORT = parseInt(process.env.PORT || '3003', 10);

package/dist/init/index.js

@@ -1,4 +1,5 @@
 // src/init/index.ts — Full moda init wizard orchestrator
+import { select } from '@inquirer/prompts';
 import { login, loadToken } from '../auth.js';
 import { selectTenantAndCreateKey } from './tenant.js';
 import { detectProject, installSDK, getInitSnippet } from './detect.js';
@@ -13,9 +14,16 @@ export async function runInit(flags) {
     console.log('  Step 1/5: Authentication');
     let token = loadToken();
     if (!token) {
-        console.log('  Opening browser for login...');
-        token = await login();
-        console.log('  Login successful');
+        const action = await select({
+            message: 'Get started',
+            choices: [
+                { name: 'Sign up', value: 'signup' },
+                { name: 'Login', value: 'login' },
+            ],
+        });
+        console.log(`  Opening browser to ${action === 'signup' ? 'sign up' : 'log in'}...`);
+        token = await login(action);
+        console.log('  Authentication successful');
     }
     else {
         console.log('  Already authenticated (cached token)');

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "CLI and MCP server for Moda - AI agent analytics and observability",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "cli": "./dist/index.js",
-    "moda-mcp": "./dist/index.js",
-    "moda": "./dist/cli.js"
+    "cli": "./dist/cli.js",
+    "moda": "./dist/cli.js",
+    "moda-mcp": "./dist/index.js"
   },
   "files": [
     "dist/**/*.js",
@@ -22,7 +22,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
     "start:http": "node dist/http-server.js",