@codebakers/cli 3.2.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/config.d.ts

@@ -45,6 +45,8 @@ interface ConfigSchema {
     trial: TrialState | null;
     lastUpdateCheck: string | null;
     latestKnownVersion: string | null;
+    lastPatternCheck: string | null;
+    latestPatternVersion: string | null;
 }
 export declare function getApiKey(): string | null;
 export declare function setApiKey(key: string): void;
@@ -122,4 +124,19 @@ export declare function setCachedUpdateInfo(latestVersion: string): void;
  * Get the current CLI version from package.json
  */
 export declare function getCliVersion(): string;
+/**
+ * Get cached pattern version info if still valid (within 6 hours)
+ */
+export declare function getCachedPatternInfo(): {
+    latestVersion: string;
+    checkedAt: string;
+} | null;
+/**
+ * Cache the latest pattern version from server
+ */
+export declare function setCachedPatternInfo(latestVersion: string): void;
+/**
+ * Clear pattern cache to force a fresh check
+ */
+export declare function clearPatternCache(): void;
 export {};

package/dist/config.js

@@ -35,6 +35,9 @@ exports.getAuthMode = getAuthMode;
 exports.getCachedUpdateInfo = getCachedUpdateInfo;
 exports.setCachedUpdateInfo = setCachedUpdateInfo;
 exports.getCliVersion = getCliVersion;
+exports.getCachedPatternInfo = getCachedPatternInfo;
+exports.setCachedPatternInfo = setCachedPatternInfo;
+exports.clearPatternCache = clearPatternCache;
 const conf_1 = __importDefault(require("conf"));
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -121,7 +124,7 @@ exports.PROVISIONABLE_KEYS = ['github', 'supabase', 'vercel'];
 const defaultServiceKeys = Object.fromEntries(exports.SERVICE_KEYS.map(key => [key, null]));
 const config = new conf_1.default({
     projectName: 'codebakers',
-    projectVersion: '1.8.0',
+    projectVersion: '1.9.0',
     defaults: {
         apiKey: null,
         apiUrl: 'https://codebakers.ai',
@@ -131,6 +134,8 @@ const config = new conf_1.default({
         trial: null,
         lastUpdateCheck: null,
         latestKnownVersion: null,
+        lastPatternCheck: null,
+        latestPatternVersion: null,
     },
     // Migration to add new keys when upgrading from old version
     migrations: {
@@ -151,6 +156,15 @@ const config = new conf_1.default({
                 store.set('trial', null);
             }
         },
+        '1.9.0': (store) => {
+            // Add pattern auto-update fields if not present
+            if (!store.has('lastPatternCheck')) {
+                store.set('lastPatternCheck', null);
+            }
+            if (!store.has('latestPatternVersion')) {
+                store.set('latestPatternVersion', null);
+            }
+        },
     },
 });
 // ============================================================
@@ -444,5 +458,36 @@ function setCachedUpdateInfo(latestVersion) {
  * Get the current CLI version from package.json
  */
 function getCliVersion() {
-    return '3.2.0'; // Keep in sync with package.json
+    return '3.3.0'; // Keep in sync with package.json
+}
+// ============================================
+// Pattern Auto-Update Cache
+// ============================================
+const PATTERN_CHECK_INTERVAL_HOURS = 6; // Check more frequently than CLI
+/**
+ * Get cached pattern version info if still valid (within 6 hours)
+ */
+function getCachedPatternInfo() {
+    const lastCheck = config.get('lastPatternCheck');
+    const latestVersion = config.get('latestPatternVersion');
+    if (!lastCheck || !latestVersion)
+        return null;
+    const hoursSinceCheck = (Date.now() - new Date(lastCheck).getTime()) / (1000 * 60 * 60);
+    if (hoursSinceCheck > PATTERN_CHECK_INTERVAL_HOURS)
+        return null;
+    return { latestVersion, checkedAt: lastCheck };
+}
+/**
+ * Cache the latest pattern version from server
+ */
+function setCachedPatternInfo(latestVersion) {
+    config.set('lastPatternCheck', new Date().toISOString());
+    config.set('latestPatternVersion', latestVersion);
+}
+/**
+ * Clear pattern cache to force a fresh check
+ */
+function clearPatternCache() {
+    config.set('lastPatternCheck', null);
+    config.set('latestPatternVersion', null);
 }

package/dist/index.js

@@ -27,34 +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.2.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);
             }
         }
     }
@@ -62,17 +67,170 @@ 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        │
   │                                                         │
   ╰─────────────────────────────────────────────────────────╯
   `));
 }
+function getLocalPatternVersion() {
+    const cwd = process.cwd();
+    const versionFile = (0, path_1.join)(cwd, '.claude', '.version.json');
+    if (!(0, fs_1.existsSync)(versionFile))
+        return null;
+    try {
+        const content = (0, fs_1.readFileSync)(versionFile, 'utf-8');
+        const info = JSON.parse(content);
+        return info.version;
+    }
+    catch {
+        return null;
+    }
+}
+function isCodeBakersProject() {
+    const cwd = process.cwd();
+    return (0, fs_1.existsSync)((0, path_1.join)(cwd, 'CLAUDE.md')) || (0, fs_1.existsSync)((0, path_1.join)(cwd, '.claude'));
+}
+async function autoUpdatePatterns() {
+    // Only auto-update if this is a CodeBakers project
+    if (!isCodeBakersProject())
+        return;
+    // Only auto-update if user has valid access
+    if (!(0, config_js_2.hasValidAccess)())
+        return;
+    const localVersion = getLocalPatternVersion();
+    // Check if we have a valid cached result first (fast path)
+    const cached = (0, config_js_2.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 = (0, config_js_2.getApiUrl)();
+        const apiKey = (0, config_js_2.getApiKey)();
+        const trial = (0, config_js_2.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
+            (0, config_js_2.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) {
+    const cwd = process.cwd();
+    const claudeMdPath = (0, path_1.join)(cwd, 'CLAUDE.md');
+    const claudeDir = (0, path_1.join)(cwd, '.claude');
+    try {
+        const apiUrl = (0, config_js_2.getApiUrl)();
+        const apiKey = (0, config_js_2.getApiKey)();
+        const trial = (0, config_js_2.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 = await response.json();
+        // Update CLAUDE.md
+        if (content.router) {
+            (0, fs_1.writeFileSync)(claudeMdPath, content.router);
+        }
+        // Update pattern modules
+        if (content.modules && Object.keys(content.modules).length > 0) {
+            if (!(0, fs_1.existsSync)(claudeDir)) {
+                (0, fs_1.mkdirSync)(claudeDir, { recursive: true });
+            }
+            for (const [name, data] of Object.entries(content.modules)) {
+                (0, fs_1.writeFileSync)((0, path_1.join)(claudeDir, name), data);
+            }
+        }
+        // Write version file
+        const moduleCount = Object.keys(content.modules || {}).length;
+        const versionInfo = {
+            version: content.version,
+            moduleCount,
+            updatedAt: new Date().toISOString(),
+            cliVersion: (0, config_js_2.getCliVersion)(),
+        };
+        (0, fs_1.writeFileSync)((0, path_1.join)(claudeDir, '.version.json'), JSON.stringify(versionInfo, null, 2));
+        // Show subtle notification
+        console.log(chalk_1.default.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() {
     console.log(chalk_1.default.blue(`
@@ -114,7 +272,7 @@ const program = new commander_1.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
     .command('go')
@@ -248,7 +406,11 @@ program
     .action(mcp_config_js_1.mcpUninstall);
 // 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
 if (process.argv.length <= 2) {

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
+    }
+}