@inkeep/create-agents 0.29.9 → 0.29.11

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

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

package/dist/__tests__/e2e/quickstart.test.js

@@ -0,0 +1,170 @@
+import path from 'node:path';
+import { execa } from 'execa';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { cleanupDir, createTempDir, linkLocalPackages, runCommand, runCreateAgentsCLI, verifyDirectoryStructure, verifyFile, waitForServerReady, } from './utils';
+const manageApiUrl = 'http://localhost:3002';
+const runApiUrl = 'http://localhost:3003';
+describe('create-agents quickstart e2e', () => {
+    let testDir;
+    let projectDir;
+    const workspaceName = 'test-project';
+    const projectId = 'activities-planner';
+    beforeEach(async () => {
+        // Create a temporary directory for each test
+        testDir = await createTempDir();
+        projectDir = path.join(testDir, workspaceName);
+    });
+    afterEach(async () => {
+        await cleanupDir(testDir);
+    });
+    it('should work e2e', async () => {
+        // Run the CLI with all options (non-interactive mode)
+        console.log('Running CLI with options:');
+        console.log(`Working directory: ${testDir}`);
+        const result = await runCreateAgentsCLI([
+            workspaceName,
+            '--openai-key',
+            'test-openai-key',
+            '--disable-git', // Skip git init for faster tests
+        ], testDir);
+        // Verify the CLI completed successfully
+        expect(result.exitCode).toBe(0);
+        console.log('CLI completed successfully');
+        // Verify the core directory structure
+        console.log('Verifying directory structure...');
+        await verifyDirectoryStructure(projectDir, [
+            'src',
+            'src/inkeep.config.ts',
+            `src/projects/${projectId}`,
+            'apps/manage-api',
+            'apps/run-api',
+            'apps/mcp',
+            'apps/manage-ui',
+            '.env',
+            'package.json',
+            'drizzle.config.ts',
+        ]);
+        console.log('Directory structure verified');
+        // Verify .env file has required variables
+        console.log('Verifying .env file...');
+        await verifyFile(path.join(projectDir, '.env'), [
+            /ENVIRONMENT=development/,
+            /OPENAI_API_KEY=test-openai-key/,
+            /DB_FILE_NAME=file:.*\/local\.db/,
+            /INKEEP_AGENTS_MANAGE_API_URL="http:\/\/localhost:3002"/,
+            /INKEEP_AGENTS_RUN_API_URL="http:\/\/localhost:3003"/,
+            /INKEEP_AGENTS_JWT_SIGNING_SECRET=\w+/, // Random secret should be generated
+        ]);
+        console.log('.env file verified');
+        // Verify inkeep.config.ts was created
+        console.log('Verifying inkeep.config.ts...');
+        await verifyFile(path.join(projectDir, 'src/inkeep.config.ts'));
+        console.log('inkeep.config.ts verified');
+        console.log('Starting dev servers');
+        // Start dev servers in background with output monitoring
+        const devProcess = execa('pnpm', ['dev'], {
+            cwd: path.join(projectDir, 'apps/manage-api'),
+            env: {
+                ...process.env,
+                FORCE_COLOR: '0',
+                NODE_ENV: 'test',
+            },
+            cleanup: true,
+            detached: false,
+            stderr: 'pipe',
+        });
+        // Monitor output for errors and readiness signals
+        let serverOutput = '';
+        const outputHandler = (data) => {
+            const text = data.toString();
+            serverOutput += text;
+            // Log important messages in CI
+            if (process.env.CI) {
+                if (text.includes('Error') || text.includes('EADDRINUSE') || text.includes('ready')) {
+                    console.log('[Server]:', text.trim());
+                }
+            }
+        };
+        if (devProcess.stderr)
+            devProcess.stderr.on('data', outputHandler);
+        // Handle process crashes during startup
+        devProcess.catch((error) => {
+            console.error('Dev process crashed during startup:', error.message);
+            console.error('Server output:', serverOutput);
+        });
+        console.log('Waiting for servers to be ready');
+        try {
+            // Wait for servers to be ready with retries
+            await waitForServerReady(`${manageApiUrl}/health`, 120000); // Increased to 2 minutes for CI
+            console.log('Manage API is ready');
+            console.log('Pushing project');
+            const pushResult = await runCommand('pnpm', [
+                'inkeep',
+                'push',
+                '--project',
+                `src/projects/${projectId}`,
+                '--config',
+                'src/inkeep.config.ts',
+            ], projectDir, 30000);
+            expect(pushResult.exitCode).toBe(0);
+            console.log('Testing API requests');
+            // Test API requests
+            const response = await fetch(`${manageApiUrl}/tenants/default/projects/${projectId}`);
+            const data = await response.json();
+            expect(data.data.tenantId).toBe('default');
+            expect(data.data.id).toBe(projectId);
+            // Link to local monorepo packages
+            const monorepoRoot = path.join(__dirname, '../../../../../'); // Go up to repo root
+            await linkLocalPackages(projectDir, monorepoRoot);
+            const pushResultLocal = await runCommand('pnpm', [
+                'inkeep',
+                'push',
+                '--project',
+                `src/projects/${projectId}`,
+                '--config',
+                'src/inkeep.config.ts',
+            ], projectDir, 30000);
+            expect(pushResultLocal.exitCode).toBe(0);
+            // Test that the project works with local packages
+            const responseLocal = await fetch(`${manageApiUrl}/tenants/default/projects/${projectId}`);
+            expect(responseLocal.status).toBe(200);
+        }
+        catch (error) {
+            console.error('Test failed with error:', error);
+            // Print server output for debugging
+            if (devProcess.stdout) {
+                const stdout = await devProcess.stdout;
+                console.log('Server stdout:', stdout);
+            }
+            if (devProcess.stderr) {
+                const stderr = await devProcess.stderr;
+                console.error('Server stderr:', stderr);
+            }
+            throw error;
+        }
+        finally {
+            console.log('Killing dev process');
+            // Kill the process and wait for it to die
+            try {
+                devProcess.kill('SIGTERM');
+            }
+            catch {
+                // Might already be dead
+            }
+            // Give it 2 seconds to shut down gracefully, then force kill
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            try {
+                devProcess.kill('SIGKILL');
+            }
+            catch {
+                // Already dead or couldn't kill
+            }
+            // Wait for the process to be fully cleaned up (with timeout)
+            await Promise.race([
+                devProcess.catch(() => { }), // Wait for process to exit
+                new Promise((resolve) => setTimeout(resolve, 5000)), // Or timeout after 5s
+            ]);
+            console.log('Dev process cleanup complete');
+        }
+    }, 720000); // 12 minute timeout for full flow with network calls (CI can be slow)
+});

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

