vibecodingmachine-core 2025.12.25-25 → 2026.1.22-1441

package/ERROR_REPORTING_API.md

@@ -0,0 +1,212 @@
+# Error Reporting API Documentation
+
+## Overview
+
+The error reporting system automatically sends error information to the admin database when the CLI or GUI encounters errors. This allows the admin to track issues and use VibeCodingMachine to fix itself.
+
+## Client Implementation
+
+The client-side error reporting is implemented in:
+- `packages/core/src/utils/error-reporter.js` - Error reporter utility
+- `packages/core/src/database/user-database-client.js` - API client with `reportError()` method
+- `packages/cli/bin/vibecodingmachine.js` - Global error handlers
+
+## API Endpoint Required
+
+### POST /api/errors/report
+
+Reports an error to the admin database for tracking and fixing.
+
+**Authentication**: Required (Bearer token)
+
+**Request Body**:
+```json
+{
+  "message": "The \"path\" argument must be of type string. Received null",
+  "stack": "TypeError: The \"path\" argument must be of type string...",
+  "name": "TypeError",
+  "code": "ERR_INVALID_ARG_TYPE",
+  "timestamp": 1704326400000,
+  "hostname": "Jesses-MacBook-Pro.local",
+  "platform": "darwin",
+  "arch": "arm64",
+  "nodeVersion": "v18.17.0",
+  "context": {
+    "command": "addRemoteRequirement",
+    "computerId": "OLSEN2018PC",
+    "requirementText": "Fix the login bug",
+    "cwd": "/Users/jesseolsen/repos/mediawink/allnightai",
+    "argv": ["computer:add-requirement", "OLSEN2018PC", "Fix the login bug"]
+  }
+}
+```
+
+**Response**:
+```json
+{
+  "success": true,
+  "errorId": "err_abc123xyz"
+}
+```
+
+**Error Response**:
+```json
+{
+  "error": "Failed to report error",
+  "details": "Database connection failed"
+}
+```
+
+## Database Schema
+
+The error reports should be stored in a DynamoDB table with the following structure:
+
+**Table Name**: `vibecodingmachine-errors`
+
+**Primary Key**: 
+- `errorId` (String) - Unique error identifier (generated server-side)
+
+**Attributes**:
+- `userId` (String) - User ID from auth token
+- `email` (String) - User email
+- `timestamp` (Number) - Unix timestamp when error occurred
+- `message` (String) - Error message
+- `stack` (String) - Error stack trace
+- `name` (String) - Error name/type
+- `code` (String) - Error code (if available)
+- `hostname` (String) - Computer hostname
+- `platform` (String) - OS platform (darwin, win32, linux)
+- `arch` (String) - CPU architecture
+- `nodeVersion` (String) - Node.js version
+- `context` (Map) - Additional context about the error
+- `status` (String) - Error status: "NEW", "INVESTIGATING", "FIXED", "IGNORED"
+- `reportedAt` (Number) - Server timestamp when error was reported
+
+**GSI (Global Secondary Index)**:
+- `userId-timestamp-index` - For querying errors by user and time
+- `status-timestamp-index` - For querying errors by status
+
+## Server Implementation Required
+
+The API server needs to implement the `/api/errors/report` endpoint:
+
+```javascript
+// Example implementation (pseudo-code)
+app.post('/api/errors/report', authenticateToken, async (req, res) => {
+  try {
+    const userId = req.user.userId;
+    const email = req.user.email;
+    
+    const errorId = generateErrorId(); // e.g., 'err_' + crypto.randomBytes(8).toString('hex')
+    
+    const errorReport = {
+      errorId,
+      userId,
+      email,
+      ...req.body,
+      status: 'NEW',
+      reportedAt: Date.now()
+    };
+    
+    // Save to DynamoDB
+    await dynamodb.put({
+      TableName: 'vibecodingmachine-errors',
+      Item: errorReport
+    }).promise();
+    
+    res.json({ success: true, errorId });
+  } catch (error) {
+    res.status(500).json({ 
+      error: 'Failed to report error',
+      details: error.message 
+    });
+  }
+});
+```
+
+## Usage Examples
+
+### Automatic Error Reporting (Global Handlers)
+
+```javascript
+// In CLI entry point
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Initialize with auth token
+const token = await auth.getAuthToken();
+errorReporter.setAuthToken(token);
+
+// Global handlers automatically report errors
+process.on('uncaughtException', async (error) => {
+  await errorReporter.reportError(error, { type: 'uncaughtException' });
+});
+```
+
+### Manual Error Reporting
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+
+try {
+  // Some operation that might fail
+  await addRemoteRequirement(computerId, requirementText);
+} catch (error) {
+  // Report error with context
+  await errorReporter.reportError(error, {
+    command: 'addRemoteRequirement',
+    computerId,
+    requirementText
+  });
+  throw error; // Re-throw to show user
+}
+```
+
+### Wrapping Functions
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Wrap a function to automatically report errors
+const safeFunction = errorReporter.wrapFunction(
+  async (arg1, arg2) => {
+    // Function implementation
+  },
+  { functionName: 'myFunction' }
+);
+```
+
+## Admin Dashboard Integration
+
+The admin dashboard should display error reports with:
+- List of all errors (filterable by status, user, date)
+- Error details view (message, stack, context)
+- Ability to change error status
+- Statistics (errors per day, most common errors)
+- Link to create a requirement/issue from an error
+
+## Privacy Considerations
+
+The error reporter automatically filters sensitive information:
+- Passwords, tokens, and secrets are removed from arguments
+- Only non-sensitive context is included
+- Stack traces may contain file paths but not file contents
+
+## Testing
+
+To test error reporting:
+
+```bash
+# Trigger an error in the CLI
+vcm computer:add-requirement TESTPC null
+
+# Check that error was reported
+# (Admin dashboard should show the error)
+```
+
+## Future Enhancements
+
+- Automatic error grouping (similar errors grouped together)
+- Error frequency tracking
+- Automatic issue creation in GitHub
+- Email notifications for critical errors
+- Error trend analysis

