@agenthippo-ai/agenthippo 0.1.0

package/out/test/serveClient.test.js

@@ -0,0 +1,173 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const http = __importStar(require("http"));
+const serveClient_js_1 = require("../remote/serveClient.js");
+function createCaptureEmitter() {
+    const events = [];
+    return {
+        events,
+        async thinking(delta) { events.push({ type: 'thinking', payload: delta }); },
+        async text(delta) { events.push({ type: 'text', payload: delta }); },
+        async toolStart(toolName, input, toolCallId) {
+            events.push({ type: 'toolStart', payload: { toolName, input, toolCallId } });
+        },
+        async toolEnd(toolName, toolCallId, result, isError) {
+            events.push({ type: 'toolEnd', payload: { toolName, toolCallId, result, isError } });
+        },
+        async progress(message) { events.push({ type: 'progress', payload: message }); },
+        async question() { return { selected: [], freeText: null, declined: true }; },
+        async error(message) { events.push({ type: 'error', payload: message }); },
+        async done() { events.push({ type: 'done', payload: null }); },
+    };
+}
+function startMockServeServer(events) {
+    let lastAuth;
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            if (req.method === 'POST' && req.url === '/v1/chat/stream') {
+                lastAuth = req.headers.authorization;
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                });
+                for (const line of events) {
+                    res.write(`data: ${line}\n\n`);
+                }
+                res.end();
+                return;
+            }
+            res.writeHead(404);
+            res.end('not found');
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                reject(new Error('failed to bind mock serve server'));
+                return;
+            }
+            resolve({
+                url: `http://127.0.0.1:${address.port}`,
+                get lastAuth() { return lastAuth; },
+                close: () => new Promise((closeResolve, closeReject) => {
+                    server.close((err) => (err ? closeReject(err) : closeResolve()));
+                }),
+            });
+        });
+    });
+}
+suite('ServeClient', () => {
+    test('normalizeServeBaseUrl strips trailing slashes', () => {
+        assert.strictEqual((0, serveClient_js_1.normalizeServeBaseUrl)('http://127.0.0.1:8787/'), 'http://127.0.0.1:8787');
+    });
+    test('buildServeAuthHeaders includes bearer and identity', () => {
+        assert.deepStrictEqual((0, serveClient_js_1.buildServeAuthHeaders)({ accessToken: 'tok', userEmail: 'you@acme.com' }), {
+            Authorization: 'Bearer tok',
+            'X-Agent-User': 'you@acme.com',
+        });
+    });
+    test('streamRemoteServeChat sends Authorization when auth provided', async () => {
+        const mock = await startMockServeServer([
+            JSON.stringify({ type: 'done' }),
+        ]);
+        try {
+            const emitter = createCaptureEmitter();
+            await (0, serveClient_js_1.streamRemoteServeChat)({
+                baseUrl: mock.url,
+                message: 'ping',
+                auth: { accessToken: 'jwt-token', userEmail: 'dev@agenthippo.ai' },
+            }, emitter);
+            assert.strictEqual(mock.lastAuth, 'Bearer jwt-token');
+        }
+        finally {
+            await mock.close();
+        }
+    });
+    test('streamRemoteServeChat maps SSE events to StreamEmitter', async () => {
+        const mock = await startMockServeServer([
+            JSON.stringify({ type: 'thinking', delta: 'hmm' }),
+            JSON.stringify({ type: 'text', delta: 'hello' }),
+            JSON.stringify({ type: 'tool_start', name: 'Read', input: '{}', tool_call_id: 't1' }),
+            JSON.stringify({ type: 'tool_end', name: 'Read', tool_call_id: 't1', result: 'ok', is_error: false }),
+            JSON.stringify({ type: 'done' }),
+        ]);
+        try {
+            const emitter = createCaptureEmitter();
+            await (0, serveClient_js_1.streamRemoteServeChat)({
+                baseUrl: mock.url,
+                message: 'ping',
+                sessionId: 'sess-1',
+            }, emitter);
+            assert.deepStrictEqual(emitter.events.map((e) => e.type), ['thinking', 'text', 'toolStart', 'toolEnd', 'done']);
+            assert.strictEqual(emitter.events[1].payload, 'hello');
+        }
+        finally {
+            await mock.close();
+        }
+    });
+    test('streamRemoteServeChat surfaces HTTP errors', async () => {
+        const server = http.createServer((_req, res) => {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Unauthorized' }));
+        });
+        await new Promise((resolve, reject) => {
+            server.listen(0, '127.0.0.1', async () => {
+                try {
+                    const address = server.address();
+                    if (!address || typeof address === 'string') {
+                        throw new Error('bad address');
+                    }
+                    const emitter = createCaptureEmitter();
+                    await (0, serveClient_js_1.streamRemoteServeChat)({ baseUrl: `http://127.0.0.1:${address.port}`, message: 'ping' }, emitter);
+                    assert.deepStrictEqual(emitter.events.map((e) => e.type), ['error', 'done']);
+                    assert.strictEqual(emitter.events[0].payload, 'Unauthorized');
+                    resolve();
+                }
+                catch (err) {
+                    reject(err);
+                }
+                finally {
+                    server.close();
+                }
+            });
+        });
+    });
+});

