@inkeep/create-agents 0.50.0 → 0.50.3

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

@@ -1,9 +1,13 @@
 import path from 'node:path';
 import { execa } from 'execa';
+import { chromium } from 'playwright';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { cleanupDir, createTempDir, linkLocalPackages, runCommand, runCreateAgentsCLI, verifyDirectoryStructure, verifyFile, waitForServerReady, } from './utils';
+import { cleanupDir, createTempDir, linkLocalPackages, runCommand, runCreateAgentsCLI, startDashboardServer, verifyDirectoryStructure, verifyFile, waitForServerReady, } from './utils';
 // Use 127.0.0.1 instead of localhost to avoid IPv6/IPv4 resolution issues on CI (Ubuntu)
 const manageApiUrl = 'http://127.0.0.1:3002';
+// Dashboard must use localhost (not 127.0.0.1) so auth cookies share the same domain
+// between the dashboard (localhost:3000) and the API (localhost:3002).
+const dashboardApiUrl = 'http://localhost:3002';
 // Use a test bypass secret for authentication in CI
 // This bypasses the need for a real login/API key
 const TEST_BYPASS_SECRET = 'e2e-test-bypass-secret-for-ci-testing-only';
@@ -29,16 +33,15 @@ describe('create-agents quickstart e2e', () => {
         console.log(`Working directory: ${testDir}`);
         const result = await runCreateAgentsCLI([
             workspaceName,
-            '--openai-key',
-            'test-openai-key',
-            '--disable-git', // Skip git init for faster tests
+            '--skip-provider',
+            '--disable-git',
             '--local-agents-prefix',
             createAgentsPrefix,
             '--local-templates-prefix',
             projectTemplatesPrefix,
             '--skip-inkeep-cli',
             '--skip-inkeep-mcp',
-            '--skip-install', // Skip initial install so we can link local packages first
+            '--skip-install',
         ], testDir);
         // Verify the CLI completed successfully
         expect(result.exitCode, `CLI failed with exit code ${result.exitCode}\nstdout: ${result.stdout}\nstderr: ${result.stderr}`).toBe(0);
@@ -62,11 +65,10 @@ describe('create-agents quickstart e2e', () => {
         console.log('Verifying .env file...');
         await verifyFile(path.join(projectDir, '.env'), [
             /ENVIRONMENT=development/,
-            /OPENAI_API_KEY=test-openai-key/,
             /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+/, // Random secret should be generated
+            /INKEEP_AGENTS_JWT_SIGNING_SECRET=\w+/,
         ]);
         console.log('.env file verified');
         // Verify inkeep.config.ts was created
@@ -92,6 +94,31 @@ describe('create-agents quickstart e2e', () => {
             },
             stream: true,
         });
+        // Run auth init separately to create the "default" organization and admin user.
+        // setup-dev:cloud may exit early if its internal migrations fail (e.g. when CI
+        // already applied migrations from the monorepo root), skipping auth init entirely.
+        console.log('Running auth init to ensure default organization exists');
+        const authInitResult = await runCommand({
+            command: 'node',
+            args: ['node_modules/@inkeep/agents-core/dist/auth/init.js'],
+            cwd: projectDir,
+            timeout: 120000, // 2 min: SpiceDB schema write retries up to 30x at 1s each
+            env: {
+                INKEEP_AGENTS_MANAGE_UI_USERNAME: 'admin@example.com',
+                INKEEP_AGENTS_MANAGE_UI_PASSWORD: 'adminADMIN!@12',
+                BETTER_AUTH_SECRET: 'test-secret-key-for-ci',
+                SPICEDB_PRESHARED_KEY: 'dev-secret-key',
+                // Explicit DB URLs in case process.env doesn't carry them
+                INKEEP_AGENTS_RUN_DATABASE_URL: process.env.INKEEP_AGENTS_RUN_DATABASE_URL ||
+                    'postgresql://appuser:password@localhost:5433/inkeep_agents',
+                INKEEP_AGENTS_MANAGE_DATABASE_URL: process.env.INKEEP_AGENTS_MANAGE_DATABASE_URL ||
+                    'postgresql://appuser:password@localhost:5432/inkeep_agents',
+            },
+            stream: true,
+        });
+        if (authInitResult.exitCode !== 0) {
+            console.warn(`Auth init exited with code ${authInitResult.exitCode}\nstdout: ${authInitResult.stdout}\nstderr: ${authInitResult.stderr}`);
+        }
         console.log('Project setup in database');
         console.log('Starting dev servers');
         // Start dev servers in background with output monitoring
@@ -132,6 +159,27 @@ describe('create-agents quickstart e2e', () => {
             // 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');
+            // Ensure admin user exists for dashboard login.
+            // Auth init may fail in CI (SpiceDB schema write, module resolution), so
+            // create the user directly via the API's Better Auth signup endpoint as a
+            // reliable fallback. Signup is idempotent — returns 200 if user exists.
+            console.log('Ensuring admin user exists via API signup');
+            try {
+                const signupRes = await fetch(`${manageApiUrl}/api/auth/sign-up/email`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', Origin: manageApiUrl },
+                    body: JSON.stringify({
+                        email: 'admin@example.com',
+                        password: 'adminADMIN!@12',
+                        name: 'admin',
+                    }),
+                });
+                const signupData = await signupRes.json().catch(() => null);
+                console.log(`Signup response: ${signupRes.status}`, signupData ? JSON.stringify(signupData).slice(0, 200) : '');
+            }
+            catch (signupError) {
+                console.warn('Signup request failed (non-fatal):', signupError);
+            }
             console.log('Pushing project');
             const pushResult = await runCommand({
                 command: 'pnpm',
@@ -158,6 +206,110 @@ describe('create-agents quickstart e2e', () => {
             const data = await response.json();
             expect(data.data.tenantId).toBe('default');
             expect(data.data.id).toBe(projectId);
+            // Verify login works at the API level before starting dashboard
+            console.log('Testing login API directly');
+            try {
+                const loginTestRes = await fetch(`${manageApiUrl}/api/auth/sign-in/email`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', Origin: manageApiUrl },
+                    body: JSON.stringify({
+                        email: 'admin@example.com',
+                        password: 'adminADMIN!@12',
+                    }),
+                });
+                const loginBody = await loginTestRes.text().catch(() => '');
+                console.log(`Login API test: ${loginTestRes.status} ${loginBody.slice(0, 300)}`);
+                if (!loginTestRes.ok) {
+                    console.error('Login API test failed — dashboard login will likely fail');
+                }
+            }
+            catch (loginTestError) {
+                console.warn('Login API test failed (non-fatal):', loginTestError);
+            }
+            // --- Dashboard Lap ---
+            console.log('Starting dashboard lap');
+            const dashboardProcess = await startDashboardServer(projectDir, {
+                INKEEP_AGENTS_API_URL: dashboardApiUrl,
+                NEXT_PUBLIC_API_URL: dashboardApiUrl,
+                PUBLIC_INKEEP_AGENTS_API_URL: dashboardApiUrl,
+                BETTER_AUTH_SECRET: 'test-secret-key-for-ci',
+                INKEEP_AGENTS_MANAGE_API_BYPASS_SECRET: TEST_BYPASS_SECRET,
+            });
+            console.log('Dashboard server started');
+            const browser = await chromium.launch({ headless: true });
+            try {
+                const page = await browser.newPage();
+                console.log('Navigating to login page');
+                await page.goto('http://localhost:3000/login', {
+                    waitUntil: 'networkidle',
+                    timeout: 15000,
+                });
+                console.log('Filling login form');
+                await page.fill('input[type="email"]', 'admin@example.com');
+                await page.fill('input[type="password"]', 'adminADMIN!@12');
+                await page.click('button[type="submit"]');
+                console.log('Waiting for redirect to projects page');
+                await page.waitForURL('**/default/projects**', {
+                    timeout: 15000,
+                    waitUntil: 'domcontentloaded',
+                });
+                console.log('Redirected to projects page');
+                console.log('Clicking activities-planner project');
+                // Use force:true because card uses a linkoverlay pattern that intercepts pointer events
+                await page.click(`a[href*="${projectId}"]`, { timeout: 15000, force: true });
+                await page.waitForURL(`**/default/projects/${projectId}/**`, {
+                    timeout: 15000,
+                    waitUntil: 'domcontentloaded',
+                });
+                console.log('Navigated to project page');
+                console.log('Clicking agent card');
+                // Use href locator to avoid matching project heading text
+                const agentId = 'activities-planner';
+                await page.click(`a[href*="/agents/${agentId}"]`, { timeout: 15000, force: true });
+                await page.waitForURL(`**/agents/${agentId}**`, {
+                    timeout: 15000,
+                    waitUntil: 'domcontentloaded',
+                });
+                console.log('Navigated to agent page');
+                console.log('Clicking Try it button');
+                await page.click('button:has-text("Try it")', { timeout: 15000, force: true });
+                console.log('Waiting for playground to open');
+                await page.waitForSelector('#playground-pane', { timeout: 15000 });
+                console.log('Playground panel is visible');
+                console.log('Verifying chat widget initialized');
+                await page.locator('#inkeep-widget-root').waitFor({ timeout: 15000 });
+                console.log('Chat widget is initialized');
+                console.log('Dashboard lap complete');
+            }
+            catch (dashboardError) {
+                console.error('Dashboard lap failed:', dashboardError);
+                try {
+                    const activePage = browser.contexts()[0]?.pages()[0];
+                    if (activePage) {
+                        const screenshotPath = path.join(testDir, 'dashboard-failure.png');
+                        await activePage.screenshot({ path: screenshotPath, fullPage: true });
+                        console.log(`Screenshot saved to: ${screenshotPath}`);
+                        console.log(`Current URL: ${activePage.url()}`);
+                        console.log(`Page content: ${await activePage.content()}`);
+                    }
+                }
+                catch (screenshotError) {
+                    console.error('Failed to capture screenshot:', screenshotError);
+                }
+                throw dashboardError;
+            }
+            finally {
+                await browser.close();
+                try {
+                    dashboardProcess.kill('SIGTERM');
+                }
+                catch { }
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+                try {
+                    dashboardProcess.kill('SIGKILL');
+                }
+                catch { }
+            }
         }
         catch (error) {
             console.error('Test failed with error:', error);

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

@@ -1,3 +1,4 @@
+import { type ChildProcess } from 'node:child_process';
 /**
  * Run the create-agents CLI with the given arguments
  */
@@ -46,3 +47,4 @@ export declare function linkLocalPackages(projectDir: string, monorepoRoot: stri
  * Wait for a server to be ready by polling a health endpoint
  */
 export declare function waitForServerReady(url: string, timeout: number): Promise<void>;
+export declare function startDashboardServer(projectDir: string, env?: Record<string, string>): Promise<ChildProcess>;

package/dist/__tests__/e2e/utils.js

@@ -1,3 +1,4 @@
+import { fork } from 'node:child_process';
 import os from 'node:os';
 import path, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -155,6 +156,7 @@ export async function linkLocalPackages(projectDir, monorepoRoot) {
         '@inkeep/agents-core': `link:${path.join(monorepoRoot, 'packages/agents-core')}`,
         '@inkeep/agents-api': `link:${path.join(monorepoRoot, 'agents-api')}`,
         '@inkeep/agents-cli': `link:${path.join(monorepoRoot, 'agents-cli')}`,
+        '@inkeep/agents-manage-ui': `link:${path.join(monorepoRoot, 'agents-manage-ui')}`,
     };
     // Replace package versions with local links
     for (const [pkg, linkPath] of Object.entries(inkeepPackages)) {
@@ -218,3 +220,37 @@ export async function waitForServerReady(url, timeout) {
     const errorDetails = lastError ? `: ${lastError.message}` : '';
     throw new Error(`Server not ready at ${url} after ${elapsed}ms (${attempts} attempts)${errorDetails}`);
 }
+export async function startDashboardServer(projectDir, env = {}) {
+    const manageUiPkgJson = path.join(projectDir, 'node_modules/@inkeep/agents-manage-ui/package.json');
+    const manageUiRoot = 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 child = fork(serverEntry, [], {
+        cwd: standaloneDir,
+        env: {
+            ...process.env,
+            NODE_ENV: 'production',
+            PORT: '3000',
+            HOSTNAME: '0.0.0.0',
+            ...env,
+        },
+        stdio: 'pipe',
+    });
+    const outputHandler = (data) => {
+        const text = data.toString();
+        if (process.env.CI) {
+            if (text.includes('Error') || text.includes('EADDRINUSE') || text.includes('ready')) {
+                console.log('[Dashboard]:', text.trim());
+            }
+        }
+    };
+    if (child.stdout)
+        child.stdout.on('data', outputHandler);
+    if (child.stderr)
+        child.stderr.on('data', outputHandler);
+    await waitForServerReady('http://localhost:3000', 30000);
+    return child;
+}

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 } from '../utils';
+import { createAgents, defaultMockModelConfigurations } 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: '' }),
@@ -278,6 +278,59 @@ describe('createAgents - Template and Project ID Logic', () => {
             expect(fs.ensureDir).toHaveBeenCalledWith('src/projects/custom');
         });
     });
+    describe('Skip provider option', () => {
+        it('should use mock model configuration when skipProvider is true', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                skipProvider: true,
+            });
+            expect(cloneTemplate).toHaveBeenCalledWith(expect.stringContaining('activities-planner'), 'src/projects/activities-planner', expect.arrayContaining([
+                expect.objectContaining({
+                    filePath: 'index.ts',
+                    replacements: expect.objectContaining({
+                        models: defaultMockModelConfigurations,
+                    }),
+                }),
+            ]));
+            const selectCalls = vi.mocked(p.select).mock.calls;
+            const providerSelectCalls = selectCalls.filter((call) => call[0] &&
+                typeof call[0] === 'object' &&
+                'message' in call[0] &&
+                call[0].message.includes('AI provider'));
+            expect(providerSelectCalls).toHaveLength(0);
+            expect(p.password).not.toHaveBeenCalled();
+        });
+        it('should use mock model configuration when skip is selected interactively', async () => {
+            vi.mocked(p.select).mockResolvedValueOnce('skip');
+            await createAgents({
+                dirName: 'test-dir',
+            });
+            expect(cloneTemplate).toHaveBeenCalledWith(expect.stringContaining('activities-planner'), 'src/projects/activities-planner', expect.arrayContaining([
+                expect.objectContaining({
+                    filePath: 'index.ts',
+                    replacements: expect.objectContaining({
+                        models: defaultMockModelConfigurations,
+                    }),
+                }),
+            ]));
+            expect(p.password).not.toHaveBeenCalled();
+        });
+        it('should take precedence over API key flags when skipProvider is true', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                skipProvider: true,
+                openAiKey: 'test-key',
+            });
+            expect(cloneTemplate).toHaveBeenCalledWith(expect.stringContaining('activities-planner'), 'src/projects/activities-planner', expect.arrayContaining([
+                expect.objectContaining({
+                    filePath: 'index.ts',
+                    replacements: expect.objectContaining({
+                        models: defaultMockModelConfigurations,
+                    }),
+                }),
+            ]));
+        });
+    });
     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

