vibecodingmachine-cli 2025.12.1-534 → 2025.12.22-2230

package/src/utils/first-run.js

@@ -0,0 +1,410 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const boxen = require('boxen');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { getProviderDefinitions, saveProviderPreferences, getDefaultProviderOrder } = require('./provider-registry');
+const { isKiroInstalled } = require('./kiro-installer');
+
+const { execSync } = require('child_process');
+
+async function checkAppOrBinary(names = [], binaries = []) {
+    // names: app bundle base names (e.g., 'Cursor' -> /Applications/Cursor.app)
+    // binaries: CLI binary names to check on PATH (e.g., 'code')
+    const platform = os.platform();
+    // Check common application directories
+    if (platform === 'darwin') {
+        const appDirs = ['/Applications', path.join(os.homedir(), 'Applications')];
+        for (const appName of names) {
+            for (const dir of appDirs) {
+                try {
+                    const p = path.join(dir, `${appName}.app`);
+                    if (await fs.pathExists(p)) {
+                        // Ensure this is a real application bundle (has Contents/MacOS executable)
+                        try {
+                            const macosDir = path.join(p, 'Contents', 'MacOS');
+                            const exists = await fs.pathExists(macosDir);
+                            if (exists) {
+                                const files = await fs.readdir(macosDir);
+                                if (files && files.length > 0) {
+                                    // Prefer to ensure the app is usable: use spctl to assess, fallback to quarantine xattr
+                                    try {
+                                        // spctl returns non-zero on rejected/invalid apps
+                                        execSync(`spctl --assess -v "${p}"`, { stdio: 'ignore', timeout: 5000 });
+                                        // additionally validate codesign quickly (timeout to avoid hangs)
+                                        try {
+                                            execSync(`codesign -v --deep --strict "${p}"`, { stdio: 'ignore', timeout: 5000 });
+                                            return true;
+                                        } catch (csErr) {
+                                            // codesign failed or timed out — treat as not usable/damaged
+                                            return false;
+                                        }
+                                    } catch (e) {
+                                        // spctl failed or timed out — check if app has quarantine attribute
+                                        try {
+                                            const out = execSync(`xattr -p com.apple.quarantine "${p}" 2>/dev/null || true`, { encoding: 'utf8' }).trim();
+                                            if (!out) {
+                                                // no quarantine attribute but spctl failed — be conservative and treat as not installed
+                                                return false;
+                                            }
+                                            // If quarantine attribute exists, treat as not installed (damaged/not allowed)
+                                            return false;
+                                        } catch (e2) {
+                                            return false;
+                                        }
+                                    }
+                                }
+                            }
+                        } catch (e) {
+                            // if we can't stat inside, be conservative and continue searching
+                        }
+                    }
+                } catch (e) {
+                    /* ignore */
+                }
+            }
+        }
+    }
+
+    // Check PATH for known binaries
+    for (const bin of binaries) {
+        try {
+            execSync(`which ${bin}`, { stdio: 'ignore' });
+            return true;
+        } catch (e) {
+            /* not found */
+        }
+    }
+
+    // Check common Homebrew bin locations
+    const brewPaths = ['/opt/homebrew/bin', '/usr/local/bin'];
+    for (const bin of binaries) {
+        for (const brew of brewPaths) {
+            try {
+                if (await fs.pathExists(path.join(brew, bin))) return true;
+            } catch (e) { /* ignore */ }
+        }
+    }
+
+    return false;
+}
+
+async function checkFirstRun() {
+    const configDir = path.join(os.homedir(), '.vibecodingmachine');
+
+    // If directory exists, we assume it's not the first run
+    if (await fs.pathExists(configDir)) {
+        return;
+    }
+
+    // FIRST RUN EXPERIENCE
+    console.clear();
+
+    // 1. Big Welcome Banner
+    console.log('\n' + boxen(
+        chalk.bold.cyan('Welcome to Vibe Coding Machine') + '\n\n' +
+        chalk.white('The future of coding is here.') + '\n' +
+        chalk.gray('Just describe what you want, and we code it for you.'),
+        {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'double',
+            borderColor: 'cyan',
+            align: 'center'
+        }
+    ));
+
+    console.log(chalk.cyan('Let\'s get you set up with the best AI coding environment.\n'));
+    await new Promise(resolve => setTimeout(resolve, 1500));
+
+    // --- NEW: Vibe Coding Introduction ---
+    const { showIntro } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'showIntro',
+            message: 'Are you new to Vibe Coding? Would you like a quick 30-second tour?',
+            default: true
+        }
+    ]);
+
+    if (showIntro) {
+        const introContent = [
+            chalk.bold.cyan('╔════════════════════════ Vibe Coding 101 ════════════════════════╗'),
+            chalk.cyan('║                                                                 ║'),
+            chalk.cyan('║  1. What is an IDE?                                             ║'),
+            chalk.cyan('║     Think of it like MS Word, but for writing code.             ║'),
+            chalk.cyan('║     You need one to build apps, but don\'t worry—we\'ll install   ║'),
+            chalk.cyan('║     the best ones for you automatically.                        ║'),
+            chalk.cyan('║                                                                 ║'),
+            chalk.cyan('║  2. How it works                                                ║'),
+            chalk.cyan('║     You simply describe the app or web page you want.           ║'),
+            chalk.cyan('║     VibeCodingMachine then takes over your keyboard to write    ║'),
+            chalk.cyan('║     the code inside the IDE (GUI mode) or runs in the           ║'),
+            chalk.cyan('║     background (CLI mode) which is even faster.                 ║'),
+            chalk.cyan('║                                                                 ║'),
+            chalk.bold.cyan('╚═════════════════════════════════════════════════════════════════╝')
+        ].join('\n');
+
+        console.log('\n' + introContent + '\n');
+
+        await inquirer.prompt([{
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to continue...'
+        }]);
+    }
+
+
+
+
+    // 2. Detect IDEs
+    const definitions = getProviderDefinitions();
+    const ideDefinitions = definitions.filter(d => d.type === 'ide');
+
+    const detectedIDEs = [];
+    const otherIDEs = [];
+
+    // Simple simulation of detection for standard apps on macOS
+    // In a real scenario, we might check other paths or registry on Windows
+    const platform = os.platform();
+
+    for (const ide of ideDefinitions) {
+        let installed = false;
+
+        if (ide.id === 'kiro') {
+            installed = isKiroInstalled();
+        } else if (ide.id === 'cursor') {
+            // Cursor: check app bundle and 'cursor' binary
+            installed = await checkAppOrBinary(['Cursor'], ['cursor']);
+        } else if (ide.id === 'windsurf') {
+            // Windsurf: check app bundle and common binary
+            installed = await checkAppOrBinary(['Windsurf'], ['windsurf']);
+        } else if (ide.id === 'vscode') {
+            // VS Code: check app bundle and 'code' CLI
+            installed = await checkAppOrBinary(['Visual Studio Code', 'Visual Studio Code - Insiders'], ['code', 'code-insiders']);
+        } else if (ide.id === 'antigravity') {
+            // Antigravity: check app bundle and 'antigravity' binary
+            installed = await checkAppOrBinary(['Antigravity'], ['antigravity']);
+        }
+
+        if (installed) {
+            detectedIDEs.push(ide);
+        } else {
+            otherIDEs.push(ide);
+        }
+    }
+
+    // 3. Status Report & Selection
+    if (detectedIDEs.length > 0) {
+        console.log(chalk.green('\n✓ We found these IDEs and enabled them for you:'));
+        detectedIDEs.forEach(ide => {
+            console.log(chalk.gray(`  • ${ide.name}`));
+        });
+    }
+
+    let selectedIDEs = [];
+
+    // Only prompt for uninstalled IDEs if there are any
+    if (otherIDEs.length > 0) {
+        console.log(); // Spacing
+        const choices = otherIDEs.map(ide => ({
+            name: ide.name,
+            value: ide.id,
+            checked: true // Select by default as requested
+        }));
+
+        const response = await inquirer.prompt([{
+            type: 'checkbox',
+            name: 'selectedIDEs',
+            message: 'Select additional IDEs to install & enable:',
+            choices: choices,
+            pageSize: 10
+        }]);
+        selectedIDEs = response.selectedIDEs;
+    }
+
+    // 4. Handle Installations (Generic)
+    // For any selected IDE that wasn't detected, try to invoke a matching installer module
+    // Installer modules are expected to live next to this file as `<id>-installer.js` and
+    // export an installation function like `install<IdPascal>()` or `install`.
+    for (const ideId of selectedIDEs) {
+        // determine if already installed using existing checks
+        let alreadyInstalled = false;
+        try {
+            if (ideId === 'kiro') {
+                alreadyInstalled = isKiroInstalled() || await checkAppOrBinary(['AWS Kiro', 'Kiro'], ['kiro']);
+            } else if (ideId === 'cursor') {
+                alreadyInstalled = await checkAppOrBinary(['Cursor'], ['cursor']);
+            } else if (ideId === 'windsurf') {
+                alreadyInstalled = await checkAppOrBinary(['Windsurf'], ['windsurf']);
+            } else if (ideId === 'vscode') {
+                alreadyInstalled = await checkAppOrBinary(['Visual Studio Code', 'Visual Studio Code - Insiders'], ['code', 'code-insiders']);
+            } else if (ideId === 'antigravity') {
+                alreadyInstalled = await checkAppOrBinary(['Antigravity'], ['antigravity']);
+            } else {
+                // default fallback: try binary name same as id
+                alreadyInstalled = await checkAppOrBinary([], [ideId]);
+            }
+        } catch (e) {
+            // detection error: assume not installed
+            alreadyInstalled = false;
+        }
+
+        if (alreadyInstalled) continue;
+
+        // Attempt to locate and run an installer module for this IDE
+        let installerModule = null;
+        const tryPaths = [`./${ideId}-installer`, `../utils/${ideId}-installer`];
+        for (const p of tryPaths) {
+            try {
+                // require may throw if module doesn't exist
+                installerModule = require(p);
+                break;
+            } catch (e) {
+                // ignore and try next
+            }
+        }
+
+        if (!installerModule) {
+            console.log(chalk.gray(`No installer module found for ${ideId}, skipping automated install.`));
+            continue;
+        }
+
+        // Resolve a callable install function from the module
+        const pascal = ideId.split(/[-_]/).map(s => s[0].toUpperCase() + s.slice(1)).join('');
+        const candidateNames = [`install${pascal}`, 'install', pascal, 'default'];
+        let installerFn = null;
+        for (const name of candidateNames) {
+            if (name === 'default' && typeof installerModule === 'function') {
+                installerFn = installerModule;
+                break;
+            }
+            if (installerModule && typeof installerModule[name] === 'function') {
+                installerFn = installerModule[name];
+                break;
+            }
+        }
+
+        if (!installerFn) {
+            console.log(chalk.gray(`Installer found for ${ideId} but no callable export (tried ${candidateNames.join(', ')}).`));
+            continue;
+        }
+
+        console.log(chalk.cyan(`\n🔧 Installing ${ideId}...`));
+        try {
+            const ok = await installerFn();
+            if (!ok) {
+                console.log(chalk.yellow(`\n⚠️  ${ideId} installation failed or was skipped.`));
+            } else {
+                console.log(chalk.green(`\n✅ ${ideId} installation complete.`));
+            }
+        } catch (err) {
+            console.log(chalk.red(`${ideId} installation error:`), err.message || err);
+        }
+    }
+
+    // 5. Configure Preferences
+    // Re-detect IDEs to ensure we only enable actually installed ones
+    const reDetected = [];
+    for (const ideDef of ideDefinitions) {
+        let installedNow = false;
+        if (ideDef.id === 'kiro') {
+            installedNow = isKiroInstalled() || await checkAppOrBinary(['AWS Kiro', 'Kiro'], ['kiro']);
+        } else if (ideDef.id === 'cursor') {
+            installedNow = await checkAppOrBinary(['Cursor'], ['cursor']);
+        } else if (ideDef.id === 'windsurf') {
+            installedNow = await checkAppOrBinary(['Windsurf'], ['windsurf']);
+        } else if (ideDef.id === 'vscode') {
+            installedNow = await checkAppOrBinary(['Visual Studio Code', 'Visual Studio Code - Insiders'], ['code', 'code-insiders']);
+        } else if (ideDef.id === 'antigravity') {
+            installedNow = await checkAppOrBinary(['Antigravity'], ['antigravity']);
+        }
+        if (installedNow) reDetected.push(ideDef.id);
+    }
+
+    const defaultOrder = getDefaultProviderOrder();
+    const enabledMap = {};
+    for (const id of defaultOrder) {
+        const def = definitions.find(d => d.id === id);
+        if (def && def.type === 'ide') {
+            const isDetectedNow = reDetected.includes(id);
+            const isSelected = selectedIDEs.includes(id);
+            enabledMap[id] = isDetectedNow || isSelected;
+        } else {
+            enabledMap[id] = true; // Keep LLMs enabled by default
+        }
+    }
+
+    // Save initial preferences. provider-registry.js usually saves to ~/.config/vibecodingmachine/config.json
+    // But here we are checking ~/.vibecodingmachine.
+    // We should create the ~/.vibecodingmachine directory to mark first run as complete.
+    await fs.ensureDir(configDir);
+    await saveProviderPreferences(defaultOrder, enabledMap);
+
+    // --- NEW: CLI Usage Onboarding ---
+    // Moved here so IDEs are set up first
+    const { isFamiliar } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'isFamiliar',
+            message: 'Are you familiar with how to use VibeCodingMachine CLI?',
+            default: false
+        }
+    ]);
+
+    if (!isFamiliar) {
+        const cliUsageContent = [
+            chalk.bold.green('╔════════════════════════ CLI Crash Course ═══════════════════════╗'),
+            chalk.green('║                                                                 ║'),
+            chalk.green('║  1. Navigation                                                  ║'),
+            chalk.green('║     [↑/↓] Arrow keys to move selection                          ║'),
+            chalk.green('║     [Space] to toggle checkboxes [x]                            ║'),
+            chalk.green('║     [Enter] to confirm your choice                              ║'),
+            chalk.green('║                                                                 ║'),
+            chalk.green('║  2. Key Features                                                ║'),
+            chalk.green('║     • Auto Mode: The autonomous coding agent                    ║'),
+            chalk.green('║     • Direct Mode: Chat directly with LLMs                      ║'),
+            chalk.green('║     • IDE Setup: Install and configure tools                    ║'),
+            chalk.green('║                                                                 ║'),
+            chalk.green('║  3. Pro Tip                                                     ║'),
+            chalk.green('║     If you ever get stuck, just restart the CLI with \'vcm\'.     ║'),
+            chalk.green('║                                                                 ║'),
+            chalk.bold.green('╚═════════════════════════════════════════════════════════════════╝')
+        ].join('\n');
+
+        console.log('\n' + cliUsageContent + '\n');
+
+        await inquirer.prompt([{
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to continue...'
+        }]);
+    }
+
+    // 6. Explanation
+    console.log('\n' + boxen(
+        chalk.bold.green(' Setup Complete! ') + '\n\n' +
+        chalk.white('Vibe Coding is about flow. You describe, we code.') + '\n' +
+        chalk.white('Using your local IDEs + Cloud LLMs for maximum power.'),
+        {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'green'
+        }
+    ));
+
+    console.log(chalk.cyan('Press any key to continue to the main menu...'));
+
+    await new Promise((resolve) => {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.once('data', () => {
+            process.stdin.setRawMode(false);
+            resolve();
+        });
+    });
+}
+
+module.exports = { checkFirstRun };