vibecodingmachine-cli 2025.12.6-1702 → 2025.12.24-2348

package/src/utils/first-run.js

@@ -5,7 +5,91 @@ const fs = require('fs-extra');
 const path = require('path');
 const os = require('os');
 const { getProviderDefinitions, saveProviderPreferences, getDefaultProviderOrder } = require('./provider-registry');
-const { isKiroInstalled, installKiro } = require('./kiro-installer');
+const { isKiroInstalled } = require('./kiro-installer');
+const { t } = require('vibecodingmachine-core');
+
+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');
@@ -68,7 +152,7 @@ async function checkFirstRun() {
         await inquirer.prompt([{
             type: 'input',
             name: 'continue',
-            message: 'Press Enter to continue...'
+            message: t('interactive.press.enter.continue')
         }]);
     }
 
@@ -85,7 +169,6 @@ async function checkFirstRun() {
     // 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();
-    const getAppPath = (name) => platform === 'darwin' ? `/Applications/${name}.app` : null;
 
     for (const ide of ideDefinitions) {
         let installed = false;
@@ -93,15 +176,17 @@ async function checkFirstRun() {
         if (ide.id === 'kiro') {
             installed = isKiroInstalled();
         } else if (ide.id === 'cursor') {
-            if (platform === 'darwin') installed = await fs.pathExists(getAppPath('Cursor'));
+            // Cursor: check app bundle and 'cursor' binary
+            installed = await checkAppOrBinary(['Cursor'], ['cursor']);
         } else if (ide.id === 'windsurf') {
-            if (platform === 'darwin') installed = await fs.pathExists(getAppPath('Windsurf'));
+            // Windsurf: check app bundle and common binary
+            installed = await checkAppOrBinary(['Windsurf'], ['windsurf']);
         } else if (ide.id === 'vscode') {
-            if (platform === 'darwin') installed = await fs.pathExists(getAppPath('Visual Studio Code'));
+            // 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 is just a provider here, maybe assume installed if running? 
-            // Or check for some component. For now default to true or false based on something simple.
-            installed = true; // Assume available
+            // Antigravity: check app bundle and 'antigravity' binary
+            installed = await checkAppOrBinary(['Antigravity'], ['antigravity']);
         }
 
         if (installed) {
@@ -140,84 +225,117 @@ async function checkFirstRun() {
         selectedIDEs = response.selectedIDEs;
     }
 
-    // 4. Handle Installations
-    if (selectedIDEs.includes('kiro')) {
-        const kiroInstalled = isKiroInstalled();
-        if (!kiroInstalled) {
-            // installKiro logs its own inputs, but we want to handle failure gracefully
-            const success = await installKiro();
-            if (!success) {
-                console.log(chalk.yellow('\n⚠️  Kiro installation failed or was skipped.'));
-                console.log(chalk.gray('You can continue setting up other IDEs.'));
-                await new Promise(resolve => setTimeout(resolve, 2000));
+    // 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 {
-                // Post-install notification with auto-launch
-                console.log('\n' + boxen(
-                    chalk.bold.yellow('⚠️  ACTION REQUIRED: SIGN IN ') + '\n\n' +
-                    chalk.white('1. I will launch AWS Kiro IDE for you.') + '\n' +
-                    chalk.white('2. Sign in with Google, GitHub, or AWS Builder ID.') + '\n' +
-                    chalk.white('3. Click "Skip all" to skip survey questions.') + '\n' +
-                    chalk.white('4. Once signed in, you can minimize or close the IDE.') + '\n\n' +
-                    chalk.cyan('You must sign in for the CLI to control the IDE.'),
-                    {
-                        padding: 1,
-                        margin: 1,
-                        borderStyle: 'round',
-                        borderColor: 'yellow'
-                    }
-                ));
+                // default fallback: try binary name same as id
+                alreadyInstalled = await checkAppOrBinary([], [ideId]);
+            }
+        } catch (e) {
+            // detection error: assume not installed
+            alreadyInstalled = false;
+        }
 
-                await inquirer.prompt([{
-                    type: 'input',
-                    name: 'launch',
-                    message: 'Press Enter and I will launch Kiro for you to sign in to...'
-                }]);
+        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
+            }
+        }
 
-                const { exec } = require('child_process');
-                console.log(chalk.gray('Launching AWS Kiro...'));
+        if (!installerModule) {
+            console.log(chalk.gray(`No installer module found for ${ideId}, skipping automated install.`));
+            continue;
+        }
 
-                try {
-                    // Try to open AWS Kiro
-                    exec('open -a "AWS Kiro"', (error) => {
-                        if (error) {
-                            // Fallback to just Kiro
-                            exec('open -a "Kiro"', (err) => {
-                                if (err) {
-                                    console.log(chalk.red('Could not auto-launch Kiro. Please open it manually.'));
-                                }
-                            });
-                        }
-                    });
-                } catch (e) {
-                    // Ignore errors, user can launch manually
-                }
+        // 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;
+        }
 
-                await inquirer.prompt([{
-                    type: 'input',
-                    name: 'continue',
-                    message: 'Press Enter once you have signed in...'
-                }]);
+        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
-    // Enable detected IDEs AND selected IDEs, disable others
+    // 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 = {};
-
-    defaultOrder.forEach(id => {
-        // Enable if it was detected OR selected
-        // For LLMs (not 'ide' type), keep enabled by default
+    for (const id of defaultOrder) {
         const def = definitions.find(d => d.id === id);
         if (def && def.type === 'ide') {
-            const isDetected = detectedIDEs.some(d => d.id === id);
+            const isDetectedNow = reDetected.includes(id);
             const isSelected = selectedIDEs.includes(id);
-            enabledMap[id] = isDetected || isSelected;
+            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.
@@ -261,7 +379,7 @@ async function checkFirstRun() {
         await inquirer.prompt([{
             type: 'input',
             name: 'continue',
-            message: 'Press Enter to continue...'
+            message: t('interactive.press.enter.continue')
         }]);
     }
 
@@ -278,7 +396,7 @@ async function checkFirstRun() {
         }
     ));
 
-    console.log(chalk.cyan('Press any key to continue to the main menu...'));
+    console.log(chalk.cyan(t('interactive.press.any.key.menu')));
 
     await new Promise((resolve) => {
         process.stdin.setRawMode(true);