package/out/test/sessionJsonlFleet.test.js

@@ -0,0 +1,78 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const sessionJsonlFleet_1 = require("../analytics/dashboard/sessionJsonlFleet");
+suite('sessionJsonlFleet', () => {
+    test('discovers completed session from turn_start/turn_end jsonl', () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fleet-jsonl-'));
+        const sessionId = '181506a7-9540-4052-86e5-ac8800e68d42';
+        const filePath = path.join(dir, `${sessionId}.jsonl`);
+        const now = Date.now();
+        const started = now - 2 * 60 * 60 * 1000;
+        const ended = started + 60_000;
+        fs.writeFileSync(filePath, [
+            JSON.stringify({ session_id: sessionId, request_id: 'req-1', timestamp: started, event_type: 'turn_start', payload: {} }),
+            JSON.stringify({ session_id: sessionId, request_id: 'req-1', timestamp: ended, event_type: 'turn_end', payload: { success: true } }),
+        ].join('\n') + '\n', 'utf8');
+        fs.utimesSync(filePath, (ended - 60_000) / 1000, (ended - 60_000) / 1000);
+        const hints = (0, sessionJsonlFleet_1.scanSessionJsonlFleetHints)(dir);
+        const row = hints.find(h => h.sessionId === sessionId);
+        assert.ok(row, 'expected session jsonl hint');
+        assert.strictEqual(row.status, 'done');
+        assert.strictEqual(row.turns, 1);
+    });
+    test('stale session without open turn is done not in_progress', () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fleet-jsonl-stale-'));
+        const sessionId = 'stale-session-id';
+        const filePath = path.join(dir, `${sessionId}.jsonl`);
+        const old = Date.now() - 3 * 60 * 60 * 1000;
+        fs.writeFileSync(filePath, [
+            JSON.stringify({ session_id: sessionId, request_id: 'req-1', timestamp: old, event_type: 'turn_start', payload: {} }),
+            JSON.stringify({ session_id: sessionId, request_id: 'req-1', timestamp: old + 60_000, event_type: 'turn_end', payload: { success: true } }),
+        ].join('\n') + '\n', 'utf8');
+        const past = Date.now() - 4 * 60 * 60 * 1000;
+        fs.utimesSync(filePath, past / 1000, past / 1000);
+        const row = (0, sessionJsonlFleet_1.scanSessionJsonlFleetHints)(dir).find(h => h.sessionId === sessionId);
+        assert.ok(row);
+        assert.strictEqual(row.status, 'done');
+    });
+});

package/out/test/shared.test.js

