vibecodingmachine-core 2026.3.14-1528 → 2026.6.17-1835

package/src/ide-integration/cli-direct-runner.js

@@ -0,0 +1,483 @@
+// @vibecodingmachine/core - Direct CLI Runner
+//
+// Runs a CLI agent (e.g. Claude Code) as a hidden child process of VCM,
+// streaming stdout/stderr to a caller-supplied logger so the output lands
+// in the VCM Console panel without opening a Terminal window, stealing
+// foreground focus, or pasting into whatever the user happens to be typing
+// in.
+//
+// Replaces the older "wt.exe cmd /k claude" + PowerShell SetForegroundWindow +
+// SendKeys Ctrl+V/Enter pipeline for Auto Mode invocations.
+
+const { spawn } = require('child_process');
+
+// Billing errors — need human action (add credits), NOT a time-based reset.
+// Detected the same as rate limits (stop retrying) but flagged separately so
+// the UI shows the raw message with no countdown timer.
+const BILLING_PATTERNS = [
+  /credit balance is too low/i,
+  /credit limit reached/i,
+  /insufficient.*credit/i,
+  /payment.*required/i,
+  /billing.*error/i,
+  /add.*credit/i,
+  /top.*up.*account/i,
+];
+
+// Strong patterns — verbatim system-error markers that don't appear in
+// assistant prose. A hit on any of these is sufficient to flag the line.
+const RATE_LIMIT_STRONG_PATTERNS = [
+  /Claude usage limit reached/i,
+  /weekly Claude limit/i,
+  /spending cap reached/i,
+  /you'?ve hit your limit/i,
+  /session limit reached/i,
+  /account limit reached/i,
+  /approaching weekly limit/i,
+  /weekly limit reached/i,
+];
+
+// Weaker phrases that ALSO appear in assistant-generated content. We only
+// flag these when the same line also contains an "Error:" or "HTTP 429"
+// marker (FR-015 / SC-006 false-positive guard).
+const RATE_LIMIT_WEAK_PATTERNS = [
+  /rate limit reached/i,
+  /quota limit/i,
+  /too many requests/i,
+  /limit exceeded/i
+];
+const SYSTEM_ERROR_MARKER = /(?:^|\s)(?:Error:|ERROR:|HTTP\s+429|\b429\b|\bClaude\b)/;
+
+const { parseResetTime } = require('../auto-mode/rate-limit-handler');
+
+function _findBillingLine(output) {
+  if (typeof output !== 'string') return null;
+  const lines = output.split('\n');
+  for (const line of lines) {
+    for (const pat of BILLING_PATTERNS) {
+      if (pat.test(line)) return line.trim();
+    }
+  }
+  return null;
+}
+
+function _findRateLimitLine(output) {
+  if (typeof output !== 'string') return null;
+  const lines = output.split('\n');
+  for (const line of lines) {
+    for (const pat of RATE_LIMIT_STRONG_PATTERNS) {
+      if (pat.test(line)) return line.trim();
+    }
+    for (const pat of RATE_LIMIT_WEAK_PATTERNS) {
+      if (pat.test(line) && SYSTEM_ERROR_MARKER.test(line)) return line.trim();
+    }
+  }
+  return null;
+}
+
+function detectRateLimit(output) {
+  // Check billing errors first — they share the "stop retrying" behaviour but
+  // must never show a countdown timer (only adding credits fixes them).
+  const billingLine = _findBillingLine(output);
+  if (billingLine) {
+    return {
+      isRateLimited: true,
+      isBillingError: true,
+      rawMessage: billingLine,
+      resetTime: null,
+      resetAt: null,
+      source: 'billing',
+      message: billingLine
+    };
+  }
+
+  const line = _findRateLimitLine(output);
+  if (!line) return { isRateLimited: false };
+
+  // Legacy hour-of-day "resets at 3pm" parse, kept for back-compat with
+  // call sites that read result.resetTime as a string.
+  const legacy = line.match(/resets?\s+(?:at\s+)?(\d+)\s*([ap]m)/i);
+  const resetTime = legacy ? `${legacy[1]}${legacy[2].toLowerCase()}` : null;
+
+  // New broader parse — returns an absolute Date when extractable.
+  const parsed = parseResetTime(line);
+
+  return {
+    isRateLimited: true,
+    isBillingError: false,
+    rawMessage: line,
+    resetTime,
+    resetAt: parsed.resetAt,
+    source: parsed.source,
+    message: 'Rate limit detected in CLI output'
+  };
+}
+
+function resolveDefaultCommand(ide, options) {
+  if (options && options.command) return options.command;
+  switch (ide) {
+    case 'claude':
+    case 'claude-code':
+      return process.env.VCM_CLAUDE_CLI || 'claude';
+    default:
+      return null;
+  }
+}
+
+function resolveDefaultArgs(ide, text, options) {
+  if (options && Array.isArray(options.args)) return options.args;
+  switch (ide) {
+    case 'claude':
+    case 'claude-code':
+      // --print runs Claude Code headless. --output-format stream-json
+      // emits JSONL events as they happen (assistant message deltas,
+      // tool use, tool result, etc.) instead of buffering all output
+      // until the final response. --verbose is required for stream-json
+      // to actually stream. We humanize each JSONL line in StreamBuffer
+      // so the Console panel sees readable text instead of raw JSON.
+      // --dangerously-skip-permissions lets the agent edit files
+      // without interactive approval.
+      return ['--print', '--dangerously-skip-permissions', '--verbose', '--output-format', 'stream-json', text];
+    default:
+      return [text];
+  }
+}
+
+/**
+ * Extract the usage block from a Claude Code stream-json line, if any.
+ * Assistant messages carry a `usage` object the Anthropic API returns:
+ *   { input_tokens, output_tokens, cache_read_input_tokens, cache_creation_input_tokens }
+ * Returns null when the line has no usage payload (tool_result, system, etc.).
+ */
+function extractClaudeUsage(rawLine) {
+  if (!rawLine || typeof rawLine !== 'string') return null;
+  let evt;
+  try { evt = JSON.parse(rawLine); }
+  catch (_) { return null; }
+  if (!evt || typeof evt !== 'object') return null;
+  const u = evt.message && evt.message.usage;
+  if (!u || typeof u !== 'object') return null;
+  return {
+    input: Number(u.input_tokens) || 0,
+    output: Number(u.output_tokens) || 0,
+    cacheRead: Number(u.cache_read_input_tokens) || 0,
+    cacheWrite: Number(u.cache_creation_input_tokens) || 0
+  };
+}
+
+// Convert a single Claude Code stream-json event into one or more
+// human-readable lines for the Console. Returns an array (possibly
+// empty) of strings.
+function humanizeClaudeStreamLine(rawLine) {
+  if (!rawLine || !rawLine.trim()) return [];
+  let evt;
+  try { evt = JSON.parse(rawLine); }
+  catch (_) {
+    // Not JSON — pass through unchanged so the user still sees it.
+    return [rawLine];
+  }
+  if (!evt || typeof evt !== 'object') return [rawLine];
+
+  const out = [];
+  const t = evt.type;
+
+  // Assistant message (the model's text + tool-use blocks)
+  if (t === 'assistant' && evt.message && Array.isArray(evt.message.content)) {
+    for (const block of evt.message.content) {
+      if (!block || !block.type) continue;
+      if (block.type === 'text' && typeof block.text === 'string') {
+        // Split on newlines so each paragraph gets its own console line.
+        for (const ln of block.text.split(/\r?\n/)) {
+          if (ln.trim()) out.push(`🤖 ${ln}`);
+        }
+      } else if (block.type === 'tool_use') {
+        const name = block.name || 'unknown';
+        const summary = _summarizeToolInput(name, block.input);
+        out.push(`🔧 ${name}${summary ? ' ' + summary : ''}`);
+      }
+    }
+  // Tool result (the user message in stream-json carries it)
+  } else if (t === 'user' && evt.message && Array.isArray(evt.message.content)) {
+    for (const block of evt.message.content) {
+      if (block && block.type === 'tool_result') {
+        const content = block.content;
+        let txt = '';
+        if (typeof content === 'string') txt = content;
+        else if (Array.isArray(content)) {
+          txt = content.map(c => (c && c.type === 'text' && c.text) ? c.text : '').filter(Boolean).join('\n');
+        }
+        const firstLine = (txt || '').split(/\r?\n/)[0] || '';
+        const preview = firstLine.length > 200 ? firstLine.slice(0, 200) + '…' : firstLine;
+        if (preview) out.push(`   ↳ ${preview}`);
+      }
+    }
+  // Final result event
+  } else if (t === 'result') {
+    if (evt.is_error) out.push(`❌ Error: ${evt.error || evt.subtype || 'unknown'}`);
+    else if (evt.subtype === 'success') out.push(`✅ done in ${evt.duration_ms || '?'}ms`);
+  } else if (t === 'system') {
+    // Init / metadata — skip silently to keep the Console focused on the
+    // actual conversation.
+  } else if (typeof evt.text === 'string') {
+    // Fallback for any event with a top-level text field.
+    out.push(evt.text);
+  }
+  return out;
+}
+
+function _summarizeToolInput(name, input) {
+  if (!input || typeof input !== 'object') return '';
+  const lc = String(name).toLowerCase();
+  if (lc === 'read' && input.file_path) return `(${input.file_path})`;
+  if (lc === 'write' && input.file_path) return `(${input.file_path})`;
+  if (lc === 'edit' && input.file_path) return `(${input.file_path})`;
+  if (lc === 'bash' && input.command) {
+    const cmd = String(input.command);
+    return `(${cmd.length > 100 ? cmd.slice(0, 100) + '…' : cmd})`;
+  }
+  if (lc === 'glob' && input.pattern) return `(${input.pattern})`;
+  if (lc === 'grep' && input.pattern) return `(${input.pattern})`;
+  return '';
+}
+
+function emitLine(logger, level, line) {
+  if (!line) return;
+  const trimmed = line.replace(/\r$/, '');
+  if (!trimmed) return;
+  if (!logger) {
+    if (level === 'error') process.stderr.write(`${trimmed}\n`);
+    else process.stdout.write(`${trimmed}\n`);
+    return;
+  }
+  const method = level === 'error' ? (logger.error || logger.log) : (logger.log || logger.info);
+  if (typeof method === 'function') {
+    method.call(logger, trimmed);
+  }
+}
+
+class StreamBuffer {
+  constructor(level, logger, onLine, transform) {
+    this.level = level;
+    this.logger = logger;
+    this.onLine = onLine;
+    // Optional transform: takes a raw line, returns an array of zero or
+    // more output lines. Used to turn Claude's stream-json events into
+    // human-readable Console text.
+    this.transform = transform || null;
+    this.buffer = '';
+  }
+
+  _emit(line) {
+    if (this.transform) {
+      const transformed = this.transform(line);
+      if (Array.isArray(transformed)) {
+        for (const t of transformed) {
+          if (t) emitLine(this.logger, this.level, t);
+        }
+      }
+    } else {
+      emitLine(this.logger, this.level, line);
+    }
+    if (this.onLine) this.onLine(line);
+  }
+
+  write(chunk) {
+    this.buffer += chunk.toString('utf8');
+    let idx;
+    // Treat both \n and \r as line breaks so Claude's TUI progress redraws
+    // (which use \r) don't all collapse into one giant unreadable line.
+    while ((idx = this.buffer.search(/[\r\n]/)) !== -1) {
+      const line = this.buffer.slice(0, idx);
+      this.buffer = this.buffer.slice(idx + 1);
+      this._emit(line);
+    }
+  }
+
+  flush() {
+    if (this.buffer.length > 0) {
+      const line = this.buffer;
+      this.buffer = '';
+      this._emit(line);
+    }
+  }
+}
+
+/**
+ * Run a CLI agent directly and stream its output to the caller-supplied
+ * logger. Resolves once the child exits.
+ *
+ * @param {Object} options
+ * @param {string} options.ide          IDE identifier (e.g. 'claude-code')
+ * @param {string} options.text         Prompt text for the agent
+ * @param {string} [options.repoPath]   Working directory for the child
+ * @param {string} [options.command]    Override the resolved command name
+ * @param {string[]} [options.args]     Override the resolved argv
+ * @param {Object} [options.logger]     Logger with .log/.error methods.
+ *                                       Defaults to console; in the Electron
+ *                                       main process pass safeLogger so the
+ *                                       output flows into the Console panel.
+ * @param {number} [options.timeoutMs]  Kill the child after this many ms.
+ *                                       0/undefined = no timeout.
+ * @param {Object} [options.env]        Extra env vars merged onto process.env
+ * @param {Function} [options.spawnFn]  Injected spawn (for tests)
+ * @returns {Promise<Object>}
+ */
+async function runCliDirect(options = {}) {
+  const {
+    ide,
+    text,
+    repoPath,
+    logger = console,
+    timeoutMs,
+    env: extraEnv,
+    spawnFn = spawn,
+    // Per-message usage callback. Receives { input, output, cacheRead, cacheWrite }
+    // for every stream-json line that carries a `usage` payload. Wired by the
+    // electron-app's rate-limit-bridge into the RateLimitBudget tracker so the
+    // Agents-tab "X% of 5h limit used" indicator updates live during a run.
+    onUsage
+  } = options;
+
+  if (!ide) {
+    throw new Error('runCliDirect: ide is required');
+  }
+  if (typeof text !== 'string' || text.length === 0) {
+    throw new Error('runCliDirect: text is required');
+  }
+
+  const command = resolveDefaultCommand(ide, options);
+  if (!command) {
+    return {
+      success: false,
+      method: 'cli-direct',
+      error: `No direct-spawn command configured for IDE: ${ide}`
+    };
+  }
+  const args = resolveDefaultArgs(ide, text, options);
+
+  const preview = text.length > 120 ? `${text.slice(0, 120)}…` : text;
+  if (logger && typeof logger.log === 'function') {
+    logger.log(`[cli-direct] ${command} (${ide}) ← ${preview.replace(/\s+/g, ' ')}`);
+  }
+
+  return new Promise((resolve) => {
+    let child;
+    const startedAt = Date.now();
+    const combined = [];
+
+    try {
+      // Strip ANTHROPIC_API_KEY from the subprocess env so Claude Code uses
+      // its saved OAuth/Pro credentials instead of API-key billing. When the
+      // key is set in the shell, it overrides the login session and hits the
+      // API-account balance (which may be zero) rather than the Pro plan.
+      const childEnv = { ...process.env, ...(extraEnv || {}) };
+      if ((ide === 'claude' || ide === 'claude-code') && childEnv.ANTHROPIC_API_KEY) {
+        delete childEnv.ANTHROPIC_API_KEY;
+      }
+      child = spawnFn(command, args, {
+        cwd: repoPath || process.cwd(),
+        env: childEnv,
+        // Important: no `shell: true` — we don't want any Terminal popup or
+        // shell window. windowsHide ensures the helper console for the
+        // child is suppressed on Windows.
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+    } catch (err) {
+      resolve({
+        success: false,
+        method: 'cli-direct',
+        error: `Failed to spawn ${command}: ${err.message}`,
+        command,
+        args
+      });
+      return;
+    }
+
+    // For Claude in stream-json mode, transform each raw JSONL line into
+    // human-readable Console text before emitting. Non-Claude IDEs (or a
+    // future caller that opts out of stream-json) get the raw line.
+    const isClaude = ide === 'claude' || ide === 'claude-code';
+    const transform = isClaude ? humanizeClaudeStreamLine : null;
+    const onStdoutLine = (line) => {
+      combined.push(line);
+      // Forward per-message Anthropic usage to the caller if Claude printed one.
+      if (isClaude && typeof onUsage === 'function') {
+        const usage = extractClaudeUsage(line);
+        if (usage) {
+          try { onUsage(usage); } catch (_) { /* never block the stream on a listener throw */ }
+        }
+      }
+    };
+    const stdoutBuf = new StreamBuffer('info', logger, onStdoutLine, transform);
+    const stderrBuf = new StreamBuffer('error', logger, (line) => combined.push(line), null);
+
+    child.stdout.on('data', (chunk) => stdoutBuf.write(chunk));
+    child.stderr.on('data', (chunk) => stderrBuf.write(chunk));
+
+    let killedByTimeout = false;
+    let timer = null;
+    if (timeoutMs && timeoutMs > 0) {
+      timer = setTimeout(() => {
+        killedByTimeout = true;
+        try { child.kill('SIGTERM'); } catch (_) { /* ignore */ }
+      }, timeoutMs);
+    }
+
+    child.on('error', (err) => {
+      if (timer) clearTimeout(timer);
+      resolve({
+        success: false,
+        method: 'cli-direct',
+        error: `Spawn error: ${err.message}`,
+        command,
+        args
+      });
+    });
+
+    child.on('close', (code, signal) => {
+      if (timer) clearTimeout(timer);
+      stdoutBuf.flush();
+      stderrBuf.flush();
+
+      const output = combined.join('\n');
+      const rl = detectRateLimit(output);
+
+      const durationMs = Date.now() - startedAt;
+      if (logger && typeof logger.log === 'function') {
+        logger.log(`[cli-direct] ${command} exited code=${code} signal=${signal || 'none'} in ${durationMs}ms`);
+      }
+
+      const success = !killedByTimeout && code === 0 && !rl.isRateLimited;
+      resolve({
+        success,
+        method: 'cli-direct',
+        exitCode: code,
+        signal,
+        durationMs,
+        command,
+        args,
+        output,
+        isRateLimited: rl.isRateLimited,
+        resetTime: rl.resetTime || undefined,
+        rateLimitMessage: rl.isRateLimited ? rl.message : undefined,
+        error: success
+          ? undefined
+          : (killedByTimeout
+            ? `Killed after ${timeoutMs}ms timeout`
+            : rl.isRateLimited
+              ? rl.message
+              : `Exited with code ${code}`)
+      });
+    });
+  });
+}
+
+module.exports = {
+  runCliDirect,
+  detectRateLimit,
+  extractClaudeUsage,
+  // Exposed for tests
+  StreamBuffer,
+  humanizeClaudeStreamLine
+};

package/src/ide-integration/cli-session-manager.js

@@ -0,0 +1,180 @@
+// @vibecodingmachine/core - CLI Session Manager
+// Manages persistent terminal sessions for CLI-based agents (Claude, etc.)
+
+const { execSync } = require('child_process');
+const { join } = require('path');
+const { homedir } = require('os');
+const { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync } = require('fs');
+const { tmpdir } = require('os');
+
+/**
+ * CLI Session Manager
+ * Manages persistent terminal sessions for CLI-based IDEs/agents
+ */
+class CliSessionManager {
+  constructor() {
+    this.logger = console;
+    this.sessionDir = join(homedir(), '.vibecodingmachine', 'cli-sessions');
+    this._ensureSessionDir();
+  }
+
+  /**
+   * Ensure session directory exists
+   */
+  _ensureSessionDir() {
+    try {
+      mkdirSync(this.sessionDir, { recursive: true });
+    } catch (error) {
+      this.logger.error('Failed to create session directory:', error.message);
+    }
+  }
+
+  /**
+   * Get or create a session for a CLI IDE
+   * @param {string} ide - IDE name (e.g., 'claude', 'cursor')
+   * @param {string} repoPath - Repository path
+   * @returns {Object} Session info with status
+   */
+  getOrCreateSession(ide, repoPath) {
+    const sessionFile = join(this.sessionDir, `${ide}.json`);
+
+    try {
+      // Try to load existing session
+      const sessionData = JSON.parse(readFileSync(sessionFile, 'utf8'));
+
+      // Verify the session is still valid (terminal still running the CLI)
+      if (this._isSessionActive(sessionData)) {
+        this.logger.log(`✅ [${ide}] Reusing existing session`);
+        return sessionData;
+      }
+
+      this.logger.log(`⚠️ [${ide}] Previous session is no longer active, creating new one`);
+    } catch (error) {
+      this.logger.log(`📝 [${ide}] No existing session found, creating new one`);
+    }
+
+    // Create new session
+    const newSession = this._createNewSession(ide, repoPath);
+
+    try {
+      writeFileSync(sessionFile, JSON.stringify(newSession, null, 2), 'utf8');
+    } catch (error) {
+      this.logger.error('Failed to save session:', error.message);
+    }
+
+    return newSession;
+  }
+
+  /**
+   * Check if a session is still active by looking for the CLI process
+   * @param {Object} sessionData - Session data
+   * @returns {boolean} True if session is active
+   */
+  _isSessionActive(sessionData) {
+    if (!sessionData.ide) {
+      return false;
+    }
+
+    try {
+      // Check if the CLI process is still running
+      const command = sessionData.ide === 'claude' ? 'claude' : sessionData.ide === 'cursor' ? 'cursor' : null;
+
+      if (!command) return false;
+
+      const processCheck = execSync(`ps aux | grep "${command} --dangerously" | grep -v grep | wc -l`, {
+        encoding: 'utf8',
+        timeout: 5000
+      }).trim();
+
+      const isActive = parseInt(processCheck) > 0;
+      this.logger.log(`🔍 [${sessionData.ide}] Session active check: ${isActive ? 'YES' : 'NO'}`);
+      return isActive;
+    } catch (error) {
+      this.logger.log(`⚠️ Session check failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Create a new terminal session for a CLI IDE
+   * @param {string} ide - IDE name
+   * @param {string} repoPath - Repository path
+   * @returns {Object} New session object
+   */
+  _createNewSession(ide, repoPath) {
+    const sessionId = `${ide}-${Date.now()}`;
+
+    this.logger.log(`🚀 [${ide}] Launching ${ide} in terminal...`);
+
+    try {
+      const command = ide === 'claude' ? 'claude' : ide === 'cursor' ? 'cursor' : null;
+
+      if (!command) {
+        throw new Error(`Unsupported CLI IDE: ${ide}`);
+      }
+
+      // Create AppleScript to launch terminal and CLI
+      // Use simple script that activates Terminal and runs commands in active window
+      const escapedPath = repoPath.replace(/'/g, "'\\''");
+      const launchScript = `tell application "Terminal"
+  activate
+  delay 0.5
+  do script "cd '${escapedPath}' && ${command} --dangerously-skip-permissions"
+  delay 3
+end tell`;
+
+      const tempFile = join(tmpdir(), `cli_launch_${ide}_${Date.now()}.scpt`);
+      writeFileSync(tempFile, launchScript, 'utf8');
+
+      try {
+        execSync(`osascript "${tempFile}"`, {
+          encoding: 'utf8',
+          timeout: 20000,
+          stdio: 'pipe'
+        });
+      } finally {
+        try { unlinkSync(tempFile); } catch (e) { /* ignore */ }
+      }
+
+      this.logger.log(`✅ [${ide}] Terminal activated and ${command} launched`);
+
+      return {
+        ide,
+        sessionId,
+        repoPath,
+        command,
+        createdAt: new Date().toISOString(),
+        status: 'active'
+      };
+    } catch (error) {
+      this.logger.error(`❌ [${ide}] Failed to launch session: ${error.message}`);
+      return {
+        ide,
+        sessionId,
+        repoPath,
+        createdAt: new Date().toISOString(),
+        status: 'error',
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Clear a session (for cleanup or reset)
+   * @param {string} ide - IDE name
+   */
+  clearSession(ide) {
+    const sessionFile = join(this.sessionDir, `${ide}.json`);
+
+    try {
+      if (existsSync(sessionFile)) {
+        unlinkSync(sessionFile);
+        this.logger.log(`🧹 [${ide}] Session cleared`);
+      }
+    } catch (error) {
+      this.logger.error(`Failed to clear session: ${error.message}`);
+    }
+  }
+}
+
+module.exports = CliSessionManager;