@codebakers/cli 1.4.6 → 1.6.0

package/dist/commands/provision.d.ts

@@ -0,0 +1,51 @@
+export interface ProvisionResult {
+    github?: {
+        repoUrl: string;
+        cloneUrl: string;
+    };
+    supabase?: {
+        projectId: string;
+        projectUrl: string;
+        apiUrl: string;
+        anonKey: string;
+    };
+    vercel?: {
+        projectId: string;
+        projectUrl: string;
+    };
+}
+/**
+ * Create a GitHub repository
+ */
+export declare function createGitHubRepo(projectName: string, description?: string): Promise<{
+    repoUrl: string;
+    cloneUrl: string;
+} | null>;
+/**
+ * Create a Supabase project
+ */
+export declare function createSupabaseProject(projectName: string, organizationId?: string): Promise<{
+    projectId: string;
+    projectUrl: string;
+    apiUrl: string;
+    anonKey: string;
+} | null>;
+/**
+ * Create a Vercel project
+ */
+export declare function createVercelProject(projectName: string, gitRepoUrl?: string): Promise<{
+    projectId: string;
+    projectUrl: string;
+} | null>;
+/**
+ * Full provisioning flow - create all services
+ */
+export declare function provisionAll(projectName: string, description?: string): Promise<ProvisionResult>;
+/**
+ * Check which services have keys configured
+ */
+export declare function getConfiguredServices(): {
+    github: boolean;
+    supabase: boolean;
+    vercel: boolean;
+};

package/dist/commands/provision.js