@@ -0,0 +1,173 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+// Import the functions we want to test
+const agentEngines_1 = require("../shared/agentEngines");
+const models_1 = require("../shared/models");
+// =============================================================================
+// Agent Engines Tests
+// =============================================================================
+suite('Agent Engines Registry', () => {
+    test('AGENT_ENGINES contains codex and claude', () => {
+        assert.ok(agentEngines_1.AGENT_ENGINES.codex, 'codex engine should exist');
+        assert.ok(agentEngines_1.AGENT_ENGINES.claude, 'claude engine should exist');
+    });
+    test('getAgentEngine returns correct engine', () => {
+        const codex = (0, agentEngines_1.getAgentEngine)('codex');
+        assert.ok(codex);
+        assert.strictEqual(codex.id, 'codex');
+        assert.strictEqual(codex.displayName, 'Codex');
+        const claude = (0, agentEngines_1.getAgentEngine)('claude');
+        assert.ok(claude);
+        assert.strictEqual(claude.id, 'claude');
+        assert.strictEqual(claude.displayName, 'Claude');
+    });
+    test('getAgentEngine returns undefined for unknown engine', () => {
+        const unknown = (0, agentEngines_1.getAgentEngine)('nonexistent');
+        assert.strictEqual(unknown, undefined);
+    });
+    test('getAllAgentEngines returns all engines', () => {
+        const engines = (0, agentEngines_1.getAllAgentEngines)();
+        assert.strictEqual(engines.length, 2);
+    });
+    test('getAllAgentEngineIds returns correct IDs', () => {
+        const ids = (0, agentEngines_1.getAllAgentEngineIds)();
+        assert.ok(ids.includes('codex'));
+        assert.ok(ids.includes('claude'));
+    });
+});
+suite('Engine-Provider Compatibility', () => {
+    test('isEngineCompatibleWithProvider: native providers are compatible', () => {
+        // Codex is compatible with OpenAI (its native provider)
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('codex', 'openai'), true);
+        // Claude is compatible with Anthropic (its native provider)
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('claude', 'anthropic'), true);
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('claude', 'anthropic-setup-token'), true);
+    });
+    test('isEngineCompatibleWithProvider: gateway providers work with all engines', () => {
+        // LiteLLM is a gateway, should work with both
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('codex', 'litellm'), true);
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('claude', 'litellm'), true);
+        // OpenRouter is also a gateway
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('codex', 'openrouter'), true);
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('claude', 'openrouter'), true);
+    });
+    test('isEngineCompatibleWithProvider: incompatible providers return false', () => {
+        // Claude engine is NOT directly compatible with OpenAI (different API format)
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('claude', 'openai'), false);
+        // Codex engine is NOT directly compatible with Anthropic
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('codex', 'anthropic'), false);
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('codex', 'anthropic-setup-token'), false);
+    });
+    test('isEngineCompatibleWithProvider: local providers with OpenAI format work with Codex', () => {
+        // Ollama uses openai-chat format, compatible with Codex (openai-responses)
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('codex', 'ollama'), true);
+        // LM Studio uses openai-chat format, compatible with Codex
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('codex', 'lmstudio'), true);
+    });
+    test('isEngineCompatibleWithProvider: unknown engine returns false', () => {
+        assert.strictEqual((0, agentEngines_1.isEngineCompatibleWithProvider)('unknown', 'openai'), false);
+    });
+    test('getCompatibleProviders returns native and gateway providers', () => {
+        const codexProviders = (0, agentEngines_1.getCompatibleProviders)('codex');
+        assert.ok(codexProviders.includes('openai'), 'Codex should be compatible with OpenAI');
+        assert.ok(codexProviders.includes('litellm'), 'Codex should be compatible with LiteLLM');
+        assert.ok(codexProviders.includes('openrouter'), 'Codex should be compatible with OpenRouter');
+        const claudeProviders = (0, agentEngines_1.getCompatibleProviders)('claude');
+        assert.ok(claudeProviders.includes('anthropic'), 'Claude should be compatible with Anthropic');
+        assert.ok(claudeProviders.includes('anthropic-setup-token'), 'Claude should be compatible with Anthropic setup-token');
+        assert.ok(claudeProviders.includes('litellm'), 'Claude should be compatible with LiteLLM');
+    });
+    test('getEnginesCompatibleWithProvider: gateway providers return all engines', () => {
+        const litellmEngines = (0, agentEngines_1.getEnginesCompatibleWithProvider)('litellm');
+        assert.strictEqual(litellmEngines.length, 2);
+    });
+});
+suite('Engine Workspace Integration', () => {
+    test('getEngineRulesFile returns correct files', () => {
+        assert.strictEqual((0, agentEngines_1.getEngineRulesFile)('codex'), 'AGENTS.md');
+        assert.strictEqual((0, agentEngines_1.getEngineRulesFile)('claude'), 'CLAUDE.md');
+    });
+    test('getEngineWorkspaceDir returns correct directories', () => {
+        assert.strictEqual((0, agentEngines_1.getEngineWorkspaceDir)('codex'), '.codex');
+        assert.strictEqual((0, agentEngines_1.getEngineWorkspaceDir)('claude'), '.claude');
+    });
+    test('getEngineRulesFile returns undefined for unknown engine', () => {
+        assert.strictEqual((0, agentEngines_1.getEngineRulesFile)('unknown'), undefined);
+    });
+});
+// =============================================================================
+// Registry Key Tests
+// =============================================================================
+suite('Registry Key Functions', () => {
+    test('getRegistryKey creates composite key', () => {
+        const key = (0, models_1.getRegistryKey)('openai', 'gpt-4o');
+        assert.strictEqual(key, 'openai::gpt-4o');
+    });
+    test('getRegistryKey uses correct separator', () => {
+        const key = (0, models_1.getRegistryKey)('litellm', 'claude-sonnet-4');
+        assert.ok(key.includes(models_1.REGISTRY_KEY_SEPARATOR));
+        assert.strictEqual(key, `litellm${models_1.REGISTRY_KEY_SEPARATOR}claude-sonnet-4`);
+    });
+    test('parseRegistryKey parses valid composite key', () => {
+        const result = (0, models_1.parseRegistryKey)('openai::gpt-4o');
+        assert.ok(result);
+        assert.strictEqual(result.providerId, 'openai');
+        assert.strictEqual(result.modelId, 'gpt-4o');
+    });
+    test('parseRegistryKey returns undefined for legacy key', () => {
+        const result = (0, models_1.parseRegistryKey)('gpt-4o');
+        assert.strictEqual(result, undefined);
+    });
+    test('isCompositeKey correctly identifies keys', () => {
+        assert.strictEqual((0, models_1.isCompositeKey)('openai::gpt-4o'), true);
+        assert.strictEqual((0, models_1.isCompositeKey)('gpt-4o'), false);
+        assert.strictEqual((0, models_1.isCompositeKey)('model:v1'), false); // single colon
+    });
+    test('round-trip: getRegistryKey and parseRegistryKey are inverse', () => {
+        const providerId = 'litellm';
+        const modelId = 'gpt-5-nano';
+        const key = (0, models_1.getRegistryKey)(providerId, modelId);
+        const parsed = (0, models_1.parseRegistryKey)(key);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.providerId, providerId);
+        assert.strictEqual(parsed.modelId, modelId);
+    });
+});