@codebakers/cli 1.5.0 → 2.0.0

package/src/commands/scaffold.ts

@@ -5,9 +5,47 @@ import { writeFileSync, mkdirSync, existsSync, readdirSync, readFileSync } from
 import { join } from 'path';
 import { execSync } from 'child_process';
 import * as templates from '../templates/nextjs-supabase.js';
-import { getApiKey, getApiUrl } from '../config.js';
+import {
+  getApiKey,
+  getApiUrl,
+  syncServiceKeys,
+  clearAllServiceKeys,
+  getConfiguredServiceKeys,
+  writeKeysToEnvFile,
+  SERVICE_KEYS,
+  SERVICE_KEY_LABELS,
+  PROVISIONABLE_KEYS,
+  type ServiceName,
+  type SyncResult,
+} from '../config.js';
 import { provisionAll, type ProvisionResult } from './provision.js';
 
+/**
+ * Fetch ALL service keys from CodeBakers server
+ */
+async function fetchServerKeys(): Promise<Partial<Record<ServiceName, string>> | null> {
+  const apiKey = getApiKey();
+  if (!apiKey) return null;
+
+  try {
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/api/cli/service-keys`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      // Handle wrapped response { data: {...} } or direct response
+      return data.data || data;
+    }
+  } catch {
+    // Server unreachable or error
+  }
+  return null;
+}
+
 // Cursor IDE configuration templates
 const CURSORRULES_TEMPLATE = `# CODEBAKERS CURSOR RULES
 # Zero-friction AI assistance - everything is automatic
@@ -262,6 +300,58 @@ async function confirm(question: string): Promise<boolean> {
   return answer.toLowerCase() !== 'n';
 }
 
+/**
+ * Display configured keys summary
+ */
+function displayKeysSummary(_source: 'server' | 'local' | 'both'): void {
+  const configuredKeys = getConfiguredServiceKeys();
+
+  if (configuredKeys.length === 0) {
+    console.log(chalk.gray('    No service keys configured\n'));
+    return;
+  }
+
+  // Group by provisionable vs other
+  const provisionable = configuredKeys.filter(k => PROVISIONABLE_KEYS.includes(k));
+  const other = configuredKeys.filter(k => !PROVISIONABLE_KEYS.includes(k));
+
+  if (provisionable.length > 0) {
+    console.log(chalk.gray('    Infrastructure (can auto-provision):'));
+    for (const key of provisionable) {
+      console.log(chalk.green(`      ✓ ${SERVICE_KEY_LABELS[key]}`));
+    }
+  }
+
+  if (other.length > 0) {
+    console.log(chalk.gray('    Other services:'));
+    for (const key of other) {
+      console.log(chalk.green(`      ✓ ${SERVICE_KEY_LABELS[key]}`));
+    }
+  }
+
+  console.log('');
+}
+
+/**
+ * Display sync results
+ */
+function displaySyncResults(result: SyncResult): void {
+  if (result.added.length > 0) {
+    console.log(chalk.green(`    + ${result.added.length} keys synced from server`));
+    for (const key of result.added) {
+      console.log(chalk.gray(`      + ${SERVICE_KEY_LABELS[key]}`));
+    }
+  }
+
+  if (result.updated.length > 0) {
+    console.log(chalk.yellow(`    ~ ${result.updated.length} keys updated from server`));
+  }
+
+  if (result.added.length === 0 && result.updated.length === 0) {
+    console.log(chalk.gray('    All keys already in sync'));
+  }
+}
+
 /**
  * Scaffold a new project with full structure
  */
@@ -443,8 +533,6 @@ export async function scaffold(): Promise<void> {
       }
     }
 
-    spinner.succeed('Project structure created!');
-
     // Auto-install CodeBakers patterns
     console.log(chalk.white('\n  Installing CodeBakers patterns...\n'));
 
@@ -532,29 +620,124 @@ export async function scaffold(): Promise<void> {
     let provisionResult: ProvisionResult = {};
 
     if (wantProvision) {
-      // Initialize git first if not already
-      try {
-        execSync('git init', { cwd, stdio: 'pipe' });
-        execSync('git add .', { cwd, stdio: 'pipe' });
-        execSync('git commit -m "Initial commit from CodeBakers scaffold"', { cwd, stdio: 'pipe' });
-      } catch {
-        // Git might already be initialized or have issues
+      // Check for saved keys in CodeBakers back office
+      const serverKeys = await fetchServerKeys();
+      const serverKeyCount = serverKeys ? Object.values(serverKeys).filter(v => v).length : 0;
+      const localKeyCount = getConfiguredServiceKeys().length;
+
+      if (serverKeyCount > 0 || localKeyCount > 0) {
+        // Show which keys are available
+        console.log(chalk.white('\n  Available service keys:\n'));
+
+        if (serverKeyCount > 0) {
+          console.log(chalk.gray(`    From CodeBakers account (${serverKeyCount} keys):`));
+          for (const key of SERVICE_KEYS) {
+            if (serverKeys && serverKeys[key]) {
+              console.log(chalk.green(`      ✓ ${SERVICE_KEY_LABELS[key]}`));
+            }
+          }
+        }
+
+        if (localKeyCount > 0) {
+          console.log(chalk.gray(`    Stored locally (${localKeyCount} keys):`));
+          displayKeysSummary('local');
+        }
+
+        console.log('');
+
+        // Ask which keys to use
+        console.log(chalk.white('  Which keys would you like to use?\n'));
+        console.log(chalk.gray('    1. ') + chalk.cyan('Use saved keys') + chalk.gray(' - Use keys from your account/local storage'));
+        console.log(chalk.gray('    2. ') + chalk.cyan('Start fresh') + chalk.gray(' - Clear local keys, enter new ones (for client projects)'));
+        console.log(chalk.gray('    3. ') + chalk.cyan('Skip') + chalk.gray(' - Don\'t provision, I\'ll do it manually\n'));
+
+        let keyChoice = '';
+        while (!['1', '2', '3'].includes(keyChoice)) {
+          keyChoice = await prompt('  Enter 1, 2, or 3: ');
+        }
+
+        if (keyChoice === '3') {
+          console.log(chalk.gray('\n  Skipping auto-provisioning.\n'));
+        } else if (keyChoice === '2') {
+          // FIX: Actually clear keys for client projects
+          console.log(chalk.yellow('\n  Clearing local keys for fresh start...\n'));
+          clearAllServiceKeys();
+          console.log(chalk.green('  ✓ Local keys cleared'));
+          console.log(chalk.gray('  You\'ll be prompted to enter keys for each service.\n'));
+
+          // Initialize git first
+          try {
+            execSync('git init', { cwd, stdio: 'pipe' });
+            execSync('git add .', { cwd, stdio: 'pipe' });
+            execSync('git commit -m "Initial commit from CodeBakers scaffold"', { cwd, stdio: 'pipe' });
+          } catch {
+            // Git might already be initialized
+          }
+
+          provisionResult = await provisionAll(projectName, `${projectName} - Built with CodeBakers`);
+        } else {
+          // Option 1: Use saved keys
+          if (serverKeyCount > 0 && serverKeys) {
+            // Sync server keys to local storage
+            console.log(chalk.white('\n  Syncing keys from CodeBakers account...\n'));
+            const syncResult = syncServiceKeys(serverKeys);
+            displaySyncResults(syncResult);
+            console.log(chalk.green('\n  ✓ Keys synced from CodeBakers account\n'));
+          } else {
+            console.log(chalk.green('\n  ✓ Using locally stored keys\n'));
+          }
+
+          // Initialize git first
+          try {
+            execSync('git init', { cwd, stdio: 'pipe' });
+            execSync('git add .', { cwd, stdio: 'pipe' });
+            execSync('git commit -m "Initial commit from CodeBakers scaffold"', { cwd, stdio: 'pipe' });
+          } catch {
+            // Git might already be initialized
+          }
+
+          provisionResult = await provisionAll(projectName, `${projectName} - Built with CodeBakers`);
+        }
+      } else {
+        // No saved keys - proceed with provisioning (will prompt for keys)
+        console.log(chalk.gray('\n  No saved keys found. You\'ll be prompted to enter keys for each service.\n'));
+        console.log(chalk.gray('  Tip: Save keys in your CodeBakers dashboard to auto-provision future projects!\n'));
+
+        // Initialize git first
+        try {
+          execSync('git init', { cwd, stdio: 'pipe' });
+          execSync('git add .', { cwd, stdio: 'pipe' });
+          execSync('git commit -m "Initial commit from CodeBakers scaffold"', { cwd, stdio: 'pipe' });
+        } catch {
+          // Git might already be initialized
+        }
+
+        provisionResult = await provisionAll(projectName, `${projectName} - Built with CodeBakers`);
       }
 
-      provisionResult = await provisionAll(projectName, `${projectName} - Built with CodeBakers`);
+      // Write ALL service keys to .env.local
+      const additionalVars: Record<string, string> = {};
 
-      // Update .env.local with Supabase credentials if available
+      // Add Supabase project-specific vars if provisioned
       if (provisionResult.supabase) {
-        const envPath = join(cwd, '.env.local');
-        let envContent = existsSync(envPath) ? readFileSync(envPath, 'utf-8') : '';
+        additionalVars['NEXT_PUBLIC_SUPABASE_URL'] = provisionResult.supabase.apiUrl;
+        additionalVars['NEXT_PUBLIC_SUPABASE_ANON_KEY'] = provisionResult.supabase.anonKey;
+        additionalVars['SUPABASE_PROJECT_ID'] = provisionResult.supabase.projectId;
+      }
+
+      // Add Vercel project-specific vars if provisioned
+      if (provisionResult.vercel) {
+        additionalVars['VERCEL_PROJECT_ID'] = provisionResult.vercel.projectId;
+      }
 
-        // Replace placeholder values with actual credentials
-        envContent = envContent
-          .replace('your-project-id.supabase.co', provisionResult.supabase.apiUrl.replace('https://', ''))
-          .replace('your-anon-key', provisionResult.supabase.anonKey || 'your-anon-key');
+      // Write all keys to .env.local
+      const { written } = writeKeysToEnvFile(cwd, {
+        includeEmpty: false,
+        additionalVars,
+      });
 
-        writeFileSync(envPath, envContent);
-        console.log(chalk.green('  ✅ Updated .env.local with Supabase credentials!\n'));
+      if (written > 0 || Object.keys(additionalVars).length > 0) {
+        console.log(chalk.green(`\n  ✅ Wrote ${written} service keys and ${Object.keys(additionalVars).length} project configs to .env.local\n`));
       }
     }
 
@@ -597,32 +780,63 @@ export async function scaffold(): Promise<void> {
     console.log('');
 
     console.log(chalk.white('  Next steps:\n'));
+
+    // Show appropriate next steps based on what was provisioned
+    let stepNum = 1;
+
+    if (!provisionResult.supabase) {
+      if (isBeginnerMode) {
+        console.log(chalk.cyan(`    ${stepNum}. `) + chalk.white('Set up Supabase (free database + login):'));
+        console.log(chalk.gray('       Go to https://supabase.com → Create free account → New Project'));
+        console.log('');
+        stepNum++;
+        console.log(chalk.cyan(`    ${stepNum}. `) + chalk.white('Connect your project:'));
+        console.log(chalk.gray('       Open .env.local file and paste your Supabase credentials'));
+        console.log(chalk.gray('       (Found in Supabase: Settings → API)'));
+        console.log('');
+        stepNum++;
+      } else {
+        console.log(chalk.cyan(`    ${stepNum}. `) + chalk.gray('Create Supabase project at https://supabase.com'));
+        stepNum++;
+        console.log(chalk.cyan(`    ${stepNum}. `) + chalk.gray('Update .env.local with Supabase credentials'));
+        stepNum++;
+      }
+    }
+
+    // CRITICAL: Add db:push step
+    console.log(chalk.cyan(`    ${stepNum}. `) + chalk.white('Push database schema:'));
+    console.log(chalk.gray('       npx drizzle-kit db:push'));
+    console.log('');
+    stepNum++;
+
+    console.log(chalk.cyan(`    ${stepNum}. `) + chalk.white('Start your app:'));
+    console.log(chalk.gray('       npm run dev'));
     if (isBeginnerMode) {
-      console.log(chalk.cyan('    1. ') + chalk.white('Set up Supabase (free database + login):'));
-      console.log(chalk.gray('       Go to https://supabase.com → Create free account → New Project'));
-      console.log('');
-      console.log(chalk.cyan('    2. ') + chalk.white('Connect your project:'));
-      console.log(chalk.gray('       Open .env.local file and paste your Supabase credentials'));
-      console.log(chalk.gray('       (Found in Supabase: Settings → API)'));
-      console.log('');
-      console.log(chalk.cyan('    3. ') + chalk.white('Start your app:'));
-      console.log(chalk.gray('       Run: npm run dev'));
       console.log(chalk.gray('       Open: http://localhost:3000 in your browser'));
+    }
+    console.log('');
+    stepNum++;
+
+    console.log(chalk.cyan(`    ${stepNum}. `) + chalk.white('Start building!'));
+    console.log(chalk.gray('       Tell your AI: "Build me a [feature]"'));
+    if (isBeginnerMode) {
+      console.log(chalk.gray('       The AI already has all the patterns loaded!'));
+    }
+    console.log('');
+
+    // Show provisioning summary if any services were created
+    if (provisionResult.github || provisionResult.supabase || provisionResult.vercel) {
+      console.log(chalk.white('  Provisioned services:\n'));
+      if (provisionResult.github) {
+        console.log(chalk.green('    ✅ GitHub: ') + chalk.gray(provisionResult.github.repoUrl));
+      }
+      if (provisionResult.supabase) {
+        console.log(chalk.green('    ✅ Supabase: ') + chalk.gray(provisionResult.supabase.projectUrl));
+      }
+      if (provisionResult.vercel) {
+        console.log(chalk.green('    ✅ Vercel: ') + chalk.gray(provisionResult.vercel.projectUrl));
+      }
       console.log('');
-      console.log(chalk.cyan('    4. ') + chalk.white('Start building!'));
-      console.log(chalk.gray('       Tell your AI: "Build me a [feature]"'));
-      console.log(chalk.gray('       The AI already has all the patterns loaded!\n'));
-    } else {
-      console.log(chalk.cyan('    1. ') + chalk.gray('Update .env.local with your Supabase credentials'));
-      console.log(chalk.cyan('    2. ') + chalk.gray('Run `npm run dev` to start development'));
-      console.log(chalk.cyan('    3. ') + chalk.gray('Tell your AI what to build - patterns are already loaded!\n'));
-
-      console.log(chalk.white('  Supabase setup:\n'));
-      console.log(chalk.gray('    1. Create a project at https://supabase.com'));
-      console.log(chalk.gray('    2. Go to Settings → API'));
-      console.log(chalk.gray('    3. Copy URL and anon key to .env.local'));
-      console.log(chalk.gray('    4. Go to Settings → Database → Connection string'));
-      console.log(chalk.gray('    5. Copy DATABASE_URL to .env.local\n'));
     }
 
   } catch (error) {

package/src/commands/setup.ts

@@ -2,7 +2,8 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { createInterface } from 'readline';
 import { execSync } from 'child_process';
-import { setApiKey, getApiKey, getApiUrl } from '../config.js';
+import { setApiKey, getApiKey, getApiUrl, syncServiceKeys, SERVICE_KEY_LABELS, type ServiceName } from '../config.js';
+import { validateApiKey, formatApiError, checkForUpdates, getCliVersion, type ApiError } from '../lib/api.js';
 
 function prompt(question: string): Promise<string> {
   const rl = createInterface({
@@ -23,6 +24,17 @@ export async function setup(): Promise<void> {
   console.log(chalk.blue('  ║') + chalk.white('     CodeBakers One-Time Setup        ') + chalk.blue('║'));
   console.log(chalk.blue('  ╚══════════════════════════════════════╝\n'));
 
+  // Check CLI version
+  const version = getCliVersion();
+  console.log(chalk.gray(`  CLI Version: ${version}\n`));
+
+  // Check for updates
+  const updateInfo = await checkForUpdates();
+  if (updateInfo?.updateAvailable) {
+    console.log(chalk.yellow(`  ⚠️  Update available: ${updateInfo.currentVersion} → ${updateInfo.latestVersion}`));
+    console.log(chalk.gray('  Run: npm install -g @codebakers/cli@latest\n'));
+  }
+
   // Check if already set up
   const existingKey = getApiKey();
   if (existingKey) {
@@ -46,29 +58,22 @@ export async function setup(): Promise<void> {
     process.exit(1);
   }
 
-  // Validate API key
+  // Validate API key using shared validation
   const spinner = ora('Validating API key...').start();
 
   try {
-    const apiUrl = getApiUrl();
-    const response = await fetch(`${apiUrl}/api/patterns`, {
-      method: 'GET',
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-    });
+    await validateApiKey(apiKey);
+    spinner.succeed('API key validated');
+  } catch (error) {
+    spinner.fail('Invalid API key');
 
-    if (!response.ok) {
-      spinner.fail('Invalid API key');
-      const error = await response.json().catch(() => ({}));
-      console.log(chalk.red(`\n  ${error.error || 'API key validation failed'}\n`));
-      process.exit(1);
+    if (error && typeof error === 'object' && 'recoverySteps' in error) {
+      console.log(chalk.red(`\n  ${formatApiError(error as ApiError)}\n`));
+    } else {
+      const message = error instanceof Error ? error.message : 'API key validation failed';
+      console.log(chalk.red(`\n  ${message}\n`));
     }
 
-    spinner.succeed('API key validated');
-  } catch {
-    spinner.fail('Could not connect to CodeBakers');
-    console.log(chalk.red('\n  Check your internet connection and try again.\n'));
     process.exit(1);
   }
 
@@ -76,15 +81,55 @@ export async function setup(): Promise<void> {
   setApiKey(apiKey);
   console.log(chalk.green('  ✓ API key saved\n'));
 
+  // Step 2: Sync service keys from server
+  console.log(chalk.white('  Step 2: Syncing service keys...\n'));
+
+  const syncSpinner = ora('Fetching service keys from your account...').start();
+
+  try {
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/api/cli/service-keys`, {
+      headers: { 'Authorization': `Bearer ${apiKey}` },
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      const serverKeys = data.data || data;
+
+      const result = syncServiceKeys(serverKeys);
+      const totalSynced = result.added.length + result.updated.length;
+
+      if (totalSynced > 0) {
+        syncSpinner.succeed(`Synced ${totalSynced} service keys`);
+
+        // Show which keys were synced
+        for (const keyName of [...result.added, ...result.updated]) {
+          console.log(chalk.green(`    ✓ ${SERVICE_KEY_LABELS[keyName as ServiceName]}`));
+        }
+        console.log('');
+      } else if (result.unchanged.length > 0) {
+        syncSpinner.succeed(`${result.unchanged.length} service keys already in sync`);
+      } else {
+        syncSpinner.succeed('No service keys configured in your account');
+        console.log(chalk.gray('  Tip: Add keys at https://codebakers.ai/settings\n'));
+      }
+    } else {
+      syncSpinner.warn('Could not sync service keys');
+      console.log(chalk.gray('  You can add keys later in the scaffold wizard.\n'));
+    }
+  } catch {
+    syncSpinner.warn('Could not sync service keys');
+    console.log(chalk.gray('  You can add keys later in the scaffold wizard.\n'));
+  }
+
   showFinalInstructions();
 }
 
 function showFinalInstructions(): void {
   const isWindows = process.platform === 'win32';
 
-  console.log(chalk.green('\n  ✅ API key saved!\n'));
   console.log(chalk.blue('  ══════════════════════════════════════════════════════════'));
-  console.log(chalk.white.bold('\n  STEP 2: Connecting CodeBakers to Claude...\n'));
+  console.log(chalk.white.bold('\n  STEP 3: Connecting CodeBakers to Claude...\n'));
   console.log(chalk.blue('  ══════════════════════════════════════════════════════════\n'));
 
   // Auto-install MCP server

package/src/commands/upgrade.ts

@@ -0,0 +1,110 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { getApiKey, getApiUrl } from '../config.js';
+import { checkForUpdates, getCliVersion } from '../lib/api.js';
+
+interface ContentResponse {
+  version: string;
+  router: string;
+  modules: Record<string, string>;
+}
+
+/**
+ * Upgrade CodeBakers patterns to the latest version
+ */
+export async function upgrade(): Promise<void> {
+  console.log(chalk.blue('\n  CodeBakers Upgrade\n'));
+
+  const cwd = process.cwd();
+  const claudeMdPath = join(cwd, 'CLAUDE.md');
+  const claudeDir = join(cwd, '.claude');
+
+  // Check if this is a CodeBakers project
+  if (!existsSync(claudeMdPath) && !existsSync(claudeDir)) {
+    console.log(chalk.yellow('  No CodeBakers installation found in this directory.\n'));
+    console.log(chalk.gray('  Run `codebakers install` to set up patterns first.\n'));
+    return;
+  }
+
+  // Check for CLI updates
+  console.log(chalk.gray('  Checking for CLI updates...\n'));
+  const updateInfo = await checkForUpdates();
+
+  if (updateInfo?.updateAvailable) {
+    console.log(chalk.yellow(`  ⚠️  CLI update available: ${updateInfo.currentVersion} → ${updateInfo.latestVersion}`));
+    console.log(chalk.gray('  Run: npm install -g @codebakers/cli@latest\n'));
+  } else {
+    console.log(chalk.green(`  ✓ CLI is up to date (v${getCliVersion()})\n`));
+  }
+
+  // Check API key
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.log(chalk.yellow('  Not logged in. Run `codebakers setup` first.\n'));
+    return;
+  }
+
+  // Fetch latest patterns
+  const spinner = ora('Fetching latest patterns...').start();
+
+  try {
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/api/content`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(error.error || 'Failed to fetch patterns');
+    }
+
+    const content: ContentResponse = await response.json();
+
+    spinner.succeed(`Patterns v${content.version} downloaded`);
+
+    // Count what we're updating
+    const moduleCount = Object.keys(content.modules).length;
+
+    console.log(chalk.gray(`  Updating ${moduleCount} modules...\n`));
+
+    // Update CLAUDE.md
+    if (content.router) {
+      writeFileSync(claudeMdPath, content.router);
+      console.log(chalk.green('  ✓ Updated CLAUDE.md'));
+    }
+
+    // Update pattern modules
+    if (content.modules && Object.keys(content.modules).length > 0) {
+      if (!existsSync(claudeDir)) {
+        mkdirSync(claudeDir, { recursive: true });
+      }
+
+      for (const [name, data] of Object.entries(content.modules)) {
+        writeFileSync(join(claudeDir, name), data);
+      }
+
+      console.log(chalk.green(`  ✓ Updated ${moduleCount} modules in .claude/`));
+    }
+
+    console.log(chalk.green(`\n  ✅ Upgraded to patterns v${content.version}!\n`));
+
+    // Show what's new if available
+    console.log(chalk.gray('  Changes take effect in your next AI session.\n'));
+
+  } catch (error) {
+    spinner.fail('Upgrade failed');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.log(chalk.red(`\n  Error: ${message}\n`));
+
+    if (message.includes('401') || message.includes('Invalid')) {
+      console.log(chalk.gray('  Your API key may have expired. Run `codebakers setup` to reconfigure.\n'));
+    }
+
+    process.exit(1);
+  }
+}