@cortexmemory/cli 0.26.0 → 0.27.1

package/dist/commands/init.js

@@ -12,7 +12,8 @@ import ora from "ora";
 import { spawn } from "child_process";
 import { loadConfig, saveUserConfig } from "../utils/config.js";
 import { isValidProjectName, isDirectoryEmpty, fetchLatestSDKMetadata, execCommand, commandExists, } from "../utils/shell.js";
-import { setupNewConvex, setupExistingConvex, deployToConvex, } from "../utils/init/convex-setup.js";
+import { setupNewConvex, setupExistingConvex, deployToConvex, ensureConvexAuth, sanitizeProjectName, } from "../utils/init/convex-setup.js";
+import { installVercelAIQuickstart, startApp, stopApp, findAppPidFiles, isAppRunning, findProcessByPort, stopProcessByPort, } from "../utils/init/quickstart-setup.js";
 import { getGraphConfig, setupGraphFiles, addGraphDependencies, createGraphExample, startGraphContainers, stopGraphContainers, } from "../utils/init/graph-setup.js";
 import { copyTemplate, deployCortexBackend, createConvexJson, ensureGitignore, } from "../utils/init/file-operations.js";
 import { createEnvFile, appendGraphEnvVars, } from "../utils/init/env-generator.js";
@@ -101,12 +102,24 @@ export function registerLifecycleCommands(program, _config) {
             console.log(pc.dim("   Use 'cortex start -d <name> -f' for foreground mode"));
             process.exit(1);
         }
-        console.log(pc.cyan(`\n   Starting ${deploymentsToStart.length} deployment(s)...\n`));
+        // Collect enabled apps for summary
+        const apps = Object.entries(config.apps || {});
+        const enabledApps = apps.filter(([, app]) => app.enabled);
+        // Show summary header
+        console.log();
+        console.log(pc.bold("  ═══════════════════════════════════════════════════════════"));
+        console.log(pc.bold("  Cortex Start"));
+        console.log(pc.bold("  ═══════════════════════════════════════════════════════════"));
+        console.log();
+        // Deployments section
+        console.log(pc.bold(pc.cyan(`  Deployments (${deploymentsToStart.length})`)));
+        console.log(pc.dim("  ───────────────────────────────────────────────────────────"));
         // Start each deployment
         for (const dep of deploymentsToStart) {
-            console.log(pc.bold(`   ${dep.name}`));
-            console.log(pc.dim(`   Project: ${dep.projectPath}`));
-            console.log(pc.dim(`   URL: ${dep.url}\n`));
+            console.log(`  ${pc.green("●")} ${pc.cyan(dep.name)}`);
+            console.log(pc.dim(`    Project: ${dep.projectPath}`));
+            console.log(pc.dim(`    URL: ${dep.url}`));
+            console.log();
             // Start graph database if configured and not convex-only
             if (!options.convexOnly) {
                 const dockerComposePath = path.join(dep.projectPath, "docker-compose.graph.yml");
@@ -185,28 +198,86 @@ export function registerLifecycleCommands(program, _config) {
                 }
             }
         }
+        // Start enabled apps (unless convex-only or graph-only)
+        if (!options.convexOnly && !options.graphOnly && !options.foreground) {
+            if (enabledApps.length > 0) {
+                console.log(pc.bold(pc.cyan(`  Apps (${enabledApps.length})`)));
+                console.log(pc.dim("  ───────────────────────────────────────────────────────────"));
+                for (const [name, app] of enabledApps) {
+                    console.log(`  ${pc.green("●")} ${pc.cyan(name)}`);
+                    console.log(pc.dim(`    Type: ${app.type}`));
+                    console.log(pc.dim(`    Path: ${path.join(app.projectPath, app.path)}`));
+                    console.log(pc.dim(`    Port: ${app.port || 3000}`));
+                    console.log();
+                    await startApp(name, app);
+                }
+            }
+        }
         // Show summary
         if (!options.foreground) {
-            console.log(pc.green("\n   ✓ All deployments started\n"));
-            console.log(pc.dim("   Use 'cortex stop' to stop all services"));
-            console.log(pc.dim("   Use 'cortex config list' to see deployment status"));
+            const totalStarted = deploymentsToStart.length + (enabledApps.length || 0);
+            console.log(pc.bold("  ═══════════════════════════════════════════════════════════"));
+            console.log(pc.green(`  ✓ Started ${totalStarted} service(s)`));
+            console.log(pc.bold("  ═══════════════════════════════════════════════════════════"));
+            console.log();
+            console.log(pc.dim("  Use 'cortex stop' to stop all services"));
+            console.log(pc.dim("  Use 'cortex config list' to see deployment status"));
+            console.log();
         }
     });
     // Stop command
     program
         .command("stop")
