vibecodingmachine-cli 2026.1.29-713 → 2026.2.20-423

package/src/utils/feedback-handler.js

@@ -0,0 +1,143 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const readline = require('readline');
+const { t } = require('vibecodingmachine-core');
+const pkg = require('../../package.json');
+
+/**
+ * Handle feedback submission
+ */
+async function handleFeedbackSubmission() {
+  console.log(chalk.bold.cyan('\n📣 ' + t('interactive.feedback.title')));
+  console.log(chalk.gray(t('interactive.feedback.instructions') + '\n'));
+
+  const { getUserProfile } = require('./auth');
+  const userProfile = await getUserProfile();
+  const userEmail = userProfile ? userProfile.email : 'anonymous';
+
+  // Ask if user wants to include a screenshot
+  let includeScreenshot = false;
+  let screenshotData = null;
+
+  try {
+    const { screenshot } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'screenshot',
+      message: 'Include a screenshot with your feedback?',
+      default: false
+    }]);
+
+    includeScreenshot = screenshot;
+
+    if (includeScreenshot) {
+      console.log(chalk.gray('📸 Capturing screenshot...'));
+      try {
+        const screenshot = require('screenshot-desktop');
+        const imgBuffer = await screenshot({ format: 'png' });
+        
+        // Convert to base64 and check size
+        const base64 = imgBuffer.toString('base64');
+        const dataUrl = `data:image/png;base64,${base64}`;
+        const size = Buffer.byteLength(dataUrl, 'utf8');
+        
+        // Much stricter size limit - 100KB max
+        if (size > 100 * 1024) {
+          console.log(chalk.yellow('⚠️ Screenshot is too large, submitting feedback without screenshot'));
+          includeScreenshot = false;
+        } else {
+          screenshotData = dataUrl;
+          console.log(chalk.green(`✅ Screenshot captured (${(size / 1024).toFixed(2)} KB)`));
+        }
+      } catch (screenshotError) {
+        console.log(chalk.yellow('⚠️ Failed to capture screenshot, continuing without it'));
+        includeScreenshot = false;
+      }
+    }
+  } catch (err) {
+    // User cancelled or error occurred
+    includeScreenshot = false;
+  }
+
+  console.log(chalk.gray('\n' + t('interactive.feedback.comment.instructions') + '\n'));
+
+  const commentLines = [];
+  let emptyLineCount = 0;
+  let isFirstLine = true;
+
+  while (true) {
+    try {
+      const { line } = await inquirer.prompt([{
+        type: 'input',
+        name: 'line',
+        message: isFirstLine ? t('interactive.feedback.comment') : ''
+      }]);
+
+      isFirstLine = false;
+
+      if (line.trim() === '') {
+        emptyLineCount++;
+        if (emptyLineCount >= 2) break;
+      } else {
+        emptyLineCount = 0;
+        commentLines.push(line);
+      }
+    } catch (err) {
+      break;
+    }
+  }
+
+  const comment = commentLines.join('\n');
+
+  if (!comment || comment.trim().length === 0) {
+    console.log(chalk.yellow('\n⚠️  ' + t('interactive.feedback.cancelled')));
+    return;
+  }
+
+  try {
+    console.log(chalk.gray('\n' + t('interactive.feedback.submitting') + '...'));
+
+    const auth = require('./auth');
+    const UserDatabase = require('vibecodingmachine-core/src/database/user-schema');
+    const userDb = new UserDatabase();
+
+    // Set auth token for API requests
+    const token = await auth.getAuthToken();
+    if (token) {
+      userDb.setAuthToken(token);
+    }
+
+    const feedbackData = {
+      email: userEmail,
+      comment: comment,
+      interface: 'cli',
+      version: pkg.version,
+      type: 'cli_feedback'
+    };
+
+    if (includeScreenshot && screenshotData) {
+      feedbackData.screenshot = screenshotData;
+    }
+
+    await userDb.submitFeedback(feedbackData);
+
+    console.log(chalk.green('\n✓ ' + t('interactive.feedback.success')));
+  } catch (error) {
+    console.log(chalk.red('\n✗ ' + t('interactive.feedback.error') + ': ') + error.message);
+  }
+
+  console.log(chalk.gray(`\n${t('interactive.press.enter.continue')}`));
+  await new Promise(resolve => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question('', () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+module.exports = {
+  handleFeedbackSubmission
+};

package/src/utils/ide-detection-complete.js

@@ -0,0 +1,126 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs-extra');
+const { exec } = require('child_process');
+const util = require('util');
+const execAsync = util.promisify(exec);
+
+/**
+ * Check if a VS Code extension is installed
+ * @param {string} extensionId - Extension ID to check
+ * @returns {boolean} - Whether extension is installed
+ */
+async function checkVSCodeExtension(extensionId) {
+  // Check if a VS Code extension is installed
+  try {
+    const { stdout } = await execAsync('code --list-extensions', { timeout: 5000 });
+    const extensions = stdout.toLowerCase().split('\n').map(e => e.trim());
+
+    // Map common extension IDs to their actual extension IDs
+    const extensionMap = {
+      'github-copilot': 'github.copilot',
+      'amazon-q': 'amazonwebservices.amazon-q-vscode'
+    };
+
+    const actualExtensionId = extensionMap[extensionId] || extensionId;
+    return extensions.includes(actualExtensionId.toLowerCase());
+  } catch (error) {
+    // If code CLI is not available or command fails, return false
+    return false;
+  }
+}
+
+/**
+ * Check if applications or binaries exist on the system
+ * @param {string[]} names - App bundle base names (e.g., 'Cursor' -> /Applications/Cursor.app)
+ * @param {string[]} binaries - CLI binary names to check on PATH (e.g., 'code')
+ * @returns {boolean} - Whether any of the specified apps/bins are found
+ */
+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
+                    // Use async exec to avoid blocking the event loop
+                    await execAsync(`spctl --assess -v "${p}"`, { timeout: 5000 });
+
+                    // additionally validate codesign quickly (timeout to avoid hangs)
+                    try {
+                      await execAsync(`codesign -v --deep --strict "${p}"`, { 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 { stdout } = await execAsync(`xattr -p com.apple.quarantine "${p}" 2>/dev/null || true`, { encoding: 'utf8' });
+                      const out = stdout.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 {
+      await execAsync(`which ${bin}`, { timeout: 2000 });
+      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;
+}
+
+module.exports = {
+  checkVSCodeExtension,
+  checkAppOrBinary
+};

package/src/utils/ide-detection-extracted.js

@@ -0,0 +1,116 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs-extra');
+const { exec } = require('child_process');
+const util = require('util');
+const execAsync = util.promisify(exec);
+
+async function checkVSCodeExtension(extensionId) {
+  // Check if a VS Code extension is installed
+  try {
+    const { stdout } = await execAsync('code --list-extensions', { timeout: 5000 });
+    const extensions = stdout.toLowerCase().split('\n').map(e => e.trim());
+
+    // Map common extension IDs to their actual extension IDs
+    const extensionMap = {
+      'github-copilot': 'github.copilot',
+      'amazon-q': 'amazonwebservices.amazon-q-vscode',
+      'cline': 'saoudrizwan.claude-dev'
+    };
+
+    const actualExtensionId = extensionMap[extensionId] || extensionId;
+    return extensions.includes(actualExtensionId.toLowerCase());
+  } catch (error) {
+    // If code CLI is not available or command fails, return false
+    return false;
+  }
+}
+
+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
+                    // Use async exec to avoid blocking the event loop
+                    await execAsync(`spctl --assess -v "${p}"`, { timeout: 5000 });
+
+                    // additionally validate codesign quickly (timeout to avoid hangs)
+                    try {
+                      await execAsync(`codesign -v --deep --strict "${p}"`, { 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 { stdout } = await execAsync(`xattr -p com.apple.quarantine "${p}" 2>/dev/null || true`, { encoding: 'utf8' });
+                      const out = stdout.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 {
+      await execAsync(`which ${bin}`, { timeout: 2000 });
+      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;
+}
+
+module.exports = {
+  checkVSCodeExtension,
+  checkAppOrBinary
+};

package/src/utils/ide-detection.js

@@ -0,0 +1,124 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs-extra');
+const { exec } = require('child_process');
+const util = require('util');
+const execAsync = util.promisify(exec);
+
+/**
+ * Check if a VS Code extension is installed
+ * @param {string} extensionId - Extension ID to check
+ * @returns {boolean} - Whether extension is installed
+ */
+async function checkVSCodeExtension(extensionId) {
+  try {
+    const { stdout } = await execAsync('code --list-extensions', { timeout: 5000 });
+    const extensions = stdout.toLowerCase().split('\n').map(e => e.trim());
+
+    // Map common extension IDs to their actual extension IDs
+    const extensionMap = {
+      'github-copilot': 'github.copilot',
+      'amazon-q': 'amazonwebservices.amazon-q-vscode'
+    };
+
+    const actualExtensionId = extensionMap[extensionId] || extensionId;
+    return extensions.includes(actualExtensionId.toLowerCase());
+  } catch (error) {
+    // If code CLI is not available or command fails, return false
+    return false;
+  }
+}
+
+/**
+ * Check if applications or binaries exist on the system
+ * @param {string[]} names - App bundle base names (e.g., 'Cursor' -> /Applications/Cursor.app)
+ * @param {string[]} binaries - CLI binary names to check on PATH (e.g., 'code')
+ * @returns {boolean} - Whether any of the specified apps/bins are found
+ */
+async function checkAppOrBinary(names = [], binaries = []) {
+  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
+                    // Use async exec to avoid blocking the event loop
+                    await execAsync(`spctl --assess -v "${p}"`, { timeout: 5000 });
+
+                    // additionally validate codesign quickly (timeout to avoid hangs)
+                    try {
+                      await execAsync(`codesign -v --deep --strict "${p}"`, { 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 { stdout } = await execAsync(`xattr -p com.apple.quarantine "${p}" 2>/dev/null || true`, { encoding: 'utf8' });
+                      const out = stdout.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 {
+      await execAsync(`which ${bin}`, { timeout: 2000 });
+      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;
+}
+
+module.exports = {
+  checkVSCodeExtension,
+  checkAppOrBinary
+};