@codebakers/cli 3.2.0 → 3.3.1

package/src/index.ts

@@ -22,43 +22,46 @@ import { pushPatterns, pushPatternsInteractive } from './commands/push-patterns.
 import { go } from './commands/go.js';
 import { extend } from './commands/extend.js';
 import { billing } from './commands/billing.js';
-import { getCachedUpdateInfo, setCachedUpdateInfo, getCliVersion } from './config.js';
+import { getCachedUpdateInfo, setCachedUpdateInfo, getCliVersion, getCachedPatternInfo, setCachedPatternInfo, getApiKey, getApiUrl, getTrialState, hasValidAccess } from './config.js';
+import { checkForUpdates } from './lib/api.js';
+import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
 
 // ============================================
 // Automatic Update Notification
 // ============================================
 
-const CURRENT_VERSION = '3.2.0';
+const CURRENT_VERSION = '3.3.1';
 
 async function checkForUpdatesInBackground(): Promise<void> {
   // Check if we have a valid cached result first (fast path)
   const cached = getCachedUpdateInfo();
   if (cached) {
     if (cached.latestVersion !== CURRENT_VERSION) {
-      showUpdateBanner(CURRENT_VERSION, cached.latestVersion);
+      showUpdateBanner(CURRENT_VERSION, cached.latestVersion, false);
     }
     return;
   }
 
-  // Fetch from npm registry (with timeout to not block CLI)
+  // Use the API-based version check (with controlled rollout support)
   try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 3000);
-
-    const response = await fetch('https://registry.npmjs.org/@codebakers/cli/latest', {
-      headers: { 'Accept': 'application/json' },
-      signal: controller.signal,
-    });
+    const updateInfo = await checkForUpdates();
 
