@inkeep/create-agents 0.29.10 → 0.30.0

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

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

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

@@ -0,0 +1,175 @@
+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';
+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 () => {
+        const monorepoRoot = path.join(__dirname, '../../../../../');
+        const createAgentsPrefix = path.join(monorepoRoot, 'create-agents-template');
+        const projectTemplatesPrefix = path.join(monorepoRoot, 'agents-cookbook/template-projects');
+        // 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
+            '--local-agents-prefix',
+            createAgentsPrefix,
+            '--local-templates-prefix',
+            projectTemplatesPrefix,
+        ], 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
+            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/__tests__/utils.test.js

@@ -1,7 +1,7 @@
 import * as p from '@clack/prompts';
 import fs from 'fs-extra';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { cloneTemplate, getAvailableTemplates } from '../templates';
+import { cloneTemplate, cloneTemplateLocal, getAvailableTemplates } from '../templates';
 import { createAgents } from '../utils';
 // Mock all dependencies
 vi.mock('fs-extra');
@@ -55,6 +55,7 @@ describe('createAgents - Template and Project ID Logic', () => {
             'data-analysis',
         ]);
         vi.mocked(cloneTemplate).mockResolvedValue(undefined);
+        vi.mocked(cloneTemplateLocal).mockResolvedValue(undefined);
         // Mock util.promisify to return a mock exec function
         const mockExecAsync = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
         const util = require('node:util');
@@ -79,10 +80,10 @@ describe('createAgents - Template and Project ID Logic', () => {
                 openAiKey: 'test-openai-key',
                 anthropicKey: 'test-anthropic-key',
             });