package/ERROR_REPORTING_USAGE.md

@@ -0,0 +1,380 @@
+# Error Reporting Usage Guide
+
+## Quick Start
+
+### 1. Import the Error Reporter
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+```
+
+### 2. Initialize with Auth Token
+
+```javascript
+const auth = require('./utils/auth');
+const token = await auth.getAuthToken();
+if (token) {
+  errorReporter.setAuthToken(token);
+}
+```
+
+### 3. Report Errors
+
+```javascript
+try {
+  // Your code here
+  await someOperation();
+} catch (error) {
+  // Report error with context
+  await errorReporter.reportError(error, {
+    command: 'someOperation',
+    additionalContext: 'value'
+  });
+  throw error; // Re-throw to show user
+}
+```
+
+## Usage Patterns
+
+### Pattern 1: Try-Catch with Error Reporting
+
+```javascript
+async function addRemoteRequirement(computerId, requirementText) {
+  try {
+    // Operation that might fail
+    const result = await performOperation(computerId, requirementText);
+    return result;
+  } catch (error) {
+    console.error(chalk.red('✗ Operation failed:'), error.message);
+    
+    // Report error with context
+    await errorReporter.reportError(error, {
+      command: 'addRemoteRequirement',
+      computerId,
+      requirementText
+    });
+    
+    throw error; // Re-throw to maintain error flow
+  }
+}
+```
+
+### Pattern 2: Global Error Handlers
+
+```javascript
+// In your main entry point
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Initialize with auth token
+const token = await auth.getAuthToken();
+if (token) {
+  errorReporter.setAuthToken(token);
+}
+
+// Setup global handlers
+process.on('uncaughtException', async (error) => {
+  console.error('Uncaught Exception:', error);
+  await errorReporter.reportError(error, { 
+    type: 'uncaughtException' 
+  });
+  process.exit(1);
+});
+
+process.on('unhandledRejection', async (error) => {
+  console.error('Unhandled Rejection:', error);
+  await errorReporter.reportError(error, { 
+    type: 'unhandledRejection' 
+  });
+  process.exit(1);
+});
+```
+
+### Pattern 3: Function Wrapping
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Wrap a function to automatically report errors
+const safeOperation = errorReporter.wrapFunction(
+  async (arg1, arg2) => {
+    // Your function implementation
+    return await performOperation(arg1, arg2);
+  },
+  { 
+    functionName: 'performOperation',
+    module: 'operations'
+  }
+);
+
+// Use the wrapped function
+try {
+  await safeOperation('value1', 'value2');
+} catch (error) {
+  // Error was already reported automatically
+  console.error('Operation failed:', error.message);
+}
+```
+
+### Pattern 4: Conditional Error Reporting
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Enable/disable error reporting
+errorReporter.setEnabled(true);  // Enable
+errorReporter.setEnabled(false); // Disable
+
+// Example: Disable in development
+if (process.env.NODE_ENV === 'development') {
+  errorReporter.setEnabled(false);
+}
+```
+
+## Context Best Practices
+
+### Good Context Examples
+
+```javascript
+// ✅ GOOD - Includes relevant context
+await errorReporter.reportError(error, {
+  command: 'addRemoteRequirement',
+  computerId: 'OLSEN2018PC',
+  requirementText: 'Fix the login bug',
+  operation: 'file_write'
+});
+
+// ✅ GOOD - Includes user action context
+await errorReporter.reportError(error, {
+  action: 'sync',
+  syncDirection: 'upload',
+  fileCount: 5,
+  retryAttempt: 2
+});
+```
+
+### Bad Context Examples
+
+```javascript
+// ❌ BAD - Includes sensitive information
+await errorReporter.reportError(error, {
+  password: 'secret123',  // Don't include passwords!
+  apiKey: 'abc123xyz'     // Don't include API keys!
+});
+
+// ❌ BAD - Too much unnecessary data
+await errorReporter.reportError(error, {
+  entireFileContents: fs.readFileSync('large-file.txt'),
+  allEnvironmentVariables: process.env
+});
+
+// ❌ BAD - No context at all
+await errorReporter.reportError(error);
+```
+
+## What Gets Reported Automatically
+
+The error reporter automatically includes:
+
+- **Error Information**:
+  - `message` - Error message
+  - `stack` - Stack trace
+  - `name` - Error type (TypeError, ReferenceError, etc.)
+  - `code` - Error code (if available)
+
+- **System Information**:
+  - `timestamp` - When error occurred
+  - `hostname` - Computer hostname
+  - `platform` - OS platform (darwin, win32, linux)
+  - `arch` - CPU architecture (x64, arm64)
+  - `nodeVersion` - Node.js version
+
+- **Context Information**:
+  - `cwd` - Current working directory
+  - `argv` - Command line arguments (filtered for sensitive data)
+  - Any custom context you provide
+
+## Privacy & Security
+
+The error reporter automatically filters sensitive information:
+
+- Passwords
+- Tokens
+- Secrets
+- API keys
+- Authentication credentials
+
+**Example**:
+```javascript
+// These will be filtered out automatically
+const args = ['--password=secret', '--token=abc123'];
+await errorReporter.reportError(error, { args });
+// Reported args will be filtered
+```
+
+## Testing Error Reporting
+
+### Test 1: Manual Error
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Initialize
+const token = await auth.getAuthToken();
+errorReporter.setAuthToken(token);
+
+// Create and report a test error
+const testError = new Error('Test error for reporting');
+testError.code = 'TEST_ERROR';
+
+await errorReporter.reportError(testError, {
+  test: true,
+  purpose: 'testing error reporting system'
+});
+
+console.log('Test error reported successfully');
+```
+
+### Test 2: Trigger Real Error
+
+```bash
+# Trigger an error in the CLI
+vcm computer:add-requirement TESTPC null
+
+# Check console output for error reporting
+# Check admin dashboard for error report
+```
+
+## Troubleshooting
+
+### Error Not Being Reported
+
+1. **Check Authentication**:
+   ```javascript
+   const token = await auth.getAuthToken();
+   console.log('Auth token:', token ? 'Present' : 'Missing');
+   ```
+
+2. **Check Error Reporter Status**:
+   ```javascript
+   console.log('Error reporter enabled:', errorReporter.enabled);
+   ```
+
+3. **Check Network**:
+   - Verify API server is running
+   - Check API endpoint URL
+   - Verify authentication token is valid
+
+### Silent Failures
+
+Error reporting is designed to fail silently to avoid disrupting the user experience. Check console warnings:
+
+```javascript
+// Look for warnings like:
+// "Failed to report error: Network error"
+// "UserDatabase: reportError failed: ..."
+```
+
+## Integration with Other Systems
+
+### Electron App
+
+```javascript
+// In main process
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Initialize with user's auth token
+const token = await getUserAuthToken();
+errorReporter.setAuthToken(token);
+
+// Report renderer process errors
+ipcMain.on('renderer-error', async (event, error) => {
+  await errorReporter.reportError(error, {
+    source: 'renderer',
+    window: event.sender.id
+  });
+});
+```
+
+### Web Application
+
+```javascript
+// In your React/Vue app
+import { errorReporter } from 'vibecodingmachine-core';
+
+// Initialize with user's auth token
+const token = await getAuthToken();
+errorReporter.setAuthToken(token);
+
+// Report errors in error boundary
+class ErrorBoundary extends React.Component {
+  componentDidCatch(error, errorInfo) {
+    errorReporter.reportError(error, {
+      source: 'react',
+      componentStack: errorInfo.componentStack
+    });
+  }
+}
+```
+
+## API Reference
+
+### `errorReporter.setAuthToken(token)`
+
+Set the authentication token for error reporting.
+
+**Parameters**:
+- `token` (string) - JWT authentication token
+
+**Example**:
+```javascript
+const token = await auth.getAuthToken();
+errorReporter.setAuthToken(token);
+```
+
+### `errorReporter.setEnabled(enabled)`
+
+Enable or disable error reporting.
+
+**Parameters**:
+- `enabled` (boolean) - True to enable, false to disable
+
+**Example**:
+```javascript
+errorReporter.setEnabled(false); // Disable in development
+```
+
+### `errorReporter.reportError(error, context)`
+
+Report an error to the admin database.
+
+**Parameters**:
+- `error` (Error) - Error object to report
+- `context` (Object) - Additional context about the error
+
+**Returns**: Promise<boolean> - True if reported successfully
+
+**Example**:
+```javascript
+await errorReporter.reportError(error, {
+  command: 'sync',
+  operation: 'upload'
+});
+```
+
+### `errorReporter.wrapFunction(fn, context)`
+
+Wrap a function to automatically report errors.
+
+**Parameters**:
+- `fn` (Function) - Function to wrap
+- `context` (Object) - Context to include in error reports
+
+**Returns**: Function - Wrapped function
+
+**Example**:
+```javascript
+const safeFunction = errorReporter.wrapFunction(
+  async (arg) => { /* ... */ },
+  { functionName: 'myFunction' }
+);
+```