@@ -0,0 +1,41 @@
+/**
+ * Run the create-agents CLI with the given arguments
+ */
+export declare function runCreateAgentsCLI(args: string[], cwd: string, timeout?: number): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number | undefined;
+}>;
+/**
+ * Run a command in the created project directory
+ */
+export declare function runCommand(command: string, args: string[], cwd: string, timeout?: number): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number | undefined;
+}>;
+/**
+ * Create a temporary directory for testing
+ */
+export declare function createTempDir(prefix?: string): Promise<string>;
+/**
+ * Clean up a test directory with retries
+ */
+export declare function cleanupDir(dir: string): Promise<void>;
+/**
+ * Verify that a file exists and optionally check its contents
+ */
+export declare function verifyFile(filePath: string, expectedContents?: string[] | RegExp[]): Promise<void>;
+/**
+ * Verify that a directory has the expected structure
+ */
+export declare function verifyDirectoryStructure(baseDir: string, expectedPaths: string[]): Promise<void>;
+/**
+ * Link local monorepo packages to the created project
+ * This replaces published @inkeep packages with local versions for testing
+ */
+export declare function linkLocalPackages(projectDir: string, monorepoRoot: string): Promise<void>;
+/**
+ * Wait for a server to be ready by polling a health endpoint
+ */
+export declare function waitForServerReady(url: string, timeout: number): Promise<void>;

package/dist/__tests__/e2e/utils.js