@@ -0,0 +1,309 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGitHubRepo = createGitHubRepo;
+exports.createSupabaseProject = createSupabaseProject;
+exports.createVercelProject = createVercelProject;
+exports.provisionAll = provisionAll;
+exports.getConfiguredServices = getConfiguredServices;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const child_process_1 = require("child_process");
+const readline_1 = require("readline");
+const config_js_1 = require("../config.js");
+function prompt(question) {
+    const rl = (0, readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Check if a service key is configured, prompt if not
+ */
+async function ensureServiceKey(service, instructions) {
+    let key = (0, config_js_1.getServiceKey)(service);
+    if (!key) {
+        console.log(chalk_1.default.yellow(`\n  No ${service} API key configured.\n`));
+        console.log(chalk_1.default.gray(instructions));
+        const inputKey = await prompt(`\n  ${service} API key (or press Enter to skip): `);
+        if (inputKey) {
+            (0, config_js_1.setServiceKey)(service, inputKey);
+            key = inputKey;
+            console.log(chalk_1.default.green(`  ✓ ${service} key saved\n`));
+        }
+        else {
+            console.log(chalk_1.default.gray(`  Skipping ${service} provisioning.\n`));
+            return null;
+        }
+    }
+    return key;
+}
+/**
+ * Create a GitHub repository
+ */
+async function createGitHubRepo(projectName, description = '') {
+    // Check if gh CLI is available
+    try {
+        (0, child_process_1.execSync)('gh --version', { stdio: 'pipe' });
+    }
+    catch {
+        console.log(chalk_1.default.yellow('  GitHub CLI (gh) not found. Install it from: https://cli.github.com\n'));
+        return null;
+    }
+    // Check if authenticated
+    try {
+        (0, child_process_1.execSync)('gh auth status', { stdio: 'pipe' });
+    }
+    catch {
+        console.log(chalk_1.default.yellow('  Not logged into GitHub CLI.\n'));
+        console.log(chalk_1.default.gray('  Run: gh auth login\n'));
+        return null;
+    }
+    const spinner = (0, ora_1.default)('Creating GitHub repository...').start();
+    try {
+        // Create the repo
+        const result = (0, child_process_1.execSync)(`gh repo create ${projectName} --public --description "${description}" --source . --remote origin --push`, { encoding: 'utf-8', stdio: 'pipe' });
+        // Get the repo URL
+        const repoUrl = (0, child_process_1.execSync)('gh repo view --json url -q .url', { encoding: 'utf-8' }).trim();
+        const cloneUrl = `${repoUrl}.git`;
+        spinner.succeed('GitHub repository created!');
+        console.log(chalk_1.default.gray(`  ${repoUrl}\n`));
+        return { repoUrl, cloneUrl };
+    }
+    catch (error) {
+        spinner.fail('Failed to create GitHub repository');
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('already exists')) {
+            console.log(chalk_1.default.yellow('  Repository already exists. Skipping.\n'));
+        }
+        else {
+            console.log(chalk_1.default.red(`  Error: ${message}\n`));
+        }
+        return null;
+    }
+}
+/**
+ * Create a Supabase project
+ */
+async function createSupabaseProject(projectName, organizationId) {
+    const accessToken = await ensureServiceKey('supabase', '  Get your access token from: https://supabase.com/dashboard/account/tokens');
+    if (!accessToken)
+        return null;
+    const spinner = (0, ora_1.default)('Creating Supabase project...').start();
+    try {
+        // Get organization if not provided
+        if (!organizationId) {
+            const orgsResponse = await fetch('https://api.supabase.com/v1/organizations', {
+                headers: {
+                    'Authorization': `Bearer ${accessToken}`,
+                },
+            });
+            if (!orgsResponse.ok) {
+                throw new Error('Failed to fetch organizations. Check your access token.');
+            }
+            const orgs = await orgsResponse.json();
+            if (orgs.length === 0) {
+                throw new Error('No organizations found. Create one at supabase.com first.');
+            }
+            organizationId = orgs[0].id;
+        }
+        // Generate a random password for the database
+        const dbPassword = Math.random().toString(36).slice(-16) +
+            Math.random().toString(36).slice(-16).toUpperCase() +
+            '!1';
+        // Create the project
+        const createResponse = await fetch('https://api.supabase.com/v1/projects', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                name: projectName,
+                organization_id: organizationId,
+                region: 'us-east-1',
+                plan: 'free',
+                db_pass: dbPassword,
+            }),
+        });
+        if (!createResponse.ok) {
+            const error = await createResponse.json();
+            throw new Error(error.message || 'Failed to create project');
+        }
+        const project = await createResponse.json();
+        spinner.succeed('Supabase project created!');
+        // Wait for project to be ready (it takes a moment)
+        const waitSpinner = (0, ora_1.default)('Waiting for project to be ready...').start();
+        let projectReady = false;
+        let attempts = 0;
+        let projectDetails = {};
+        while (!projectReady && attempts < 30) {
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            const statusResponse = await fetch(`https://api.supabase.com/v1/projects/${project.id}`, {
+                headers: {
+                    'Authorization': `Bearer ${accessToken}`,
+                },
+            });
+            if (statusResponse.ok) {
+                projectDetails = await statusResponse.json();
+                if (projectDetails.api_url) {
+                    projectReady = true;
+                }
+            }
+            attempts++;
+        }
+        if (!projectReady) {
+            waitSpinner.warn('Project created but may not be fully ready yet.');
+        }
+        else {
+            waitSpinner.succeed('Project ready!');
+        }
+        const projectUrl = `https://supabase.com/dashboard/project/${project.id}`;
+        console.log(chalk_1.default.gray(`  ${projectUrl}\n`));
+        // Get the anon key
+        const keysResponse = await fetch(`https://api.supabase.com/v1/projects/${project.id}/api-keys`, {
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+            },
+        });
+        let anonKey = '';
+        if (keysResponse.ok) {
+            const keys = await keysResponse.json();
+            const anonKeyObj = keys.find((k) => k.name === 'anon');
+            anonKey = anonKeyObj?.api_key || '';
+        }
+        return {
+            projectId: project.id,
+            projectUrl,
+            apiUrl: projectDetails.api_url || `https://${project.id}.supabase.co`,
+            anonKey,
+        };
+    }
+    catch (error) {
+        spinner.fail('Failed to create Supabase project');
+        const message = error instanceof Error ? error.message : String(error);
+        console.log(chalk_1.default.red(`  Error: ${message}\n`));
+        return null;
+    }
+}
+/**
+ * Create a Vercel project
+ */
+async function createVercelProject(projectName, gitRepoUrl) {
+    const accessToken = await ensureServiceKey('vercel', '  Get your token from: https://vercel.com/account/tokens');
+    if (!accessToken)
+        return null;
+    const spinner = (0, ora_1.default)('Creating Vercel project...').start();
+    try {
+        // Create the project
+        const createResponse = await fetch('https://api.vercel.com/v10/projects', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                name: projectName,
+                framework: 'nextjs',
+                ...(gitRepoUrl && {
+                    gitRepository: {
+                        type: 'github',
+                        repo: gitRepoUrl.replace('https://github.com/', ''),
+                    },
+                }),
+            }),
+        });
+        if (!createResponse.ok) {
+            const error = await createResponse.json();
+            throw new Error(error.error?.message || 'Failed to create project');
+        }
+        const project = await createResponse.json();
+        spinner.succeed('Vercel project created!');
+        const projectUrl = `https://vercel.com/${project.accountId}/${project.name}`;
+        console.log(chalk_1.default.gray(`  ${projectUrl}\n`));
+        return {
+            projectId: project.id,
+            projectUrl,
+        };
+    }
+    catch (error) {
+        spinner.fail('Failed to create Vercel project');
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('already exists')) {
+            console.log(chalk_1.default.yellow('  Project already exists. Skipping.\n'));
+        }
+        else {
+            console.log(chalk_1.default.red(`  Error: ${message}\n`));
+        }
+        return null;
+    }
+}
+/**
+ * Full provisioning flow - create all services
+ */
+async function provisionAll(projectName, description = '') {
+    console.log(chalk_1.default.blue('\n  ══════════════════════════════════════════════════════════'));
+    console.log(chalk_1.default.white.bold('  🚀 Auto-Provisioning Services\n'));
+    console.log(chalk_1.default.blue('  ══════════════════════════════════════════════════════════\n'));
+    const result = {};
+    // 1. GitHub
+    console.log(chalk_1.default.white('  Step 1: GitHub Repository\n'));
+    const github = await createGitHubRepo(projectName, description);
+    if (github) {
+        result.github = github;
+    }
+    // 2. Supabase
+    console.log(chalk_1.default.white('  Step 2: Supabase Project\n'));
+    const supabase = await createSupabaseProject(projectName);
+    if (supabase) {
+        result.supabase = supabase;
+    }
+    // 3. Vercel
+    console.log(chalk_1.default.white('  Step 3: Vercel Project\n'));
+    const vercel = await createVercelProject(projectName, result.github?.repoUrl);
+    if (vercel) {
+        result.vercel = vercel;
+    }
+    // Summary
+    console.log(chalk_1.default.blue('  ══════════════════════════════════════════════════════════'));
+    console.log(chalk_1.default.white.bold('  📋 Provisioning Summary\n'));
+    console.log(chalk_1.default.blue('  ══════════════════════════════════════════════════════════\n'));
+    if (result.github) {
+        console.log(chalk_1.default.green('  ✅ GitHub: ') + chalk_1.default.gray(result.github.repoUrl));
+    }
+    else {
+        console.log(chalk_1.default.yellow('  ⏭️  GitHub: Skipped'));
+    }
+    if (result.supabase) {
+        console.log(chalk_1.default.green('  ✅ Supabase: ') + chalk_1.default.gray(result.supabase.projectUrl));
+    }
+    else {
+        console.log(chalk_1.default.yellow('  ⏭️  Supabase: Skipped'));
+    }
+    if (result.vercel) {
+        console.log(chalk_1.default.green('  ✅ Vercel: ') + chalk_1.default.gray(result.vercel.projectUrl));
+    }
+    else {
+        console.log(chalk_1.default.yellow('  ⏭️  Vercel: Skipped'));
+    }
+    console.log('');
+    return result;
+}
+/**
+ * Check which services have keys configured
+ */
+function getConfiguredServices() {
+    return {
+        github: false, // GitHub uses gh CLI auth, not stored key
+        supabase: !!(0, config_js_1.getServiceKey)('supabase'),
+        vercel: !!(0, config_js_1.getServiceKey)('vercel'),
+    };
+}

