vibecodingmachine-core 2025.12.6-1702 → 2025.12.24-2348

package/src/quota-management/index.js

@@ -0,0 +1,108 @@
+const sharedAuth = require('../auth/shared-auth-storage');
+const ProviderManager = require('../ide-integration/provider-manager.cjs');
+
+// In-memory cache for quota data.
+const quotaCache = new Map();
+
+/**
+ * Represents the quota details for a specific agent.
+ */
+class Quota {
+  /**
+   * @param {string} agentId - The unique identifier for the agent (e.g., 'openai:gpt-4').
+   * @param {number} limit - The total quota limit.
+   * @param {number} remaining - The remaining quota.
+   * @param {Date} resetsAt - The timestamp when the quota resets.
+   * @param {string} type - The type of quota ('global', 'rate-limit', 'infinite').
+   */
+  constructor(agentId, limit, remaining, resetsAt, type = 'rate-limit') {
+    this.agentId = agentId;
+    this.limit = limit;
+    this.remaining = remaining;
+    this.resetsAt = resetsAt;
+    this.lastUpdated = new Date();
+    this.type = type;
+  }
+
+  /**
+   * Checks if the quota has been exceeded.
+   * @returns {boolean} True if the remaining quota is zero or less.
+   */
+  isExceeded() {
+    return this.remaining <= 0;
+  }
+}
+
+/**
+ * Fetches quota information for a given agent.
+ * 
+ * @param {string} agentId - The ID of the agent to fetch quota for (e.g., 'anthropic:claude-3').
+ * @returns {Promise<Quota>} A promise that resolves to a Quota object.
+ */
+async function fetchQuotaForAgent(agentId) {
+  // 1. Handle Global Daily Iteration Quota
+  if (agentId === 'global:iterations') {
+    const quotaInfo = await sharedAuth.canRunAutoMode();
+    const today = new Date();
+    const tonight = new Date(today);
+    tonight.setHours(24, 0, 0, 0);
+
+    const quota = new Quota(
+      'global:iterations',
+      quotaInfo.maxIterations || 10,
+      quotaInfo.todayUsage !== undefined ? Math.max(0, (quotaInfo.maxIterations || 10) - quotaInfo.todayUsage) : 10,
+      tonight,
+      'global'
+    );
+    quotaCache.set(agentId, quota);
+    return quota;
+  }
+
+  // 2. Handle Local Agent (Infinite Quota)
+  if (agentId.startsWith('local-') || agentId.includes('ollama')) {
+    const quota = new Quota(agentId, Infinity, Infinity, null, 'infinite');
+    quotaCache.set(agentId, quota);
+    return quota;
+  }
+
+  // 3. Handle Provider Rate Limits via ProviderManager
+  try {
+    const providerManager = new ProviderManager();
+    const parts = agentId.split(':');
+    const provider = parts[0];
+    const model = parts[1] || provider;
+
+    const isLimited = providerManager.isRateLimited(provider, model);
+    const timeUntilReset = providerManager.getTimeUntilReset(provider, model);
+
+    const quota = new Quota(
+      agentId,
+      1, // Binary limit for rate limits (1 if available, 0 if limited)
+      isLimited ? 0 : 1,
+      timeUntilReset ? new Date(Date.now() + timeUntilReset) : null,
+      'rate-limit'
+    );
+
+    quotaCache.set(agentId, quota);
+    return quota;
+  } catch (error) {
+    console.error(`Error fetching provider quota for ${agentId}:`, error);
+    return new Quota(agentId, 1, 1, null, 'rate-limit');
+  }
+}
+
+/**
+ * Retrieves the cached quota for a given agent.
+ * 
+ * @param {string} agentId - The ID of the agent.
+ * @returns {Quota | undefined} The cached Quota object or undefined if not found.
+ */
+function getCachedQuota(agentId) {
+  return quotaCache.get(agentId);
+}
+
+module.exports = {
+  Quota,
+  fetchQuotaForAgent,
+  getCachedQuota,
+};

package/src/sync/sync-engine.js

@@ -54,17 +54,27 @@ class SyncEngine extends EventEmitter {
       // Initialize DynamoDB client
       const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
       const { DynamoDBDocumentClient } = require('@aws-sdk/lib-dynamodb');
-      
+
       const region = process.env.AWS_REGION || 'us-east-1';
       const client = new DynamoDBClient({ region });
       this.dynamoClient = DynamoDBDocumentClient.from(client);
-      
+
       // Initialize WebSocket client for real-time updates
       await this._initializeWebSocket();
-      
+
       this.emit('initialized');
       return true;
     } catch (error) {
+      // If AWS SDK is not installed in this environment (common in local dev),
+      // fall back to offline mode instead of throwing so the CLI remains usable.
+      if (error && error.code === 'MODULE_NOT_FOUND' && /@aws-sdk\//.test(error.message)) {
+        this.options.offlineMode = true;
+        this.isOnline = false;
+        this.emit('warning', { type: 'offline-fallback', message: 'AWS SDK not available, running in offline mode', error });
+        this.emit('initialized');
+        return false;
+      }
+
       this.emit('error', { type: 'initialization', error });
       throw error;
     }
