vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/runEvidencePack.js

@@ -0,0 +1,362 @@
+/**
+ * vibecheck evidence-pack - Bundle Proof Artifacts
+ *
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * Creates shareable evidence packs from vibecheck proof runs.
+ * Bundles videos, traces, screenshots, and findings into a single artifact.
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+// Colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+};
+
+const rgb = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+
+const colors = {
+  accent: rgb(0, 212, 255),
+  success: rgb(16, 185, 129),
+  warning: rgb(245, 158, 11),
+  error: rgb(239, 68, 68),
+};
+
+const ICONS = {
+  pack: '📦',
+  check: '✓',
+  cross: '✗',
+  video: '🎥',
+  trace: '📊',
+  screenshot: '📸',
+  file: '📄',
+};
+
+function printHelp(opts = {}) {
+  console.log(`
+  ${c.bold}vibecheck evidence-pack${c.reset} - Bundle Proof Artifacts
+
+  ${c.bold}Usage:${c.reset} vibecheck evidence-pack [options]
+
+  ${c.bold}What It Bundles:${c.reset}
+    ${ICONS.video} ${c.dim}Videos${c.reset}       Browser session recordings
+    ${ICONS.trace} ${c.dim}Traces${c.reset}       Playwright traces (view at trace.playwright.dev)
+    ${ICONS.screenshot} ${c.dim}Screenshots${c.reset}  Finding screenshots
+    ${ICONS.file} ${c.dim}Reports${c.reset}      JSON reports with evidence
+
+  ${c.bold}Options:${c.reset}
+    ${colors.accent}--output, -o <path>${c.reset}     Output directory ${c.dim}(default: .vibecheck/evidence-packs/)${c.reset}
+    ${colors.accent}--run-id <id>${c.reset}           Bundle specific run by ID
+    ${colors.accent}--latest${c.reset}                Bundle the most recent run ${c.dim}(default)${c.reset}
+    ${colors.accent}--no-videos${c.reset}             Exclude video recordings
+    ${colors.accent}--no-traces${c.reset}             Exclude Playwright traces
+    ${colors.accent}--no-screenshots${c.reset}        Exclude screenshots
+    ${colors.accent}--markdown${c.reset}              Generate markdown report
+    ${colors.accent}--json${c.reset}                  Output JSON manifest only
+    ${colors.accent}--help, -h${c.reset}              Show this help
+
+  ${c.bold}Examples:${c.reset}
+    ${c.dim}# Create evidence pack from latest run${c.reset}
+    vibecheck evidence-pack
+
+    ${c.dim}# Custom output path${c.reset}
+    vibecheck evidence-pack --output ./artifacts/proof
+
+    ${c.dim}# Bundle specific run${c.reset}
+    vibecheck evidence-pack --run-id abc123
+
+    ${c.dim}# Generate markdown report${c.reset}
+    vibecheck evidence-pack --markdown > evidence-report.md
+
+    ${c.dim}# Exclude large files${c.reset}
+    vibecheck evidence-pack --no-videos --no-traces
+  `);
+}
+
+async function runEvidencePack(args = [], context = {}) {
+  // Parse arguments
+  const getArg = (flags) => {
+    for (const f of flags) {
+      const idx = args.indexOf(f);
+      if (idx !== -1 && idx < args.length - 1) return args[idx + 1];
+    }
+    return undefined;
+  };
+  
+  const hasFlag = (flags) => flags.some(f => args.includes(f));
+
+  if (hasFlag(["--help", "-h"])) {
+    printHelp();
+    return 0;
+  }
+
+  const options = {
+    repoRoot: context.repoRoot || process.cwd(),
+    output: getArg(["--output", "-o"]),
+    runId: getArg(["--run-id"]),
+    latest: hasFlag(["--latest"]) || !getArg(["--run-id"]),
+    includeVideos: !hasFlag(["--no-videos"]),
+    includeTraces: !hasFlag(["--no-traces"]),
+    includeScreenshots: !hasFlag(["--no-screenshots"]),
+    markdown: hasFlag(["--markdown"]),
+    json: hasFlag(["--json"]),
+    quiet: hasFlag(["--quiet", "-q"]),
+  };
+
+  const root = options.repoRoot;
+  const vibecheckDir = path.join(root, ".vibecheck");
+  const runsDir = path.join(vibecheckDir, "runs");
+
+  if (!options.quiet && !options.json && !options.markdown) {
+    console.log(`\n  ${ICONS.pack} ${c.bold}Building Evidence Pack${c.reset}\n`);
+  }
+
+  try {
+    // Find the run to bundle
+    let runId = options.runId;
+    
+    if (options.latest || !runId) {
+      // Find the most recent run
+      if (!fs.existsSync(runsDir)) {
+        throw new Error("No runs found. Run 'vibecheck prove' first.");
+      }
+      
+      const runs = fs.readdirSync(runsDir)
+        .filter(d => fs.statSync(path.join(runsDir, d)).isDirectory())
+        .map(d => {
+          const manifestPath = path.join(runsDir, d, "manifest.json");
+          if (fs.existsSync(manifestPath)) {
+            try {
+              const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+              return { id: d, timestamp: manifest.timestamp || 0 };
+            } catch {
+              return { id: d, timestamp: 0 };
+            }
+          }
+          return { id: d, timestamp: 0 };
+        })
+        .sort((a, b) => b.timestamp - a.timestamp);
+      
+      if (runs.length === 0) {
+        throw new Error("No runs found. Run 'vibecheck prove' first.");
+      }
+      
+      runId = runs[0].id;
+    }
+
+    const runDir = path.join(runsDir, runId);
+    if (!fs.existsSync(runDir)) {
+      throw new Error(`Run not found: ${runId}`);
+    }
+
+    // Build the evidence pack
+    const pack = await buildEvidencePack(runDir, runId, options);
+
+    // Output based on format
+    if (options.markdown) {
+      console.log(generateMarkdownReport(pack));
+      return pack.summary.verdict === 'SHIP' ? 0 : pack.summary.verdict === 'WARN' ? 1 : 2;
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(pack.manifest, null, 2));
+      return pack.summary.verdict === 'SHIP' ? 0 : pack.summary.verdict === 'WARN' ? 1 : 2;
+    }
+
+    // Print summary
+    const { summary, manifest } = pack;
+    const verdictColor = summary.verdict === 'SHIP' ? colors.success : 
+                         summary.verdict === 'WARN' ? colors.warning : colors.error;
+
+    console.log(`  ${c.dim}Pack ID:${c.reset}    ${pack.id}`);
+    console.log(`  ${c.dim}Run ID:${c.reset}     ${runId}`);
+    console.log(`  ${c.dim}Verdict:${c.reset}    ${verdictColor}${c.bold}${summary.verdict}${c.reset}`);
+    console.log(`  ${c.dim}Score:${c.reset}      ${summary.score}/100`);
+    console.log(`  ${c.dim}Findings:${c.reset}   ${summary.totalFindings}`);
+    console.log();
+
+    // Artifact summary
+    const artifacts = manifest.artifacts;
+    if (artifacts.screenshots && artifacts.screenshots.length > 0) {
+      console.log(`  ${ICONS.screenshot} Screenshots: ${artifacts.screenshots.length}`);
+    }
+    if (artifacts.videos && artifacts.videos.length > 0) {
+      console.log(`  ${ICONS.video} Videos: ${artifacts.videos.length}`);
+    }
+    if (artifacts.traces && artifacts.traces.length > 0) {
+      console.log(`  ${ICONS.trace} Traces: ${artifacts.traces.length}`);
+    }
+    
+    console.log();
+    console.log(`  ${colors.success}${ICONS.check}${c.reset} Output: ${path.relative(root, pack.outputDir)}`);
+    console.log();
+
+    // Tips
+    if (artifacts.traces && artifacts.traces.length > 0) {
+      console.log(`  ${c.dim}View traces at: ${c.cyan}https://trace.playwright.dev${c.reset}`);
+    }
+
+    return summary.verdict === 'SHIP' ? 0 : summary.verdict === 'WARN' ? 1 : 2;
+
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error.message }, null, 2));
+    } else {
+      console.error(`\n  ${colors.error}${ICONS.cross}${c.reset} ${error.message}\n`);
+    }
+    return 1;
+  }
+}
+
+async function buildEvidencePack(runDir, runId, options) {
+  const packId = `pack_${Date.now().toString(36)}`;
+  const outputDir = options.output || path.join(path.dirname(path.dirname(runDir)), "evidence-packs", packId);
+  
+  // Create output directory
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  // Read run manifest
+  const manifestPath = path.join(runDir, "manifest.json");
+  let runManifest = {};
+  if (fs.existsSync(manifestPath)) {
+    runManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+  }
+
+  // Read summary
+  const summaryPath = path.join(runDir, "artifacts", "summary.json");
+  let summary = { verdict: 'UNKNOWN', score: 0, totalFindings: 0 };
+  if (fs.existsSync(summaryPath)) {
+    summary = JSON.parse(fs.readFileSync(summaryPath, "utf-8"));
+  }
+
+  // Collect artifacts
+  const artifacts = {
+    screenshots: [],
+    videos: [],
+    traces: [],
+    reports: [],
+  };
+
+  const artifactsDir = path.join(runDir, "artifacts");
+  if (fs.existsSync(artifactsDir)) {
+    const files = fs.readdirSync(artifactsDir);
+    
+    for (const file of files) {
+      const filePath = path.join(artifactsDir, file);
+      const stat = fs.statSync(filePath);
+      
+      if (stat.isFile()) {
+        const ext = path.extname(file).toLowerCase();
+        const destPath = path.join(outputDir, file);
+        
+        if (['.png', '.jpg', '.jpeg'].includes(ext) && options.includeScreenshots) {
+          fs.copyFileSync(filePath, destPath);
+          artifacts.screenshots.push({ name: file, size: stat.size });
+        } else if (['.webm', '.mp4'].includes(ext) && options.includeVideos) {
+          fs.copyFileSync(filePath, destPath);
+          artifacts.videos.push({ name: file, size: stat.size });
+        } else if (ext === '.zip' && file.includes('trace') && options.includeTraces) {
+          fs.copyFileSync(filePath, destPath);
+          artifacts.traces.push({ name: file, size: stat.size });
+        } else if (ext === '.json') {
+          fs.copyFileSync(filePath, destPath);
+          artifacts.reports.push({ name: file, size: stat.size });
+        }
+      }
+    }
+  }
+
+  // Create pack manifest
+  const packManifest = {
+    id: packId,
+    runId,
+    createdAt: new Date().toISOString(),
+    summary,
+    artifacts,
+    source: runManifest,
+  };
+
+  const packManifestPath = path.join(outputDir, "manifest.json");
+  fs.writeFileSync(packManifestPath, JSON.stringify(packManifest, null, 2));
+
+  return {
+    id: packId,
+    runId,
+    outputDir,
+    manifestPath: packManifestPath,
+    manifest: packManifest,
+    summary,
+  };
+}
+
+function generateMarkdownReport(pack) {
+  const { manifest, summary } = pack;
+  const verdictEmoji = summary.verdict === 'SHIP' ? '✅' : summary.verdict === 'WARN' ? '⚠️' : '🚫';
+  
+  let md = `# Evidence Pack Report
+
+## Summary
+
+| Metric | Value |
+|--------|-------|
+| Pack ID | \`${pack.id}\` |
+| Run ID | \`${pack.runId}\` |
+| Verdict | ${verdictEmoji} **${summary.verdict}** |
+| Score | ${summary.score}/100 |
+| Findings | ${summary.totalFindings} |
+| Created | ${manifest.createdAt} |
+
+## Artifacts
+
+`;
+
+  if (manifest.artifacts.screenshots.length > 0) {
+    md += `### Screenshots (${manifest.artifacts.screenshots.length})\n\n`;
+    for (const s of manifest.artifacts.screenshots) {
+      md += `- \`${s.name}\` (${formatBytes(s.size)})\n`;
+    }
+    md += '\n';
+  }
+
+  if (manifest.artifacts.videos.length > 0) {
+    md += `### Videos (${manifest.artifacts.videos.length})\n\n`;
+    for (const v of manifest.artifacts.videos) {
+      md += `- \`${v.name}\` (${formatBytes(v.size)})\n`;
+    }
+    md += '\n';
+  }
+
+  if (manifest.artifacts.traces.length > 0) {
+    md += `### Traces (${manifest.artifacts.traces.length})\n\n`;
+    md += `View traces at [trace.playwright.dev](https://trace.playwright.dev)\n\n`;
+    for (const t of manifest.artifacts.traces) {
+      md += `- \`${t.name}\` (${formatBytes(t.size)})\n`;
+    }
+    md += '\n';
+  }
+
+  md += `---\n\n*Generated by vibecheck evidence-pack*\n`;
+
+  return md;
+}
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+}
+
+module.exports = { runEvidencePack };

package/bin/runners/runFirewall.d.ts

@@ -0,0 +1,5 @@
+export interface FirewallOptions {
+  action?: 'on' | 'off' | 'status' | 'lock';
+  projectRoot?: string;
+}
+export function runFirewall(options?: FirewallOptions): Promise<void>;

package/bin/runners/runFirewall.js

@@ -0,0 +1,134 @@
+/**
+ * Firewall Command Handler
+ * 
+ * Main firewall command handler.
+ * Enable/disable firewall, set mode, show status and statistics.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { loadPolicy, savePolicy, getDefaultPolicy } = require("./lib/agent-firewall/policy/loader");
+const { getPacketStats, queryPackets } = require("./lib/agent-firewall/change-packet/store");
+const { isTruthpackFresh } = require("./lib/agent-firewall/truthpack/loader");
+
+/**
+ * Run firewall command
+ * @param {object} options - Command options
+ * @param {string} options.mode - Set mode: 'observe' or 'enforce'
+ * @param {boolean} options.status - Show firewall status
+ * @param {boolean} options.stats - Show statistics
+ * @param {string} options.projectRoot - Project root directory
+ */
+async function runFirewall(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  
+  if (options.status) {
+    return showStatus(projectRoot);
+  }
+  
+  if (options.stats) {
+    return showStats(projectRoot);
+  }
+  
+  if (options.mode) {
+    return setMode(projectRoot, options.mode);
+  }
+  
+  // Default: show status
+  return showStatus(projectRoot);
+}
+
+/**
+ * Show firewall status
+ */
+function showStatus(projectRoot) {
+  try {
+    const policy = loadPolicy(projectRoot);
+    const truthpackFresh = isTruthpackFresh(projectRoot);
+    
+    const output = {
+      mode: policy.mode || "observe",
+      profile: policy.profile || "default",
+      truthpackFresh,
+      rulesEnabled: Object.keys(policy.rules || {}).filter(
+        key => policy.rules[key]?.enabled !== false
+      ).length
+    };
+    
+    return output;
+  } catch (error) {
+    return {
+      error: error.message,
+      mode: "unknown",
+      truthpackFresh: false
+    };
+  }
+}
+
+/**
+ * Show firewall statistics
+ */
+function showStats(projectRoot) {
+  try {
+    const stats = getPacketStats(projectRoot);
+    const recentPackets = queryPackets(projectRoot, { limit: 10 });
+    
+    return {
+      total: stats.total,
+      byAgent: stats.byAgent,
+      byVerdict: stats.byVerdict,
+      byDate: stats.byDate,
+      recent: recentPackets.map(p => ({
+        id: p.id,
+        timestamp: p.timestamp,
+        agentId: p.agentId,
+        verdict: p.verdict?.decision,
+        files: p.files.length
+      }))
+    };
+  } catch (error) {
+    return {
+      error: error.message,
+      total: 0
+    };
+  }
+}
+
+/**
+ * Set firewall mode
+ */
+function setMode(projectRoot, mode) {
+  if (mode !== "observe" && mode !== "enforce") {
+    throw new Error(`Invalid mode: ${mode}. Must be 'observe' or 'enforce'`);
+  }
+  
+  try {
+    let policy;
+    try {
+      policy = loadPolicy(projectRoot);
+    } catch {
+      // Policy doesn't exist, use default
+      policy = getDefaultPolicy();
+    }
+    
+    policy.mode = mode;
+    savePolicy(projectRoot, policy);
+    
+    return {
+      success: true,
+      mode,
+      message: `Firewall mode set to: ${mode}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+module.exports = {
+  runFirewall
+};

package/bin/runners/runFirewallHook.d.ts

@@ -0,0 +1,5 @@
+export interface FirewallHookOptions {
+  action?: 'install' | 'start' | 'status';
+  projectRoot?: string;
+}
+export function runFirewallHook(options?: FirewallHookOptions): Promise<void>;

package/bin/runners/runFirewallHook.js

@@ -0,0 +1,56 @@
+/**
+ * Firewall Hook Manager
+ * 
+ * Manages file system hook installation and control.
+ */
+
+"use strict";
+
+const { installFileSystemHook, startFileSystemHook, stopFileSystemHook } = require("./lib/agent-firewall/fs-hook/installer");
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Run firewall hook command
+ * @param {object} options - Command options
+ * @param {string} options.action - Action: 'install', 'start', 'stop', 'status'
+ * @param {string} options.projectRoot - Project root directory
+ */
+async function runFirewallHook(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const action = options.action || "status";
+
+  switch (action) {
+    case "install":
+      return installFileSystemHook(projectRoot);
+
+    case "start":
+      startFileSystemHook(projectRoot);
+      return {
+        success: true,
+        message: "File system hook started"
+      };
+
+    case "stop":
+      stopFileSystemHook();
+      return {
+        success: true,
+        message: "File system hook stopped"
+      };
+
+    case "status":
+      const markerFile = path.join(projectRoot, ".vibecheck", "fs-hook-enabled");
+      const installed = fs.existsSync(markerFile);
+      return {
+        installed,
+        running: false // Would need process management to check
+      };
+
+    default:
+      throw new Error(`Unknown action: ${action}`);
+  }
+}
+
+module.exports = {
+  runFirewallHook
+};