@inkeep/agents-cli 0.1.0

package/dist/__tests__/utils/port-manager.test.js

@@ -0,0 +1,144 @@
+import { createServer } from 'node:net';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { PortManager } from '../../utils/port-manager.js';
+describe('PortManager', () => {
+    let portManager;
+    let allocatedPorts = [];
+    beforeEach(() => {
+        portManager = PortManager.getInstance();
+        // Clean up any existing allocations
+        portManager.releaseAll();
+        allocatedPorts = [];
+    });
+    afterEach(() => {
+        // Clean up any ports we allocated during tests
+        for (const port of allocatedPorts) {
+            portManager.releasePort(port);
+        }
+        portManager.releaseAll();
+    });
+    describe('getInstance', () => {
+        it('should return a singleton instance', () => {
+            const instance1 = PortManager.getInstance();
+            const instance2 = PortManager.getInstance();
+            expect(instance1).toBe(instance2);
+        });
+    });
+    describe('allocatePort', () => {
+        it('should allocate a port in the valid range', async () => {
+            const port = await portManager.allocatePort();
+            allocatedPorts.push(port);
+            expect(port).toBeGreaterThanOrEqual(3100);
+            expect(port).toBeLessThanOrEqual(3200);
+            expect(portManager.getAllocatedPorts()).toContain(port);
+        });
+        it('should allocate preferred port when available', async () => {
+            const preferredPort = 3150;
+            const port = await portManager.allocatePort(preferredPort);
+            allocatedPorts.push(port);
+            expect(port).toBe(preferredPort);
+            expect(portManager.getAllocatedPorts()).toContain(port);
+        });
+        it('should allocate different port when preferred port is not available', async () => {
+            // Create a server on preferred port to make it unavailable
+            const preferredPort = 3151;
+            const server = createServer();
+            return new Promise((resolve) => {
+                server.listen(preferredPort, '127.0.0.1', async () => {
+                    try {
+                        const port = await portManager.allocatePort(preferredPort);
+                        allocatedPorts.push(port);
+                        expect(port).not.toBe(preferredPort);
+                        expect(port).toBeGreaterThanOrEqual(3100);
+                        expect(port).toBeLessThanOrEqual(3200);
+                        server.close(() => resolve());
+                    }
+                    catch (error) {
+                        server.close(() => {
+                            throw error;
+                        });
+                    }
+                });
+            });
+        });
+        it('should not allocate the same port twice', async () => {
+            const port1 = await portManager.allocatePort();
+            const port2 = await portManager.allocatePort();
+            allocatedPorts.push(port1, port2);
+            expect(port1).not.toBe(port2);
+            expect(portManager.getAllocatedPorts()).toContain(port1);
+            expect(portManager.getAllocatedPorts()).toContain(port2);
+        });
+        it('should throw error when no ports are available', async () => {
+            // Allocate all ports in the range (101 ports: 3100-3200 inclusive)
+            const allPorts = [];
+            for (let i = 3100; i <= 3200; i++) {
+                try {
+                    const port = await portManager.allocatePort();
+                    allPorts.push(port);
+                }
+                catch {
+                    break; // Stop when we can't allocate more
+                }
+            }
+            allocatedPorts.push(...allPorts);
+            // Try to allocate one more port
+            await expect(portManager.allocatePort()).rejects.toThrow('No available ports in range 3100-3200');
+        });
+    });
+    describe('releasePort', () => {
+        it('should release an allocated port', async () => {
+            const port = await portManager.allocatePort();
+            expect(portManager.getAllocatedPorts()).toContain(port);
+            portManager.releasePort(port);
+            expect(portManager.getAllocatedPorts()).not.toContain(port);
+        });
+        it('should allow releasing a non-allocated port without error', () => {
+            expect(() => portManager.releasePort(9999)).not.toThrow();
+        });
+    });
+    describe('releaseAll', () => {
+        it('should release all allocated ports', async () => {
+            const port1 = await portManager.allocatePort();
+            const port2 = await portManager.allocatePort();
+            expect(portManager.getAllocatedPorts()).toHaveLength(2);
+            portManager.releaseAll();
+            expect(portManager.getAllocatedPorts()).toHaveLength(0);
+        });
+    });
+    describe('getAllocatedPorts', () => {
+        it('should return empty array when no ports allocated', () => {
+            expect(portManager.getAllocatedPorts()).toEqual([]);
+        });
+        it('should return sorted array of allocated ports', async () => {
+            const port1 = await portManager.allocatePort(3120);
+            const port2 = await portManager.allocatePort(3110);
+            allocatedPorts.push(port1, port2);
+            const allocated = portManager.getAllocatedPorts();
+            expect(allocated).toEqual([3110, 3120]);
+        });
+    });
+    describe('getStats', () => {
+        it('should return correct statistics when no ports allocated', () => {
+            const stats = portManager.getStats();
+            expect(stats).toEqual({
+                allocated: 0,
+                available: 101, // 3100-3200 inclusive = 101 ports
+                range: { min: 3100, max: 3200 },
+                ports: [],
+            });
+        });
+        it('should return correct statistics with allocated ports', async () => {
+            const port1 = await portManager.allocatePort();
+            const port2 = await portManager.allocatePort();
+            allocatedPorts.push(port1, port2);
+            const stats = portManager.getStats();
+            expect(stats.allocated).toBe(2);
+            expect(stats.available).toBe(99);
+            expect(stats.range).toEqual({ min: 3100, max: 3200 });
+            expect(stats.ports).toHaveLength(2);
+            expect(stats.ports).toContain(port1);
+            expect(stats.ports).toContain(port2);
+        });
+    });
+});