@@ -177,11 +187,16 @@ class SyncEngine extends EventEmitter {
    * Fetch remote changes from DynamoDB
    */
   async _fetchRemoteChanges() {
+    if (!this.dynamoClient) {
+      this.emit('warning', { type: 'no-dynamo', message: 'DynamoDB client not initialized, skipping remote fetch' });
+      return [];
+    }
+
     const { ScanCommand } = require('@aws-sdk/lib-dynamodb');
-    
+
     const tableName = process.env.DYNAMODB_TABLE_NAME || 'vibecodingmachine-requirements';
     const lastSync = this.lastSyncTime || 0;
-    
+
     try {
       // Use Scan with filter instead of Query since we need to check all items
       // In production, consider using DynamoDB Streams for real-time updates
@@ -195,7 +210,7 @@ class SyncEngine extends EventEmitter {
           ':lastSync': lastSync
         }
       });
-      
+
       const response = await this.dynamoClient.send(command);
       return response.Items || [];
     } catch (error) {
@@ -303,10 +318,17 @@ class SyncEngine extends EventEmitter {
    * Push local changes to remote
    */
   async _pushLocalChanges(changes) {
+    if (!this.dynamoClient) {
+      this.emit('warning', { type: 'no-dynamo', message: 'DynamoDB client not initialized, queuing local changes' });
+      // Queue all changes for later push
+      this.offlineQueue.push(...changes);
+      return;
+    }
+
     const { PutCommand } = require('@aws-sdk/lib-dynamodb');
-    
+
     const tableName = process.env.DYNAMODB_TABLE_NAME || 'vibecodingmachine-requirements';
-    
+
     for (const change of changes) {
       try {
         const command = new PutCommand({
@@ -317,12 +339,12 @@ class SyncEngine extends EventEmitter {
             ...change
           }
         });
-        
+
         await this.dynamoClient.send(command);
         this.emit('local-change-pushed', change);
       } catch (error) {
         this.emit('error', { type: 'push-local', change, error });
-        
+
         // Add to offline queue if push fails
         if (!this.isOnline) {
           this.offlineQueue.push(change);

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

@@ -0,0 +1,92 @@
+const fs = require('fs');
+const { pipeline } = require('stream');
+const { promisify } = require('util');
+const streamPipeline = promisify(pipeline);
+const ora = require('ora');
+
+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 downloadWithProgress(url, dest, opts = {}) {
+  const fetch = require('node-fetch');
+  const spinner = opts.spinner || ora();
+  const label = opts.label || 'Downloading...';
+  const onProgress = typeof opts.onProgress === 'function' ? opts.onProgress : null;
+
+  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 spinner so progress prints are not overwritten
+  try { spinner.stop(); } catch (e) {}
+  try { process.stdout.write('\r\x1b[2KDownloading: 0.0 MB'); } catch (e) {}
+
+  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);
+          // CLI/UI progress
+          if (onProgress) {
+            onProgress({ percent, downloaded, total, mbDownloaded, mbTotal, eta, bar });
+          } else {
+            process.stdout.write(`\r\x1b[2K[${bar}] ${percent}% ${mbDownloaded}MB / ${mbTotal}MB ETA: ${eta}`);
+          }
+        }
+      } else {
+        const mbDownloaded = (downloaded / (1024 * 1024)).toFixed(1);
+        if (onProgress) onProgress({ percent: null, downloaded, total, mbDownloaded });
+        else 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();
+    });
+
+    res.body.pipe(fileStream);
+  });
+}
+
+module.exports = { downloadWithProgress };

package/src/utils/electron-update-checker.js

@@ -39,12 +39,19 @@ function formatVersionTimestamp(versionString, date) {
   }
 }
 
+const { shouldCheckUpdates } = require('./env-helpers');
+
 /**
  * Check for Electron app updates from S3 version manifest
  * @param {string} currentVersion - Current version (e.g., '2025.11.26-0519')
  * @returns {Promise<Object>} Update info or null if no update available
  */
 async function checkForElectronUpdates(currentVersion) {
+  if (!shouldCheckUpdates()) {
+    console.log('ℹ️ [UPDATE CHECK] Skipped in development environment');
+    return { hasUpdate: false, currentVersion };
+  }
+
   return new Promise((resolve, reject) => {
     const manifestUrl = `https://d3fh7zgi8horze.cloudfront.net/downloads/version.json?t=${Date.now()}`;
     console.log(`🔍 [UPDATE CHECK] Current version: ${currentVersion}`);

package/src/utils/env-helpers.js

@@ -0,0 +1,54 @@
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Check if running in development environment
+ * @returns {boolean} True if in development
+ */
+function isDevelopment() {
+    // Check standard environment variables
+    if (process.env.NODE_ENV === 'development' ||
+        process.env.VIBECODINGMACHINE_ENV === 'development' ||
+        process.env.ELECTRON_IS_DEV === '1') {
+        return true;
+    }
+
+    // Check for --dev flag in arguments
+    if (process.argv.includes('--dev')) {
+        return true;
+    }
+
+    // Heuristics for local development
+    // 1. Check if we are in a git repository that looks like the source code
+    // Root of the monorepo usually has 'packages' directory and 'lerna.json' or 'pnpm-workspace.yaml'
+    // But this might be too aggressive if user installs via git clone.
+
+    // 2. Check if electron is running from default app (not packaged)
+    if (process.versions && process.versions.electron) {
+        const electron = require('electron');
+        if (electron.app && !electron.app.isPackaged) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Check if we should perform update checks
+ * @returns {boolean} True if update checks are allowed
+ */
+function shouldCheckUpdates() {
+    // Don't check updates in development unless explicitly forced (not implemented yet)
+    if (isDevelopment()) {
+        return false;
+    }
+
+    // Can add more logic here (e.g. disable updates via config)
+    return true;
+}
+
+module.exports = {
+    isDevelopment,
+    shouldCheckUpdates
+};