package/dist/commands/scaffold.js

@@ -45,6 +45,41 @@ const path_1 = require("path");
 const child_process_1 = require("child_process");
 const templates = __importStar(require("../templates/nextjs-supabase.js"));
 const config_js_1 = require("../config.js");
+const provision_js_1 = require("./provision.js");
+/**
+ * Fetch service keys from CodeBakers server
+ */
+async function fetchServerKeys() {
+    const apiKey = (0, config_js_1.getApiKey)();
+    if (!apiKey)
+        return null;
+    try {
+        const apiUrl = (0, config_js_1.getApiUrl)();
+        const response = await fetch(`${apiUrl}/api/cli/service-keys`, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+        });
+        if (response.ok) {
+            return await response.json();
+        }
+    }
+    catch {
+        // Server unreachable or error
+    }
+    return null;
+}
+/**
+ * Sync server keys to local storage
+ */
+function syncKeysToLocal(keys) {
+    if (keys.github)
+        (0, config_js_1.setServiceKey)('github', keys.github);
+    if (keys.supabase)
+        (0, config_js_1.setServiceKey)('supabase', keys.supabase);
+    if (keys.vercel)
+        (0, config_js_1.setServiceKey)('vercel', keys.vercel);
+}
 // Cursor IDE configuration templates
 const CURSORRULES_TEMPLATE = `# CODEBAKERS CURSOR RULES
 # Zero-friction AI assistance - everything is automatic
@@ -507,6 +542,103 @@ async function scaffold() {
         else {
             console.log(chalk_1.default.yellow('  ⚠️  Not logged in - run `codebakers setup` first to get patterns\n'));
         }
+        // Ask about auto-provisioning
+        console.log(chalk_1.default.white('\n  Would you like to auto-provision your infrastructure?\n'));
+        console.log(chalk_1.default.gray('    This can create GitHub repo, Supabase database, and Vercel project automatically.'));
+        console.log(chalk_1.default.gray('    You\'ll need API keys for each service (one-time setup).\n'));
+        const wantProvision = await confirm('  Auto-provision services?');
+        let provisionResult = {};
+        if (wantProvision) {
+            // Check for saved keys in CodeBakers back office
+            const serverKeys = await fetchServerKeys();
+            const hasServerKeys = serverKeys && (serverKeys.github || serverKeys.supabase || serverKeys.vercel);
+            const localGithub = (0, config_js_1.getServiceKey)('github');
+            const localSupabase = (0, config_js_1.getServiceKey)('supabase');
+            const localVercel = (0, config_js_1.getServiceKey)('vercel');
+            const hasLocalKeys = localGithub || localSupabase || localVercel;
+            if (hasServerKeys || hasLocalKeys) {
+                // Show which keys are available
+                console.log(chalk_1.default.white('\n  Available service keys:\n'));
+                if (hasServerKeys) {
+                    console.log(chalk_1.default.gray('    From CodeBakers account:'));
+                    if (serverKeys?.github)
+                        console.log(chalk_1.default.green('      ✓ GitHub'));
+                    if (serverKeys?.supabase)
+                        console.log(chalk_1.default.green('      ✓ Supabase'));
+                    if (serverKeys?.vercel)
+                        console.log(chalk_1.default.green('      ✓ Vercel'));
+                }
+                if (hasLocalKeys) {
+                    console.log(chalk_1.default.gray('    Stored locally:'));
+                    if (localGithub)
+                        console.log(chalk_1.default.green('      ✓ GitHub'));
+                    if (localSupabase)
+                        console.log(chalk_1.default.green('      ✓ Supabase'));
+                    if (localVercel)
+                        console.log(chalk_1.default.green('      ✓ Vercel'));
+                }
+                console.log('');
+                // Ask which keys to use
+                console.log(chalk_1.default.white('  Which keys would you like to use?\n'));
+                console.log(chalk_1.default.gray('    1. ') + chalk_1.default.cyan('Use saved keys') + chalk_1.default.gray(' - Use keys from your account/local storage'));
+                console.log(chalk_1.default.gray('    2. ') + chalk_1.default.cyan('Enter new keys') + chalk_1.default.gray(' - For a client project or different account'));
+                console.log(chalk_1.default.gray('    3. ') + chalk_1.default.cyan('Skip') + chalk_1.default.gray(' - Don\'t provision, I\'ll do it manually\n'));
+                let keyChoice = '';
+                while (!['1', '2', '3'].includes(keyChoice)) {
+                    keyChoice = await prompt('  Enter 1, 2, or 3: ');
+                }
+                if (keyChoice === '3') {
+                    console.log(chalk_1.default.gray('\n  Skipping auto-provisioning.\n'));
+                }
+                else {
+                    if (keyChoice === '1' && hasServerKeys) {
+                        // Sync server keys to local storage for this session
+                        syncKeysToLocal(serverKeys);
+                        console.log(chalk_1.default.green('\n  ✓ Using saved keys from CodeBakers account\n'));
+                    }
+                    else if (keyChoice === '2') {
+                        // Clear local keys so provision.ts will prompt for new ones
+                        console.log(chalk_1.default.gray('\n  You\'ll be prompted to enter keys for each service.\n'));
+                    }
+                    // Initialize git first if not already
+                    try {
+                        (0, child_process_1.execSync)('git init', { cwd, stdio: 'pipe' });
+                        (0, child_process_1.execSync)('git add .', { cwd, stdio: 'pipe' });
+                        (0, child_process_1.execSync)('git commit -m "Initial commit from CodeBakers scaffold"', { cwd, stdio: 'pipe' });
+                    }
+                    catch {
+                        // Git might already be initialized or have issues
+                    }
+                    provisionResult = await (0, provision_js_1.provisionAll)(projectName, `${projectName} - Built with CodeBakers`);
+                }
+            }
+            else {
+                // No saved keys - proceed with provisioning (will prompt for keys)
+                console.log(chalk_1.default.gray('\n  No saved keys found. You\'ll be prompted to enter keys for each service.\n'));
+                console.log(chalk_1.default.gray('  Tip: Save keys in your CodeBakers dashboard to auto-provision future projects!\n'));
+                // Initialize git first if not already
+                try {
+                    (0, child_process_1.execSync)('git init', { cwd, stdio: 'pipe' });
+                    (0, child_process_1.execSync)('git add .', { cwd, stdio: 'pipe' });
+                    (0, child_process_1.execSync)('git commit -m "Initial commit from CodeBakers scaffold"', { cwd, stdio: 'pipe' });
+                }
+                catch {
+                    // Git might already be initialized or have issues
+                }
+                provisionResult = await (0, provision_js_1.provisionAll)(projectName, `${projectName} - Built with CodeBakers`);
+            }
+            // Update .env.local with Supabase credentials if available
+            if (provisionResult.supabase) {
+                const envPath = (0, path_1.join)(cwd, '.env.local');
+                let envContent = (0, fs_1.existsSync)(envPath) ? (0, fs_1.readFileSync)(envPath, 'utf-8') : '';
+                // Replace placeholder values with actual credentials
+                envContent = envContent
+                    .replace('your-project-id.supabase.co', provisionResult.supabase.apiUrl.replace('https://', ''))
+                    .replace('your-anon-key', provisionResult.supabase.anonKey || 'your-anon-key');
+                (0, fs_1.writeFileSync)(envPath, envContent);
+                console.log(chalk_1.default.green('  ✅ Updated .env.local with Supabase credentials!\n'));
+            }
+        }
         // Success message
         console.log(chalk_1.default.green(`
   ╔═══════════════════════════════════════════════════════════╗