package/dist/__tests__/utils/ts-loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/utils/ts-loader.test.js

@@ -0,0 +1,233 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { loadTypeScriptModule } from '../../utils/ts-loader.js';
+describe('TypeScript Loader', () => {
+    let testDir;
+    let testGraphFile;
+    beforeEach(() => {
+        // Create a unique test directory with process ID to avoid conflicts
+        const uniqueId = `${process.pid}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+        testDir = join(tmpdir(), 'ts-loader-test', uniqueId);
+        mkdirSync(testDir, { recursive: true });
+        testGraphFile = join(testDir, 'test-graph.ts');
+    });
+    afterEach(async () => {
+        // Small delay to ensure file handles are released
+        await new Promise(resolve => setTimeout(resolve, 50));
+        // Clean up test directory with retries
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true, force: true, maxRetries: 3 });
+        }
+    });
+    describe('loadTypeScriptModule', () => {
+        it('should load a simple TypeScript module with exports', async () => {
+            // Create a simple test module
+            const moduleContent = `
+export const simpleValue = 'test-value';
+export const numberValue = 42;
+export const booleanValue = true;
+
+export function testFunction() {
+    return 'hello world';
+}
+
+export const testObject = {
+    id: 'test-id',
+    name: 'Test Object',
+    description: 'A test object for testing',
+    port: 3000,
+};
+`;
+            writeFileSync(testGraphFile, moduleContent);
+            const result = await loadTypeScriptModule(testGraphFile);
+            expect(result.simpleValue).toBe('test-value');
+            expect(result.numberValue).toBe(42);
+            expect(result.booleanValue).toBe(true);
+            expect(result.testFunction).toEqual({
+                __type: 'function',
+                name: 'testFunction',
+            });
+            expect(result.testObject).toEqual({
+                __type: 'object',
+                id: 'test-id',
+                name: 'Test Object',
+                description: 'A test object for testing',
+                port: 3000,
+            });
+        });
+        it('should handle array exports', async () => {
+            const moduleContent = `
+export const servers = [
+    {
+        id: 'server1',
+        name: 'Test Server 1',
+        port: 3001,
+        deployment: 'local'
+    },
+    {
+        id: 'server2', 
+        name: 'Test Server 2',
+        serverUrl: 'http://localhost:3002',
+        deployment: 'remote'
+    }
+];
+
+export const simpleArray = ['item1', 'item2', 'item3'];
+`;
+            writeFileSync(testGraphFile, moduleContent);
+            const result = await loadTypeScriptModule(testGraphFile);
+            expect(result.servers.__type).toBe('array');
+            expect(result.servers.items).toHaveLength(2);
+            expect(result.servers.items[0]).toEqual({
+                id: 'server1',
+                name: 'Test Server 1',
+                port: 3001,
+                deployment: 'local',
+            });
+            expect(result.servers.items[1]).toEqual({
+                id: 'server2',
+                name: 'Test Server 2',
+                serverUrl: 'http://localhost:3002',
+                deployment: 'remote',
+            });
+            expect(result.simpleArray.__type).toBe('array');
+            expect(result.simpleArray.items).toEqual(['item1', 'item2', 'item3']);
+        });
+        it('should handle objects with methods', async () => {
+            const moduleContent = `
+export const toolWithMethods = {
+    id: 'tool-with-methods',
+    name: 'Tool With Methods',
+    
+    execute() {
+        return 'executed';
+    },
+    
+    init() {
+        return 'initialized';
+    },
+    
+    getServerUrl() {
+        return 'http://localhost:3000';
+    }
+};
+
+export const graphObject = {
+    getId() {
+        return 'test-graph-id';
+    }
+};
+`;
+            writeFileSync(testGraphFile, moduleContent);
+            const result = await loadTypeScriptModule(testGraphFile);
+            expect(result.toolWithMethods).toEqual({
+                __type: 'object',
+                id: 'tool-with-methods',
+                name: 'Tool With Methods',
+                hasExecute: true,
+                hasInit: true,
+                hasGetServerUrl: true,
+            });
+            expect(result.graphObject).toEqual({
+                __type: 'object',
+                graphId: 'test-graph-id',
+            });
+        });
+        it('should handle module loading errors gracefully', async () => {
+            // Create a module with syntax errors
+            const moduleContent = `
+export const badSyntax = {
+    // Missing closing brace
+    id: 'test'
+`;
+            writeFileSync(testGraphFile, moduleContent);
+            await expect(loadTypeScriptModule(testGraphFile)).rejects.toThrow();
+        });
+        it('should handle non-existent files', async () => {
+            const nonExistentFile = join(testDir, 'non-existent.ts');
+            await expect(loadTypeScriptModule(nonExistentFile)).rejects.toThrow();
+        });
+        it('should handle empty modules', async () => {
+            writeFileSync(testGraphFile, '');
+            const result = await loadTypeScriptModule(testGraphFile);
+            // Empty modules may have a default export object
+            expect(result).toEqual(expect.objectContaining({
+                default: expect.objectContaining({
+                    __type: 'object',
+                }),
+            }));
+        });
+        it('should handle complex nested objects', async () => {
+            const moduleContent = `
+export const complexConfig = {
+    servers: [
+        {
+            id: 'nested-server',
+            name: 'Nested Server',
+            transport: 'http',
+            deployment: 'local'
+        }
+    ],
+    metadata: {
+        version: '1.0.0',
+        author: 'test'
+    }
+};
+`;
+            writeFileSync(testGraphFile, moduleContent);
+            const result = await loadTypeScriptModule(testGraphFile);
+            expect(result.complexConfig.__type).toBe('object');
+            // Note: The loader has specific handling for certain property names
+            // It may not serialize arbitrary nested structures completely
+        });
+        it('should use test environment defaults when no environment is set', async () => {
+            // Clear environment variables that might affect the test
+            const originalEnv = process.env.ENVIRONMENT;
+            delete process.env.ENVIRONMENT;
+            const moduleContent = `
+export const envValue = process.env.ENVIRONMENT;
+export const dbFileName = process.env.DB_FILE_NAME;
+export const tenantId = process.env.INKEEP_TENANT_ID;
+`;
+            writeFileSync(testGraphFile, moduleContent);
+            try {
+                const result = await loadTypeScriptModule(testGraphFile);
+                // The loader should set test defaults
+                expect(result.envValue).toBe('test');
+                expect(result.dbFileName).toBe(':memory:');
+                expect(result.tenantId).toBe('test-tenant');
+            }
+            finally {
+                if (originalEnv !== undefined) {
+                    process.env.ENVIRONMENT = originalEnv;
+                }
+            }
+        });
+        it('should preserve existing environment variables', async () => {
+            const originalEnv = process.env.ENVIRONMENT;
+            process.env.ENVIRONMENT = 'production';
+            process.env.CUSTOM_VAR = 'custom-value';
+            const moduleContent = `
+export const envValue = process.env.ENVIRONMENT;
+export const customVar = process.env.CUSTOM_VAR;
+`;
+            writeFileSync(testGraphFile, moduleContent);
+            try {
+                const result = await loadTypeScriptModule(testGraphFile);
+                expect(result.envValue).toBe('production');
+                expect(result.customVar).toBe('custom-value');
+            }
+            finally {
+                if (originalEnv !== undefined) {
+                    process.env.ENVIRONMENT = originalEnv;
+                }
+                else {
+                    delete process.env.ENVIRONMENT;
+                }
+                delete process.env.CUSTOM_VAR;
+            }
+        });
+    });
+});

package/dist/api.d.ts

@@ -0,0 +1,23 @@
+declare abstract class BaseApiClient {
+    protected apiUrl: string;
+    protected tenantId: string | undefined;
+    protected projectId: string;
+    protected constructor(apiUrl: string, tenantId: string | undefined, projectId: string);
+    protected checkTenantId(): string;
+    getTenantId(): string | undefined;
+    getProjectId(): string;
+    getApiUrl(): string;
+}
+export declare class ManagementApiClient extends BaseApiClient {
+    private constructor();
+    static create(apiUrl?: string, configPath?: string, tenantIdOverride?: string, projectIdOverride?: string): Promise<ManagementApiClient>;
+    listGraphs(): Promise<any[]>;
+    getGraph(graphId: string): Promise<any>;
+    pushGraph(graphDefinition: any): Promise<any>;
+}
+export declare class ExecutionApiClient extends BaseApiClient {
+    private constructor();
+    static create(apiUrl?: string, configPath?: string, tenantIdOverride?: string, projectIdOverride?: string): Promise<ExecutionApiClient>;
+    chatCompletion(graphId: string, messages: any[], conversationId?: string): Promise<ReadableStream<Uint8Array> | string>;
+}
+export {};

package/dist/api.js

@@ -0,0 +1,140 @@
+import { getManagementApiUrl, getExecutionApiUrl, getProjectId, getTenantId } from './config.js';
+class BaseApiClient {
+    apiUrl;
+    tenantId;
+    projectId;
+    constructor(apiUrl, tenantId, projectId) {
+        this.apiUrl = apiUrl;
+        this.tenantId = tenantId;
+        this.projectId = projectId;
+    }
+    checkTenantId() {
+        if (!this.tenantId) {
+            throw new Error('No tenant ID configured. Please run: inkeep init');
+        }
+        return this.tenantId;
+    }
+    getTenantId() {
+        return this.tenantId;
+    }
+    getProjectId() {
+        return this.projectId;
+    }
+    getApiUrl() {
+        return this.apiUrl;
+    }
+}
+export class ManagementApiClient extends BaseApiClient {
+    constructor(apiUrl, tenantId, projectId) {
+        super(apiUrl, tenantId, projectId);
+    }
+    static async create(apiUrl, configPath, tenantIdOverride, projectIdOverride) {
+        const resolvedApiUrl = await getManagementApiUrl(apiUrl, configPath);
+        const tenantId = tenantIdOverride || (await getTenantId(configPath));
+        const projectId = projectIdOverride || (await getProjectId(configPath));
+        return new ManagementApiClient(resolvedApiUrl, tenantId, projectId);
+    }
+    async listGraphs() {
+        const tenantId = this.checkTenantId();
+        const projectId = this.getProjectId();
+        const response = await fetch(`${this.apiUrl}/tenants/${tenantId}/crud/projects/${projectId}/agent-graphs`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(process.env.INKEEP_AGENTS_MANAGE_API_SECRET && {
+                    Authorization: `Bearer ${process.env.INKEEP_AGENTS_MANAGE_API_SECRET}`,
+                }),
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to list graphs: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.data || [];
+    }
+    async getGraph(graphId) {
+        // Since there's no dedicated GET endpoint for graphs,
+        // we check if the graph exists in the CRUD endpoint
+        const graphs = await this.listGraphs();
+        const graph = graphs.find((g) => g.id === graphId);
+        // If found in CRUD, return it as a valid graph
+        // The graph is usable for chat even without a dedicated GET endpoint
+        return graph || null;
+    }
+    async pushGraph(graphDefinition) {
+        const tenantId = this.checkTenantId();
+        const projectId = this.getProjectId();
+        // Ensure the graph has the correct tenant ID
+        graphDefinition.tenantId = tenantId;
+        const graphId = graphDefinition.id;
+        if (!graphId) {
+            throw new Error('Graph must have an id property');
+        }
+        // Try to update first using PUT, if it doesn't exist, it will create it
+        const response = await fetch(`${this.apiUrl}/tenants/${tenantId}/crud/projects/${projectId}/graph/${graphId}`, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(process.env.INKEEP_AGENTS_MANAGE_API_SECRET && {
+                    Authorization: `Bearer ${process.env.INKEEP_AGENTS_MANAGE_API_SECRET}`,
+                }),
+            },
+            body: JSON.stringify(graphDefinition),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to push graph: ${response.statusText}\n${errorText}`);
+        }
+        const data = await response.json();
+        return data.data;
+    }
+}
+export class ExecutionApiClient extends BaseApiClient {
+    constructor(apiUrl, tenantId, projectId) {
+        super(apiUrl, tenantId, projectId);
+    }
+    static async create(apiUrl, configPath, tenantIdOverride, projectIdOverride) {
+        const resolvedApiUrl = await getExecutionApiUrl(apiUrl, configPath);
+        const tenantId = tenantIdOverride || (await getTenantId(configPath));
+        const projectId = projectIdOverride || (await getProjectId(configPath));
+        return new ExecutionApiClient(resolvedApiUrl, tenantId, projectId);
+    }
+    async chatCompletion(graphId, messages, conversationId) {
+        const response = await fetch(`${this.apiUrl}/v1/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'text/event-stream',
+                ...(process.env.INKEEP_AGENTS_RUN_BYPASS_SECRET && {
+                    Authorization: `Bearer ${process.env.INKEEP_AGENTS_RUN_BYPASS_SECRET}`,
+                }),
+                'x-inkeep-tenant-id': this.tenantId || 'test-tenant-id',
+                'x-inkeep-project-id': this.projectId,
+                'x-inkeep-graph-id': graphId,
+            },
+            body: JSON.stringify({
+                model: 'gpt-4o-mini', // Required but will be overridden by graph config
+                messages,
+                conversationId,
+                stream: true,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Chat request failed: ${response.statusText}\n${errorText}`);
+        }
+        // Check if response is streaming
+        const contentType = response.headers.get('content-type');
+        if (contentType?.includes('text/event-stream')) {
+            if (!response.body) {
+                throw new Error('No response body for streaming request');
+            }
+            return response.body;
+        }
+        else {
+            // Non-streaming response
+            const data = await response.json();
+            return data.choices?.[0]?.message?.content || data.result || '';
+        }
+    }
+}

package/dist/commands/chat-enhanced.d.ts

@@ -0,0 +1,7 @@
+export interface ChatOptions {
+    tenantId?: string;
+    managementApiUrl?: string;
+    executionApiUrl?: string;
+    configFilePath?: string;
+}
+export declare function chatCommandEnhanced(graphIdInput?: string, options?: ChatOptions): Promise<void>;