@inkeep/agents-cli 0.1.0

package/dist/utils/port-manager.js

@@ -0,0 +1,92 @@
+import { createServer } from 'node:net';
+/**
+ * Manages dynamic port allocation for local MCP servers
+ */
+export class PortManager {
+    static instance;
+    static BASE_PORT = 3100;
+    static MAX_PORT = 3200;
+    allocatedPorts = new Set();
+    constructor() { }
+    static getInstance() {
+        if (!PortManager.instance) {
+            PortManager.instance = new PortManager();
+        }
+        return PortManager.instance;
+    }
+    /**
+     * Allocate an available port in the configured range
+     */
+    async allocatePort(preferredPort) {
+        // If a preferred port is provided and available, use it
+        if (preferredPort) {
+            const isAvailable = await this.isPortAvailable(preferredPort);
+            if (isAvailable && !this.allocatedPorts.has(preferredPort)) {
+                this.allocatedPorts.add(preferredPort);
+                return preferredPort;
+            }
+        }
+        // Find next available port in range
+        for (let port = PortManager.BASE_PORT; port <= PortManager.MAX_PORT; port++) {
+            if (this.allocatedPorts.has(port)) {
+                continue;
+            }
+            const isAvailable = await this.isPortAvailable(port);
+            if (isAvailable) {
+                this.allocatedPorts.add(port);
+                return port;
+            }
+        }
+        throw new Error(`No available ports in range ${PortManager.BASE_PORT}-${PortManager.MAX_PORT}`);
+    }
+    /**
+     * Release a previously allocated port
+     */
+    releasePort(port) {
+        this.allocatedPorts.delete(port);
+    }
+    /**
+     * Release all allocated ports
+     */
+    releaseAll() {
+        this.allocatedPorts.clear();
+    }
+    /**
+     * Check if a specific port is available
+     */
+    async isPortAvailable(port) {
+        return new Promise((resolve) => {
+            const server = createServer();
+            server.once('error', () => {
+                resolve(false);
+            });
+            server.once('listening', () => {
+                server.close(() => {
+                    resolve(true);
+                });
+            });
+            server.listen(port, '127.0.0.1');
+        });
+    }
+    /**
+     * Get list of currently allocated ports
+     */
+    getAllocatedPorts() {
+        return Array.from(this.allocatedPorts).sort((a, b) => a - b);
+    }
+    /**
+     * Get port allocation statistics
+     */
+    getStats() {
+        const totalPorts = PortManager.MAX_PORT - PortManager.BASE_PORT + 1;
+        return {
+            allocated: this.allocatedPorts.size,
+            available: totalPorts - this.allocatedPorts.size,
+            range: {
+                min: PortManager.BASE_PORT,
+                max: PortManager.MAX_PORT,
+            },
+            ports: this.getAllocatedPorts(),
+        };
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Loads a TypeScript module and returns its exports
+ * This works by creating a temporary loader script that tsx can execute
+ */
+export declare function loadTypeScriptModule(filePath: string): Promise<any>;

package/dist/utils/ts-loader.js

@@ -0,0 +1,146 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+/**
+ * Loads a TypeScript module and returns its exports
+ * This works by creating a temporary loader script that tsx can execute
+ */
+export async function loadTypeScriptModule(filePath) {
+    const tempDir = join(tmpdir(), 'inkeep-cli-loader');
+    mkdirSync(tempDir, { recursive: true });
+    const loaderPath = join(tempDir, 'loader.mjs');
+    const outputPath = join(tempDir, 'output.json');
+    // Create a loader script that will import the module and serialize its exports
+    const loaderScript = `
+import { writeFileSync } from 'fs';
+
+async function loadModule() {
+    try {
+        const module = await import('${pathToFileURL(filePath).href}');
+        
+        // Serialize the module exports (functions can't be serialized, so we just mark them)
+        const serializable = {};
+        
+        for (const [key, value] of Object.entries(module)) {
+            if (typeof value === 'function') {
+                // Mark functions
+                serializable[key] = { __type: 'function', name: value.name || key };
+            } else if (value && typeof value === 'object') {
+                // For objects, check if they have specific methods/properties
+                const obj = { __type: 'object' };
+                
+                // Check for config-like properties (for inkeep.config.ts files)
+                if (value.tenantId) obj.tenantId = value.tenantId;
+                if (value.projectId) obj.projectId = value.projectId;
+                if (value.apiUrl) obj.apiUrl = value.apiUrl;
+                if (value.outputDirectory) obj.outputDirectory = value.outputDirectory;
+                if (value.modelSettings) obj.modelSettings = value.modelSettings;
+                
+                // Check for tool-like properties
+                if (value.id) obj.id = value.id;
+                if (value.name) obj.name = value.name;
+                if (value.description) obj.description = value.description;
+                if (value.serverUrl) obj.serverUrl = value.serverUrl;
+                if (value.port) obj.port = value.port;
+                if (value.deployment) obj.deployment = value.deployment;
+                if (value.transport) obj.transport = value.transport;
+                if (typeof value.execute === 'function') obj.hasExecute = true;
+                if (typeof value.init === 'function') obj.hasInit = true;
+                if (typeof value.getServerUrl === 'function') obj.hasGetServerUrl = true;
+                if (typeof value.getId === 'function') {
+                    try {
+                        obj.graphId = value.getId();
+                    } catch {}
+                }
+                
+                // Check if it's an array
+                if (Array.isArray(value)) {
+                    obj.__type = 'array';
+                    obj.items = value.map(item => {
+                        if (item && typeof item === 'object') {
+                            const itemObj = {};
+                            if (item.id) itemObj.id = item.id;
+                            if (item.name) itemObj.name = item.name;
+                            if (item.description) itemObj.description = item.description;
+                            if (item.serverUrl) itemObj.serverUrl = item.serverUrl;
+                            if (item.port) itemObj.port = item.port;
+                            if (item.deployment) itemObj.deployment = item.deployment;
+                            if (item.transport) itemObj.transport = item.transport;
+                            if (typeof item.execute === 'function') itemObj.hasExecute = true;
+                            if (typeof item.init === 'function') itemObj.hasInit = true;
+                            if (typeof item.getServerUrl === 'function') itemObj.hasGetServerUrl = true;
+                            return itemObj;
+                        }
+                        return item;
+                    });
+                }
+                
+                serializable[key] = obj;
+            } else {
+                serializable[key] = value;
+            }
+        }
+        
+        writeFileSync('${outputPath}', JSON.stringify(serializable, null, 2));
+        process.exit(0);
+    } catch (error) {
+        console.error('Failed to load module:', error.message);
+        writeFileSync('${outputPath}', JSON.stringify({ __error: error.message }));
+        process.exit(1);
+    }
+}
+
+loadModule();
+`;
+    try {
+        // Write the loader script
+        writeFileSync(loaderPath, loaderScript);
+        // Execute the loader script with tsx, passing environment variables
+        // Load the .env file from the graph directory if it exists
+        const graphDir = dirname(filePath);
+        const envPath = join(graphDir, '..', '.env');
+        const envVars = { ...process.env };
+        // If no environment variables are set, use test defaults
+        if (!process.env.ENVIRONMENT) {
+            envVars.ENVIRONMENT = 'test';
+            envVars.DB_FILE_NAME = ':memory:'; // Use in-memory DB for CLI testing
+            envVars.INKEEP_TENANT_ID = 'test-tenant';
+            envVars.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || 'test-key';
+        }
+        // Use node directly with tsx for better performance in CI
+        // Try to find tsx in node_modules first for better performance
+        const tsxPath = join(process.cwd(), 'node_modules', '.bin', 'tsx');
+        const command = require('fs').existsSync(tsxPath) ? tsxPath : 'tsx';
+        execFileSync(command, [loaderPath], {
+            cwd: process.cwd(), // Use cwd which is in the pnpm workspace
+            stdio: 'pipe',
+            encoding: 'utf-8',
+            env: envVars,
+            timeout: 15000, // Reduced to 15 second timeout for faster failure detection
+            windowsHide: true, // Hide console window on Windows
+        });
+        // Read the output
+        const outputJson = readFileSync(outputPath, 'utf-8');
+        const output = JSON.parse(outputJson);
+        // Clean up with retries to handle file locks
+        rmSync(tempDir, { recursive: true, force: true, maxRetries: 3 });
+        if (output.__error) {
+            throw new Error(output.__error);
+        }
+        return output;
+    }
+    catch (error) {
+        // Clean up on error
+        try {
+            rmSync(tempDir, { recursive: true, force: true, maxRetries: 3 });
+        }
+        catch { }
+        // Add more context to timeout errors
+        if (error.code === 'ETIMEDOUT' || error.message?.includes('timed out')) {
+            throw new Error(`TypeScript module loading timed out for ${filePath}: ${error.message}`);
+        }
+        throw error;
+    }
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@inkeep/agents-cli",
+  "version": "0.1.0",
+  "description": "Inkeep CLI tool",
+  "type": "module",
+  "main": "./dist/exports.js",
+  "bin": {
+    "inkeep": "./dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/exports.js",
+    "./config": "./dist/exports.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node ./dist/index.js",
+    "test": "node -e \"process.exit(process.env.CI ? 0 : 1)\" && vitest --run --config vitest.config.ci.ts || vitest --run",
+    "test:debug": "vitest --run --reporter=verbose --no-coverage",
+    "test:watch": "vitest",
+    "test:coverage": "node -e \"process.exit(process.env.CI ? 0 : 1)\" && vitest --run --coverage --config vitest.config.ci.ts || vitest --run --coverage",
+    "test:ci": "vitest --run --config vitest.config.ci.ts",
+    "typecheck": "tsc --noEmit --project tsconfig.typecheck.json"
+  },
+  "keywords": [
+    "cli",
+    "inkeep",
+    "agent"
+  ],
+  "author": "Inkeep <support@inkeep.com>",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "dependencies": {
+    "@ai-sdk/anthropic": "2.0.2",
+    "@ai-sdk/openai": "2.0.11",
+    "@babel/parser": "^7.23.0",
+    "@babel/types": "^7.23.0",
+    "@inkeep/agents-core": "workspace:*",
+    "@libsql/client": "^0.15.7",
+    "ai": "5.0.11",
+    "ast-types": "^0.14.2",
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.3",
+    "commander": "^14.0.0",
+    "dotenv": "^17.2.1",
+    "drizzle-orm": "^0.37.0",
+    "inquirer": "^9.2.12",
+    "inquirer-autocomplete-prompt": "^3.0.1",
+    "ora": "^8.0.1",
+    "recast": "^0.23.0",
+    "ts-morph": "^26.0.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.10.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=20.x"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/inkeep/agent-framework.git",
+    "directory": "agents-cli"
+  }
+}