-        .description("Stop background services (Convex and graph database)")
+        .description("Stop background services (Convex, graph database, and apps)")
         .option("-d, --deployment <name>", "Stop specific deployment only")
+        .option("-a, --app <name>", "Stop specific app only")
         .option("--convex-only", "Only stop Convex server", false)
         .option("--graph-only", "Only stop graph database", false)
+        .option("--apps-only", "Only stop template apps", false)
         .action(async (options) => {
+        // Load fresh config to get current state
+        const config = await loadConfig();
         let stoppedSomething = false;
         let stoppedCount = 0;
-        // Determine which deployments to stop
+        let stoppedAppsCount = 0;
+        // If stopping specific app only
+        if (options.app) {
+            const appConfig = config.apps?.[options.app];
+            if (!appConfig) {
+                // Try to find app in current directory
+                const cwd = process.cwd();
+                const appPidFiles = await findAppPidFiles(cwd);
+                const matchingApp = appPidFiles.find((a) => a.name === options.app);
+                if (!matchingApp) {
+                    console.error(pc.red(`\n   Error: App "${options.app}" not found`));
+                    console.log(pc.dim("   Run 'cortex config list' to see available apps\n"));
+                    process.exit(1);
+                }
+                // Stop from current directory
+                const stopped = await stopApp(options.app, cwd);
+                if (stopped) {
+                    console.log(pc.green(`\n   ✓ App "${options.app}" stopped\n`));
+                }
+                else {
+                    console.log(pc.yellow(`\n   App "${options.app}" was not running\n`));
+                }
+                return;
+            }
+            // Stop specific configured app
+            const stopped = await stopApp(options.app, appConfig.projectPath);
+            if (stopped) {
+                console.log(pc.green(`\n   ✓ App "${options.app}" stopped\n`));
+            }
+            else {
+                console.log(pc.yellow(`\n   App "${options.app}" was not running\n`));
+            }
+            return;
+        }
+        // Determine which deployments/project paths to stop
         const deploymentsToStop = [];
         if (options.deployment) {
             // Stop specific deployment
-            const deployment = _config.deployments?.[options.deployment];
+            const deployment = config.deployments?.[options.deployment];
             if (!deployment) {
                 console.error(pc.red(`\n   Error: Deployment "${options.deployment}" not found`));
                 console.log(pc.dim("   Run 'cortex config list' to see available deployments\n"));
@@ -224,36 +295,52 @@ export function registerLifecycleCommands(program, _config) {
         }
         else {
             // Stop all deployments that have running processes
-            const deploymentEntries = Object.entries(_config.deployments || {});
-            if (deploymentEntries.length === 0) {
+            const deploymentEntries = Object.entries(config.deployments || {});
+            // Collect project paths from both deployments and apps
+            const projectPaths = new Map(); // path -> name
+            if (deploymentEntries.length === 0 && !config.apps) {
                 // Fallback to current directory
                 const cwd = process.cwd();
-                deploymentsToStop.push({
-                    name: "current directory",
-                    projectPath: cwd,
-                });
+                projectPaths.set(cwd, "current directory");
             }
             else {
+                // Add deployment project paths
                 for (const [name, deployment] of deploymentEntries) {
                     if (deployment.projectPath &&
                         fs.existsSync(deployment.projectPath)) {
-                        // Check if anything is running for this deployment
-                        const pidFile = path.join(deployment.projectPath, ".convex-dev.pid");
-                        const dockerCompose = path.join(deployment.projectPath, "docker-compose.graph.yml");
-                        const hasPidFile = fs.existsSync(pidFile);
-                        const hasDockerCompose = fs.existsSync(dockerCompose);
-                        if (hasPidFile || hasDockerCompose) {
-                            deploymentsToStop.push({
-                                name,
-                                projectPath: deployment.projectPath,
-                            });
+                        projectPaths.set(deployment.projectPath, name);
+                    }
+                }
+                // Add app project paths (may overlap with deployments)
+                if (config.apps) {
+                    for (const [appName, app] of Object.entries(config.apps)) {
+                        if (app.projectPath && fs.existsSync(app.projectPath)) {
+                            // Use app name if no deployment for this path
+                            if (!projectPaths.has(app.projectPath)) {
+                                projectPaths.set(app.projectPath, `app:${appName}`);
+                            }
                         }
                     }
                 }
             }
+            // Check each project path for running services
+            for (const [projectPath, name] of projectPaths) {
+                // Check if anything is running for this deployment
+                const pidFile = path.join(projectPath, ".convex-dev.pid");
+                const dockerCompose = path.join(projectPath, "docker-compose.graph.yml");
+                const appPidFiles = await findAppPidFiles(projectPath);
+                const hasPidFile = fs.existsSync(pidFile);
+                const hasDockerCompose = fs.existsSync(dockerCompose);
+                const hasApps = appPidFiles.length > 0;
+                if (hasPidFile || hasDockerCompose || hasApps) {
+                    deploymentsToStop.push({ name, projectPath });
+                }
+            }
         }
         if (deploymentsToStop.length === 0) {
-            console.log(pc.yellow("\n   No deployments with running services found\n"));
+            console.log(pc.yellow("\n   No deployments with running services found"));
+            console.log(pc.dim("   Note: Services started without PID files cannot be auto-detected.\n" +
+                "   Use 'ps aux | grep convex' or 'ps aux | grep next' to find running processes.\n"));
             return;
         }
         console.log(pc.cyan(`\n   Stopping ${deploymentsToStop.length} deployment(s)...\n`));
@@ -261,8 +348,9 @@ export function registerLifecycleCommands(program, _config) {
             console.log(pc.bold(`   ${name}`));
             console.log(pc.dim(`   ${projectPath}`));
             let deploymentStopped = false;
-            // Stop Convex if not graph-only
-            if (!options.graphOnly) {
+            let convexStopped = false;
+            // Stop Convex if not graph-only and not apps-only
+            if (!options.graphOnly && !options.appsOnly) {
                 const pidFile = path.join(projectPath, ".convex-dev.pid");
                 try {
                     const pid = await fs.readFile(pidFile, "utf-8");
@@ -272,11 +360,13 @@ export function registerLifecycleCommands(program, _config) {
                         console.log(pc.green(`   ✓ Convex stopped (PID: ${pidNum})`));
                         stoppedSomething = true;
                         deploymentStopped = true;
+                        convexStopped = true;
                     }
                     catch (e) {
                         const err = e;
                         if (err.code === "ESRCH") {
                             console.log(pc.yellow("   Convex was already stopped"));
+                            convexStopped = true; // Consider it handled
                         }
                         else {
                             throw e;
@@ -290,13 +380,37 @@ export function registerLifecycleCommands(program, _config) {
                     if (err.code !== "ENOENT") {
                         console.error(pc.red("   Error stopping Convex:"), e);
                     }
-                    else if (!options.graphOnly) {
-                        console.log(pc.dim("   No Convex process running"));
+                    // No PID file - will try port-based detection below
+                }
+                // Fallback: try to stop by port if no PID file and deployment is local
+                if (!convexStopped) {
+                    // Check if this is a local deployment (port 3210)
+                    const deploymentConfig = Object.values(config.deployments || {}).find((d) => d.projectPath === projectPath);
+                    const isLocal = deploymentConfig?.url?.includes("127.0.0.1:3210") ||
+                        deploymentConfig?.url?.includes("localhost:3210");
+                    if (isLocal) {
+                        const convexPid = await findProcessByPort(3210);
+                        if (convexPid) {
+                            console.log(pc.yellow(`   Found Convex on port 3210 (no PID file)`));
+                            const stopped = await stopProcessByPort(3210);
+                            if (stopped) {
+                                console.log(pc.green(`   ✓ Convex stopped (port 3210, PID: ${convexPid})`));
+                                stoppedSomething = true;
+                                deploymentStopped = true;
+                                convexStopped = true;
+                            }
+                        }
+                        else {
+                            console.log(pc.dim("   No Convex process running"));
+                        }
+                    }
+                    else if (!options.graphOnly && !options.appsOnly) {
+                        console.log(pc.dim("   No Convex process running (PID file not found)"));
                     }
                 }
             }
-            // Stop graph containers if not convex-only
-            if (!options.convexOnly) {
+            // Stop graph containers if not convex-only and not apps-only
+            if (!options.convexOnly && !options.appsOnly) {
                 const dockerComposePath = path.join(projectPath, "docker-compose.graph.yml");
                 if (fs.existsSync(dockerComposePath)) {
                     const stopped = await stopGraphContainers(projectPath);
@@ -309,17 +423,76 @@ export function registerLifecycleCommands(program, _config) {
                         console.log(pc.dim("   No graph container running"));
                     }
                 }
-                else if (!options.convexOnly) {
+                else if (!options.convexOnly && !options.appsOnly) {
                     console.log(pc.dim("   No graph database configured"));
                 }
             }
+            // Stop apps if not convex-only and not graph-only
+            if (!options.convexOnly && !options.graphOnly) {
+                const appPidFiles = await findAppPidFiles(projectPath);
+                const stoppedAppNames = new Set();
+                // First, try to stop apps with PID files
+                if (appPidFiles.length > 0) {
+                    for (const { name: appName } of appPidFiles) {
+                        const appStatus = await isAppRunning(appName, projectPath);
+                        if (appStatus.running) {
+                            const stopped = await stopApp(appName, projectPath);
+                            if (stopped) {
+                                console.log(pc.green(`   ✓ App "${appName}" stopped (PID: ${appStatus.pid})`));
+                                stoppedSomething = true;
+                                stoppedAppsCount++;
+                                deploymentStopped = true;
+                                stoppedAppNames.add(appName);
+                            }
+                        }
+                        else {
+                            // Clean up stale PID file (already handled by isAppRunning)
+                            console.log(pc.dim(`   App "${appName}" was not running`));
+                        }
+                    }
+                }
+                // Also check configured apps that might not have PID files
+                // (started before PID tracking was added)
+                if (config.apps) {
+                    for (const [appName, appConfig] of Object.entries(config.apps)) {
+                        // Skip if already stopped via PID file or not matching this project
+                        if (stoppedAppNames.has(appName))
+                            continue;
+                        if (appConfig.projectPath !== projectPath)
+                            continue;
+                        const port = appConfig.port || 3000;
+                        const pid = await findProcessByPort(port);
+                        if (pid) {
+                            console.log(pc.yellow(`   Found app "${appName}" on port ${port} (no PID file)`));
+                            const stopped = await stopProcessByPort(port);
+                            if (stopped) {
+                                console.log(pc.green(`   ✓ App "${appName}" stopped (port ${port}, PID: ${pid})`));
+                                stoppedSomething = true;
+                                stoppedAppsCount++;
+                                deploymentStopped = true;
+                            }
+                        }
+                    }
+                }
+                if (appPidFiles.length === 0 && !config.apps && options.appsOnly) {
+                    console.log(pc.dim("   No apps configured"));
+                }
+            }
             if (deploymentStopped) {
                 stoppedCount++;
             }
             console.log();
         }
+        // Summary
         if (stoppedSomething) {
-            console.log(pc.green(`   ✓ Stopped ${stoppedCount} deployment(s)\n`));
+            const parts = [];
+            if (stoppedCount > 0 && !options.appsOnly) {
+                parts.push(`${stoppedCount} deployment(s)`);
+            }
+            if (stoppedAppsCount > 0) {
+                parts.push(`${stoppedAppsCount} app(s)`);
+            }
+            console.log(pc.green(`   ✓ Stopped ${parts.join(" and ")}\n`));
         }
         else {
             console.log(pc.yellow("   No services were running\n"));
@@ -368,8 +541,8 @@ export async function runInitWizard(targetDir, options = {}) {
     const projectInfo = await getProjectInfo(targetDir);
     // Step 2: Installation type
     const installationType = await getInstallationType(projectInfo.projectPath);
-    // Step 3: Convex setup
-    const convexConfig = await getConvexSetup(options);
+    // Step 3: Convex setup (pass project name for non-interactive setup)
+    const convexConfig = await getConvexSetup(options, projectInfo.projectName);
     // Step 4: Graph database (optional)
     let graphConfig = null;
     if (!options.skipGraph) {
@@ -387,6 +560,8 @@ export async function runInitWizard(targetDir, options = {}) {
         convexSetupType: convexConfig.type,
         convexUrl: convexConfig.config.convexUrl,
         deployKey: convexConfig.config.deployKey,
+        teamSlug: convexConfig.config.teamSlug,
+        sanitizedProjectName: convexConfig.config.sanitizedProjectName,
         graphEnabled: graphConfig !== null,
         graphType: graphConfig?.type || "skip",
         graphUri: graphConfig?.uri,
@@ -399,26 +574,64 @@ export async function runInitWizard(targetDir, options = {}) {
     if (!options.yes) {
         await showConfirmation(config);
     }
-    // Execute setup
-    await executeSetup(config);
-    // Ask to start Convex if not already specified
+    // Execute setup (returns SDK metadata for post-setup steps)
+    const sdkMetadata = await executeSetup(config);
+    // Ask about Vercel AI quickstart (optional demo app)
+    let installedQuickstart = false;
+    let quickstartAppConfig = null;
+    if (!options.yes) {
+        const { installQuickstart } = await prompts({
+            type: "confirm",
+            name: "installQuickstart",
+            message: "Install Vercel AI quickstart demo?",
+            initial: false,
+        });
+        if (installQuickstart) {
+            // Need the actual Convex URL from the config that was just set up
+            const convexUrl = config.convexUrl || "";
+            // Pass graph config if it was enabled during init
+            const graphConfig = config.graphEnabled
+                ? {
+                    enabled: true,
+                    uri: config.graphUri,
+                    username: config.graphUsername,
+                    password: config.graphPassword,
+                }
+                : undefined;
+            quickstartAppConfig = await installVercelAIQuickstart(config.projectPath, sdkMetadata.sdkVersion, convexUrl, config.openaiApiKey, graphConfig);
+            // Save app to CLI config
+            const cliConfig = await loadConfig();
+            cliConfig.apps = cliConfig.apps || {};
+            cliConfig.apps["quickstart"] = quickstartAppConfig;
+            await saveUserConfig(cliConfig);
+            installedQuickstart = true;
+        }
+    }
+    // Context-aware start prompt
     let shouldStart = options.start;
     if (!shouldStart && !options.yes) {
+        const message = installedQuickstart
+            ? "Start Convex backend and quickstart app now?"
+            : "Start Convex development server now?";
         const response = await prompts({
             type: "confirm",
             name: "startNow",
-            message: "Start Convex development server now?",
+            message,
             initial: true,
         });
         shouldStart = response.startNow;
     }
-    // Start Convex if requested
+    // Start services if requested
     if (shouldStart) {
         const isLocal = config.convexSetupType === "local";
         await startConvexInBackground(config.projectPath, isLocal);
+        // Start quickstart app if installed
+        if (installedQuickstart && quickstartAppConfig) {
+            await startApp("quickstart", quickstartAppConfig);
+        }
         // Show running status dashboard
         console.log();
-        await showRunningStatus(config.projectPath, isLocal);
+        await showRunningStatus(config.projectPath, isLocal, installedQuickstart);
     }
 }
 /**
@@ -477,49 +690,89 @@ async function getInstallationType(projectPath) {
 }
 /**
  * Get Convex setup configuration
+ *
+ * Handles auth, gets team slug, and sanitizes project name for non-interactive setup.
  */
-async function getConvexSetup(options) {
-    // Quick options
+async function getConvexSetup(options, projectName) {
+    console.log(pc.cyan("\n   Convex Database Setup"));
+    console.log(pc.dim("   Cortex uses Convex as its backend database\n"));
+    // Ensure user is logged in and get team slug
+    const authStatus = await ensureConvexAuth();
+    const teamSlug = authStatus.teamSlug;
+    const sanitizedName = sanitizeProjectName(projectName);
+    // Quick options via CLI flags
     if (options.local) {
         return {
             type: "local",
-            config: { convexUrl: "http://127.0.0.1:3210" },
+            config: {
+                convexUrl: "http://127.0.0.1:3210",
+                teamSlug,
+                sanitizedProjectName: sanitizedName,
+            },
         };
     }
     if (options.cloud) {
         return {
             type: "new",
-            config: { convexUrl: "" },
+            config: {
+                convexUrl: "",
+                teamSlug,
+                sanitizedProjectName: sanitizedName,
+            },
         };
     }
-    console.log(pc.cyan("\n   Convex Database Setup"));
-    console.log(pc.dim("   Cortex uses Convex as its backend database\n"));
+    // Build menu choices with project name context
+    const choices = [
+        {
+            title: "Local development (fast, recommended)",
+            description: `Creates "${sanitizedName}" with local backend`,
+            value: "local",
+        },
+        {
+            title: "Create new cloud project",
+            description: teamSlug
+                ? `Creates "${sanitizedName}" in team "${teamSlug}"`
+                : `Creates "${sanitizedName}" on Convex cloud`,
+            value: "new",
+        },
+        {
+            title: "Use existing Convex project",
+            description: "Connect to your existing deployment",
+            value: "existing",
+        },
+    ];
     const response = await prompts({
         type: "select",
         name: "setupType",
         message: "How would you like to set up Convex?",
-        choices: [
-            {
-                title: "Create new Convex project",
-                description: "Full features including vector search",
-                value: "new",
-            },
-            {
-                title: "Use existing Convex deployment",
-                description: "Connect to your existing deployment",
-                value: "existing",
-            },
-        ],
+        choices,
         initial: 0,
     });
     if (!response.setupType) {
         throw new Error("Convex setup is required");
     }
+    // For existing projects, ask for the project name
+    let existingProjectName = sanitizedName;
+    if (response.setupType === "existing") {
+        const existingResponse = await prompts({
+            type: "text",
+            name: "projectName",
+            message: "Enter the name of your existing Convex project:",
+            initial: sanitizedName,
+            validate: (value) => (value ? true : "Project name is required"),
+        });
+        if (!existingResponse.projectName) {
+            throw new Error("Project name is required");
+        }
+        existingProjectName = existingResponse.projectName;
+    }
     return {
         type: response.setupType,
         config: {
             convexUrl: "",
             deployKey: undefined,
+            teamSlug,
+            sanitizedProjectName: response.setupType === "existing" ? existingProjectName : sanitizedName,
         },
     };
 }
@@ -601,6 +854,7 @@ async function showConfirmation(config) {
 }
 /**
  * Execute the setup
+ * Returns SDK metadata for use in post-setup steps (like quickstart installation)
  */
 async function executeSetup(config) {
     console.log(pc.cyan("\n   Setting up Cortex...\n"));
@@ -648,15 +902,46 @@ async function executeSetup(config) {
         await createConvexJson(config.projectPath);
         backendSpinner.succeed("Cortex backend files ready");
         // Setup and deploy Convex in ONE step
+        // Pass teamSlug and projectName for non-interactive setup
+        // IMPORTANT: Always pass useLocalBackend when local mode is selected,
+        // even if teamSlug/projectName are missing (falls back to interactive)
         let convexConfig;
-        if (config.convexSetupType === "new") {
-            // For new projects: prompt for project creation and deploy everything
-            convexConfig = await setupNewConvex(config.projectPath);
+        const isLocalMode = config.convexSetupType === "local";
+        const convexOptions = config.teamSlug && config.sanitizedProjectName
+            ? {
+                teamSlug: config.teamSlug,
+                projectName: config.sanitizedProjectName,
+                useLocalBackend: isLocalMode,
+            }
+            : isLocalMode
+                ? { useLocalBackend: true }
+                : undefined;
+        if (config.convexSetupType === "new" ||
+            config.convexSetupType === "local") {
+            // For new projects (cloud or local): create project and deploy
+            convexConfig = await setupNewConvex(config.projectPath, convexOptions);
         }
         else {
-            // For existing projects: get URL/key, then deploy
-            convexConfig = await setupExistingConvex();
-            await deployToConvex(config.projectPath, convexConfig, false);
+            // For existing projects: connect and deploy
+            try {
+                convexConfig = await setupExistingConvex(config.projectPath, convexOptions
+                    ? {
+                        teamSlug: convexOptions.teamSlug,
+                        projectName: convexOptions.projectName,
+                    }
+                    : undefined);
+                // Only deploy if we used interactive mode (no options)
+                if (!convexOptions) {
+                    await deployToConvex(config.projectPath, convexConfig, false);
+                }
+            }
+            catch (error) {
+                // The Convex CLI already printed the actual error (e.g., "Project not found",
+                // "Authentication failed", "Network error", etc.) to the console.
+                // Just provide a helpful hint without assuming the cause.
+                console.log(pc.dim("\n   If the project wasn't found, check for typos or select 'Create new' instead."));
+                throw error;
+            }
         }
         // Update config with actual Convex details
         config.convexUrl = convexConfig.convexUrl;
@@ -715,6 +1000,11 @@ async function executeSetup(config) {
         await saveDeploymentToConfig(config);
         // Success!
         showSuccessMessage(config);
+        // Return SDK metadata for use in post-setup steps
+        return {
+            sdkVersion: sdkMetadata.sdkVersion,
+            convexVersion: sdkMetadata.convexVersion,
+        };
     }
     catch (error) {
         console.error(pc.red("\n   Setup failed:"), error);
@@ -736,11 +1026,12 @@ async function saveDeploymentToConfig(config) {
         const deploymentName = config.projectName
             .toLowerCase()
             .replace(/[^a-z0-9-]/g, "-");
-        // Add the deployment
+        // Add the deployment (enabled by default when created by init)
         userConfig.deployments[deploymentName] = {
             url: config.convexUrl,
             key: config.deployKey,
             projectPath: config.projectPath,
+            enabled: true,
         };
         // Set as default if no default exists
         if (!userConfig.default) {
@@ -861,7 +1152,7 @@ async function startConvexInBackground(projectPath, isLocal, deploymentUrl, depl
 /**
  * Show running services status dashboard
  */
-async function showRunningStatus(projectPath, isLocal) {
+async function showRunningStatus(projectPath, isLocal, hasQuickstart = false) {
     const width = 56;
     const line = "═".repeat(width);
     const thinLine = "─".repeat(width);
@@ -933,6 +1224,15 @@ async function showRunningStatus(projectPath, isLocal) {
         console.log(`   ${pc.dim("○")} Not configured`);
     }
     console.log();
+    // Quickstart App Status (if installed)
+    if (hasQuickstart) {
+        console.log(pc.bold(pc.white("  Vercel AI Quickstart")));
+        console.log(pc.dim("  " + thinLine));
+        console.log(`   ${pc.green("●")} Running`);
+        console.log(pc.dim("     URL: http://localhost:3000"));
+        console.log(pc.dim("     Interactive chat demo with memory visualization"));
+        console.log();
+    }
     // Quick Actions
     console.log(pc.bold(pc.white("  Quick Actions")));
     console.log(pc.dim("  " + thinLine));
@@ -941,6 +1241,9 @@ async function showRunningStatus(projectPath, isLocal) {
         pc.dim("         # Foreground mode (see logs)"));
     console.log(pc.dim("   cortex stop") +
         pc.dim("             # Stop background services"));
+    if (hasQuickstart) {
+        console.log(pc.dim("   npm run quickstart") + pc.dim("      # Start quickstart demo"));
+    }
     console.log(pc.dim("   npm start") + pc.dim("               # Run your AI agent"));
     console.log();
     // Log file hint