package/dist/index.js

@@ -16,6 +16,7 @@ program
     .option('--skip-inkeep-cli', 'Skip installing Inkeep CLI globally')
     .option('--skip-inkeep-mcp', 'Skip installing Inkeep MCP server')
     .option('--skip-install', 'Skip installing dependencies')
+    .option('--skip-provider', 'Skip AI provider setup (uses mock provider)')
     .parse();
 async function main() {
     const options = program.opts();
@@ -33,6 +34,7 @@ async function main() {
             skipInkeepCli: options.skipInkeepCli,
             skipInkeepMcp: options.skipInkeepMcp,
             skipInstall: options.skipInstall,
+            skipProvider: options.skipProvider,
         });
     }
     catch (error) {

package/dist/utils.d.ts

@@ -31,6 +31,11 @@ export declare const defaultAnthropicModelConfigurations: {
         model: "anthropic/claude-sonnet-4-5";
     };
 };
+export declare const defaultMockModelConfigurations: {
+    base: {
+        model: string;
+    };
+};
 export declare const createAgents: (args?: {
     dirName?: string;
     templateName?: string;
@@ -46,6 +51,7 @@ export declare const createAgents: (args?: {
     skipInkeepCli?: boolean;
     skipInkeepMcp?: boolean;
     skipInstall?: boolean;
+    skipProvider?: boolean;
 }) => Promise<void>;
 export declare function createCommand(dirName?: string, options?: any): Promise<void>;
 export declare function addInkeepMcp(): Promise<void>;

package/dist/utils.js

@@ -66,8 +66,11 @@ export const defaultAnthropicModelConfigurations = {
         model: ANTHROPIC_MODELS.CLAUDE_SONNET_4_5,
     },
 };
+export const defaultMockModelConfigurations = {
+    base: { model: 'mock/default' },
+};
 export const createAgents = async (args = {}) => {
-    let { dirName, openAiKey, anthropicKey, googleKey, azureKey, template, customProjectId, disableGit, localAgentsPrefix, localTemplatesPrefix, skipInkeepCli, skipInkeepMcp, skipInstall, } = args;
+    let { dirName, openAiKey, anthropicKey, googleKey, azureKey, template, customProjectId, disableGit, localAgentsPrefix, localTemplatesPrefix, skipInkeepCli, skipInkeepMcp, skipInstall, skipProvider, } = args;
     const tenantId = 'default';
     let projectId;
     let templateName;
@@ -111,7 +114,7 @@ export const createAgents = async (args = {}) => {
             throw new Error(validationError);
         }
     }
-    if (!anthropicKey && !openAiKey && !googleKey && !azureKey) {
+    if (!skipProvider && !anthropicKey && !openAiKey && !googleKey && !azureKey) {
         const providerChoice = await p.select({
             message: 'Which AI provider would you like to use?',
             options: [
@@ -119,6 +122,7 @@ export const createAgents = async (args = {}) => {
                 { value: 'openai', label: 'OpenAI' },
                 { value: 'google', label: 'Google' },
                 { value: 'azure', label: 'Azure' },
+                { value: 'skip', label: 'Skip', hint: 'scaffolds with mock provider, no API key needed' },
             ],
         });
         if (p.isCancel(providerChoice)) {
@@ -189,9 +193,18 @@ export const createAgents = async (args = {}) => {
             }
             azureKey = azureKeyResponse;
         }
+        else if (providerChoice === 'skip') {
+            skipProvider = true;
+        }
     }
     let defaultModelSettings = {};
-    if (anthropicKey) {
+    if (skipProvider) {
+        defaultModelSettings = defaultMockModelConfigurations;
+        if (openAiKey || anthropicKey || googleKey || azureKey) {
+            p.log.warn('--skip-provider is active. Provider key flags are ignored; mock/default model will be used.');
+        }
+    }
+    else if (anthropicKey) {
         defaultModelSettings = defaultAnthropicModelConfigurations;
     }
     else if (openAiKey) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/create-agents",
-  "version": "0.50.0",
+  "version": "0.50.3",
   "description": "Create an Inkeep Agent Framework project",
   "type": "module",
   "bin": {
@@ -33,13 +33,14 @@
     "degit": "^2.8.4",
     "fs-extra": "^11.0.0",
     "picocolors": "^1.0.0",
-    "@inkeep/agents-core": "0.50.0"
+    "@inkeep/agents-core": "0.50.3"
   },
   "devDependencies": {
     "@types/degit": "^2.8.6",
     "@types/fs-extra": "^11.0.0",
     "@types/node": "^20.12.0",
     "execa": "^9.6.0",
+    "playwright": "^1.58.2",
     "tsx": "^4.7.0",
     "typescript": "^5.4.0",
     "vitest": "^3.2.4"