vibecodingmachine-cli 2025.12.1-534 → 2025.12.22-2230

package/bin/vibecodingmachine.js

@@ -3,10 +3,12 @@
 const path = require('path');
 const fs = require('fs');
 
-// Auto-load .env.auth if it exists
-const envAuthPath = path.join(__dirname, '..', '..', '.env.auth');
-if (fs.existsSync(envAuthPath)) {
-  const envContent = fs.readFileSync(envAuthPath, 'utf8');
+// Auto-load .env.cognito from root
+const rootDir = path.join(__dirname, '..', '..', '..');
+const envCognitoPath = path.join(rootDir, '.env.cognito');
+
+if (fs.existsSync(envCognitoPath)) {
+  const envContent = fs.readFileSync(envCognitoPath, 'utf8');
   envContent.split('\n').forEach(line => {
     const trimmed = line.trim();
     if (trimmed && !trimmed.startsWith('#')) {
@@ -23,10 +25,23 @@ if (fs.existsSync(envAuthPath)) {
  * "Big Dreams + AI + VibeCodingMachine.com = Your money making apps"
  */
 
+const { cleanupBrokenAssets } = require('../src/utils/asset-cleanup');
+
+(async () => {
+  // mitigate broken assets issue
+  await cleanupBrokenAssets();
+})();
+
 const { program } = require('commander');
 const chalk = require('chalk');
 const inquirer = require('inquirer');
-const { execSync } = require('child_process');
+const { execSync, spawn } = require('child_process');
+const ora = require('ora');
+const https = require('https');
+const os = require('os');
+const { pipeline } = require('stream');
+const { promisify } = require('util');
+const streamPipeline = promisify(pipeline);
 // const path = require('path'); // Moved to top for .env.auth loading
 const packageJson = require('../package.json');
 
@@ -108,6 +123,11 @@ program
   .option('--no-never-stop', 'Disable never stop mode')
   .action(autoCommands.config);
 
+program
+  .command('auto:agents')
+  .description('List available agents and their quota status')
+  .action(autoCommands.listAgents);
+
 // Requirements management commands
 program
   .command('req:list')
@@ -140,6 +160,11 @@ program
   .description('Watch requirements file for changes')
   .action(reqCommands.watch);
 
+program
+  .command('req:rename <old-title> <new-title> [description...]')
+  .description('Rename requirement and optionally update description')
+  .action((oldTitle, newTitle, description) => reqCommands.rename(oldTitle, newTitle, description));
+
 // IDE integration commands
 program
   .command('ide:list')
@@ -201,6 +226,76 @@ program
   .description('Check authentication status')
   .action(authCommands.status);
 
+// Multi-computer management commands
+const computerCommands = require('../src/commands/computers');
+const remoteReqCommands = require('../src/commands/requirements-remote');
+program
+  .command('computers')
+  .description('List all registered computers')
+  .option('-f, --focus <area>', 'Filter by focus area')
+  .option('-s, --status <status>', 'Filter by status (active, idle, error)')
+  .action(computerCommands.listComputers);
+
+program
+  .command('computer:status <computerId>')
+  .description('Show detailed status of a specific computer')
+  .action(computerCommands.showComputerStatus);
+
+program
+  .command('computer:register <focusArea>')
+  .description('Register current computer with focus area')
+  .action(computerCommands.registerComputer);
+
+program
+  .command('computer:focus [newFocusArea]')
+  .description('View or update focus area for current computer')
+  .action((newFocusArea) => {
+    if (newFocusArea) {
+      computerCommands.updateFocus(newFocusArea);
+    } else {
+      // Show current focus
+      computerCommands.showComputerStatus(require('os').hostname());
+    }
+  });
+
+program
+  .command('computer:requirements <computerId>')
+  .description('View requirements for another computer')
+  .action(remoteReqCommands.listRemoteRequirements);
+
+program
+  .command('computer:add-requirement <computerId> <requirement>')
+  .description('Add requirement to another computer')
+  .action(remoteReqCommands.addRemoteRequirement);
+
+// Sync management commands
+const syncCommands = require('../src/commands/sync');
+program
+  .command('sync:now')
+  .description('Trigger immediate sync')
+  .action(syncCommands.syncNow);
+
+program
+  .command('sync:status')
+  .description('Show sync status and statistics')
+  .action(syncCommands.syncStatus);
+
+program
+  .command('sync:queue')
+  .description('View pending changes in offline queue')
+  .action(syncCommands.viewQueue);
+
+program
+  .command('sync:force')
+  .description('Force sync even if offline')
+  .action(syncCommands.forceSync);
+
+program
+  .command('sync:history')
+  .description('View sync history')
+  .option('-n, --limit <number>', 'Number of history entries to show', '50')
+  .action(syncCommands.viewHistory);
+
 // Interactive mode
 program
   .command('interactive')
@@ -214,18 +309,33 @@ program
 // Error handling
 process.on('uncaughtException', (error) => {
   console.error(chalk.red('Error:'), error.message);
+  if (process.env.DEBUG) {
+    console.error(chalk.gray('Stack:'), error.stack);
+  }
   process.exit(1);
 });
 
 process.on('unhandledRejection', (error) => {
   console.error(chalk.red('Error:'), error.message);
+  if (process.env.DEBUG) {
+    console.error(chalk.gray('Stack:'), error.stack);
+  }
   process.exit(1);
 });
 
 // Check for updates and display notification
 async function checkForUpdates() {
   try {
+    if (process.env.VCM_SKIP_UPDATE_CHECK === '1' || process.env.VCM_SKIP_UPDATE_CHECK === 'true') {
+      return;
+    }
     const { checkForCLIUpdates } = require('vibecodingmachine-core');
+    // If running inside the repository (local development), skip update checks entirely
+    const isDevWorkspace = fs.existsSync(path.join(rootDir, '.git'));
+    if (isDevWorkspace) {
+      console.log(chalk.yellow('\nDetected local development workspace; skipping update check.'));
+      return;
+    }
     console.log(chalk.gray(`\n🔍 Checking for updates... (current: v${packageJson.version})`));
     const updateInfo = await checkForCLIUpdates(packageJson.version);
     console.log(chalk.gray(`   Update check result: ${JSON.stringify(updateInfo)}\n`));
@@ -251,14 +361,136 @@ async function checkForUpdates() {
       if (answer.shouldUpdate) {
         console.log(chalk.cyan('\n🔄 Updating VibeCodingMachine CLI...\n'));
         try {
-          // Run npm install with inherited stdio to show progress
-          execSync('npm install -g vibecodingmachine-cli@latest', {
-            stdio: 'inherit',
-            encoding: 'utf8'
+          // If we're running from the repository (local dev), avoid performing a global install
+          const isDevWorkspace = fs.existsSync(path.join(rootDir, '.git'));
+          if (isDevWorkspace) {
+            console.log(chalk.yellow('\nDetected local development workspace; skipping automatic global install.'));
+            console.log(chalk.gray('   To update the globally installed CLI run:') + ' ' + chalk.bold.white('npm install -g vibecodingmachine-cli@latest\n'));
+            // Do not attempt global install during development to avoid confusing local dev flow
+            return;
+          }
+          const spinner = ora('Fetching package metadata...').start();
+
+          // Get latest package metadata from npm registry
+          const registryUrl = 'https://registry.npmjs.org/vibecodingmachine-cli/latest';
+          const meta = await new Promise((resolve, reject) => {
+            https.get(registryUrl, (res) => {
+              let data = '';
+              res.on('data', (chunk) => data += chunk);
+              res.on('end', () => {
+                try {
+                  resolve(JSON.parse(data));
+                } catch (err) {
+                  reject(err);
+                }
+              });
+            }).on('error', reject);
+          });
+
+          const tarball = meta && meta.dist && meta.dist.tarball;
+          if (!tarball) {
+            spinner.fail('Could not determine tarball URL for update');
+            console.log(chalk.yellow('   You can manually update with: ') + chalk.bold.white('npm install -g vibecodingmachine-cli@latest\n'));
+            return;
+          }
+
+          spinner.text = 'Resolving tarball...';
+
+          // HEAD to get content-length
+          const totalBytes = await new Promise((resolve) => {
+            const req = https.request(tarball, { method: 'HEAD' }, (res) => {
+              const len = parseInt(res.headers['content-length'] || '0', 10);
+              resolve(Number.isFinite(len) ? len : 0);
+            });
+            req.on('error', () => resolve(0));
+            req.end();
           });
-          console.log(chalk.green('\n✅ Successfully updated to v' + updateInfo.latestVersion + '!'));
-          console.log(chalk.gray('   Please restart your command to use the new version.\n'));
-          process.exit(0);
+
+          const tmpFile = path.join(os.tmpdir(), `vcm-update-${Date.now()}.tgz`);
+
+          // Download tarball with progress
+          spinner.text = 'Downloading update...';
+          // Stop the spinner so we can write a single-line progress indicator without conflicts
+          try { spinner.stop(); } catch (e) {}
+          // Print initial progress line (clear line first)
+          process.stdout.write('\r\x1b[2KDownloading: 0% — 0.0 MB');
+          const progressStart = Date.now();
+          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')}`;
+          }
+          await new Promise((resolve, reject) => {
+            https.get(tarball, (res) => {
+              const fileStream = fs.createWriteStream(tmpFile);
+              let downloaded = 0;
+
+              // Print an updating single-line progress indicator (percent + MB)
+              let lastPercent = -1;
+              let lastMbReported = -1;
+              res.on('data', (chunk) => {
+                downloaded += chunk.length;
+                const percent = totalBytes ? Math.round((downloaded / totalBytes) * 100) : null;
+                const mbDownloaded = +(downloaded / (1024 * 1024));
+                const mbTotal = totalBytes ? (totalBytes / (1024 * 1024)) : null;
+
+                // ETA and speed
+                const elapsedSec = Math.max(0.001, (Date.now() - progressStart) / 1000);
+                const speed = downloaded / elapsedSec; // bytes/sec
+                const remaining = totalBytes ? Math.max(0, totalBytes - downloaded) : null;
+                const etaSec = remaining && speed > 0 ? remaining / speed : null;
+
+                // Build simple ASCII progress bar
+                const width = 30;
+                const fill = percent !== null ? Math.round((percent / 100) * width) : Math.min(width, Math.max(0, Math.round((mbDownloaded / (mbTotal || 1)) * width)));
+                const bar = '█'.repeat(fill) + '-'.repeat(Math.max(0, width - fill));
+
+                const pctText = percent !== null ? `${percent}%` : '--%';
+                const mbText = mbTotal ? `${mbDownloaded.toFixed(1)} MB / ${mbTotal.toFixed(1)} MB` : `${mbDownloaded.toFixed(1)} MB`;
+                const etaText = etaSec ? formatEta(etaSec) : '--:--';
+
+                // Update only when percent changes or every 0.5 MB to reduce noise
+                const mbReport = Math.floor(mbDownloaded * 2) / 2;
+                if ((percent !== null && percent !== lastPercent) || (percent === null && mbReport !== lastMbReported) || Math.random() < 0.001) {
+                  lastPercent = percent;
+                  lastMbReported = mbReport;
+                  process.stdout.write(`\r\x1b[2K[${bar}] ${pctText} ${mbText} ETA: ${etaText}`);
+                }
+              });
+
+              res.on('end', () => fileStream.end());
+              res.on('error', (err) => reject(err));
+
+              fileStream.on('finish', () => resolve());
+              fileStream.on('error', (err) => reject(err));
+
+              res.pipe(fileStream);
+            }).on('error', reject);
+          });
+
+          // Ensure progress line ends and move to next line
+          process.stdout.write('\n');
+          spinner.start();
+          spinner.succeed('Downloaded update');
+
+          // Install the downloaded tarball
+          spinner.start('Installing update...');
+          try {
+            execSync(`npm install -g "${tmpFile}"`, { stdio: 'inherit', encoding: 'utf8' });
+            spinner.succeed('Installed update');
+            console.log(chalk.green('\n✅ Successfully updated to v' + updateInfo.latestVersion + '!'));
+            console.log(chalk.gray('   Please restart your command to use the new version.\n'));
+            // Cleanup
+            try { fs.unlinkSync(tmpFile); } catch (e) {}
+            process.exit(0);
+          } catch (err) {
+            spinner.fail('Installation failed');
+            console.log(chalk.red('\n❌ Update failed:'), err.message);
+            console.log(chalk.yellow('   You can manually update with: ') + chalk.bold.white('npm install -g vibecodingmachine-cli@latest\n'));
+            try { fs.unlinkSync(tmpFile); } catch (e) {}
+          }
         } catch (error) {
           console.log(chalk.red('\n❌ Update failed:'), error.message);
           console.log(chalk.yellow('   You can manually update with: ') + chalk.bold.white('npm install -g vibecodingmachine-cli@latest\n'));
@@ -281,6 +513,10 @@ if (!process.argv.slice(2).length) {
     // Check for updates first
     await checkForUpdates();
 
+    // Check for first run experience
+    const { checkFirstRun } = require('../src/utils/first-run');
+    await checkFirstRun();
+
     // Check authentication before allowing interactive mode
     const auth = require('../src/utils/auth');
     const isAuth = await auth.isAuthenticated();
@@ -296,6 +532,18 @@ if (!process.argv.slice(2).length) {
       }
     }
 
+    // Check compliance after authentication
+    const { checkCompliance } = require('../src/utils/compliance-check');
+    const isCompliant = await checkCompliance();
+    
+    if (!isCompliant) {
+      console.log(chalk.red('\n✗ Compliance check failed. Exiting.\n'));
+      process.exit(1);
+    }
+
+    // Track CLI usage - interactive mode
+    await auth.trackCLIActivity('interactive_mode_started');
+
     const { startInteractive } = require('../src/utils/interactive');
     await startInteractive();
   })();
@@ -303,6 +551,47 @@ if (!process.argv.slice(2).length) {
   // Check for updates before parsing commands
   (async () => {
     await checkForUpdates();
+    
+    // Check authentication for all commands (except auth commands)
+    const command = process.argv[2] || 'unknown';
+    const authCommands = ['auth:login', 'auth:logout', 'auth:status'];
+    const skipAuthCheck = authCommands.includes(command);
+    
+    const auth = require('../src/utils/auth');
+    
+    if (!skipAuthCheck) {
+      const isAuth = await auth.isAuthenticated();
+      
+      if (!isAuth) {
+        console.log(chalk.cyan('\n🔐 Opening browser for authentication...\n'));
+        try {
+          await auth.login();
+          console.log(chalk.green('\n✓ Authentication successful!\n'));
+        } catch (error) {
+          console.log(chalk.red('\n✗ Authentication failed:'), error.message);
+          process.exit(1);
+        }
+      }
+    }
+    
+    // Check compliance after authentication (skip for auth commands)
+    if (!skipAuthCheck) {
+      const { checkCompliance } = require('../src/utils/compliance-check');
+      const isCompliant = await checkCompliance();
+      
+      if (!isCompliant) {
+        console.log(chalk.red('\n✗ Compliance check failed. Exiting.\n'));
+        process.exit(1);
+      }
+      
+      // Track CLI usage - command execution
+      const args = process.argv.slice(3);
+      await auth.trackCLIActivity('command_executed', {
+        command,
+        args: args.filter(arg => !arg.includes('password') && !arg.includes('token'))
+      });
+    }
+    
     // Parse arguments only if commands were provided
     program.parse(process.argv);
   })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecodingmachine-cli",
-  "version": "2025.12.01-0534",
+  "version": "2025.12.22-2230",
   "description": "Command-line interface for Vibe Coding Machine - Autonomous development",
   "main": "src/index.js",
   "bin": {
@@ -25,10 +25,13 @@
   "author": "Vibe Coding Machine Team",
   "license": "MIT",
   "dependencies": {
-    "vibecodingmachine-core": "^2025.12.01-0534",
+    "vibecodingmachine-core": "^2025.12.22-2230",
+    "@aws-sdk/client-dynamodb": "^3.600.0",
+    "@aws-sdk/lib-dynamodb": "^3.600.0",
     "boxen": "^5.1.2",
     "chalk": "^4.1.2",
     "chokidar": "^3.6.0",
+    "cli-table3": "^0.6.3",
     "commander": "^11.1.0",
     "fs-extra": "^11.2.0",
     "ink": "^6.4.0",

package/repro_open.js

@@ -0,0 +1,13 @@
+try {
+    const open = require('open');
+    console.log('Type of open:', typeof open);
+    console.log('open:', open);
+    if (typeof open !== 'function') {
+        console.log('Exports:', Object.keys(open));
+        if (open.default) {
+            console.log('Type of open.default:', typeof open.default);
+        }
+    }
+} catch (e) {
+    console.error('Require failed:', e.message);
+}

package/reproduce_issue.js

@@ -0,0 +1,160 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { getRequirementsPath } = require('vibecodingmachine-core');
+const { getRepoPath } = require('./src/utils/config');
+const requirements = require('./src/commands/requirements');
+
+// Mock specific functions we need from interactive.js's logic
+// helping function to move requirement to recycled (deletion logic)
+async function moveRequirementToRecycled(reqPath, requirementTitle, fromSection) {
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    let requirementStartIndex = -1;
+    let requirementEndIndex = -1;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('###')) {
+            const title = line.replace(/^###\s*/, '').trim();
+            // Logic from interactive.js
+            if (title && title.includes(requirementTitle)) {
+                requirementStartIndex = i;
+                for (let j = i + 1; j < lines.length; j++) {
+                    const nextLine = lines[j].trim();
+                    if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+                        requirementEndIndex = j;
+                        break;
+                    }
+                }
+                if (requirementEndIndex === -1) {
+                    requirementEndIndex = lines.length;
+                }
+                break;
+            }
+        }
+    }
+
+    if (requirementStartIndex === -1) {
+        console.log('⚠️  Could not find requirement to recycle');
+        return false;
+    }
+
+    console.log(`Found requirement at lines ${requirementStartIndex}-${requirementEndIndex}`);
+
+    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
+
+    if (requirementStartIndex < lines.length) {
+        const nextLine = lines[requirementStartIndex]?.trim();
+        const packageNames = ['cli', 'core', 'electron-app', 'web', 'mobile', 'vscode-extension', 'sync-server'];
+        if (nextLine && packageNames.includes(nextLine.toLowerCase()) &&
+            !nextLine.startsWith('###') && !nextLine.startsWith('PACKAGE:')) {
+            lines.splice(requirementStartIndex, 1);
+        }
+        while (requirementStartIndex < lines.length && lines[requirementStartIndex]?.trim() === '') {
+            lines.splice(requirementStartIndex, 1);
+        }
+    }
+
+    let recycledIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes('♻️ Recycled') || lines[i].includes('🗑️ Recycled')) {
+            recycledIndex = i;
+            break;
+        }
+    }
+
+    if (recycledIndex === -1) {
+        let lastSectionIndex = -1;
+        for (let i = lines.length - 1; i >= 0; i--) {
+            if (lines[i].startsWith('##') && !lines[i].startsWith('###')) {
+                lastSectionIndex = i;
+                break;
+            }
+        }
+        const insertIndex = lastSectionIndex > 0 ? lastSectionIndex : lines.length;
+        lines.splice(insertIndex, 0, '', '## ♻️ Recycled', '');
+        recycledIndex = insertIndex + 1;
+    }
+
+    let insertIndex = recycledIndex + 1;
+    while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+        insertIndex++;
+    }
+    lines.splice(insertIndex, 0, ...requirementBlock);
+
+    if (insertIndex + requirementBlock.length < lines.length && lines[insertIndex + requirementBlock.length].trim() !== '') {
+        lines.splice(insertIndex + requirementBlock.length, 0, '');
+    }
+
+    await fs.writeFile(reqPath, lines.join('\n'));
+    return true;
+}
+
+async function run() {
+    try {
+        const repoPath = '/Users/jesse/code/mediawink/vibecodingmachine'; // Hardcoded valid repo path
+        console.log('Repo path:', repoPath);
+
+        const reqPath = await getRequirementsPath(repoPath);
+        console.log('<<< PATH >>>', reqPath);
+
+        if (await fs.pathExists(reqPath)) {
+            const content = await fs.readFile(reqPath, 'utf8');
+            console.log('Current content length:', content.length);
+            console.log('Current content PRE-TEST:\n', content);
+        } else {
+            console.log('Requirements file does not exist');
+        }
+
+        console.log('\n--- Adding TESTREQ1 ---');
+        await requirements.add('TESTREQ1', 'all', 'Description 1');
+
+        console.log('\n--- Adding TESTREQ2 ---');
+        await requirements.add('TESTREQ2', 'all', 'Description 2');
+
+        let content = await fs.readFile(reqPath, 'utf8');
+        console.log('Content after adding:\n', content);
+
+        // Verify order
+        // We expect TESTREQ2 to be above TESTREQ1 if it inserts at the top of the section
+        const lines = content.split('\n');
+        let idx1 = -1, idx2 = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes('### TESTREQ1')) idx1 = i;
+            if (lines[i].includes('### TESTREQ2')) idx2 = i;
+        }
+        console.log(`TESTREQ1 line: ${idx1}, TESTREQ2 line: ${idx2}`);
+        if (idx2 < idx1 && idx2 > -1) {
+            console.log('SUCCESS: TESTREQ2 is above TESTREQ1 (Correct LIFO/Stack behavior for "Top of list")');
+        } else {
+            console.log('FAIL: Order is not correct for "Top of list" insertion');
+        }
+
+        console.log('\n--- Deleting TESTREQ1 ---');
+        const success = await moveRequirementToRecycled(reqPath, 'TESTREQ1', 'todo');
+        console.log('Delete success:', success);
+
+        content = await fs.readFile(reqPath, 'utf8');
+        console.log('Content after delete:\n', content);
+
+        if (content.includes('### TESTREQ1')) {
+            // It should be in recycled section
+            const recycledIndex = content.indexOf('## ♻️ Recycled');
+            const reqIndex = content.indexOf('### TESTREQ1');
+            if (reqIndex > recycledIndex) {
+                console.log('SUCCESS: TESTREQ1 moved to Recycled');
+            } else {
+                console.log('FAIL: TESTREQ1 is still in TODO or wrong place');
+            }
+        } else {
+            console.log('FAIL: TESTREQ1 disappeared completely (should be recycled)');
+        }
+
+    } catch (error) {
+        console.error('Error:', error);
+    }
+}
+
+run();