package/__tests__/provider-manager-fallback.test.js

@@ -0,0 +1,43 @@
+const ProviderManager = require('../src/ide-integration/provider-manager.cjs');
+
+describe('ProviderManager fallback behavior', () => {
+  let pm;
+
+  beforeEach(() => {
+    pm = new ProviderManager();
+    pm.clearAllRateLimits();
+  });
+
+  afterEach(() => {
+    pm.clearAllRateLimits();
+  });
+
+  test('isRateLimited should return true for provider when only legacy/model-agnostic key exists', () => {
+    // Simulate legacy stored key with model undefined (string 'undefined')
+    const resetTime = Date.now() + 10 * 60 * 1000; // 10 minutes from now
+    pm.rateLimits['antigravity:undefined'] = {
+      provider: 'antigravity',
+      model: undefined,
+      resetTime,
+      resetDate: new Date(resetTime).toISOString(),
+      reason: 'Quota limit reached',
+      markedAt: new Date().toISOString()
+    };
+
+    expect(pm.isRateLimited('antigravity', 'antigravity')).toBe(true);
+    const t = pm.getTimeUntilReset('antigravity', 'antigravity');
+    expect(t).toBeGreaterThan(0);
+  });
+
+  test('getRateLimitInfo should return earliest reset for provider when model-specific not present', () => {
+    const resetA = Date.now() + 60 * 60 * 1000; // 60m
+    const resetB = Date.now() + 5 * 60 * 1000;  // 5m
+
+    pm.rateLimits['antigravity:legacy'] = { provider: 'antigravity', model: 'legacy', resetTime: resetA, reason: 'legacy', markedAt: new Date().toISOString() };
+    pm.rateLimits['antigravity:other'] = { provider: 'antigravity', model: 'other', resetTime: resetB, reason: 'other', markedAt: new Date().toISOString() };
+
+    const info = pm.getRateLimitInfo('antigravity', 'antigravity');
+    expect(info.isRateLimited).toBe(true);
+    expect(info.resetTime).toBe(resetB);
+  });
+});

