@codebakers/cli 3.3.0 → 3.3.1

package/dist/commands/go.js

@@ -24,6 +24,43 @@ function prompt(question) {
         });
     });
 }
+/**
+ * Get CLI version from package.json
+ */
+function getCliVersion() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const pkg = require('../../package.json');
+        return pkg.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/**
+ * Confirm download to server (non-blocking, fire-and-forget)
+ */
+async function confirmDownload(apiUrl, auth, data) {
+    try {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (auth.apiKey) {
+            headers['Authorization'] = `Bearer ${auth.apiKey}`;
+        }
+        if (auth.trialId) {
+            headers['X-Trial-ID'] = auth.trialId;
+        }
+        await fetch(`${apiUrl}/api/content/confirm`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(data),
+        });
+    }
+    catch {
+        // Silently ignore - this is just for analytics
+    }
+}
 function log(message, options) {
     if (options?.verbose) {
         console.log(chalk_1.default.gray(`  [verbose] ${message}`));
@@ -264,7 +301,7 @@ async function installPatternsWithApiKey(apiKey, options = {}) {
         log('Response OK, parsing JSON...', options);
         const content = await response.json();
         log(`Received version: ${content.version}, modules: ${Object.keys(content.modules || {}).length}`, options);
-        await writePatternFiles(cwd, content, spinner, options);
+        await writePatternFiles(cwd, content, spinner, options, { apiKey });
     }
     catch (error) {
         log(`Error: ${error instanceof Error ? error.message : String(error)}`, options);
@@ -305,12 +342,12 @@ async function installPatterns(trialId, options = {}) {
             }
             const content = await publicResponse.json();
             log(`Received version: ${content.version}, modules: ${Object.keys(content.modules || {}).length}`, options);
-            await writePatternFiles(cwd, content, spinner, options);
+            await writePatternFiles(cwd, content, spinner, options, { trialId });
             return;
         }
         const content = await response.json();
         log(`Received version: ${content.version}, modules: ${Object.keys(content.modules || {}).length}`, options);
-        await writePatternFiles(cwd, content, spinner, options);
+        await writePatternFiles(cwd, content, spinner, options, { trialId });
     }
     catch (error) {
         log(`Error: ${error instanceof Error ? error.message : String(error)}`, options);
@@ -318,7 +355,7 @@ async function installPatterns(trialId, options = {}) {
         console.log(chalk_1.default.gray('  Patterns will be available via MCP tools.\n'));
     }
 }
-async function writePatternFiles(cwd, content, spinner, options = {}) {
+async function writePatternFiles(cwd, content, spinner, options = {}, auth) {
     log(`Writing pattern files to ${cwd}...`, options);
     // Check if patterns already exist
     const claudeMdPath = (0, path_1.join)(cwd, 'CLAUDE.md');
@@ -331,7 +368,8 @@ async function writePatternFiles(cwd, content, spinner, options = {}) {
         (0, fs_1.writeFileSync)(claudeMdPath, content.router);
     }
     // Write pattern modules to .claude/
-    if (content.modules && Object.keys(content.modules).length > 0) {
+    const moduleCount = Object.keys(content.modules || {}).length;
+    if (content.modules && moduleCount > 0) {
         const modulesDir = (0, path_1.join)(cwd, '.claude');
         if (!(0, fs_1.existsSync)(modulesDir)) {
             (0, fs_1.mkdirSync)(modulesDir, { recursive: true });
@@ -350,5 +388,15 @@ async function writePatternFiles(cwd, content, spinner, options = {}) {
         }
     }
     spinner.succeed(`CodeBakers patterns installed (v${content.version})`);
-    console.log(chalk_1.default.gray(`  ${Object.keys(content.modules || {}).length} pattern modules ready\n`));
+    console.log(chalk_1.default.gray(`  ${moduleCount} pattern modules ready\n`));
+    // Confirm download to server (non-blocking)
+    if (auth) {
+        const apiUrl = (0, config_js_1.getApiUrl)();
+        confirmDownload(apiUrl, auth, {
+            version: content.version,
+            moduleCount,
+            cliVersion: getCliVersion(),
+            command: 'go',
+        }).catch(() => { }); // Silently ignore
+    }
 }

package/dist/commands/upgrade.js

@@ -10,6 +10,24 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const config_js_1 = require("../config.js");
 const api_js_1 = require("../lib/api.js");
+/**
+ * Confirm download to server (non-blocking, fire-and-forget)
+ */
+async function confirmDownload(apiUrl, apiKey, data) {
+    try {
+        await fetch(`${apiUrl}/api/content/confirm`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(data),
+        });
+    }
+    catch {
+        // Silently ignore - this is just for analytics
+    }
+}
 /**
  * Upgrade CodeBakers patterns to the latest version
  */
@@ -83,6 +101,13 @@ async function upgrade() {
         };
         (0, fs_1.writeFileSync)((0, path_1.join)(claudeDir, '.version.json'), JSON.stringify(versionInfo, null, 2));
         console.log(chalk_1.default.green('  ✓ Version info saved'));
+        // Confirm download to server (non-blocking)
+        confirmDownload(apiUrl, apiKey, {
+            version: content.version,
+            moduleCount,
+            cliVersion: (0, api_js_1.getCliVersion)(),
+            command: 'upgrade',
+        }).catch(() => { }); // Silently ignore confirmation failures
         console.log(chalk_1.default.green(`\n  ✅ Upgraded to patterns v${content.version}!\n`));
         // Show what's new if available
         console.log(chalk_1.default.gray('  Changes take effect in your next AI session.\n'));

package/dist/index.js

@@ -27,36 +27,39 @@ const go_js_1 = require("./commands/go.js");
 const extend_js_1 = require("./commands/extend.js");
 const billing_js_1 = require("./commands/billing.js");
 const config_js_2 = require("./config.js");
+const api_js_1 = require("./lib/api.js");
 const fs_1 = require("fs");
 const path_1 = require("path");
 // ============================================
 // Automatic Update Notification
 // ============================================
-const CURRENT_VERSION = '3.3.0';
+const CURRENT_VERSION = '3.3.1';
 async function checkForUpdatesInBackground() {
     // Check if we have a valid cached result first (fast path)
     const cached = (0, config_js_2.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,
-        });
-        clearTimeout(timeout);
-        if (response.ok) {
-            const data = await response.json();
-            const latestVersion = data.version;
-            (0, config_js_2.setCachedUpdateInfo)(latestVersion);
-            if (latestVersion !== CURRENT_VERSION) {
-                showUpdateBanner(CURRENT_VERSION, latestVersion);
+        const updateInfo = await (0, api_js_1.checkForUpdates)();
+        if (updateInfo) {
+            (0, config_js_2.setCachedUpdateInfo)(updateInfo.latestVersion);
+            // Show blocked version warning first (critical)
+            if (updateInfo.isBlocked) {
+                showBlockedVersionWarning(updateInfo.currentVersion, updateInfo.latestVersion);
+                return;
+            }
+            // 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);
             }
         }
     }
@@ -64,11 +67,26 @@ async function checkForUpdatesInBackground() {
         // Silently fail - don't block CLI for update check
     }
 }
-function showUpdateBanner(currentVersion, latestVersion) {
+function showBlockedVersionWarning(currentVersion, recommendedVersion) {
+    console.log(chalk_1.default.red(`
+  ╭─────────────────────────────────────────────────────────╮
+  │                                                         │
+  │   ${chalk_1.default.bold('⚠️  VERSION BLOCKED')}                                   │
+  │                                                         │
+  │   Your CLI version ${chalk_1.default.gray(currentVersion)} has critical issues.       │
+  │   Please update immediately to ${chalk_1.default.green(recommendedVersion)}                   │
+  │                                                         │
+  │   Run ${chalk_1.default.cyan('npm i -g @codebakers/cli@latest')} to update        │
+  │                                                         │
+  ╰─────────────────────────────────────────────────────────╯
+  `));
+}
+function showUpdateBanner(currentVersion, latestVersion, isRecommended) {
+    const updateType = isRecommended ? chalk_1.default.green('Recommended update') : chalk_1.default.bold('Update available!');
     console.log(chalk_1.default.yellow(`
   ╭─────────────────────────────────────────────────────────╮
   │                                                         │
-  │   ${chalk_1.default.bold('Update available!')} ${chalk_1.default.gray(currentVersion)} → ${chalk_1.default.green(latestVersion)}                     │
+  │   ${updateType} ${chalk_1.default.gray(currentVersion)} → ${chalk_1.default.green(latestVersion)}                     │
   │                                                         │
   │   Run ${chalk_1.default.cyan('npm i -g @codebakers/cli@latest')} to update        │
   │                                                         │

package/dist/lib/api.d.ts

@@ -37,9 +37,19 @@ export declare function checkApiKeyValidity(): Promise<{
 export declare 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 declare function checkForUpdates(): Promise<{
     currentVersion: string;
     latestVersion: string;
     updateAvailable: boolean;
+    autoUpdateEnabled: boolean;
+    autoUpdateVersion: string | null;
+    isBlocked: boolean;
 } | null>;
+/**
+ * Report a CLI error to the server for tracking
+ * This helps identify problematic versions for blocking
+ */
+export declare function reportCliError(errorType: string, errorMessage: string, context?: Record<string, unknown>): Promise<void>;

package/dist/lib/api.js

@@ -7,6 +7,7 @@ exports.formatApiError = formatApiError;
 exports.checkApiKeyValidity = checkApiKeyValidity;
 exports.getCliVersion = getCliVersion;
 exports.checkForUpdates = checkForUpdates;
+exports.reportCliError = reportCliError;
 const config_js_1 = require("../config.js");
 /**
  * Validate an API key format
@@ -136,24 +137,92 @@ function getCliVersion() {
 }
 /**
  * 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
  */
 async function checkForUpdates() {
     try {
         const currentVersion = getCliVersion();
-        const response = await fetch('https://registry.npmjs.org/@codebakers/cli/latest', {
+        const apiUrl = (0, config_js_1.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)
+        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
+ */
+async function reportCliError(errorType, errorMessage, context) {
+    try {
+        const apiUrl = (0, config_js_1.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/dist/mcp/server.js

@@ -89,6 +89,30 @@ class CodeBakersServer {
         }
         return {};
     }
+    /**
+     * Confirm download to server (non-blocking analytics)
+     */
+    async confirmDownload(version, moduleCount) {
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+                ...this.getAuthHeaders(),
+            };
+            await fetch(`${this.apiUrl}/api/content/confirm`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    version,
+                    moduleCount,
+                    cliVersion: (0, api_js_1.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
@@ -178,6 +202,19 @@ class CodeBakersServer {
                 cliVersion: (0, api_js_1.getCliVersion)(),
             };
             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;
             // Log success (visible in MCP logs)
@@ -902,6 +939,14 @@ 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',
+                        properties: {},
+                    },
+                },
             ],
         }));
         // Handle tool calls
@@ -987,6 +1032,8 @@ class CodeBakersServer {
                     return this.handleAddPage(args);
                 case 'add_api_route':
                     return this.handleAddApiRoute(args);
+                case 'check_update_notification':
+                    return this.handleCheckUpdateNotification();
                 default:
                     throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
             }
@@ -4266,6 +4313,40 @@ export default ${asyncKeyword}function ${pageName}Page() {${authCheck}
                 }],
         };
     }
+    /**
+     * Check for update notifications and return message to show user
+     */
+    async handleCheckUpdateNotification() {
+        const cwd = process.cwd();
+        const notificationPath = path.join(cwd, '.claude', '.update-notification.json');
+        try {
+            if (!fs.existsSync(notificationPath)) {
+                return {
+                    content: [{
+                            type: 'text',
+                            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',
+                        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',
+                        text: 'No update notification.',
+                    }],
+            };
+        }
+    }
     parseApiRouteRequest(request) {
         const lower = request.toLowerCase();
         // Detect webhook

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebakers/cli",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "description": "CodeBakers CLI - Production patterns for AI-assisted development",
   "main": "dist/index.js",
   "bin": {
@@ -15,7 +15,8 @@
     "mcp": "tsx src/mcp/server.ts",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "postpublish": "node scripts/register-version.js"
   },
   "keywords": [
     "codebakers",

package/scripts/register-version.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+/**
+ * Automatically registers a new CLI version with the CodeBakers server
+ * Called automatically after npm publish via postpublish hook
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const API_URL = process.env.CODEBAKERS_API_URL || 'https://codebakers.ai';
+const ADMIN_API_KEY = process.env.CODEBAKERS_ADMIN_KEY;
+
+async function registerVersion() {
+  // Read version from package.json
+  const packagePath = path.join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+  const version = pkg.version;
+
+  console.log(`\n📦 Registering CLI version ${version} with CodeBakers server...\n`);
+
+  if (!ADMIN_API_KEY) {
+    console.log('⚠️  CODEBAKERS_ADMIN_KEY not set - skipping auto-registration');
+    console.log('   You can manually add this version in Admin → CLI Versions\n');
+    return;
+  }
+
+  try {
+    // Read changelog if it exists
+    let changelog = '';
+    const changelogPath = path.join(__dirname, '..', 'CHANGELOG.md');
+    if (fs.existsSync(changelogPath)) {
+      const content = fs.readFileSync(changelogPath, 'utf-8');
+      // Extract the latest version's changes
+      const match = content.match(/## \[?\d+\.\d+\.\d+\]?[^\n]*\n([\s\S]*?)(?=## \[?\d+\.\d+\.\d+|$)/);
+      if (match) {
+        changelog = match[1].trim().slice(0, 2000); // Limit length
+      }
+    }
+
+    const response = await fetch(`${API_URL}/api/cli/register-version`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${ADMIN_API_KEY}`,
+      },
+      body: JSON.stringify({
+        version,
+        npmTag: 'latest',
+        changelog,
+        minNodeVersion: '18',
+      }),
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      console.log(`✅ Version ${version} registered successfully!`);
+      console.log(`   Status: ${data.data?.version?.status || 'draft'}`);
+      console.log(`\n   Next steps:`);
+      console.log(`   1. Test the version`);
+      console.log(`   2. Go to Admin → CLI Versions`);
+      console.log(`   3. Promote to "testing" then "stable"`);
+      console.log(`   4. Enable auto-update when ready\n`);
+    } else {
+      const error = await response.json().catch(() => ({}));
+      if (error.error?.includes('already exists')) {
+        console.log(`ℹ️  Version ${version} already registered\n`);
+      } else {
+        console.log(`⚠️  Failed to register: ${error.error || response.statusText}`);
+        console.log(`   You can manually add this version in Admin → CLI Versions\n`);
+      }
+    }
+  } catch (error) {
+    console.log(`⚠️  Could not reach server: ${error.message}`);
+    console.log(`   You can manually add this version in Admin → CLI Versions\n`);
+  }
+}
+
+registerVersion();

package/src/commands/go.ts

@@ -39,6 +39,57 @@ interface GoOptions {
   verbose?: boolean;
 }
 
+interface ConfirmData {
+  version: string;
+  moduleCount: number;
+  cliVersion?: string;
+  command: string;
+  projectName?: string;
+}
+
+interface AuthInfo {
+  apiKey?: string;
+  trialId?: string;
+}
+
+/**
+ * Get CLI version from package.json
+ */
+function getCliVersion(): string {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const pkg = require('../../package.json');
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Confirm download to server (non-blocking, fire-and-forget)
+ */
+async function confirmDownload(apiUrl: string, auth: AuthInfo, data: ConfirmData): Promise<void> {
+  try {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+    if (auth.apiKey) {
+      headers['Authorization'] = `Bearer ${auth.apiKey}`;
+    }
+    if (auth.trialId) {
+      headers['X-Trial-ID'] = auth.trialId;
+    }
+
+    await fetch(`${apiUrl}/api/content/confirm`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(data),
+    });
+  } catch {
+    // Silently ignore - this is just for analytics
+  }
+}
+
 function log(message: string, options?: GoOptions): void {
   if (options?.verbose) {
     console.log(chalk.gray(`  [verbose] ${message}`));
@@ -317,7 +368,7 @@ async function installPatternsWithApiKey(apiKey: string, options: GoOptions = {}
     log('Response OK, parsing JSON...', options);
     const content: ContentResponse = await response.json();
     log(`Received version: ${content.version}, modules: ${Object.keys(content.modules || {}).length}`, options);
-    await writePatternFiles(cwd, content, spinner, options);
+    await writePatternFiles(cwd, content, spinner, options, { apiKey });
 
   } catch (error) {
     log(`Error: ${error instanceof Error ? error.message : String(error)}`, options);
@@ -363,13 +414,13 @@ async function installPatterns(trialId: string, options: GoOptions = {}): Promis
 
       const content: ContentResponse = await publicResponse.json();
       log(`Received version: ${content.version}, modules: ${Object.keys(content.modules || {}).length}`, options);
-      await writePatternFiles(cwd, content, spinner, options);
+      await writePatternFiles(cwd, content, spinner, options, { trialId });
       return;
     }
 
     const content: ContentResponse = await response.json();
     log(`Received version: ${content.version}, modules: ${Object.keys(content.modules || {}).length}`, options);
-    await writePatternFiles(cwd, content, spinner, options);
+    await writePatternFiles(cwd, content, spinner, options, { trialId });
 
   } catch (error) {
     log(`Error: ${error instanceof Error ? error.message : String(error)}`, options);
@@ -378,7 +429,13 @@ async function installPatterns(trialId: string, options: GoOptions = {}): Promis
   }
 }
 
-async function writePatternFiles(cwd: string, content: ContentResponse, spinner: ReturnType<typeof ora>, options: GoOptions = {}): Promise<void> {
+async function writePatternFiles(
+  cwd: string,
+  content: ContentResponse,
+  spinner: ReturnType<typeof ora>,
+  options: GoOptions = {},
+  auth?: AuthInfo
+): Promise<void> {
   log(`Writing pattern files to ${cwd}...`, options);
   // Check if patterns already exist
   const claudeMdPath = join(cwd, 'CLAUDE.md');
@@ -393,7 +450,8 @@ async function writePatternFiles(cwd: string, content: ContentResponse, spinner:
   }
 
   // Write pattern modules to .claude/
-  if (content.modules && Object.keys(content.modules).length > 0) {
+  const moduleCount = Object.keys(content.modules || {}).length;
+  if (content.modules && moduleCount > 0) {
     const modulesDir = join(cwd, '.claude');
     if (!existsSync(modulesDir)) {
       mkdirSync(modulesDir, { recursive: true });
@@ -415,5 +473,16 @@ async function writePatternFiles(cwd: string, content: ContentResponse, spinner:
   }
 
   spinner.succeed(`CodeBakers patterns installed (v${content.version})`);
-  console.log(chalk.gray(`  ${Object.keys(content.modules || {}).length} pattern modules ready\n`));
+  console.log(chalk.gray(`  ${moduleCount} pattern modules ready\n`));
+
+  // Confirm download to server (non-blocking)
+  if (auth) {
+    const apiUrl = getApiUrl();
+    confirmDownload(apiUrl, auth, {
+      version: content.version,
+      moduleCount,
+      cliVersion: getCliVersion(),
+      command: 'go',
+    }).catch(() => {}); // Silently ignore
+  }
 }

package/src/commands/upgrade.ts

@@ -11,6 +11,32 @@ interface ContentResponse {
   modules: Record<string, string>;
 }
 
+interface ConfirmData {
+  version: string;
+  moduleCount: number;
+  cliVersion: string;
+  command: string;
+  projectName?: string;
+}
+
+/**
+ * Confirm download to server (non-blocking, fire-and-forget)
+ */
+async function confirmDownload(apiUrl: string, apiKey: string, data: ConfirmData): Promise<void> {
+  try {
+    await fetch(`${apiUrl}/api/content/confirm`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify(data),
+    });
+  } catch {
+    // Silently ignore - this is just for analytics
+  }
+}
+
 /**
  * Upgrade CodeBakers patterns to the latest version
  */
@@ -101,6 +127,14 @@ export async function upgrade(): Promise<void> {
     writeFileSync(join(claudeDir, '.version.json'), JSON.stringify(versionInfo, null, 2));
     console.log(chalk.green('  ✓ Version info saved'));
 
+    // Confirm download to server (non-blocking)
+    confirmDownload(apiUrl, apiKey, {
+      version: content.version,
+      moduleCount,
+      cliVersion: getCliVersion(),
+      command: 'upgrade',
+    }).catch(() => {}); // Silently ignore confirmation failures
+
     console.log(chalk.green(`\n  ✅ Upgraded to patterns v${content.version}!\n`));
 
     // Show what's new if available

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/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;