package/dist/config.d.ts

@@ -1,4 +1,9 @@
 export type ExperienceLevel = 'beginner' | 'intermediate' | 'advanced';
+interface ServiceKeys {
+    github: string | null;
+    supabase: string | null;
+    vercel: string | null;
+}
 export declare function getApiKey(): string | null;
 export declare function setApiKey(key: string): void;
 export declare function clearApiKey(): void;
@@ -6,3 +11,9 @@ export declare function getApiUrl(): string;
 export declare function setApiUrl(url: string): void;
 export declare function getExperienceLevel(): ExperienceLevel;
 export declare function setExperienceLevel(level: ExperienceLevel): void;
+export type ServiceName = 'github' | 'supabase' | 'vercel';
+export declare function getServiceKey(service: ServiceName): string | null;
+export declare function setServiceKey(service: ServiceName, key: string): void;
+export declare function clearServiceKey(service: ServiceName): void;
+export declare function getAllServiceKeys(): ServiceKeys;
+export {};

package/dist/config.js

@@ -10,6 +10,10 @@ exports.getApiUrl = getApiUrl;
 exports.setApiUrl = setApiUrl;
 exports.getExperienceLevel = getExperienceLevel;
 exports.setExperienceLevel = setExperienceLevel;
+exports.getServiceKey = getServiceKey;
+exports.setServiceKey = setServiceKey;
+exports.clearServiceKey = clearServiceKey;
+exports.getAllServiceKeys = getAllServiceKeys;
 const conf_1 = __importDefault(require("conf"));
 const config = new conf_1.default({
     projectName: 'codebakers',
@@ -17,6 +21,11 @@ const config = new conf_1.default({
         apiKey: null,
         apiUrl: 'https://codebakers.ai',
         experienceLevel: 'intermediate',
+        serviceKeys: {
+            github: null,
+            supabase: null,
+            vercel: null,
+        },
     },
 });
 function getApiKey() {
@@ -40,3 +49,20 @@ function getExperienceLevel() {
 function setExperienceLevel(level) {
     config.set('experienceLevel', level);
 }
+function getServiceKey(service) {
+    const keys = config.get('serviceKeys');
+    return keys[service];
+}
+function setServiceKey(service, key) {
+    const keys = config.get('serviceKeys');
+    keys[service] = key;
+    config.set('serviceKeys', keys);
+}
+function clearServiceKey(service) {
+    const keys = config.get('serviceKeys');
+    keys[service] = null;
+    config.set('serviceKeys', keys);
+}
+function getAllServiceKeys() {
+    return config.get('serviceKeys');
+}

package/dist/index.js

@@ -53,7 +53,7 @@ const program = new commander_1.Command();
 program
     .name('codebakers')
     .description('CodeBakers CLI - Production patterns for AI-assisted development')
-    .version('1.4.6');
+    .version('1.6.0');
 // Primary command - one-time setup
 program
     .command('setup')

package/dist/mcp/server.js

@@ -1131,7 +1131,7 @@ phase: development
 ## Connection Status
 - **MCP Server:** Running
 - **API Connected:** Yes
-- **Version:** 1.4.6
+- **Version:** 1.5.0
 
 ## Current Settings
 - **Experience Level:** ${level.charAt(0).toUpperCase() + level.slice(1)}

package/package.json

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

package/src/commands/provision.ts

@@ -0,0 +1,380 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync, exec } from 'child_process';
+import { createInterface } from 'readline';
+import { getServiceKey, setServiceKey, type ServiceName } from '../config.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());
+    });
+  });
+}
+
+export interface ProvisionResult {
+  github?: {
+    repoUrl: string;
+    cloneUrl: string;
+  };
+  supabase?: {
+    projectId: string;
+    projectUrl: string;
+    apiUrl: string;
+    anonKey: string;
+  };
+  vercel?: {
+    projectId: string;
+    projectUrl: string;
+  };
+}
+
+/**
+ * Check if a service key is configured, prompt if not
+ */
+async function ensureServiceKey(service: ServiceName, instructions: string): Promise<string | null> {
+  let key = getServiceKey(service);
+
+  if (!key) {
+    console.log(chalk.yellow(`\n  No ${service} API key configured.\n`));
+    console.log(chalk.gray(instructions));
+
+    const inputKey = await prompt(`\n  ${service} API key (or press Enter to skip): `);
+
+    if (inputKey) {
+      setServiceKey(service, inputKey);
+      key = inputKey;
+      console.log(chalk.green(`  ✓ ${service} key saved\n`));
+    } else {
+      console.log(chalk.gray(`  Skipping ${service} provisioning.\n`));
+      return null;
+    }
+  }
+
+  return key;
+}
+
+/**
+ * Create a GitHub repository
+ */
+export async function createGitHubRepo(
+  projectName: string,
+  description: string = ''
+): Promise<{ repoUrl: string; cloneUrl: string } | null> {
+  // Check if gh CLI is available
+  try {
+    execSync('gh --version', { stdio: 'pipe' });
+  } catch {
+    console.log(chalk.yellow('  GitHub CLI (gh) not found. Install it from: https://cli.github.com\n'));
+    return null;
+  }
+
+  // Check if authenticated
+  try {
+    execSync('gh auth status', { stdio: 'pipe' });
+  } catch {
+    console.log(chalk.yellow('  Not logged into GitHub CLI.\n'));
+    console.log(chalk.gray('  Run: gh auth login\n'));
+    return null;
+  }
+
+  const spinner = ora('Creating GitHub repository...').start();
+
+  try {
+    // Create the repo
+    const result = execSync(
+      `gh repo create ${projectName} --public --description "${description}" --source . --remote origin --push`,
+      { encoding: 'utf-8', stdio: 'pipe' }
+    );
+
+    // Get the repo URL
+    const repoUrl = execSync('gh repo view --json url -q .url', { encoding: 'utf-8' }).trim();
+    const cloneUrl = `${repoUrl}.git`;
+
+    spinner.succeed('GitHub repository created!');
+    console.log(chalk.gray(`  ${repoUrl}\n`));
+
+    return { repoUrl, cloneUrl };
+  } catch (error) {
+    spinner.fail('Failed to create GitHub repository');
+    const message = error instanceof Error ? error.message : String(error);
+
+    if (message.includes('already exists')) {
+      console.log(chalk.yellow('  Repository already exists. Skipping.\n'));
+    } else {
+      console.log(chalk.red(`  Error: ${message}\n`));
+    }
+    return null;
+  }
+}
+
+/**
+ * Create a Supabase project
+ */
+export async function createSupabaseProject(
+  projectName: string,
+  organizationId?: string
+): Promise<{ projectId: string; projectUrl: string; apiUrl: string; anonKey: string } | null> {
+  const accessToken = await ensureServiceKey('supabase',
+    '  Get your access token from: https://supabase.com/dashboard/account/tokens'
+  );
+
+  if (!accessToken) return null;
+
+  const spinner = ora('Creating Supabase project...').start();
+
+  try {
+    // Get organization if not provided
+    if (!organizationId) {
+      const orgsResponse = await fetch('https://api.supabase.com/v1/organizations', {
+        headers: {
+          'Authorization': `Bearer ${accessToken}`,
+        },
+      });
+
+      if (!orgsResponse.ok) {
+        throw new Error('Failed to fetch organizations. Check your access token.');
+      }
+
+      const orgs = await orgsResponse.json();
+      if (orgs.length === 0) {
+        throw new Error('No organizations found. Create one at supabase.com first.');
+      }
+
+      organizationId = orgs[0].id;
+    }
+
+    // Generate a random password for the database
+    const dbPassword = Math.random().toString(36).slice(-16) +
+                       Math.random().toString(36).slice(-16).toUpperCase() +
+                       '!1';
+
+    // Create the project
+    const createResponse = await fetch('https://api.supabase.com/v1/projects', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name: projectName,
+        organization_id: organizationId,
+        region: 'us-east-1',
+        plan: 'free',
+        db_pass: dbPassword,
+      }),
+    });
+
+    if (!createResponse.ok) {
+      const error = await createResponse.json();
+      throw new Error(error.message || 'Failed to create project');
+    }
+
+    const project = await createResponse.json();
+
+    spinner.succeed('Supabase project created!');
+
+    // Wait for project to be ready (it takes a moment)
+    const waitSpinner = ora('Waiting for project to be ready...').start();
+
+    let projectReady = false;
+    let attempts = 0;
+    let projectDetails: { api_url?: string; anon_key?: string } = {};
+
+    while (!projectReady && attempts < 30) {
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      const statusResponse = await fetch(`https://api.supabase.com/v1/projects/${project.id}`, {
+        headers: {
+          'Authorization': `Bearer ${accessToken}`,
+        },
+      });
+
+      if (statusResponse.ok) {
+        projectDetails = await statusResponse.json();
+        if (projectDetails.api_url) {
+          projectReady = true;
+        }
+      }
+      attempts++;
+    }
+
+    if (!projectReady) {
+      waitSpinner.warn('Project created but may not be fully ready yet.');
+    } else {
+      waitSpinner.succeed('Project ready!');
+    }
+
+    const projectUrl = `https://supabase.com/dashboard/project/${project.id}`;
+    console.log(chalk.gray(`  ${projectUrl}\n`));
+
+    // Get the anon key
+    const keysResponse = await fetch(`https://api.supabase.com/v1/projects/${project.id}/api-keys`, {
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+      },
+    });
+
+    let anonKey = '';
+    if (keysResponse.ok) {
+      const keys = await keysResponse.json();
+      const anonKeyObj = keys.find((k: { name: string }) => k.name === 'anon');
+      anonKey = anonKeyObj?.api_key || '';
+    }
+
+    return {
+      projectId: project.id,
+      projectUrl,
+      apiUrl: projectDetails.api_url || `https://${project.id}.supabase.co`,
+      anonKey,
+    };
+  } catch (error) {
+    spinner.fail('Failed to create Supabase project');
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(chalk.red(`  Error: ${message}\n`));
+    return null;
+  }
+}
+
+/**
+ * Create a Vercel project
+ */
+export async function createVercelProject(
+  projectName: string,
+  gitRepoUrl?: string
+): Promise<{ projectId: string; projectUrl: string } | null> {
+  const accessToken = await ensureServiceKey('vercel',
+    '  Get your token from: https://vercel.com/account/tokens'
+  );
+
+  if (!accessToken) return null;
+
+  const spinner = ora('Creating Vercel project...').start();
+
+  try {
+    // Create the project
+    const createResponse = await fetch('https://api.vercel.com/v10/projects', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name: projectName,
+        framework: 'nextjs',
+        ...(gitRepoUrl && {
+          gitRepository: {
+            type: 'github',
+            repo: gitRepoUrl.replace('https://github.com/', ''),
+          },
+        }),
+      }),
+    });
+
+    if (!createResponse.ok) {
+      const error = await createResponse.json();
+      throw new Error(error.error?.message || 'Failed to create project');
+    }
+
+    const project = await createResponse.json();
+
+    spinner.succeed('Vercel project created!');
+
+    const projectUrl = `https://vercel.com/${project.accountId}/${project.name}`;
+    console.log(chalk.gray(`  ${projectUrl}\n`));
+
+    return {
+      projectId: project.id,
+      projectUrl,
+    };
+  } catch (error) {
+    spinner.fail('Failed to create Vercel project');
+    const message = error instanceof Error ? error.message : String(error);
+
+    if (message.includes('already exists')) {
+      console.log(chalk.yellow('  Project already exists. Skipping.\n'));
+    } else {
+      console.log(chalk.red(`  Error: ${message}\n`));
+    }
+    return null;
+  }
+}
+
+/**
+ * Full provisioning flow - create all services
+ */
+export async function provisionAll(
+  projectName: string,
+  description: string = ''
+): Promise<ProvisionResult> {
+  console.log(chalk.blue('\n  ══════════════════════════════════════════════════════════'));
+  console.log(chalk.white.bold('  🚀 Auto-Provisioning Services\n'));
+  console.log(chalk.blue('  ══════════════════════════════════════════════════════════\n'));
+
+  const result: ProvisionResult = {};
+
+  // 1. GitHub
+  console.log(chalk.white('  Step 1: GitHub Repository\n'));
+  const github = await createGitHubRepo(projectName, description);
+  if (github) {
+    result.github = github;
+  }
+
+  // 2. Supabase
+  console.log(chalk.white('  Step 2: Supabase Project\n'));
+  const supabase = await createSupabaseProject(projectName);
+  if (supabase) {
+    result.supabase = supabase;
+  }
+
+  // 3. Vercel
+  console.log(chalk.white('  Step 3: Vercel Project\n'));
+  const vercel = await createVercelProject(projectName, result.github?.repoUrl);
+  if (vercel) {
+    result.vercel = vercel;
+  }
+
+  // Summary
+  console.log(chalk.blue('  ══════════════════════════════════════════════════════════'));
+  console.log(chalk.white.bold('  📋 Provisioning Summary\n'));
+  console.log(chalk.blue('  ══════════════════════════════════════════════════════════\n'));
+
+  if (result.github) {
+    console.log(chalk.green('  ✅ GitHub: ') + chalk.gray(result.github.repoUrl));
+  } else {
+    console.log(chalk.yellow('  ⏭️  GitHub: Skipped'));
+  }
+
+  if (result.supabase) {
+    console.log(chalk.green('  ✅ Supabase: ') + chalk.gray(result.supabase.projectUrl));
+  } else {
+    console.log(chalk.yellow('  ⏭️  Supabase: Skipped'));
+  }
+
+  if (result.vercel) {
+    console.log(chalk.green('  ✅ Vercel: ') + chalk.gray(result.vercel.projectUrl));
+  } else {
+    console.log(chalk.yellow('  ⏭️  Vercel: Skipped'));
+  }
+
+  console.log('');
+
+  return result;
+}
+
+/**
+ * Check which services have keys configured
+ */
+export function getConfiguredServices(): { github: boolean; supabase: boolean; vercel: boolean } {
+  return {
+    github: false, // GitHub uses gh CLI auth, not stored key
+    supabase: !!getServiceKey('supabase'),
+    vercel: !!getServiceKey('vercel'),
+  };
+}