package/__tests__/provider-manager-rate-limit.test.js

@@ -0,0 +1,61 @@
+const ProviderManager = require('../src/ide-integration/provider-manager.cjs');
+
+describe('ProviderManager rate limit handling', () => {
+  let pm;
+
+  beforeEach(() => {
+    pm = new ProviderManager();
+    pm.clearAllRateLimits();
+  });
+
+  afterEach(() => {
+    pm.clearAllRateLimits();
+  });
+
+  test('markRateLimited with undefined model normalizes model to provider', () => {
+    // Call with model undefined to simulate IDE provider case
+    pm.markRateLimited('antigravity', undefined, 'Quota limit reached');
+
+    // The provider should be considered rate-limited when queried using provider as model
+    expect(pm.isRateLimited('antigravity', 'antigravity')).toBe(true);
+
+    const info = pm.getRateLimitInfo('antigravity', 'antigravity');
+    expect(info.isRateLimited).toBe(true);
+    expect(info.resetTime).toBeGreaterThan(Date.now());
+
+    const ms = pm.getTimeUntilReset('antigravity', 'antigravity');
+    expect(ms).toBeGreaterThan(0);
+  });
+
+
+  test('parses "resets Month Day at Time" format correctly', () => {
+    // Mock Date.now to Jan 13, 2026 10:00 AM
+    const mockNow = new Date('2026-01-13T10:00:00').getTime();
+    const originalDateNow = Date.now;
+    Date.now = jest.fn(() => mockNow);
+
+    try {
+      const errorMessage = 'Spending cap reached resets Jan 17 at 12pm';
+
+      // Expected: Jan 17 12:00 PM = 12:00 + (17-13)*24 hours
+      // Jan 13 10am to Jan 17 12pm
+      // Diff: 4 days + 2 hours = 98 hours
+      const expectedDuration = (4 * 24 * 60 * 60 * 1000) + (2 * 60 * 60 * 1000);
+
+      // Verify regex in test env
+      const regex = /resets\s+([a-zA-Z]+)\s+(\d{1,2})\s+at\s+(\d{1,2}(?::\d{2})?)\s*(am|pm)?/i;
+      const match = errorMessage.match(regex);
+      expect(match).not.toBeNull();
+
+      const duration = pm.parseRateLimitDuration(errorMessage);
+
+      // Allow for some minor variance if calculation logic differs slightly, but it should be close
+      expect(duration).toBeDefined();
+      expect(duration).not.toBeNull();
+      expect(Math.abs(duration - expectedDuration)).toBeLessThan(1000);
+
+    } finally {
+      Date.now = originalDateNow;
+    }
+  });
+});