@codebakers/cli 3.3.0 → 3.3.2

package/src/index.ts

@@ -23,6 +23,7 @@ import { go } from './commands/go.js';
 import { extend } from './commands/extend.js';
 import { billing } from './commands/billing.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';
 
@@ -30,37 +31,37 @@ import { join } from 'path';
 // Automatic Update Notification
 // ============================================
 
-const CURRENT_VERSION = '3.3.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 {
@@ -68,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        │
   │                                                         │

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/lib/stats.ts

@@ -0,0 +1,10 @@
+/**
+ * Central configuration for CodeBakers CLI stats.
+ * Keep in sync with server-side src/lib/stats.ts
+ */
+
+export const CODEBAKERS_STATS = {
+  moduleCount: 59,
+  totalLinesDisplay: '50K+',
+  patternCount: 150,
+} as const;

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,29 @@ 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: {},
+          },
+        },
+        {
+          name: 'update_patterns',
+          description:
+            'Download and update CodeBakers pattern files from the server. Use when user says "upgrade codebakers", "update patterns", "download latest patterns", "sync codebakers", or when patterns are missing or outdated. This tool fetches the latest CLAUDE.md router and all .claude/ module files from the server and writes them to disk.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              force: {
+                type: 'boolean',
+                description: 'Force update even if already at latest version (default: false)',
+              },
+            },
+          },
+        },
       ],
     }));
 
@@ -1111,6 +1174,12 @@ class CodeBakersServer {
         case 'add_api_route':
           return this.handleAddApiRoute(args as { request: string });
 
+        case 'check_update_notification':
+          return this.handleCheckUpdateNotification();
+
+        case 'update_patterns':
+          return this.handleUpdatePatterns(args as { force?: boolean });
+
         default:
           throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
       }
@@ -4839,6 +4908,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;
@@ -5041,6 +5148,161 @@ ${handlers.join('\n')}
 `;
   }
 
+  /**
+   * Download and update CodeBakers patterns from server
+   * This is the MCP equivalent of the `codebakers upgrade` CLI command
+   */
+  private async handleUpdatePatterns(args: { force?: boolean }) {
+    const { force = false } = args;
+    const cwd = process.cwd();
+    const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+    const claudeDir = path.join(cwd, '.claude');
+    const versionPath = path.join(claudeDir, '.version.json');
+
+    let response = `# 🔄 CodeBakers Pattern Update\n\n`;
+
+    try {
+      // Check current version
+      let currentVersion: string | null = null;
+      let currentModuleCount = 0;
+
+      if (fs.existsSync(versionPath)) {
+        try {
+          const versionInfo = JSON.parse(fs.readFileSync(versionPath, 'utf-8'));
+          currentVersion = versionInfo.version;
+          currentModuleCount = versionInfo.moduleCount || 0;
+        } catch {
+          // Ignore parse errors
+        }
+      }
+
+      // Count current modules
+      if (fs.existsSync(claudeDir)) {
+        try {
+          const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.md'));
+          currentModuleCount = files.length;
+        } catch {
+          // Ignore read errors
+        }
+      }
+
+      response += `## Current Status\n`;
+      response += `- Version: ${currentVersion || 'Unknown'}\n`;
+      response += `- Modules: ${currentModuleCount}\n\n`;
+
+      // Fetch latest version info first
+      const versionResponse = await fetch(`${this.apiUrl}/api/content/version`, {
+        headers: this.getAuthHeaders(),
+      });
+
+      if (!versionResponse.ok) {
+        throw new Error('Failed to check version from server');
+      }
+
+      const latestInfo = await versionResponse.json();
+      const latestVersion = latestInfo.version;
+      const latestModuleCount = latestInfo.moduleCount || 0;
+
+      response += `## Server Status\n`;
+      response += `- Latest Version: ${latestVersion}\n`;
+      response += `- Available Modules: ${latestModuleCount}\n\n`;
+
+      // Check if update needed
+      const needsUpdate = force || !currentVersion || currentVersion !== latestVersion || currentModuleCount < latestModuleCount;
+
+      if (!needsUpdate) {
+        response += `✅ **Already up to date!**\n\n`;
+        response += `Your patterns are current (v${latestVersion} with ${latestModuleCount} modules).\n`;
+        response += `Use \`force: true\` to re-download anyway.\n`;
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: response,
+          }],
+        };
+      }
+
+      response += `## Downloading Updates...\n\n`;
+
+      // Fetch full content
+      const contentResponse = await fetch(`${this.apiUrl}/api/content`, {
+        headers: this.getAuthHeaders(),
+      });
+
+      if (!contentResponse.ok) {
+        const error = await contentResponse.json().catch(() => ({}));
+        throw new Error(error.error || error.message || 'Failed to fetch patterns');
+      }
+
+      const content = await contentResponse.json();
+      const moduleCount = content.modules ? Object.keys(content.modules).length : 0;
+
+      // Create .claude directory if needed
+      if (!fs.existsSync(claudeDir)) {
+        fs.mkdirSync(claudeDir, { recursive: true });
+        response += `✓ Created .claude/ directory\n`;
+      }
+
+      // Update CLAUDE.md router
+      if (content.router) {
+        fs.writeFileSync(claudeMdPath, content.router);
+        response += `✓ Updated CLAUDE.md (router)\n`;
+      }
+
+      // Update all modules
+      if (content.modules && moduleCount > 0) {
+        for (const [name, data] of Object.entries(content.modules)) {
+          fs.writeFileSync(path.join(claudeDir, name), data as string);
+        }
+        response += `✓ Updated ${moduleCount} modules in .claude/\n`;
+      }
+
+      // Save version info
+      const newVersionInfo = {
+        version: content.version || latestVersion,
+        moduleCount,
+        installedAt: currentVersion ? undefined : new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        cliVersion: getCliVersion(),
+      };
+      fs.writeFileSync(versionPath, JSON.stringify(newVersionInfo, null, 2));
+      response += `✓ Saved version info\n`;
+
+      // Confirm download to server (non-blocking analytics)
+      this.confirmDownload(content.version || latestVersion, moduleCount).catch(() => {});
+
+      response += `\n## ✅ Update Complete!\n\n`;
+      response += `- **From:** v${currentVersion || 'none'} (${currentModuleCount} modules)\n`;
+      response += `- **To:** v${content.version || latestVersion} (${moduleCount} modules)\n\n`;
+
+      if (moduleCount > currentModuleCount) {
+        response += `🆕 **${moduleCount - currentModuleCount} new modules added!**\n\n`;
+      }
+
+      response += `Your patterns are now up to date. The new patterns will be used in your next response.\n`;
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      response += `\n## ❌ Update Failed\n\n`;
+      response += `Error: ${message}\n\n`;
+
+      if (message.includes('401') || message.includes('Invalid') || message.includes('expired')) {
+        response += `Your API key may be invalid or expired.\n`;
+        response += `Run \`codebakers setup\` in terminal to reconfigure.\n`;
+      } else {
+        response += `Please try again or run \`codebakers upgrade\` in terminal.\n`;
+      }
+    }
+
+    return {
+      content: [{
+        type: 'text' as const,
+        text: response,
+      }],
+    };
+  }
+
   async run(): Promise<void> {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);