-    clearTimeout(timeout);
+    if (updateInfo) {
+      setCachedUpdateInfo(updateInfo.latestVersion);
 
-    if (response.ok) {
-      const data = await response.json();
-      const latestVersion = data.version;
-      setCachedUpdateInfo(latestVersion);
+      // Show blocked version warning first (critical)
+      if (updateInfo.isBlocked) {
+        showBlockedVersionWarning(updateInfo.currentVersion, updateInfo.latestVersion);
+        return;
+      }
 
-      if (latestVersion !== CURRENT_VERSION) {
-        showUpdateBanner(CURRENT_VERSION, latestVersion);
+      // Only show update banner if auto-update is enabled for this version
+      if (updateInfo.autoUpdateEnabled && updateInfo.autoUpdateVersion) {
+        showUpdateBanner(updateInfo.currentVersion, updateInfo.autoUpdateVersion, true);
+      } else if (updateInfo.updateAvailable) {
+        // Update available but not auto-update enabled - show regular banner
+        showUpdateBanner(updateInfo.currentVersion, updateInfo.latestVersion, false);
       }
     }
   } catch {
@@ -66,11 +69,27 @@ async function checkForUpdatesInBackground(): Promise<void> {
   }
 }
 
-function showUpdateBanner(currentVersion: string, latestVersion: string): void {
+function showBlockedVersionWarning(currentVersion: string, recommendedVersion: string): void {
+  console.log(chalk.red(`
+  ╭─────────────────────────────────────────────────────────╮
+  │                                                         │
+  │   ${chalk.bold('⚠️  VERSION BLOCKED')}                                   │
+  │                                                         │
+  │   Your CLI version ${chalk.gray(currentVersion)} has critical issues.       │
+  │   Please update immediately to ${chalk.green(recommendedVersion)}                   │
+  │                                                         │
+  │   Run ${chalk.cyan('npm i -g @codebakers/cli@latest')} to update        │
+  │                                                         │
+  ╰─────────────────────────────────────────────────────────╯
+  `));
+}
+
+function showUpdateBanner(currentVersion: string, latestVersion: string, isRecommended: boolean): void {
+  const updateType = isRecommended ? chalk.green('Recommended update') : chalk.bold('Update available!');
   console.log(chalk.yellow(`
   ╭─────────────────────────────────────────────────────────╮
   │                                                         │
-  │   ${chalk.bold('Update available!')} ${chalk.gray(currentVersion)} → ${chalk.green(latestVersion)}                     │
+  │   ${updateType} ${chalk.gray(currentVersion)} → ${chalk.green(latestVersion)}                     │
   │                                                         │
   │   Run ${chalk.cyan('npm i -g @codebakers/cli@latest')} to update        │
   │                                                         │
@@ -78,6 +97,181 @@ function showUpdateBanner(currentVersion: string, latestVersion: string): void {
   `));
 }
 
+// ============================================
+// Automatic Pattern Updates
+// ============================================
+
+interface PatternVersionInfo {
+  version: string;
+  moduleCount: number;
+  updatedAt: string;
+  cliVersion: string;
+}
+
+interface ContentResponse {
+  version: string;
+  router: string;
+  modules: Record<string, string>;
+}
+
+function getLocalPatternVersion(): string | null {
+  const cwd = process.cwd();
+  const versionFile = join(cwd, '.claude', '.version.json');
+
+  if (!existsSync(versionFile)) return null;
+
+  try {
+    const content = readFileSync(versionFile, 'utf-8');
+    const info: PatternVersionInfo = JSON.parse(content);
+    return info.version;
+  } catch {
+    return null;
+  }
+}
+
+function isCodeBakersProject(): boolean {
+  const cwd = process.cwd();
+  return existsSync(join(cwd, 'CLAUDE.md')) || existsSync(join(cwd, '.claude'));
+}
+
+async function autoUpdatePatterns(): Promise<void> {
+  // Only auto-update if this is a CodeBakers project
+  if (!isCodeBakersProject()) return;
+
+  // Only auto-update if user has valid access
+  if (!hasValidAccess()) return;
+
+  const localVersion = getLocalPatternVersion();
+
+  // Check if we have a valid cached result first (fast path)
+  const cached = getCachedPatternInfo();
+  if (cached) {
+    // If local matches latest, nothing to do
+    if (localVersion === cached.latestVersion) return;
+    // If we know there's an update but haven't updated yet, do it now
+    if (localVersion !== cached.latestVersion) {
+      await performPatternUpdate(cached.latestVersion);
+    }
+    return;
+  }
+
+  // Fetch from server to check for updates (with timeout)
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+
+    const apiUrl = getApiUrl();
+    const apiKey = getApiKey();
+    const trial = getTrialState();
+
+    // Build authorization header
+    let authHeader = '';
+    if (apiKey) {
+      authHeader = `Bearer ${apiKey}`;
+    } else if (trial?.trialId) {
+      authHeader = `Trial ${trial.trialId}`;
+    }
+
+    if (!authHeader) return;
+
+    // First, check the version endpoint (lightweight)
+    const versionResponse = await fetch(`${apiUrl}/api/content/version`, {
+      method: 'GET',
+      headers: {
+        'Authorization': authHeader,
+      },
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+
+    if (versionResponse.ok) {
+      const versionData = await versionResponse.json();
+      const serverVersion = versionData.version;
+
+      // Cache the version info
+      setCachedPatternInfo(serverVersion);
+
+      // If local version is different, update
+      if (localVersion !== serverVersion) {
+        await performPatternUpdate(serverVersion);
+      }
+    }
+  } catch {
+    // Silently fail - don't block CLI for pattern check
+  }
+}
+
+async function performPatternUpdate(targetVersion: string): Promise<void> {
+  const cwd = process.cwd();
+  const claudeMdPath = join(cwd, 'CLAUDE.md');
+  const claudeDir = join(cwd, '.claude');
+
+  try {
+    const apiUrl = getApiUrl();
+    const apiKey = getApiKey();
+    const trial = getTrialState();
+
+    let authHeader = '';
+    if (apiKey) {
+      authHeader = `Bearer ${apiKey}`;
+    } else if (trial?.trialId) {
+      authHeader = `Trial ${trial.trialId}`;
+    }
+
+    if (!authHeader) return;
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10000);
+
+    const response = await fetch(`${apiUrl}/api/content`, {
+      method: 'GET',
+      headers: {
+        'Authorization': authHeader,
+      },
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+
+    if (!response.ok) return;
+
+    const content: ContentResponse = await response.json();
+
+    // Update CLAUDE.md
+    if (content.router) {
+      writeFileSync(claudeMdPath, content.router);
+    }
+
+    // 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);
+      }
+    }
+
+    // Write version file
+    const moduleCount = Object.keys(content.modules || {}).length;
+    const versionInfo: PatternVersionInfo = {
+      version: content.version,
+      moduleCount,
+      updatedAt: new Date().toISOString(),
+      cliVersion: getCliVersion(),
+    };
+    writeFileSync(join(claudeDir, '.version.json'), JSON.stringify(versionInfo, null, 2));
+
+    // Show subtle notification
+    console.log(chalk.green(`  ✓ Patterns auto-updated to v${content.version} (${moduleCount} modules)\n`));
+
+  } catch {
+    // Silently fail - don't block the user
+  }
+}
+
 // Show welcome message when no command is provided
 function showWelcome(): void {
   console.log(chalk.blue(`
@@ -127,7 +321,7 @@ const program = new Command();
 program
   .name('codebakers')
   .description('CodeBakers CLI - Production patterns for AI-assisted development')
-  .version('3.2.0');
+  .version('3.3.0');
 
 // Zero-friction trial entry (no signup required)
 program
@@ -282,7 +476,11 @@ program
 
 // Add update check hook (runs before every command)
 program.hook('preAction', async () => {
-  await checkForUpdatesInBackground();
+  // Run CLI update check and pattern auto-update in parallel
+  await Promise.all([
+    checkForUpdatesInBackground(),
+    autoUpdatePatterns(),
+  ]);
 });
 
 // Show welcome if no command provided

package/src/lib/api.ts

@@ -155,29 +155,108 @@ export function getCliVersion(): string {
 
 /**
  * Check if there's a newer version of the CLI available
+ * Uses the CodeBakers API for controlled rollouts (only recommends stable, tested versions)
+ * Falls back to npm registry if API is unavailable
  */
 export async function checkForUpdates(): Promise<{
   currentVersion: string;
   latestVersion: string;
   updateAvailable: boolean;
+  autoUpdateEnabled: boolean;
+  autoUpdateVersion: string | null;
+  isBlocked: boolean;
 } | null> {
   try {
     const currentVersion = getCliVersion();
-    const response = await fetch('https://registry.npmjs.org/@codebakers/cli/latest', {
+    const apiUrl = getApiUrl();
+
+    // First, try the CodeBakers API for controlled rollout info
+    try {
+      const response = await fetch(`${apiUrl}/api/cli/version`, {
+        headers: {
+          'Accept': 'application/json',
+          'X-CLI-Version': currentVersion,
+        },
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        const latestVersion = data.stableVersion || data.latestVersion;
+        const autoUpdateVersion = data.autoUpdateVersion;
+        const isBlocked = data.isBlocked === true;
+
+        return {
+          currentVersion,
+          latestVersion,
+          updateAvailable: latestVersion !== currentVersion,
+          autoUpdateEnabled: data.autoUpdateEnabled === true,
+          autoUpdateVersion: autoUpdateVersion || null,
+          isBlocked,
+        };
+      }
+    } catch {
+      // API unavailable, fall through to npm
+    }
+
+    // Fallback: check npm registry directly
+    const npmResponse = await fetch('https://registry.npmjs.org/@codebakers/cli/latest', {
       headers: { 'Accept': 'application/json' },
     });
 
-    if (!response.ok) return null;
+    if (!npmResponse.ok) return null;
 
-    const data = await response.json();
-    const latestVersion = data.version;
+    const npmData = await npmResponse.json();
+    const latestVersion = npmData.version;
 
     return {
       currentVersion,
       latestVersion,
       updateAvailable: currentVersion !== latestVersion,
+      autoUpdateEnabled: false, // npm fallback doesn't have controlled rollout
+      autoUpdateVersion: null,
+      isBlocked: false,
     };
   } catch {
     return null;
   }
 }
+
+/**
+ * Report a CLI error to the server for tracking
+ * This helps identify problematic versions for blocking
+ */
+export async function reportCliError(
+  errorType: string,
+  errorMessage: string,
+  context?: Record<string, unknown>
+): Promise<void> {
+  try {
+    const apiUrl = getApiUrl();
+    const cliVersion = getCliVersion();
+
+    // Fire and forget - don't block on error reporting
+    fetch(`${apiUrl}/api/cli/error-report`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-CLI-Version': cliVersion,
+      },
+      body: JSON.stringify({
+        cliVersion,
+        errorType,
+        errorMessage,
+        stackTrace: context?.stack,
+        context: JSON.stringify({
+          ...context,
+          nodeVersion: process.version,
+          platform: process.platform,
+          arch: process.arch,
+        }),
+      }),
+    }).catch(() => {
+      // Ignore reporting failures
+    });
+  } catch {
+    // Never fail on error reporting
+  }
+}

package/src/mcp/server.ts

@@ -108,6 +108,31 @@ class CodeBakersServer {
     return {};
   }
 
+  /**
+   * Confirm download to server (non-blocking analytics)
+   */
+  private async confirmDownload(version: string, moduleCount: number): Promise<void> {
+    try {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        ...this.getAuthHeaders(),
+      };
+
+      await fetch(`${this.apiUrl}/api/content/confirm`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          version,
+          moduleCount,
+          cliVersion: getCliVersion(),
+          command: 'auto-update',
+        }),
+      });
+    } catch {
+      // Silently ignore - this is just for analytics
+    }
+  }
+
   /**
    * Automatically check for and apply pattern updates
    * Runs silently in background - no user intervention needed
@@ -213,6 +238,21 @@ class CodeBakersServer {
       };
       fs.writeFileSync(versionPath, JSON.stringify(versionInfo, null, 2));
 
+      // Write notification file for AI to read and show to user
+      const notificationPath = path.join(claudeDir, '.update-notification.json');
+      const notification = {
+        type: 'patterns_updated',
+        previousVersion: installed?.version || 'unknown',
+        newVersion: content.version,
+        moduleCount,
+        updatedAt: new Date().toISOString(),
+        message: `CodeBakers patterns have been automatically updated from v${installed?.version || 'unknown'} to v${content.version} (${moduleCount} modules). Your AI tools now have the latest production patterns.`,
+      };
+      fs.writeFileSync(notificationPath, JSON.stringify(notification, null, 2));
+
+      // Confirm to server (non-blocking, fire-and-forget)
+      this.confirmDownload(content.version, moduleCount).catch(() => {});
+
       this.autoUpdateChecked = true;
       this.autoUpdateInProgress = false;
 
@@ -984,6 +1024,15 @@ class CodeBakersServer {
             required: ['request'],
           },
         },
+        {
+          name: 'check_update_notification',
+          description:
+            'ALWAYS CALL THIS AT THE START OF EACH SESSION. Checks if CodeBakers patterns were recently auto-updated and returns a notification message to show the user. If an update occurred, tell the user about it with the returned message. After showing, the notification is cleared.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {},
+          },
+        },
       ],
     }));
 
@@ -1111,6 +1160,9 @@ class CodeBakersServer {
         case 'add_api_route':
           return this.handleAddApiRoute(args as { request: string });
 
+        case 'check_update_notification':
+          return this.handleCheckUpdateNotification();
+
         default:
           throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
       }
@@ -4839,6 +4891,44 @@ export default ${asyncKeyword}function ${pageName}Page() {${authCheck}
     };
   }
 
+  /**
+   * Check for update notifications and return message to show user
+   */
+  private async handleCheckUpdateNotification() {
+    const cwd = process.cwd();
+    const notificationPath = path.join(cwd, '.claude', '.update-notification.json');
+
+    try {
+      if (!fs.existsSync(notificationPath)) {
+        return {
+          content: [{
+            type: 'text' as const,
+            text: 'No update notification.',
+          }],
+        };
+      }
+
+      const notification = JSON.parse(fs.readFileSync(notificationPath, 'utf-8'));
+
+      // Delete the notification file after reading (so it only shows once)
+      fs.unlinkSync(notificationPath);
+
+      return {
+        content: [{
+          type: 'text' as const,
+          text: `🍪 **CodeBakers Update**\n\n${notification.message}\n\n**Previous version:** ${notification.previousVersion}\n**New version:** ${notification.newVersion}\n**Modules:** ${notification.moduleCount}\n**Updated:** ${new Date(notification.updatedAt).toLocaleString()}`,
+        }],
+      };
+    } catch {
+      return {
+        content: [{
+          type: 'text' as const,
+          text: 'No update notification.',
+        }],
+      };
+    }
+  }
+
   private parseApiRouteRequest(request: string): {
     success: boolean;
     routeName?: string;