-            // Should clone base template and weather-project template
+            // Should clone base template and activities-planner template
             expect(cloneTemplate).toHaveBeenCalledTimes(2);
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/create-agents-template', expect.any(String));
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/template-projects/activities-planner', 'src/projects/activities-planner', expect.arrayContaining([
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/create-agents-template', expect.any(String), undefined);
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/agents-cookbook/template-projects/activities-planner', 'src/projects/activities-planner', expect.arrayContaining([
                 expect.objectContaining({
                     filePath: 'index.ts',
                     replacements: expect.objectContaining({
@@ -117,8 +118,8 @@ describe('createAgents - Template and Project ID Logic', () => {
             expect(getAvailableTemplates).toHaveBeenCalled();
             // Should clone base template and the specified template
             expect(cloneTemplate).toHaveBeenCalledTimes(2);
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/create-agents-template', expect.any(String));
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/template-projects/chatbot', 'src/projects/chatbot', expect.arrayContaining([
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/create-agents-template', expect.any(String), undefined);
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/agents-cookbook/template-projects/chatbot', 'src/projects/chatbot', expect.arrayContaining([
                 expect.objectContaining({
                     filePath: 'index.ts',
                     replacements: expect.objectContaining({
@@ -168,7 +169,7 @@ describe('createAgents - Template and Project ID Logic', () => {
             });
             // Should clone base template but NOT project template
             expect(cloneTemplate).toHaveBeenCalledTimes(1);
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/create-agents-template', expect.any(String));
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/create-agents-template', expect.any(String), undefined);
             // Should NOT validate templates
             expect(getAvailableTemplates).not.toHaveBeenCalled();
             // Should create empty project directory
@@ -190,7 +191,7 @@ describe('createAgents - Template and Project ID Logic', () => {
             });
             // Should only clone base template, not project template
             expect(cloneTemplate).toHaveBeenCalledTimes(1);
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/create-agents-template', expect.any(String));
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/create-agents-template', expect.any(String), undefined);
             expect(getAvailableTemplates).not.toHaveBeenCalled();
             expect(fs.ensureDir).toHaveBeenCalledWith('src/projects/my-custom-project');
             // Check that .env file is created
@@ -214,7 +215,7 @@ describe('createAgents - Template and Project ID Logic', () => {
                 anthropicKey: 'test-key',
             });
             expect(cloneTemplate).toHaveBeenCalledTimes(2);
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/template-projects/my-complex-template', 'src/projects/my-complex-template', expect.arrayContaining([
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/agents-cookbook/template-projects/my-complex-template', 'src/projects/my-complex-template', expect.arrayContaining([
                 expect.objectContaining({
                     filePath: 'index.ts',
                     replacements: expect.objectContaining({
@@ -328,4 +329,5 @@ function setupDefaultMocks() {
     vi.mocked(fs.writeFile).mockResolvedValue(undefined);
     vi.mocked(getAvailableTemplates).mockResolvedValue(['event-planner', 'chatbot', 'data-analysis']);
     vi.mocked(cloneTemplate).mockResolvedValue(undefined);
+    vi.mocked(cloneTemplateLocal).mockResolvedValue(undefined);
 }

package/dist/index.js

@@ -11,6 +11,8 @@ program
     .option('--anthropic-key <anthropic-key>', 'Anthropic API key')
     .option('--custom-project-id <custom-project-id>', 'Custom project id for experienced users who want an empty project directory')
     .option('--disable-git', 'Disable git initialization')
+    .option('--local-agents-prefix <local-agents-prefix>', 'Local prefix for create-agents-template')
+    .option('--local-templates-prefix <local-templates-prefix>', 'Local prefix for project templates')
     .parse();
 async function main() {
     const options = program.opts();
@@ -23,6 +25,8 @@ async function main() {
             customProjectId: options.customProjectId,
             template: options.template,
             disableGit: options.disableGit,
+            localAgentsPrefix: options.localAgentsPrefix,
+            localTemplatesPrefix: options.localTemplatesPrefix,
         });
     }
     catch (error) {

package/dist/templates.d.ts

@@ -5,7 +5,7 @@ export interface ContentReplacement {
     replacements: Record<string, any>;
 }
 export declare function cloneTemplate(templatePath: string, targetPath: string, replacements?: ContentReplacement[]): Promise<void>;
-export declare function cloneTemplateLocal(templatePath: string, targetPath: string, replacements: ContentReplacement[]): Promise<void>;
+export declare function cloneTemplateLocal(templatePath: string, targetPath: string, replacements?: ContentReplacement[]): Promise<void>;
 /**
  * Replace content in cloned template files
  */
@@ -14,4 +14,4 @@ export declare function replaceContentInFiles(targetPath: string, replacements:
  * Replace object properties in TypeScript code content
  */
 export declare function replaceObjectProperties(content: string, replacements: Record<string, any>): Promise<string>;
-export declare function getAvailableTemplates(): Promise<string[]>;
+export declare function getAvailableTemplates(localPrefix?: string): Promise<string[]>;

package/dist/templates.js

@@ -253,9 +253,16 @@ function injectPropertyIntoObject(content, propertyPath, replacement) {
     console.warn(`Could not inject property "${propertyPath}" - no suitable object found in content`);
     return content;
 }
-export async function getAvailableTemplates() {
-    // Fetch the list of templates from your repo
-    const response = await fetch('https://api.github.com/repos/inkeep/agents-cookbook/contents/template-projects');
-    const contents = await response.json();
-    return contents.filter((item) => item.type === 'dir').map((item) => item.name);
+export async function getAvailableTemplates(localPrefix) {
+    if (localPrefix && localPrefix.length > 0) {
+        const fullTemplatePath = path.join(localPrefix, 'template-projects');
+        const response = await fs.readdir(fullTemplatePath);
+        return response.filter((item) => fs.stat(path.join(fullTemplatePath, item)).then((stat) => stat.isDirectory()));
+    }
+    else {
+        // Fetch the list of templates from your repo
+        const response = await fetch(`https://api.github.com/repos/inkeep/agents/contents/agents-cookbook/template-projects`);
+        const contents = await response.json();
+        return contents.filter((item) => item.type === 'dir').map((item) => item.name);
+    }
 }

package/dist/utils.d.ts

@@ -40,5 +40,7 @@ export declare const createAgents: (args?: {
     template?: string;
     customProjectId?: string;
     disableGit?: boolean;
+    localAgentsPrefix?: string;
+    localTemplatesPrefix?: string;
 }) => Promise<void>;
 export declare function createCommand(dirName?: string, options?: any): Promise<void>;

package/dist/utils.js

@@ -6,7 +6,7 @@ import * as p from '@clack/prompts';
 import { ANTHROPIC_MODELS, GOOGLE_MODELS, OPENAI_MODELS } from '@inkeep/agents-core';
 import fs from 'fs-extra';
 import color from 'picocolors';
-import { cloneTemplate, getAvailableTemplates } from './templates.js';
+import { cloneTemplate, cloneTemplateLocal, getAvailableTemplates, } from './templates.js';
 // Shared validation utility
 const DIRECTORY_VALIDATION = {
     pattern: /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/,
@@ -28,6 +28,8 @@ const DIRECTORY_VALIDATION = {
         return undefined;
     },
 };
+const agentsTemplateRepo = 'https://github.com/inkeep/agents/create-agents-template';
+const projectTemplateRepo = 'https://github.com/inkeep/agents/agents-cookbook/template-projects';
 const execAsync = promisify(exec);
 const manageApiPort = '3002';
 const runApiPort = '3003';
@@ -65,7 +67,7 @@ export const defaultAnthropicModelConfigurations = {
     },
 };
 export const createAgents = async (args = {}) => {
-    let { dirName, openAiKey, anthropicKey, googleKey, template, customProjectId, disableGit } = args;
+    let { dirName, openAiKey, anthropicKey, googleKey, template, customProjectId, disableGit, localAgentsPrefix, localTemplatesPrefix, } = args;
     const tenantId = 'default';
     let projectId;
     let templateName;
@@ -74,7 +76,7 @@ export const createAgents = async (args = {}) => {
         templateName = '';
     }
     else if (template) {
-        const availableTemplates = await getAvailableTemplates();
+        const availableTemplates = await getAvailableTemplates(localTemplatesPrefix);
         if (!availableTemplates.includes(template)) {
             p.cancel(`${color.red('✗')} Template "${template}" not found\n\n` +
                 `${color.yellow('Available templates:')}\n` +
@@ -188,10 +190,6 @@ export const createAgents = async (args = {}) => {
     const s = p.spinner();
     s.start('Creating directory structure...');
     try {
-        const agentsTemplateRepo = 'https://github.com/inkeep/create-agents-template';
-        const projectTemplateRepo = templateName
-            ? `https://github.com/inkeep/agents-cookbook/template-projects/${templateName}`
-            : null;
         const directoryPath = path.resolve(process.cwd(), dirName);
         if (await fs.pathExists(directoryPath)) {
             s.stop();
@@ -206,7 +204,10 @@ export const createAgents = async (args = {}) => {
             await fs.emptyDir(directoryPath);
         }
         s.message('Building template...');
-        await cloneTemplate(agentsTemplateRepo, directoryPath);
+        await cloneTemplateHelper({
+            targetPath: directoryPath,
+            localPrefix: localAgentsPrefix,
+        });
         process.chdir(directoryPath);
         const config = {
             dirName,
@@ -223,7 +224,7 @@ export const createAgents = async (args = {}) => {
         await createWorkspaceStructure();
         s.message('Setting up environment files...');
         await createEnvironmentFiles(config);
-        if (projectTemplateRepo) {
+        if (templateName && templateName.length > 0) {
             s.message('Creating project template folder...');
             const templateTargetPath = `src/projects/${projectId}`;
             const contentReplacements = [
@@ -234,7 +235,12 @@ export const createAgents = async (args = {}) => {
                     },
                 },
             ];
-            await cloneTemplate(projectTemplateRepo, templateTargetPath, contentReplacements);
+            await cloneTemplateHelper({
+                templateName,
+                targetPath: templateTargetPath,
+                localPrefix: localTemplatesPrefix,
+                replacements: contentReplacements,
+            });
         }
         else {
             s.message('Creating empty project folder...');
@@ -316,14 +322,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 +368,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 +411,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 +442,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 +460,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);
@@ -474,6 +511,27 @@ async function setupDatabase() {
         throw new Error(`Failed to setup database: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
+async function cloneTemplateHelper(options) {
+    const { targetPath, templateName, localPrefix, replacements } = options;
+    // If local prefix is provided, use it to clone the template. This is useful for local development and testing.
+    if (localPrefix && localPrefix.length > 0) {
+        if (templateName) {
+            const fullTemplatePath = path.join(localPrefix, templateName);
+            await cloneTemplateLocal(fullTemplatePath, targetPath, replacements);
+        }
+        else {
+            await cloneTemplateLocal(localPrefix, targetPath, replacements);
+        }
+    }
+    else {
+        if (templateName) {
+            await cloneTemplate(`${projectTemplateRepo}/${templateName}`, targetPath, replacements);
+        }
+        else {
+            await cloneTemplate(agentsTemplateRepo, targetPath, replacements);
+        }
+    }
+}
 export async function createCommand(dirName, options) {
     await createAgents({
         dirName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/create-agents",
-  "version": "0.29.10",
+  "version": "0.30.0",
   "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.10"
+    "@inkeep/agents-core": "0.30.0"
   },
   "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"
   }
 }