@@ -0,0 +1,217 @@
+import os from 'node:os';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execa } from 'execa';
+import fs from 'fs-extra';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Run the create-agents CLI with the given arguments
+ */
+export async function runCreateAgentsCLI(args, cwd, timeout = 300000 // 5 minutes default for full flow
+) {
+    const cliPath = path.join(__dirname, '../../../src/index.ts');
+    try {
+        // Run using tsx to execute TypeScript directly
+        const result = await execa('tsx', [cliPath, ...args], {
+            cwd,
+            timeout,
+            env: { ...process.env, FORCE_COLOR: '0' }, // Disable colors for easier assertion
+            all: true, // Capture combined stdout + stderr in order
+        });
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+        };
+    }
+    catch (error) {
+        // execa throws on non-zero exit codes, capture the error info
+        return {
+            stdout: error.stdout || '',
+            stderr: error.stderr || '',
+            exitCode: error.exitCode || 1,
+        };
+    }
+}
+/**
+ * Run a command in the created project directory
+ */
+export async function runCommand(command, args, cwd, timeout = 120000 // 2 minutes default
+) {
+    try {
+        const result = await execa(command, args, {
+            cwd,
+            timeout,
+            env: { ...process.env, FORCE_COLOR: '0' },
+            shell: true,
+        });
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+        };
+    }
+    catch (error) {
+        return {
+            stdout: error.stdout || '',
+            stderr: error.stderr || '',
+            exitCode: error.exitCode || 1,
+        };
+    }
+}
+/**
+ * Create a temporary directory for testing
+ */
+export async function createTempDir(prefix = 'create-agents-e2e-') {
+    return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+/**
+ * Clean up a test directory with retries
+ */
+export async function cleanupDir(dir) {
+    if (!(await fs.pathExists(dir))) {
+        return;
+    }
+    try {
+        // Try multiple times with delays (common in CI)
+        for (let i = 0; i < 3; i++) {
+            try {
+                await fs.remove(dir);
+                return;
+            }
+            catch (error) {
+                if (i === 2)
+                    throw error; // Last attempt, throw the error
+                await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1s before retry
+            }
+        }
+    }
+    catch (error) {
+        // If still failing, try force removal
+        if (error.code === 'ENOTEMPTY' || error.code === 'EBUSY') {
+            await execa('rm', ['-rf', dir], { shell: true }).catch(() => {
+                console.warn(`Failed to clean up ${dir}`);
+            });
+        }
+    }
+}
+/**
+ * Verify that a file exists and optionally check its contents
+ */
+export async function verifyFile(filePath, expectedContents) {
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+        throw new Error(`Expected file to exist: ${filePath}`);
+    }
+    if (expectedContents) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        for (const expected of expectedContents) {
+            if (typeof expected === 'string') {
+                if (!content.includes(expected)) {
+                    throw new Error(`Expected file ${filePath} to contain: ${expected}`);
+                }
+            }
+            else {
+                if (!expected.test(content)) {
+                    throw new Error(`Expected file ${filePath} to match pattern: ${expected}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * Verify that a directory has the expected structure
+ */
+export async function verifyDirectoryStructure(baseDir, expectedPaths) {
+    for (const expectedPath of expectedPaths) {
+        const fullPath = path.join(baseDir, expectedPath);
+        const exists = await fs.pathExists(fullPath);
+        if (!exists) {
+            throw new Error(`Expected path to exist: ${fullPath}`);
+        }
+    }
+}
+/**
+ * Link local monorepo packages to the created project
+ * This replaces published @inkeep packages with local versions for testing
+ */
+export async function linkLocalPackages(projectDir, monorepoRoot) {
+    const packageJsonPaths = [
+        path.join(projectDir, 'package.json'),
+        path.join(projectDir, 'apps/manage-api/package.json'),
+        path.join(projectDir, 'apps/run-api/package.json'),
+    ];
+    const packageJsons = {};
+    for (const packageJsonPath of packageJsonPaths) {
+        packageJsons[packageJsonPath] = await fs.readJson(packageJsonPath);
+    }
+    // Define local @inkeep packages to link
+    const inkeepPackages = {
+        '@inkeep/agents-sdk': `link:${path.join(monorepoRoot, 'packages/agents-sdk')}`,
+        '@inkeep/agents-core': `link:${path.join(monorepoRoot, 'packages/agents-core')}`,
+        '@inkeep/agents-manage-api': `link:${path.join(monorepoRoot, 'agents-manage-api')}`,
+        '@inkeep/agents-run-api': `link:${path.join(monorepoRoot, 'agents-run-api')}`,
+        '@inkeep/agents-cli': `link:${path.join(monorepoRoot, 'agents-cli')}`,
+    };
+    // Replace package versions with local links
+    for (const [pkg, linkPath] of Object.entries(inkeepPackages)) {
+        for (const packageJsonPath of packageJsonPaths) {
+            if (packageJsons[packageJsonPath].dependencies?.[pkg]) {
+                packageJsons[packageJsonPath].dependencies[pkg] = linkPath;
+            }
+            if (packageJsons[packageJsonPath].devDependencies?.[pkg]) {
+                packageJsons[packageJsonPath].devDependencies[pkg] = linkPath;
+            }
+        }
+    }
+    // Write updated package.json
+    for (const packageJsonPath of packageJsonPaths) {
+        await fs.writeJson(packageJsonPath, packageJsons[packageJsonPath], { spaces: 2 });
+    }
+    // Reinstall to create the symlinks
+    await execa('pnpm', ['install', '--no-frozen-lockfile'], {
+        cwd: projectDir,
+        env: { ...process.env, FORCE_COLOR: '0' },
+    });
+}
+/**
+ * Wait for a server to be ready by polling a health endpoint
+ */
+export async function waitForServerReady(url, timeout) {
+    const start = Date.now();
+    let lastError = null;
+    let attempts = 0;
+    console.log(`Waiting for server at ${url}...`);
+    while (Date.now() - start < timeout) {
+        attempts++;
+        try {
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(5000), // 5 second timeout per request
+            });
+            if (response.ok) {
+                console.log(`✓ Server ready at ${url} after ${attempts} attempts (${Date.now() - start}ms)`);
+                return;
+            }
+            lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+            // Log status every 10 attempts in CI
+            if (process.env.CI && attempts % 10 === 0) {
+                console.log(`Still waiting for ${url}... (attempt ${attempts}, ${Math.floor((Date.now() - start) / 1000)}s elapsed)`);
+            }
+        }
+        catch (error) {
+            // Server not ready yet or connection refused
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // Log connection errors periodically in CI
+            if (process.env.CI && attempts % 15 === 0) {
+                console.log(`Connection attempt ${attempts} failed: ${lastError.message}`);
+            }
+        }
+        // Wait before next attempt (exponential backoff up to 5s)
+        const waitTime = Math.min(1000 + attempts * 100, 5000);
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+    }
+    // Timeout reached - provide detailed error
+    const elapsed = Date.now() - start;
+    const errorDetails = lastError ? `: ${lastError.message}` : '';
+    throw new Error(`Server not ready at ${url} after ${elapsed}ms (${attempts} attempts)${errorDetails}`);
+}

package/dist/utils.js

@@ -316,14 +316,18 @@ INKEEP_AGENTS_JWT_SIGNING_SECRET=${jwtSigningSecret}
 }
 async function createInkeepConfig(config) {
     const inkeepConfig = `import { defineConfig } from '@inkeep/agents-cli/config';
-
-  const config = defineConfig({
-    tenantId: "${config.tenantId}",
-    agentsManageApiUrl: 'http://localhost:3002',
-    agentsRunApiUrl: 'http://localhost:3003',
-  });
-      
-  export default config;`;
+    
+const config = defineConfig({
+  tenantId: "${config.tenantId}",
+  agentsManageApi: {
+    url: 'http://localhost:3002',
+  },
+  agentsRunApi: {
+    url: 'http://localhost:3003',
+  },
+});
+    
+export default config;`;
     await fs.writeFile(`src/inkeep.config.ts`, inkeepConfig);
     if (config.customProject) {
         const customIndexContent = `import { project } from '@inkeep/agents-sdk';
@@ -358,14 +362,16 @@ async function isPortAvailable(port) {
     const net = await import('node:net');
     return new Promise((resolve) => {
         const server = net.createServer();
-        server.once('error', () => {
-            resolve(false);
+        server.once('error', (err) => {
+            // Only treat EADDRINUSE as "port in use", other errors might be transient
+            resolve(err.code === 'EADDRINUSE' ? false : true);
         });
         server.once('listening', () => {
-            server.close();
-            resolve(true);
+            server.close(() => {
+                resolve(true);
+            });
         });
-        server.listen(port);
+        server.listen(port, 'localhost');
     });
 }
 /**
@@ -399,6 +405,25 @@ async function checkPortsAvailability() {
         });
     }
 }
+/**
+ * Wait for a server to be ready by polling a health endpoint
+ */
+async function waitForServerReady(url, timeout) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        try {
+            const response = await fetch(url);
+            if (response.ok) {
+                return;
+            }
+        }
+        catch {
+            // Server not ready yet, continue polling
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000)); // Check every second
+    }
+    throw new Error(`Server not ready at ${url} after ${timeout}ms`);
+}
 async function setupProjectInDatabase(config) {
     // Proactively check if ports are available BEFORE starting servers
     await checkPortsAvailability();
@@ -411,7 +436,6 @@ async function setupProjectInDatabase(config) {
         shell: true,
         windowsHide: true,
     });
-    await new Promise((resolve) => setTimeout(resolve, 5000));
     // Track if port errors occur during startup (as a safety fallback)
     const portErrors = { runApi: false, manageApi: false };
     // Regex patterns for detecting port errors in output
@@ -430,8 +454,15 @@ async function setupProjectInDatabase(config) {
         }
     };
     devProcess.stdout.on('data', checkForPortErrors);
-    // Give servers time to start
-    await new Promise((resolve) => setTimeout(resolve, 3000));
+    // Wait for servers to be ready
+    try {
+        await waitForServerReady(`http://localhost:${manageApiPort}/health`, 60000);
+        await waitForServerReady(`http://localhost:${runApiPort}/health`, 60000);
+    }
+    catch (error) {
+        // If servers don't start, we'll still try push but it will likely fail
+        console.warn('Warning: Servers may not be fully ready:', error instanceof Error ? error.message : String(error));
+    }
     // Check if any port errors occurred during startup
     if (portErrors.runApi || portErrors.manageApi) {
         displayPortConflictError(portErrors);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/create-agents",
-  "version": "0.29.9",
+  "version": "0.29.11",
   "description": "Create an Inkeep Agent Framework project",
   "type": "module",
   "bin": {
@@ -31,15 +31,16 @@
     "@clack/prompts": "^0.11.0",
     "commander": "^12.0.0",
     "degit": "^2.8.4",
+    "drizzle-kit": "^0.31.5",
     "fs-extra": "^11.0.0",
     "picocolors": "^1.0.0",
-    "drizzle-kit": "^0.31.5",
-    "@inkeep/agents-core": "0.29.9"
+    "@inkeep/agents-core": "0.29.11"
   },
   "devDependencies": {
     "@types/degit": "^2.8.6",
     "@types/fs-extra": "^11.0.0",
     "@types/node": "^20.12.0",
+    "execa": "^9.6.0",
     "tsx": "^4.7.0",
     "typescript": "^5.4.0",
     "vitest": "^3.2.4"
@@ -62,8 +63,12 @@
     "lint": "biome lint src",
     "lint:fix": "biome check --write .",
     "format": "biome format --write .",
-    "test": "vitest --run --passWithNoTests",
-    "test:watch": "vitest",
+    "test": "vitest --run src/__tests__ --exclude src/__tests__/e2e/** --passWithNoTests",
+    "test:watch": "vitest src/__tests__ --exclude src/__tests__/e2e/**",
+    "test:unit": "vitest --run src/__tests__ --exclude src/__tests__/e2e/**",
+    "test:e2e": "vitest --run src/__tests__/e2e",
+    "test:e2e:watch": "vitest src/__tests__/e2e",
+    "test:all": "vitest --run --passWithNoTests",
     "typecheck": "tsc --noEmit"
   }
 }