package/src/commands/scaffold.ts

@@ -5,7 +5,47 @@ import { writeFileSync, mkdirSync, existsSync, readdirSync, readFileSync } from
 import { join } from 'path';
 import { execSync } from 'child_process';
 import * as templates from '../templates/nextjs-supabase.js';
-import { getApiKey, getApiUrl } from '../config.js';
+import { getApiKey, getApiUrl, setServiceKey, getServiceKey } from '../config.js';
+import { provisionAll, type ProvisionResult } from './provision.js';
+
+interface ServerServiceKeys {
+  github: string | null;
+  supabase: string | null;
+  vercel: string | null;
+}
+
+/**
+ * Fetch service keys from CodeBakers server
+ */
+async function fetchServerKeys(): Promise<ServerServiceKeys | null> {
+  const apiKey = getApiKey();
+  if (!apiKey) return null;
+
+  try {
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/api/cli/service-keys`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+    });
+
+    if (response.ok) {
+      return await response.json();
+    }
+  } catch {
+    // Server unreachable or error
+  }
+  return null;
+}
+
+/**
+ * Sync server keys to local storage
+ */
+function syncKeysToLocal(keys: ServerServiceKeys): void {
+  if (keys.github) setServiceKey('github', keys.github);
+  if (keys.supabase) setServiceKey('supabase', keys.supabase);
+  if (keys.vercel) setServiceKey('vercel', keys.vercel);
+}
 
 // Cursor IDE configuration templates
 const CURSORRULES_TEMPLATE = `# CODEBAKERS CURSOR RULES
@@ -522,6 +562,109 @@ export async function scaffold(): Promise<void> {
       console.log(chalk.yellow('  ⚠️  Not logged in - run `codebakers setup` first to get patterns\n'));
     }
 
+    // Ask about auto-provisioning
+    console.log(chalk.white('\n  Would you like to auto-provision your infrastructure?\n'));
+    console.log(chalk.gray('    This can create GitHub repo, Supabase database, and Vercel project automatically.'));
+    console.log(chalk.gray('    You\'ll need API keys for each service (one-time setup).\n'));
+
+    const wantProvision = await confirm('  Auto-provision services?');
+    let provisionResult: ProvisionResult = {};
+
+    if (wantProvision) {
+      // Check for saved keys in CodeBakers back office
+      const serverKeys = await fetchServerKeys();
+      const hasServerKeys = serverKeys && (serverKeys.github || serverKeys.supabase || serverKeys.vercel);
+      const localGithub = getServiceKey('github');
+      const localSupabase = getServiceKey('supabase');
+      const localVercel = getServiceKey('vercel');
+      const hasLocalKeys = localGithub || localSupabase || localVercel;
+
+      if (hasServerKeys || hasLocalKeys) {
+        // Show which keys are available
+        console.log(chalk.white('\n  Available service keys:\n'));
+
+        if (hasServerKeys) {
+          console.log(chalk.gray('    From CodeBakers account:'));
+          if (serverKeys?.github) console.log(chalk.green('      ✓ GitHub'));
+          if (serverKeys?.supabase) console.log(chalk.green('      ✓ Supabase'));
+          if (serverKeys?.vercel) console.log(chalk.green('      ✓ Vercel'));
+        }
+
+        if (hasLocalKeys) {
+          console.log(chalk.gray('    Stored locally:'));
+          if (localGithub) console.log(chalk.green('      ✓ GitHub'));
+          if (localSupabase) console.log(chalk.green('      ✓ Supabase'));
+          if (localVercel) console.log(chalk.green('      ✓ Vercel'));
+        }
+
+        console.log('');
+
+        // Ask which keys to use
+        console.log(chalk.white('  Which keys would you like to use?\n'));
+        console.log(chalk.gray('    1. ') + chalk.cyan('Use saved keys') + chalk.gray(' - Use keys from your account/local storage'));
+        console.log(chalk.gray('    2. ') + chalk.cyan('Enter new keys') + chalk.gray(' - For a client project or different account'));
+        console.log(chalk.gray('    3. ') + chalk.cyan('Skip') + chalk.gray(' - Don\'t provision, I\'ll do it manually\n'));
+
+        let keyChoice = '';
+        while (!['1', '2', '3'].includes(keyChoice)) {
+          keyChoice = await prompt('  Enter 1, 2, or 3: ');
+        }
+
+        if (keyChoice === '3') {
+          console.log(chalk.gray('\n  Skipping auto-provisioning.\n'));
+        } else {
+          if (keyChoice === '1' && hasServerKeys) {
+            // Sync server keys to local storage for this session
+            syncKeysToLocal(serverKeys!);
+            console.log(chalk.green('\n  ✓ Using saved keys from CodeBakers account\n'));
+          } else if (keyChoice === '2') {
+            // Clear local keys so provision.ts will prompt for new ones
+            console.log(chalk.gray('\n  You\'ll be prompted to enter keys for each service.\n'));
+          }
+
+          // Initialize git first if not already
+          try {
+            execSync('git init', { cwd, stdio: 'pipe' });
+            execSync('git add .', { cwd, stdio: 'pipe' });
+            execSync('git commit -m "Initial commit from CodeBakers scaffold"', { cwd, stdio: 'pipe' });
+          } catch {
+            // Git might already be initialized or have issues
+          }
+
+          provisionResult = await provisionAll(projectName, `${projectName} - Built with CodeBakers`);
+        }
+      } else {
+        // No saved keys - proceed with provisioning (will prompt for keys)
+        console.log(chalk.gray('\n  No saved keys found. You\'ll be prompted to enter keys for each service.\n'));
+        console.log(chalk.gray('  Tip: Save keys in your CodeBakers dashboard to auto-provision future projects!\n'));
+
+        // Initialize git first if not already
+        try {
+          execSync('git init', { cwd, stdio: 'pipe' });
+          execSync('git add .', { cwd, stdio: 'pipe' });
+          execSync('git commit -m "Initial commit from CodeBakers scaffold"', { cwd, stdio: 'pipe' });
+        } catch {
+          // Git might already be initialized or have issues
+        }
+
+        provisionResult = await provisionAll(projectName, `${projectName} - Built with CodeBakers`);
+      }
+
+      // Update .env.local with Supabase credentials if available
+      if (provisionResult.supabase) {
+        const envPath = join(cwd, '.env.local');
+        let envContent = existsSync(envPath) ? readFileSync(envPath, 'utf-8') : '';
+
+        // Replace placeholder values with actual credentials
+        envContent = envContent
+          .replace('your-project-id.supabase.co', provisionResult.supabase.apiUrl.replace('https://', ''))
+          .replace('your-anon-key', provisionResult.supabase.anonKey || 'your-anon-key');
+
+        writeFileSync(envPath, envContent);
+        console.log(chalk.green('  ✅ Updated .env.local with Supabase credentials!\n'));
+      }
+    }
+
     // Success message
     console.log(chalk.green(`
   ╔═══════════════════════════════════════════════════════════╗

package/src/config.ts

@@ -2,10 +2,17 @@ import Conf from 'conf';
 
 export type ExperienceLevel = 'beginner' | 'intermediate' | 'advanced';
 
+interface ServiceKeys {
+  github: string | null;
+  supabase: string | null;
+  vercel: string | null;
+}
+
 interface ConfigSchema {
   apiKey: string | null;
   apiUrl: string;
   experienceLevel: ExperienceLevel;
+  serviceKeys: ServiceKeys;
 }
 
 const config = new Conf<ConfigSchema>({
@@ -14,6 +21,11 @@ const config = new Conf<ConfigSchema>({
     apiKey: null,
     apiUrl: 'https://codebakers.ai',
     experienceLevel: 'intermediate',
+    serviceKeys: {
+      github: null,
+      supabase: null,
+      vercel: null,
+    },
   },
 });
 
@@ -44,3 +56,27 @@ export function getExperienceLevel(): ExperienceLevel {
 export function setExperienceLevel(level: ExperienceLevel): void {
   config.set('experienceLevel', level);
 }
+
+// Service API Keys
+export type ServiceName = 'github' | 'supabase' | 'vercel';
+
+export function getServiceKey(service: ServiceName): string | null {
+  const keys = config.get('serviceKeys');
+  return keys[service];
+}
+
+export function setServiceKey(service: ServiceName, key: string): void {
+  const keys = config.get('serviceKeys');
+  keys[service] = key;
+  config.set('serviceKeys', keys);
+}
+
+export function clearServiceKey(service: ServiceName): void {
+  const keys = config.get('serviceKeys');
+  keys[service] = null;
+  config.set('serviceKeys', keys);
+}
+
+export function getAllServiceKeys(): ServiceKeys {
+  return config.get('serviceKeys');
+}

package/src/index.ts

@@ -57,7 +57,7 @@ const program = new Command();
 program
   .name('codebakers')
   .description('CodeBakers CLI - Production patterns for AI-assisted development')
-  .version('1.4.6');
+  .version('1.6.0');
 
 // Primary command - one-time setup
 program

package/src/mcp/server.ts

@@ -1285,7 +1285,7 @@ phase: development
 ## Connection Status
 - **MCP Server:** Running
 - **API Connected:** Yes
-- **Version:** 1.4.6
+- **Version:** 1.5.0
 
 ## Current Settings
 - **Experience Level:** ${level.charAt(0).toUpperCase() + level.slice(1)}