@inkeep/create-agents 0.51.0 → 0.53.0

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

@@ -62,13 +62,15 @@ describe('create-agents quickstart e2e', () => {
         ]);
         console.log('Directory structure verified');
         // Verify .env file has required variables
+        // After createEnvironmentFiles(), .env is a copy of .env.example with CLI-prompted
+        // values injected. Secrets (JWT keys, signing secret, etc.) remain as placeholders
+        // until setup-dev runs generateSecrets().
         console.log('Verifying .env file...');
         await verifyFile(path.join(projectDir, '.env'), [
             /ENVIRONMENT=development/,
             /INKEEP_AGENTS_MANAGE_DATABASE_URL=postgresql:\/\/appuser:password@localhost:5432\/inkeep_agents/,
             /INKEEP_AGENTS_RUN_DATABASE_URL=postgresql:\/\/appuser:password@localhost:5433\/inkeep_agents/,
-            /INKEEP_AGENTS_API_URL="http:\/\/127\.0\.0\.1:3002"/,
-            /INKEEP_AGENTS_JWT_SIGNING_SECRET=\w+/,
+            /INKEEP_AGENTS_API_URL=http:\/\/localhost:3002/,
         ]);
         console.log('.env file verified');
         // Verify inkeep.config.ts was created
@@ -167,7 +169,7 @@ describe('create-agents quickstart e2e', () => {
             try {
                 const signupRes = await fetch(`${manageApiUrl}/api/auth/sign-up/email`, {
                     method: 'POST',
-                    headers: { 'Content-Type': 'application/json', Origin: manageApiUrl },
+                    headers: { 'Content-Type': 'application/json', Origin: dashboardApiUrl },
                     body: JSON.stringify({
                         email: 'admin@example.com',
                         password: 'adminADMIN!@12',
@@ -211,7 +213,7 @@ describe('create-agents quickstart e2e', () => {
             try {
                 const loginTestRes = await fetch(`${manageApiUrl}/api/auth/sign-in/email`, {
                     method: 'POST',
-                    headers: { 'Content-Type': 'application/json', Origin: manageApiUrl },
+                    headers: { 'Content-Type': 'application/json', Origin: dashboardApiUrl },
                     body: JSON.stringify({
                         email: 'admin@example.com',
                         password: 'adminADMIN!@12',

package/dist/__tests__/e2e/utils.js

@@ -222,11 +222,15 @@ export async function waitForServerReady(url, timeout) {
 }
 export async function startDashboardServer(projectDir, env = {}) {
     const manageUiPkgJson = path.join(projectDir, 'node_modules/@inkeep/agents-manage-ui/package.json');
-    const manageUiRoot = path.dirname(manageUiPkgJson);
+    // Resolve symlinks so linked packages (link:) point to the actual monorepo directory
+    const manageUiRoot = await fs.realpath(path.dirname(manageUiPkgJson));
     const standaloneDir = path.join(manageUiRoot, '.next/standalone/agents-manage-ui');
     const serverEntry = path.join(standaloneDir, 'server.js');
     if (!(await fs.pathExists(serverEntry))) {
-        throw new Error(`Dashboard standalone server not found at ${serverEntry}`);
+        const originalPath = path.dirname(manageUiPkgJson);
+        throw new Error(`Dashboard standalone server not found at ${serverEntry}` +
+            (originalPath !== manageUiRoot ? ` (symlink resolved from ${originalPath})` : '') +
+            `. Ensure the package is built with 'output: standalone' (run turbo build).`);
     }
     const child = fork(serverEntry, [], {
         cwd: standaloneDir,

package/dist/__tests__/utils.test.js

@@ -2,7 +2,7 @@ import * as p from '@clack/prompts';
 import fs from 'fs-extra';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { cloneTemplate, cloneTemplateLocal, getAvailableTemplates } from '../templates';
-import { createAgents, defaultMockModelConfigurations } from '../utils';
+import { createAgents, defaultMockModelConfigurations, syncTemplateDependencies } from '../utils';
 // Create the mock execAsync function that will be used by promisify - hoisted so it's available in mocks
 const { mockExecAsync } = vi.hoisted(() => ({
     mockExecAsync: vi.fn().mockResolvedValue({ stdout: '', stderr: '' }),
@@ -23,12 +23,54 @@ vi.mock('node:child_process', () => ({
 vi.mock('node:util', () => ({
     promisify: vi.fn(() => mockExecAsync),
 }));
+vi.mock('node:fs', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        readFileSync: vi.fn(() => JSON.stringify({ version: '1.2.3' })),
+    };
+});
+vi.mock('node:url', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        fileURLToPath: vi.fn(() => '/fake/dist/utils.js'),
+    };
+});
 // Setup default mocks
 const mockSpinner = {
     start: vi.fn().mockReturnThis(),
     stop: vi.fn().mockReturnThis(),
     message: vi.fn().mockReturnThis(),
 };
+const mockEnvExample = [
+    'ENVIRONMENT=development',
+    'NODE_ENV=development',
+    'LOG_LEVEL=info',
+    'INKEEP_AGENTS_MANAGE_DATABASE_URL=postgresql://appuser:password@localhost:5432/inkeep_agents',
+    'INKEEP_AGENTS_RUN_DATABASE_URL=postgresql://appuser:password@localhost:5433/inkeep_agents',
+    'INKEEP_AGENTS_API_URL=http://localhost:3002',
+    'PUBLIC_INKEEP_AGENTS_API_URL=http://localhost:3002',
+    'TENANT_ID=default',
+    'ANTHROPIC_API_KEY=',
+    'OPENAI_API_KEY=',
+    'GOOGLE_GENERATIVE_AI_API_KEY=',
+    'AZURE_API_KEY=',
+    'DEFAULT_PROJECT_ID=',
+    'NANGO_SECRET_KEY=',
+    'NANGO_SERVER_URL=http://localhost:3050',
+    'SIGNOZ_URL=http://localhost:3080',
+    'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=',
+    'INKEEP_AGENTS_MANAGE_UI_USERNAME=admin@example.com',
+    'INKEEP_AGENTS_MANAGE_UI_PASSWORD=adminADMIN!@12',
+    'BETTER_AUTH_SECRET=your-secret-key-change-in-production',
+    'SPICEDB_ENDPOINT=localhost:50051',
+    'SPICEDB_PRESHARED_KEY=dev-secret-key',
+    'INKEEP_AGENTS_MANAGE_API_BYPASS_SECRET=test-bypass-secret-for-ci',
+    '# INKEEP_AGENTS_JWT_SIGNING_SECRET=',
+    '# INKEEP_AGENTS_TEMP_JWT_PRIVATE_KEY=',
+    '# INKEEP_AGENTS_TEMP_JWT_PUBLIC_KEY=',
+].join('\n');
 describe('createAgents - Template and Project ID Logic', () => {
     let processExitSpy;
     let processChdirSpy;
@@ -64,6 +106,8 @@ describe('createAgents - Template and Project ID Logic', () => {
         vi.mocked(fs.writeFile).mockResolvedValue(undefined);
         vi.mocked(fs.writeJson).mockResolvedValue(undefined);
         vi.mocked(fs.readJson).mockResolvedValue({});
+        vi.mocked(fs.readFile).mockResolvedValue(mockEnvExample);
+        vi.mocked(fs.readdir).mockResolvedValue([]);
         vi.mocked(fs.mkdir).mockResolvedValue(undefined);
         vi.mocked(fs.remove).mockResolvedValue(undefined);
         // Mock templates
@@ -331,6 +375,49 @@ describe('createAgents - Template and Project ID Logic', () => {
             ]));
         });
     });
+    describe('Environment file generation', () => {
+        it('should contain INKEEP_AGENTS_MANAGE_API_BYPASS_SECRET from .env.example', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                openAiKey: 'test-openai-key',
+                anthropicKey: 'test-anthropic-key',
+            });
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('INKEEP_AGENTS_MANAGE_API_BYPASS_SECRET=test-bypass-secret-for-ci'));
+        });
+        it('should inject CLI-prompted API keys into the .env', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                openAiKey: 'sk-openai-123',
+                anthropicKey: 'sk-ant-456',
+                googleKey: 'google-789',
+                azureKey: 'azure-abc',
+            });
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('ANTHROPIC_API_KEY=sk-ant-456'));
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('OPENAI_API_KEY=sk-openai-123'));
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('GOOGLE_GENERATIVE_AI_API_KEY=google-789'));
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('AZURE_API_KEY=azure-abc'));
+        });
+        it('should use localhost URLs (not 127.0.0.1)', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                openAiKey: 'test-key',
+                anthropicKey: 'test-key',
+            });
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('PUBLIC_INKEEP_AGENTS_API_URL=http://localhost:3002'));
+        });
+        it('should not generate any secrets inline', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                openAiKey: 'test-key',
+                anthropicKey: 'test-key',
+            });
+            const envWriteCall = vi.mocked(fs.writeFile).mock.calls.find((call) => call[0] === '.env');
+            const envContent = envWriteCall?.[1];
+            expect(envContent).toContain('BETTER_AUTH_SECRET=your-secret-key-change-in-production');
+            expect(envContent).toContain('INKEEP_AGENTS_MANAGE_UI_PASSWORD=adminADMIN!@12');
+            expect(envContent).toContain('# INKEEP_AGENTS_JWT_SIGNING_SECRET=');
+        });
+    });
     describe('Security - Password input for API keys', () => {
         it('should use password input instead of text input for API keys', async () => {
             // Mock the select to return 'anthropic' to trigger the API key prompt
@@ -388,9 +475,205 @@ function setupDefaultMocks() {
     vi.mocked(fs.writeFile).mockResolvedValue(undefined);
     vi.mocked(fs.writeJson).mockResolvedValue(undefined);
     vi.mocked(fs.readJson).mockResolvedValue({});
+    vi.mocked(fs.readFile).mockResolvedValue(mockEnvExample);
+    vi.mocked(fs.readdir).mockResolvedValue([]);
     vi.mocked(getAvailableTemplates).mockResolvedValue(['event-planner', 'chatbot', 'data-analysis']);
     vi.mocked(cloneTemplate).mockResolvedValue(undefined);
     vi.mocked(cloneTemplateLocal).mockResolvedValue(undefined);
-    // Reset mockExecAsync for tests that clear mocks
     mockExecAsync.mockResolvedValue({ stdout: '', stderr: '' });
 }
+describe('syncTemplateDependencies', () => {
+    function mockDirent(name, isDir) {
+        return { name, isDirectory: () => isDir, isFile: () => !isDir };
+    }
+    function setupFlatTemplate(rootPkg) {
+        vi.mocked(fs.pathExists).mockResolvedValue(true);
+        vi.mocked(fs.readdir).mockResolvedValue([]);
+        vi.mocked(fs.readJson).mockResolvedValue(rootPkg);
+        vi.mocked(fs.writeJson).mockResolvedValue(undefined);
+    }
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should update @inkeep/* dependencies to match CLI version', async () => {
+        const mockPkg = {
+            name: 'test-project',
+            dependencies: {
+                '@inkeep/agents-core': '^0.50.3',
+                '@inkeep/agents-sdk': '^0.50.3',
+                'some-other-package': '^1.0.0',
+            },
+        };
+        setupFlatTemplate(mockPkg);
+        await syncTemplateDependencies('/test/path');
+        expect(fs.writeJson).toHaveBeenCalledWith('/test/path/package.json', expect.objectContaining({
+            dependencies: {
+                '@inkeep/agents-core': '^1.2.3',
+                '@inkeep/agents-sdk': '^1.2.3',
+                'some-other-package': '^1.0.0',
+            },
+        }), { spaces: 2 });
+    });
+    it('should skip if template package.json does not exist', async () => {
+        vi.mocked(fs.pathExists).mockResolvedValue(false);
+        vi.mocked(fs.readdir).mockResolvedValue([]);
+        await syncTemplateDependencies('/test/path');
+        expect(fs.readJson).not.toHaveBeenCalled();
+        expect(fs.writeJson).not.toHaveBeenCalled();
+    });
+    it('should handle template with no @inkeep/* dependencies', async () => {
+        const mockPkg = {
+            name: 'test-project',
+            dependencies: {
+                'some-other-package': '^1.0.0',
+            },
+        };
+        setupFlatTemplate(mockPkg);
+        await syncTemplateDependencies('/test/path');
+        expect(fs.writeJson).toHaveBeenCalledWith('/test/path/package.json', expect.objectContaining({
+            dependencies: {
+                'some-other-package': '^1.0.0',
+            },
+        }), { spaces: 2 });
+    });
+    it('should handle template with no devDependencies', async () => {
+        const mockPkg = {
+            name: 'test-project',
+            dependencies: {
+                '@inkeep/agents-core': '^0.50.3',
+            },
+        };
+        setupFlatTemplate(mockPkg);
+        await syncTemplateDependencies('/test/path');
+        expect(fs.writeJson).toHaveBeenCalledWith('/test/path/package.json', expect.objectContaining({
+            dependencies: {
+                '@inkeep/agents-core': '^1.2.3',
+            },
+        }), { spaces: 2 });
+    });
+    it('should update devDependencies @inkeep/* packages', async () => {
+        const mockPkg = {
+            name: 'test-project',
+            dependencies: {},
+            devDependencies: {
+                '@inkeep/agents-sdk': '^0.49.0',
+                vitest: '^1.0.0',
+            },
+        };
+        setupFlatTemplate(mockPkg);
+        await syncTemplateDependencies('/test/path');
+        expect(fs.writeJson).toHaveBeenCalledWith('/test/path/package.json', expect.objectContaining({
+            devDependencies: {
+                '@inkeep/agents-sdk': '^1.2.3',
+                vitest: '^1.0.0',
+            },
+        }), { spaces: 2 });
+    });
+    it('should not modify non-@inkeep dependencies', async () => {
+        const mockPkg = {
+            name: 'test-project',
+            dependencies: {
+                '@inkeep/agents-core': '^0.50.3',
+                react: '^18.0.0',
+                next: '^14.0.0',
+            },
+        };
+        setupFlatTemplate(mockPkg);
+        await syncTemplateDependencies('/test/path');
+        expect(fs.writeJson).toHaveBeenCalledWith('/test/path/package.json', expect.objectContaining({
+            dependencies: {
+                '@inkeep/agents-core': '^1.2.3',
+                react: '^18.0.0',
+                next: '^14.0.0',
+            },
+        }), { spaces: 2 });
+    });
+    it('should not update excluded packages like @inkeep/agents-ui', async () => {
+        const mockPkg = {
+            name: 'test-project',
+            dependencies: {
+                '@inkeep/agents-core': '^0.50.3',
+                '@inkeep/agents-ui': '^0.50.3',
+                '@inkeep/agents-sdk': '^0.50.3',
+            },
+        };
+        setupFlatTemplate(mockPkg);
+        await syncTemplateDependencies('/test/path');
+        expect(fs.writeJson).toHaveBeenCalledWith('/test/path/package.json', expect.objectContaining({
+            dependencies: {
+                '@inkeep/agents-core': '^1.2.3',
+                '@inkeep/agents-ui': '^0.50.3',
+                '@inkeep/agents-sdk': '^1.2.3',
+            },
+        }), { spaces: 2 });
+    });
+    it('should skip sync when CLI version cannot be determined', async () => {
+        const nodeFs = await import('node:fs');
+        vi.mocked(nodeFs.readFileSync).mockImplementation(() => {
+            throw new Error('ENOENT');
+        });
+        vi.mocked(fs.pathExists).mockResolvedValue(true);
+        vi.mocked(fs.readdir).mockResolvedValue([]);
+        vi.mocked(fs.readJson).mockResolvedValue({
+            name: 'test-project',
+            dependencies: { '@inkeep/agents-core': '^0.50.3' },
+        });
+        await syncTemplateDependencies('/test/path');
+        expect(fs.writeJson).not.toHaveBeenCalled();
+    });
+    it('should sync nested package.json files in subdirectories', async () => {
+        const nodeFs = await import('node:fs');
+        vi.mocked(nodeFs.readFileSync).mockReturnValue(JSON.stringify({ version: '1.2.3' }));
+        const rootPkg = {
+            name: 'monorepo',
+            dependencies: { '@inkeep/agents-core': '^0.50.3' },
+        };
+        const nestedPkg = {
+            name: 'nested-app',
+            dependencies: { '@inkeep/agents-sdk': '^0.50.3', express: '^4.0.0' },
+        };
+        vi.mocked(fs.pathExists).mockResolvedValue(true);
+        vi.mocked(fs.readdir)
+            .mockResolvedValueOnce([mockDirent('apps', true), mockDirent('README.md', false)])
+            .mockResolvedValueOnce([mockDirent('api', true)])
+            .mockResolvedValueOnce([]);
+        vi.mocked(fs.readJson)
+            .mockResolvedValueOnce(rootPkg)
+            .mockResolvedValueOnce(nestedPkg)
+            .mockResolvedValueOnce(nestedPkg);
+        vi.mocked(fs.writeJson).mockResolvedValue(undefined);
+        await syncTemplateDependencies('/test/path');
+        expect(fs.writeJson).toHaveBeenCalledTimes(3);
+        expect(fs.writeJson).toHaveBeenCalledWith('/test/path/package.json', expect.objectContaining({
+            dependencies: { '@inkeep/agents-core': '^1.2.3' },
+        }), { spaces: 2 });
+        expect(fs.writeJson).toHaveBeenCalledWith(expect.stringContaining('apps/package.json'), expect.anything(), { spaces: 2 });
+        expect(fs.writeJson).toHaveBeenCalledWith(expect.stringContaining('apps/api/package.json'), expect.objectContaining({
+            dependencies: { '@inkeep/agents-sdk': '^1.2.3', express: '^4.0.0' },
+        }), { spaces: 2 });
+    });
+    it('should skip node_modules and dot directories', async () => {
+        const nodeFs = await import('node:fs');
+        vi.mocked(nodeFs.readFileSync).mockReturnValue(JSON.stringify({ version: '1.2.3' }));
+        const rootPkg = {
+            name: 'test-project',
+            dependencies: { '@inkeep/agents-core': '^0.50.3' },
+        };
+        vi.mocked(fs.pathExists).mockResolvedValue(true);
+        vi.mocked(fs.readdir)
+            .mockResolvedValueOnce([
+            mockDirent('node_modules', true),
+            mockDirent('.git', true),
+            mockDirent('src', true),
+        ])
+            .mockResolvedValueOnce([]);
+        vi.mocked(fs.readJson).mockResolvedValue(rootPkg);
+        vi.mocked(fs.writeJson).mockResolvedValue(undefined);
+        await syncTemplateDependencies('/test/path');
+        expect(fs.readdir).toHaveBeenCalledTimes(2);
+        expect(fs.readdir).toHaveBeenCalledWith('/test/path', { withFileTypes: true });
+        expect(fs.readdir).toHaveBeenCalledWith(expect.stringContaining('src'), {
+            withFileTypes: true,
+        });
+    });
+});

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
+export declare function syncTemplateDependencies(templatePath: string): Promise<void>;
 export declare const defaultGoogleModelConfigurations: {
     base: {
         model: "google/gemini-2.5-flash";

package/dist/utils.js

@@ -1,7 +1,8 @@
 import { exec } from 'node:child_process';
-import crypto from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import * as p from '@clack/prompts';
 import { ANTHROPIC_MODELS, GOOGLE_MODELS, OPENAI_MODELS } from '@inkeep/agents-core';
@@ -33,6 +34,52 @@ const agentsTemplateRepo = 'https://github.com/inkeep/agents/create-agents-templ
 const projectTemplateRepo = 'https://github.com/inkeep/agents/agents-cookbook/template-projects';
 const execAsync = promisify(exec);
 const agentsApiPort = '3002';
+function getCliVersion() {
+    try {
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const pkgJson = JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
+        return pkgJson.version;
+    }
+    catch {
+        return '';
+    }
+}
+export async function syncTemplateDependencies(templatePath) {
+    const cliVersion = getCliVersion();
+    if (!cliVersion)
+        return;
+    const packageJsonPaths = await findPackageJsonFiles(templatePath);
+    await Promise.all(packageJsonPaths.map(async (pkgPath) => {
+        const pkg = await fs.readJson(pkgPath);
+        for (const depType of ['dependencies', 'devDependencies']) {
+            const deps = pkg[depType];
+            if (!deps)
+                continue;
+            for (const name of Object.keys(deps)) {
+                if (name.startsWith('@inkeep/') && name !== '@inkeep/agents-ui') {
+                    deps[name] = `^${cliVersion}`;
+                }
+            }
+        }
+        await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+    }));
+}
+async function findPackageJsonFiles(dir) {
+    const results = [];
+    const rootPkg = path.join(dir, 'package.json');
+    if (await fs.pathExists(rootPkg)) {
+        results.push(rootPkg);
+    }
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === 'node_modules' || entry.name.startsWith('.')) {
+            continue;
+        }
+        const nested = await findPackageJsonFiles(path.join(dir, entry.name));
+        results.push(...nested);
+    }
+    return results;
+}
 export const defaultGoogleModelConfigurations = {
     base: {
         model: GOOGLE_MODELS.GEMINI_2_5_FLASH,
@@ -314,6 +361,7 @@ export const createAgents = async (args = {}) => {
             localPrefix: localAgentsPrefix,
         });
         process.chdir(directoryPath);
+        await syncTemplateDependencies('.');
         const config = {
             dirName,
             tenantId,
@@ -397,8 +445,8 @@ export const createAgents = async (args = {}) => {
             `   pnpm setup-dev\n` +
             `   pnpm dev\n\n` +
             `${color.yellow('2. Explore:')}\n` +
-            `   • Dashboard:  http://127.0.0.1:3000\n` +
-            `   • Agents API: http://127.0.0.1:3002\n\n` +
+            `   • Dashboard:  http://localhost:3000\n` +
+            `   • Agents API: http://localhost:3002\n\n` +
             `${color.yellow('3. Customize:')}\n` +
             `   • Edit your agents in src/projects/\n` +
             `   • Use 'inkeep push' to apply`, 'Next steps 🚀');
@@ -413,80 +461,29 @@ async function createWorkspaceStructure() {
     await fs.ensureDir(`src`);
 }
 async function createEnvironmentFiles(config) {
-    // Convert to forward slashes for cross-platform SQLite URI compatibility
-    const jwtSigningSecret = crypto.randomBytes(32).toString('hex');
-    const betterAuthSecret = crypto.randomBytes(32).toString('hex');
-    const manageUiPassword = crypto.randomBytes(6).toString('base64url');
-    // Generate RSA key pair for temporary JWT tokens
-    let tempJwtPrivateKey = '';
-    let tempJwtPublicKey = '';
+    let envExampleContent;
     try {
-        const { generateKeyPairSync } = await import('node:crypto');
-        const { privateKey, publicKey } = generateKeyPairSync('rsa', {
-            modulusLength: 2048,
-            publicKeyEncoding: { type: 'spki', format: 'pem' },
-            privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
-        });
-        tempJwtPrivateKey = Buffer.from(privateKey).toString('base64');
-        tempJwtPublicKey = Buffer.from(publicKey).toString('base64');
+        envExampleContent = await fs.readFile('.env.example', 'utf-8');
     }
     catch {
-        console.warn('Warning: Failed to generate JWT keys. Playground may not work.');
-        console.warn('You can manually generate keys later with: pnpm run generate-jwt-keys');
+        throw new Error('Could not read .env.example from the template. The template may be corrupted — try running the command again.');
     }
-    const envContent = `# Environment
-ENVIRONMENT=development
-
-# Database Configuration (Split Database Setup)
-# Management entities database uses DoltgreSQL on port 5432 for version control features
-INKEEP_AGENTS_MANAGE_DATABASE_URL=postgresql://appuser:password@localhost:5432/inkeep_agents
-# Runtime entities database uses PostgreSQL on port 5433 for runtime operations
-INKEEP_AGENTS_RUN_DATABASE_URL=postgresql://appuser:password@localhost:5433/inkeep_agents
-
-# AI Provider Keys  
-ANTHROPIC_API_KEY=${config.anthropicKey || 'your-anthropic-key-here'}
-OPENAI_API_KEY=${config.openAiKey || 'your-openai-key-here'}
-GOOGLE_GENERATIVE_AI_API_KEY=${config.googleKey || 'your-google-key-here'}
-AZURE_API_KEY=${config.azureKey || 'your-azure-key-here'}
-
-# Inkeep API URLs
-# Internal URLs (server-side, Docker internal networking)
-# Using 127.0.0.1 instead of localhost to avoid IPv6/IPv4 resolution issues
-INKEEP_AGENTS_API_URL="http://127.0.0.1:3002"
-
-# Public URLs (client-side, browser accessible)
-PUBLIC_INKEEP_AGENTS_API_URL="http://127.0.0.1:3002"
-
-# SigNoz Configuration
-SIGNOZ_URL=your-signoz-url-here
-SIGNOZ_API_KEY=your-signoz-api-key-here
-
-# OTEL Configuration
-OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://ingest.us.signoz.cloud:443/v1/traces
-OTEL_EXPORTER_OTLP_TRACES_HEADERS="signoz-ingestion-key=<your-ingestion-key>"
-
-# Nango Configuration
-NANGO_SECRET_KEY=
-
-# JWT Signing Secret
-INKEEP_AGENTS_JWT_SIGNING_SECRET=${jwtSigningSecret}
-
-# Temporary JWT Keys for Playground
-INKEEP_AGENTS_TEMP_JWT_PRIVATE_KEY=${tempJwtPrivateKey}
-INKEEP_AGENTS_TEMP_JWT_PUBLIC_KEY=${tempJwtPublicKey}
-
-# initial project information
-DEFAULT_PROJECT_ID=${config.projectId}
-
-# Auth Configuration
-INKEEP_AGENTS_MANAGE_UI_USERNAME=admin@example.com
-INKEEP_AGENTS_MANAGE_UI_PASSWORD=${manageUiPassword}
-BETTER_AUTH_SECRET=${betterAuthSecret}
-SPICEDB_ENDPOINT=localhost:50051
-SPICEDB_PRESHARED_KEY=dev-secret-key
-
-`;
-    await fs.writeFile('.env', envContent);
+    const lines = envExampleContent.split('\n');
+    const injections = {
+        ANTHROPIC_API_KEY: config.anthropicKey || '',
+        OPENAI_API_KEY: config.openAiKey || '',
+        GOOGLE_GENERATIVE_AI_API_KEY: config.googleKey || '',
+        AZURE_API_KEY: config.azureKey || '',
+        DEFAULT_PROJECT_ID: config.projectId,
+    };
+    for (let i = 0; i < lines.length; i++) {
+        for (const [varName, value] of Object.entries(injections)) {
+            if (lines[i].startsWith(`${varName}=`)) {
+                lines[i] = `${varName}=${value}`;
+            }
+        }
+    }
+    await fs.writeFile('.env', lines.join('\n'));
 }
 async function createInkeepConfig(config) {
     const inkeepConfig = `import { defineConfig } from '@inkeep/agents-cli/config';
@@ -494,8 +491,7 @@ async function createInkeepConfig(config) {
 const config = defineConfig({
   tenantId: "${config.tenantId}",
   agentsApi: {
-    // Using 127.0.0.1 instead of localhost to avoid IPv6/IPv4 resolution issues
-    url: 'http://127.0.0.1:3002',
+    url: 'http://localhost:3002',
   },
 });
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/create-agents",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "description": "Create an Inkeep Agent Framework project",
   "type": "module",
   "bin": {
@@ -33,7 +33,7 @@
     "degit": "^2.8.4",
     "fs-extra": "^11.0.0",
     "picocolors": "^1.0.0",
-    "@inkeep/agents-core": "0.51.0"
+    "@inkeep/agents-core": "0.53.0"
   },
   "devDependencies": {
     "@types/degit": "^2.8.6",
@@ -67,8 +67,8 @@
     "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:e2e": "turbo run build --filter=@inkeep/create-agents --filter=@inkeep/agents-api --filter=@inkeep/agents-cli --filter=@inkeep/agents-manage-ui && vitest --run src/__tests__/e2e",
+    "test:e2e:watch": "turbo run build --filter=@inkeep/create-agents --filter=@inkeep/agents-api --filter=@inkeep/agents-cli --filter=@inkeep/agents-manage-ui && vitest src/__tests__/e2e",
     "test:all": "vitest --run --passWithNoTests",
     "typecheck": "tsc --noEmit"
   }