@codebakers/cli 2.9.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebakers/cli",
-  "version": "2.9.0",
+  "version": "3.0.1",
   "description": "CodeBakers CLI - Production patterns for AI-assisted development",
   "main": "dist/index.js",
   "bin": {

package/src/commands/billing.ts

@@ -0,0 +1,99 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { getApiUrl, getApiKey, getTrialState, isTrialExpired, getTrialDaysRemaining } from '../config.js';
+
+/**
+ * Open a URL in the default browser
+ */
+function openBrowser(url: string): void {
+  const platform = process.platform;
+
+  try {
+    if (platform === 'win32') {
+      execSync(`start "" "${url}"`, { stdio: 'ignore', shell: 'cmd.exe' });
+    } else if (platform === 'darwin') {
+      execSync(`open "${url}"`, { stdio: 'ignore' });
+    } else {
+      execSync(`xdg-open "${url}" || sensible-browser "${url}" || x-www-browser "${url}"`, {
+        stdio: 'ignore',
+        shell: '/bin/sh',
+      });
+    }
+  } catch {
+    console.log(chalk.yellow(`\n  Could not open browser automatically.`));
+    console.log(chalk.gray(`  Please open this URL manually:\n`));
+    console.log(chalk.cyan(`  ${url}\n`));
+  }
+}
+
+/**
+ * Open billing page for subscription management
+ */
+export async function billing(): Promise<void> {
+  console.log(chalk.blue(`
+  ╔═══════════════════════════════════════════════════════════╗
+  ║                                                           ║
+  ║   ${chalk.bold.white('CodeBakers Billing & Subscription')}                   ║
+  ║                                                           ║
+  ╚═══════════════════════════════════════════════════════════╝
+  `));
+
+  // Check current status
+  const apiKey = getApiKey();
+  const trial = getTrialState();
+
+  if (apiKey) {
+    console.log(chalk.green('  ✓ You have an active subscription\n'));
+    console.log(chalk.gray('  Opening settings page to manage your subscription...\n'));
+
+    const apiUrl = getApiUrl();
+    const settingsUrl = `${apiUrl}/settings`;
+
+    openBrowser(settingsUrl);
+    console.log(chalk.gray(`  ${settingsUrl}\n`));
+    return;
+  }
+
+  if (trial) {
+    if (isTrialExpired()) {
+      console.log(chalk.yellow('  ⚠️  Your trial has expired\n'));
+    } else {
+      const daysRemaining = getTrialDaysRemaining();
+      console.log(chalk.gray(`  Trial: ${daysRemaining} day${daysRemaining !== 1 ? 's' : ''} remaining\n`));
+    }
+  }
+
+  // Show pricing
+  console.log(chalk.white('  Choose your plan:\n'));
+
+  console.log(chalk.cyan('  Pro     ') + chalk.white('- $49/month  ') + chalk.gray('(1 seat)'));
+  console.log(chalk.gray('           All 40 pattern modules'));
+  console.log(chalk.gray('           Unlimited projects'));
+  console.log(chalk.gray('           Priority support\n'));
+
+  console.log(chalk.cyan('  Team    ') + chalk.white('- $149/month ') + chalk.gray('(5 seats)'));
+  console.log(chalk.gray('           Everything in Pro'));
+  console.log(chalk.gray('           Team collaboration'));
+  console.log(chalk.gray('           Shared API keys\n'));
+
+  console.log(chalk.cyan('  Agency  ') + chalk.white('- $349/month ') + chalk.gray('(unlimited seats)'));
+  console.log(chalk.gray('           Everything in Team'));
+  console.log(chalk.gray('           White-label option'));
+  console.log(chalk.gray('           Dedicated support\n'));
+
+  console.log(chalk.gray('  Enterprise pricing available for large teams.\n'));
+
+  // Open billing page
+  const apiUrl = getApiUrl();
+  const billingUrl = `${apiUrl}/billing`;
+
+  console.log(chalk.white('  Opening billing page...\n'));
+
+  openBrowser(billingUrl);
+
+  console.log(chalk.gray(`  ${billingUrl}\n`));
+
+  console.log(chalk.gray('  After subscribing, run:'));
+  console.log(chalk.cyan('    codebakers setup\n'));
+  console.log(chalk.gray('  to configure your API key.\n'));
+}

package/src/commands/extend.ts

@@ -0,0 +1,157 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import {
+  getTrialState,
+  setTrialState,
+  getApiUrl,
+  getApiKey,
+  isTrialExpired,
+  type TrialState,
+} from '../config.js';
+
+/**
+ * Open a URL in the default browser
+ */
+function openBrowser(url: string): void {
+  const platform = process.platform;
+
+  try {
+    if (platform === 'win32') {
+      execSync(`start "" "${url}"`, { stdio: 'ignore', shell: 'cmd.exe' });
+    } else if (platform === 'darwin') {
+      execSync(`open "${url}"`, { stdio: 'ignore' });
+    } else {
+      // Linux - try common browsers
+      execSync(`xdg-open "${url}" || sensible-browser "${url}" || x-www-browser "${url}"`, {
+        stdio: 'ignore',
+        shell: '/bin/sh',
+      });
+    }
+  } catch {
+    console.log(chalk.yellow(`\n  Could not open browser automatically.`));
+    console.log(chalk.gray(`  Please open this URL manually:\n`));
+    console.log(chalk.cyan(`  ${url}\n`));
+  }
+}
+
+/**
+ * Sleep for a specified number of milliseconds
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Extend trial by connecting GitHub account
+ */
+export async function extend(): Promise<void> {
+  console.log(chalk.blue(`
+  ╔═══════════════════════════════════════════════════════════╗
+  ║                                                           ║
+  ║   ${chalk.bold.white('Extend Your Trial with GitHub')}                       ║
+  ║                                                           ║
+  ╚═══════════════════════════════════════════════════════════╝
+  `));
+
+  // Check if user already has an API key (paid user)
+  const apiKey = getApiKey();
+  if (apiKey) {
+    console.log(chalk.green('  ✓ You\'re already logged in with an API key!\n'));
+    console.log(chalk.gray('  You have unlimited access. No extension needed.\n'));
+    return;
+  }
+
+  // Check for existing trial
+  const trial = getTrialState();
+
+  if (!trial) {
+    console.log(chalk.yellow('  No trial found.\n'));
+    console.log(chalk.white('  Start your free trial first:\n'));
+    console.log(chalk.cyan('    codebakers go\n'));
+    return;
+  }
+
+  // Check if already extended
+  if (trial.stage === 'extended') {
+    console.log(chalk.yellow('  Your trial has already been extended.\n'));
+
+    if (isTrialExpired()) {
+      console.log(chalk.white('  Ready to upgrade? $49/month for unlimited access:\n'));
+      console.log(chalk.cyan('    codebakers upgrade\n'));
+    } else {
+      const expiresAt = new Date(trial.expiresAt);
+      const daysRemaining = Math.max(0, Math.ceil((expiresAt.getTime() - Date.now()) / (1000 * 60 * 60 * 24)));
+      console.log(chalk.gray(`  ${daysRemaining} day${daysRemaining !== 1 ? 's' : ''} remaining.\n`));
+    }
+    return;
+  }
+
+  // Check if converted
+  if (trial.stage === 'converted') {
+    console.log(chalk.green('  ✓ You\'ve upgraded to a paid plan!\n'));
+    console.log(chalk.gray('  Run ') + chalk.cyan('codebakers setup') + chalk.gray(' to configure your API key.\n'));
+    return;
+  }
+
+  // Open browser for GitHub OAuth
+  const apiUrl = getApiUrl();
+  const authUrl = `${apiUrl}/api/auth/github?trial_id=${trial.trialId}`;
+
+  console.log(chalk.white('  Opening browser for GitHub authorization...\n'));
+
+  openBrowser(authUrl);
+
+  console.log(chalk.gray('  Waiting for authorization...'));
+  console.log(chalk.gray('  (This may take a moment)\n'));
+
+  // Poll for completion
+  const spinner = ora('Checking authorization status...').start();
+  let extended = false;
+  let pollCount = 0;
+  const maxPolls = 60; // 2 minutes max
+
+  while (pollCount < maxPolls && !extended) {
+    await sleep(2000);
+    pollCount++;
+
+    try {
+      const response = await fetch(`${apiUrl}/api/trial/status?trialId=${trial.trialId}`);
+      const data = await response.json();
+
+      if (data.stage === 'extended') {
+        extended = true;
+
+        // Update local trial state
+        const updatedTrial: TrialState = {
+          ...trial,
+          stage: 'extended',
+          expiresAt: data.expiresAt,
+          extendedAt: new Date().toISOString(),
+          ...(data.githubUsername && { githubUsername: data.githubUsername }),
+        };
+
+        setTrialState(updatedTrial);
+        spinner.succeed('Trial extended!');
+      }
+    } catch {
+      // Ignore polling errors
+    }
+  }
+
+  if (extended) {
+    console.log(chalk.green(`
+  ╔═══════════════════════════════════════════════════════════╗
+  ║  ✅ Trial Extended!                                       ║
+  ║                                                           ║
+  ║  ${chalk.white('You have 7 more days to build with CodeBakers.')}         ║
+  ║                                                           ║
+  ║  ${chalk.gray('Keep building - your project is waiting!')}                ║
+  ╚═══════════════════════════════════════════════════════════╝
+    `));
+  } else {
+    spinner.warn('Authorization timed out');
+    console.log(chalk.yellow('\n  Please try again or authorize manually:\n'));
+    console.log(chalk.cyan(`  ${authUrl}\n`));
+  }
+}

package/src/commands/go.ts

@@ -0,0 +1,386 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync, spawn } from 'child_process';
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { createInterface } from 'readline';
+import {
+  getTrialState,
+  setTrialState,
+  getApiUrl,
+  getApiKey,
+  isTrialExpired,
+  getTrialDaysRemaining,
+  type TrialState,
+} from '../config.js';
+import { getDeviceFingerprint } from '../lib/fingerprint.js';
+
+function prompt(question: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+interface ContentResponse {
+  version: string;
+  router: string;
+  modules: Record<string, string>;
+}
+
+/**
+ * Zero-friction entry point - start using CodeBakers instantly
+ */
+export async function go(): Promise<void> {
+  console.log(chalk.blue(`
+  ╔═══════════════════════════════════════════════════════════╗
+  ║                                                           ║
+  ║   ${chalk.bold.white('CodeBakers - Zero Setup Required')}                    ║
+  ║                                                           ║
+  ╚═══════════════════════════════════════════════════════════╝
+  `));
+
+  // Check if user already has an API key (paid user)
+  const apiKey = getApiKey();
+  if (apiKey) {
+    console.log(chalk.green('  ✓ You\'re already logged in with an API key!\n'));
+
+    // Still install patterns if not already installed
+    await installPatternsWithApiKey(apiKey);
+    await configureMCP();
+    return;
+  }
+
+  // Check existing trial
+  const existingTrial = getTrialState();
+
+  if (existingTrial && !isTrialExpired()) {
+    const daysRemaining = getTrialDaysRemaining();
+    console.log(chalk.green(`  ✓ Trial active (${daysRemaining} day${daysRemaining !== 1 ? 's' : ''} remaining)\n`));
+
+    if (existingTrial.stage === 'anonymous' && daysRemaining <= 2) {
+      console.log(chalk.yellow('  ⚠️  Trial expiring soon! Extend with GitHub:\n'));
+      console.log(chalk.cyan('    codebakers extend\n'));
+    }
+
+    // Install patterns if not already installed
+    await installPatterns(existingTrial.trialId);
+
+    await configureMCP();
+    return;
+  }
+
+  // Check if trial expired
+  if (existingTrial && isTrialExpired()) {
+    console.log(chalk.yellow('  ⚠️  Your trial has expired.\n'));
+
+    if (existingTrial.stage === 'anonymous') {
+      console.log(chalk.white('  Extend your trial for 7 more days with GitHub:\n'));
+      console.log(chalk.cyan('    codebakers extend\n'));
+      console.log(chalk.gray('  Or upgrade to Pro ($49/month):\n'));
+      console.log(chalk.cyan('    codebakers upgrade\n'));
+    } else {
+      console.log(chalk.white('  Ready to upgrade? $49/month for unlimited access:\n'));
+      console.log(chalk.cyan('    codebakers upgrade\n'));
+    }
+    return;
+  }
+
+  // Start new trial
+  const spinner = ora('Starting your free trial...').start();
+
+  try {
+    const fingerprint = getDeviceFingerprint();
+    const apiUrl = getApiUrl();
+
+    const response = await fetch(`${apiUrl}/api/trial/start`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        deviceHash: fingerprint.deviceHash,
+        machineId: fingerprint.machineId,
+        platform: fingerprint.platform,
+        hostname: fingerprint.hostname,
+      }),
+    });
+
+    const data = await response.json();
+
+    if (data.error === 'trial_not_available') {
+      spinner.fail('Trial not available');
+      console.log(chalk.yellow(`
+  It looks like you've already used a CodeBakers trial.
+
+  Ready to upgrade? $49/month for unlimited access.
+
+  ${chalk.cyan('codebakers upgrade')} or visit ${chalk.underline('https://codebakers.ai/pricing')}
+      `));
+      return;
+    }
+
+    if (!response.ok) {
+      throw new Error(data.error || 'Failed to start trial');
+    }
+
+    // Check if returning existing trial
+    if (data.stage === 'expired') {
+      spinner.warn('Your previous trial has expired');
+      console.log('');
+
+      if (data.canExtend) {
+        console.log(chalk.white('  Extend your trial for 7 more days with GitHub:\n'));
+        console.log(chalk.cyan('    codebakers extend\n'));
+      } else {
+        console.log(chalk.white('  Ready to upgrade? $49/month for unlimited access:\n'));
+        console.log(chalk.cyan('    codebakers upgrade\n'));
+      }
+      return;
+    }
+
+    // Save trial state
+    const trialState: TrialState = {
+      trialId: data.trialId,
+      stage: data.stage,
+      deviceHash: fingerprint.deviceHash,
+      expiresAt: data.expiresAt,
+      startedAt: data.startedAt,
+      ...(data.githubUsername && { githubUsername: data.githubUsername }),
+      ...(data.projectId && { projectId: data.projectId }),
+      ...(data.projectName && { projectName: data.projectName }),
+    };
+
+    setTrialState(trialState);
+
+    spinner.succeed(`Trial started (${data.daysRemaining} days free)`);
+    console.log('');
+
+    // Install patterns (CLAUDE.md and .claude/)
+    await installPatterns(data.trialId);
+
+    // Configure MCP
+    await configureMCP();
+
+    // Show success message
+    console.log(chalk.green(`
+  ╔═══════════════════════════════════════════════════════════╗
+  ║  ✅ CodeBakers is ready!                                  ║
+  ║                                                           ║
+  ║  ${chalk.white('Your 7-day free trial has started.')}                    ║
+  ║                                                           ║
+  ║  ${chalk.gray('Try: "Build me a todo app with authentication"')}        ║
+  ╚═══════════════════════════════════════════════════════════╝
+    `));
+
+    // Attempt auto-restart Claude Code
+    await attemptAutoRestart();
+
+  } catch (error) {
+    spinner.fail('Failed to start trial');
+
+    if (error instanceof Error) {
+      if (error.message.includes('fetch') || error.message.includes('network')) {
+        console.log(chalk.red('\n  Could not connect to CodeBakers server.'));
+        console.log(chalk.gray('  Check your internet connection and try again.\n'));
+      } else {
+        console.log(chalk.red(`\n  ${error.message}\n`));
+      }
+    } else {
+      console.log(chalk.red('\n  An unexpected error occurred.\n'));
+    }
+  }
+}
+
+async function configureMCP(): Promise<void> {
+  const spinner = ora('Configuring Claude Code integration...').start();
+  const isWindows = process.platform === 'win32';
+
+  const mcpCmd = isWindows
+    ? 'claude mcp add --transport stdio codebakers -- cmd /c npx -y @codebakers/cli serve'
+    : 'claude mcp add --transport stdio codebakers -- npx -y @codebakers/cli serve';
+
+  try {
+    execSync(mcpCmd, { stdio: 'pipe' });
+    spinner.succeed('CodeBakers connected to Claude Code');
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes('already exists') || errorMessage.includes('already registered')) {
+      spinner.succeed('CodeBakers already connected to Claude Code');
+    } else {
+      spinner.warn('Could not auto-configure Claude Code');
+      console.log(chalk.gray('\n  Run this command manually:\n'));
+      console.log(chalk.cyan(`  ${mcpCmd}\n`));
+    }
+  }
+}
+
+async function attemptAutoRestart(): Promise<void> {
+  const cwd = process.cwd();
+
+  console.log(chalk.yellow('\n  ⚠️  RESTART REQUIRED\n'));
+  console.log(chalk.gray('  Claude Code needs to restart to load CodeBakers.\n'));
+
+  const answer = await prompt(chalk.cyan('  Restart Claude Code now? (Y/n): '));
+
+  if (answer === 'n' || answer === 'no') {
+    console.log(chalk.gray('\n  No problem! Just restart Claude Code manually when ready.\n'));
+    return;
+  }
+
+  // Attempt to restart Claude Code
+  console.log(chalk.gray('\n  Restarting Claude Code...\n'));
+
+  try {
+    const isWindows = process.platform === 'win32';
+
+    if (isWindows) {
+      // On Windows, spawn a new Claude process detached and exit
+      spawn('cmd', ['/c', 'start', 'claude'], {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+        shell: true,
+      }).unref();
+    } else {
+      // On Mac/Linux, spawn claude in new terminal
+      spawn('claude', [], {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+        shell: true,
+      }).unref();
+    }
+
+    console.log(chalk.green('  ✓ Claude Code is restarting...\n'));
+    console.log(chalk.gray('  This terminal will close. Claude Code will open in a new window.\n'));
+
+    // Give the spawn a moment to start
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    // Exit this process
+    process.exit(0);
+
+  } catch (error) {
+    console.log(chalk.yellow('  Could not auto-restart. Please restart Claude Code manually.\n'));
+  }
+}
+
+/**
+ * Install pattern files for API key users (paid users)
+ */
+async function installPatternsWithApiKey(apiKey: string): Promise<void> {
+  const spinner = ora('Installing CodeBakers patterns...').start();
+  const cwd = process.cwd();
+  const apiUrl = getApiUrl();
+
+  try {
+    const response = await fetch(`${apiUrl}/api/content`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    });
+
+    if (!response.ok) {
+      spinner.warn('Could not download patterns');
+      return;
+    }
+
+    const content: ContentResponse = await response.json();
+    await writePatternFiles(cwd, content, spinner);
+
+  } catch (error) {
+    spinner.warn('Could not install patterns');
+    console.log(chalk.gray('  Check your internet connection.\n'));
+  }
+}
+
+/**
+ * Install pattern files (CLAUDE.md and .claude/) for trial users
+ */
+async function installPatterns(trialId: string): Promise<void> {
+  const spinner = ora('Installing CodeBakers patterns...').start();
+  const cwd = process.cwd();
+  const apiUrl = getApiUrl();
+
+  try {
+    // Fetch patterns using trial ID
+    const response = await fetch(`${apiUrl}/api/content`, {
+      method: 'GET',
+      headers: {
+        'X-Trial-ID': trialId,
+      },
+    });
+
+    if (!response.ok) {
+      // Try without auth - some patterns may be available for trial
+      const publicResponse = await fetch(`${apiUrl}/api/content/trial`, {
+        method: 'GET',
+        headers: {
+          'X-Trial-ID': trialId,
+        },
+      });
+
+      if (!publicResponse.ok) {
+        spinner.warn('Could not download patterns (will use MCP tools)');
+        return;
+      }
+
+      const content: ContentResponse = await publicResponse.json();
+      await writePatternFiles(cwd, content, spinner);
+      return;
+    }
+
+    const content: ContentResponse = await response.json();
+    await writePatternFiles(cwd, content, spinner);
+
+  } catch (error) {
+    spinner.warn('Could not install patterns (will use MCP tools)');
+    console.log(chalk.gray('  Patterns will be available via MCP tools.\n'));
+  }
+}
+
+async function writePatternFiles(cwd: string, content: ContentResponse, spinner: ReturnType<typeof ora>): Promise<void> {
+  // Check if patterns already exist
+  const claudeMdPath = join(cwd, 'CLAUDE.md');
+  if (existsSync(claudeMdPath)) {
+    spinner.succeed('CodeBakers patterns already installed');
+    return;
+  }
+
+  // Write CLAUDE.md (router file)
+  if (content.router) {
+    writeFileSync(claudeMdPath, content.router);
+  }
+
+  // Write pattern modules to .claude/
+  if (content.modules && Object.keys(content.modules).length > 0) {
+    const modulesDir = join(cwd, '.claude');
+    if (!existsSync(modulesDir)) {
+      mkdirSync(modulesDir, { recursive: true });
+    }
+
+    for (const [name, data] of Object.entries(content.modules)) {
+      writeFileSync(join(modulesDir, name), data);
+    }
+  }
+
+  // Update .gitignore to exclude encoded patterns
+  const gitignorePath = join(cwd, '.gitignore');
+  if (existsSync(gitignorePath)) {
+    const { readFileSync } = await import('fs');
+    const gitignore = readFileSync(gitignorePath, 'utf-8');
+    if (!gitignore.includes('.claude/')) {
+      writeFileSync(gitignorePath, gitignore + '\n# CodeBakers patterns\n.claude/\n');
+    }
+  }
+
+  spinner.succeed(`CodeBakers patterns installed (v${content.version})`);
+  console.log(chalk.gray(`  ${Object.keys(content.modules || {}).length} pattern modules ready\n`));
+}