vibecodingmachine-cli 2025.12.6-1702 → 2025.12.22-2230

package/src/utils/copy-with-progress.js

@@ -0,0 +1,167 @@
+const { spawn, execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+
+function progressBar(percent, width) {
+  const fill = Math.round((percent / 100) * width);
+  return '█'.repeat(fill) + '-'.repeat(Math.max(0, width - fill));
+}
+
+function formatEta(sec) {
+  if (!isFinite(sec) || sec === null) return '--:--';
+  const s = Math.max(0, Math.round(sec));
+  const m = Math.floor(s / 60);
+  const ss = s % 60;
+  return `${m}:${ss.toString().padStart(2, '0')}`;
+}
+
+async function tryRsync(src, dest, spinner, timeoutMs = 5 * 60 * 1000) {
+  try {
+    execSync('which rsync', { stdio: 'ignore' });
+  } catch (e) {
+    return false;
+  }
+  // choose progress option based on rsync version
+  let rsyncArgs = ['-a'];
+  try {
+    const verOut = execSync('rsync --version', { encoding: 'utf8', timeout: 2000 });
+    const m = verOut.match(/version\s+(\d+)\.(\d+)/i);
+    if (m) {
+      const major = Number(m[1]);
+      const minor = Number(m[2] || 0);
+      if (major > 3 || (major === 3 && minor >= 1)) {
+        rsyncArgs.push('--info=progress2');
+      } else {
+        rsyncArgs.push('--progress');
+      }
+    } else {
+      rsyncArgs.push('--progress');
+    }
+  } catch (e) {
+    rsyncArgs.push('--progress');
+  }
+
+  return await new Promise((resolve) => {
+    const rsync = spawn('rsync', rsyncArgs.concat([src + '/', dest]), { stdio: 'inherit' });
+    let finished = false;
+    const to = setTimeout(() => {
+      if (!finished) {
+        try { rsync.kill('SIGINT'); } catch (e) { /* ignore */ }
+        resolve(false);
+      }
+    }, timeoutMs);
+    rsync.on('close', (code) => { finished = true; clearTimeout(to); resolve(code === 0); });
+    rsync.on('error', () => { finished = true; clearTimeout(to); resolve(false); });
+  });
+}
+
+async function tryDitto(src, dest, spinner, timeoutMs = 5 * 60 * 1000) {
+  try {
+    await fs.ensureDir(path.dirname(dest));
+    return await new Promise((resolve) => {
+      const ditto = spawn('ditto', ['-v', src, dest], { stdio: 'inherit' });
+      let finished = false;
+      const to = setTimeout(() => {
+        if (!finished) {
+          try { ditto.kill('SIGINT'); } catch (e) { /* ignore */ }
+          resolve(false);
+        }
+      }, timeoutMs);
+      ditto.on('close', (code) => { finished = true; clearTimeout(to); resolve(code === 0); });
+      ditto.on('error', () => { finished = true; clearTimeout(to); resolve(false); });
+    });
+  } catch (e) {
+    return false;
+  }
+}
+
+async function nodeStreamCopy(src, dest, _spinner) {
+  // Determine total size (attempt du -sk fallback to recursive stat)
+  let total = 0;
+  try {
+    const out = execSync(`du -sk "${src}" | cut -f1`, { encoding: 'utf8' }).trim();
+    total = Number(out) * 1024;
+  } catch (e) {
+    // fallback: sum file sizes via traversal
+    await (async function walk(p) {
+      const entries = await fs.readdir(p);
+      for (const e of entries) {
+        const full = path.join(p, e);
+        const stat = await fs.stat(full);
+        if (stat.isDirectory()) await walk(full);
+        else total += stat.size;
+      }
+    })(src);
+  }
+
+  let copied = 0;
+  const start = Date.now();
+  const width = 30;
+
+  async function copyEntry(srcPath, dstPath) {
+    const stat = await fs.stat(srcPath);
+    if (stat.isDirectory()) {
+      await fs.ensureDir(dstPath);
+      const entries = await fs.readdir(srcPath);
+      for (const e of entries) {
+        await copyEntry(path.join(srcPath, e), path.join(dstPath, e));
+      }
+    } else {
+      await fs.ensureDir(path.dirname(dstPath));
+      await new Promise((resolve, reject) => {
+        const rs = fs.createReadStream(srcPath);
+        const ws = fs.createWriteStream(dstPath);
+        rs.on('data', (chunk) => {
+          copied += chunk.length;
+          if (total) {
+            const percent = Math.round((copied / total) * 100);
+            const mbCopied = (copied / (1024 * 1024)).toFixed(1);
+            const mbTotal = (total / (1024 * 1024)).toFixed(1);
+            const elapsed = Math.max(0.001, (Date.now() - start) / 1000);
+            const speed = copied / elapsed;
+            const eta = formatEta((total - copied) / (speed || 1));
+            const bar = progressBar(percent, width);
+            process.stdout.write(`\r\x1b[2K[${bar}] ${percent}% ${mbCopied}MB / ${mbTotal}MB ETA: ${eta}`);
+          } else {
+            process.stdout.write(`\r\x1b[2KCopying ${ (copied/(1024*1024)).toFixed(1) } MB`);
+          }
+        });
+        rs.on('error', reject);
+        ws.on('error', reject);
+        ws.on('close', resolve);
+        rs.pipe(ws);
+      });
+    }
+  }
+
+  await copyEntry(src, dest);
+  process.stdout.write('\n');
+  return true;
+}
+
+async function copyAppWithProgress(src, dest, opts = {}) {
+  const spinner = (opts && opts.spinner) || { start: () => {}, stop: () => {}, fail: () => {}, succeed: () => {} };
+
+  // Try rsync first
+  spinner.stop && spinner.stop();
+  console.log(`Copying ${path.basename(src)} -> ${dest} (attempting rsync...)`);
+  const okRsync = await tryRsync(src, dest, spinner);
+  if (okRsync) return true;
+
+  // Try ditto (macOS)
+  console.log('rsync failed or not available — trying ditto...');
+  const okDitto = await tryDitto(src, dest, spinner);
+  if (okDitto) return true;
+
+  // Fallback to Node streaming copy with progress
+  console.log('Falling back to node-stream copy with progress...');
+  try {
+    await nodeStreamCopy(src, dest, spinner);
+    return true;
+  } catch (e) {
+    console.error('node-stream copy failed:', e.message || e);
+    return false;
+  }
+}
+
+module.exports = { copyAppWithProgress };

package/src/utils/download-with-progress.js

@@ -0,0 +1,84 @@
+const fs = require('fs');
+const ora = require('ora');
+
+async function downloadWithProgress(url, dest, opts = {}) {
+  const fetch = require('node-fetch');
+  const spinner = opts.spinner || ora();
+  const label = opts.label || 'Downloading...';
+
+  spinner.start(label);
+
+  const res = await fetch(url);
+  if (!res.ok) {
+    spinner.fail(`Download failed: ${res.status} ${res.statusText}`);
+    throw new Error(`Failed to download ${url}: ${res.status}`);
+  }
+  // Stop the ora spinner so we can write an in-place progress line without conflicts
+  try { spinner.stop(); } catch (e) { /* ignore */ }
+  // Print initial progress line so user sees immediate feedback
+  try { process.stdout.write('\r\x1b[2KDownloading: 0.0 MB'); } catch (e) { /* ignore */ }
+
+  const total = Number(res.headers.get('content-length')) || 0;
+  const fileStream = fs.createWriteStream(dest);
+
+  return await new Promise((resolve, reject) => {
+    let downloaded = 0;
+    const start = Date.now();
+    let lastPercent = -1;
+
+    res.body.on('data', (chunk) => {
+      downloaded += chunk.length;
+      if (total) {
+        const percent = Math.round((downloaded / total) * 100);
+        if (percent !== lastPercent) {
+          lastPercent = percent;
+          const mbDownloaded = (downloaded / (1024 * 1024)).toFixed(1);
+          const mbTotal = (total / (1024 * 1024)).toFixed(1);
+          const elapsed = Math.max(0.001, (Date.now() - start) / 1000);
+          const speed = downloaded / elapsed; // bytes/sec
+          const etaSec = (total - downloaded) / (speed || 1);
+          const eta = formatEta(etaSec);
+          const bar = progressBar(percent, 30);
+          process.stdout.write(`\r\x1b[2K[${bar}] ${percent}% ${mbDownloaded}MB / ${mbTotal}MB ETA: ${eta}`);
+        }
+      } else {
+        const mbDownloaded = (downloaded / (1024 * 1024)).toFixed(1);
+        process.stdout.write(`\r\x1b[2K${label} ${mbDownloaded} MB`);
+      }
+    });
+
+    res.body.on('error', (err) => {
+      spinner.fail('Download error');
+      reject(err);
+    });
+
+    fileStream.on('error', (err) => {
+      spinner.fail('File write error');
+      reject(err);
+    });
+
+    fileStream.on('finish', () => {
+      process.stdout.write('\n');
+      spinner.succeed('Download complete');
+      resolve();
+    });
+
+    // Pipe the response body to file
+    res.body.pipe(fileStream);
+  });
+}
+
+function progressBar(percent, width) {
+  const fill = Math.round((percent / 100) * width);
+  return '█'.repeat(fill) + '-'.repeat(Math.max(0, width - fill));
+}
+
+function formatEta(sec) {
+  if (!isFinite(sec) || sec === null) return '--:--';
+  const s = Math.max(0, Math.round(sec));
+  const m = Math.floor(s / 60);
+  const ss = s % 60;
+  return `${m}:${ss.toString().padStart(2, '0')}`;
+}
+
+module.exports = { downloadWithProgress };

package/src/utils/first-run.js

@@ -5,7 +5,90 @@ 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 { 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');
@@ -85,7 +168,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 +175,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 +224,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.