vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/authority-badge.js

@@ -0,0 +1,425 @@
+/**
+ * Authority Badge Generator
+ * 
+ * Generates SVG badges for PROCEED verdicts from the Authority System.
+ * Part of the PRO tier - requires verified verdicts.
+ * 
+ * Badge Types:
+ * - authority-approved: Standard approval badge
+ * - safe-consolidation: Safe Consolidation authority badge
+ * - inventory: Inventory analysis badge
+ * 
+ * Output formats:
+ * - SVG (default, scalable)
+ * - Markdown (for README embedding)
+ * - HTML (for web embedding)
+ */
+
+const path = require("path");
+const fs = require("fs");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// COLOR PALETTE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const BADGE_COLORS = {
+  PROCEED: {
+    background: '#22C55E',
+    text: '#FFFFFF',
+  },
+  DEFER: {
+    background: '#F59E0B',
+    text: '#000000',
+  },
+  STOP: {
+    background: '#EF4444',
+    text: '#FFFFFF',
+  },
+  neutral: {
+    background: '#555555',
+    text: '#FFFFFF',
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SVG TEMPLATES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Generate an SVG badge
+ */
+function generateSVGBadge(options) {
+  const {
+    label = 'Authority Approved',
+    message,
+    color,
+    textColor = '#FFFFFF',
+    logo = null,
+    style = 'flat',
+  } = options;
+
+  // Calculate widths based on text length
+  const labelWidth = Math.max(label.length * 7 + 10, 80);
+  const messageWidth = Math.max(message.length * 7 + 10, 50);
+  const totalWidth = labelWidth + messageWidth;
+  
+  if (style === 'flat-square') {
+    return generateFlatSquareBadge({ label, message, color, textColor, labelWidth, messageWidth, totalWidth, logo });
+  }
+  
+  return generateFlatBadge({ label, message, color, textColor, labelWidth, messageWidth, totalWidth, logo });
+}
+
+function generateFlatBadge(opts) {
+  const { label, message, color, textColor, labelWidth, messageWidth, totalWidth, logo } = opts;
+  
+  let logoSvg = '';
+  let logoOffset = 0;
+  
+  if (logo === 'vibecheck') {
+    logoOffset = 16;
+    logoSvg = `
+    <g transform="translate(5, 3)">
+      <path fill="${textColor}" d="M7 1l7 12H0L7 1zm0 3l-4 7h8L7 4z"/>
+    </g>`;
+  }
+  
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${totalWidth + logoOffset}" height="20" role="img" aria-label="${label}: ${message}">
+  <title>${label}: ${message}</title>
+  <linearGradient id="s" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <clipPath id="r">
+    <rect width="${totalWidth + logoOffset}" height="20" rx="3" fill="#fff"/>
+  </clipPath>
+  <g clip-path="url(#r)">
+    <rect width="${labelWidth + logoOffset}" height="20" fill="#555"/>
+    <rect x="${labelWidth + logoOffset}" width="${messageWidth}" height="20" fill="${color}"/>
+    <rect width="${totalWidth + logoOffset}" height="20" fill="url(#s)"/>
+  </g>
+  ${logoSvg}
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="11">
+    <text aria-hidden="true" x="${(labelWidth + logoOffset) / 2 + logoOffset/2}" y="15" fill="#010101" fill-opacity=".3">${label}</text>
+    <text x="${(labelWidth + logoOffset) / 2 + logoOffset/2}" y="14" fill="#fff">${label}</text>
+    <text aria-hidden="true" x="${labelWidth + logoOffset + messageWidth / 2}" y="15" fill="#010101" fill-opacity=".3">${message}</text>
+    <text x="${labelWidth + logoOffset + messageWidth / 2}" y="14" fill="${textColor}">${message}</text>
+  </g>
+</svg>`;
+}
+
+function generateFlatSquareBadge(opts) {
+  const { label, message, color, textColor, labelWidth, messageWidth, totalWidth, logo } = opts;
+  
+  let logoSvg = '';
+  let logoOffset = 0;
+  
+  if (logo === 'vibecheck') {
+    logoOffset = 16;
+    logoSvg = `
+    <g transform="translate(5, 3)">
+      <path fill="${textColor}" d="M7 1l7 12H0L7 1zm0 3l-4 7h8L7 4z"/>
+    </g>`;
+  }
+  
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${totalWidth + logoOffset}" height="20" role="img" aria-label="${label}: ${message}">
+  <title>${label}: ${message}</title>
+  <g shape-rendering="crispEdges">
+    <rect width="${labelWidth + logoOffset}" height="20" fill="#555"/>
+    <rect x="${labelWidth + logoOffset}" width="${messageWidth}" height="20" fill="${color}"/>
+  </g>
+  ${logoSvg}
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="11">
+    <text x="${(labelWidth + logoOffset) / 2 + logoOffset/2}" y="14" fill="#fff">${label}</text>
+    <text x="${labelWidth + logoOffset + messageWidth / 2}" y="14" fill="${textColor}">${message}</text>
+  </g>
+</svg>`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// BADGE GENERATORS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Generate an authority verdict badge
+ */
+function generateVerdictBadge(verdict, options = {}) {
+  const {
+    style = 'flat',
+    logo = 'vibecheck',
+    includeConfidence = true,
+  } = options;
+  
+  const action = verdict.action || 'UNKNOWN';
+  const confidence = verdict.confidence || 0;
+  const authorityId = verdict.authority || 'authority';
+  
+  const colors = BADGE_COLORS[action] || BADGE_COLORS.neutral;
+  
+  let message = action;
+  if (includeConfidence && action !== 'STOP') {
+    message = `${action} ${Math.round(confidence * 100)}%`;
+  }
+  
+  return generateSVGBadge({
+    label: `Authority: ${authorityId}`,
+    message,
+    color: colors.background,
+    textColor: colors.text,
+    logo,
+    style,
+  });
+}
+
+/**
+ * Generate a simple "Authority Approved" badge
+ */
+function generateApprovedBadge(options = {}) {
+  const {
+    authority = 'vibecheck',
+    confidence = 100,
+    version = '1.0',
+    style = 'flat',
+  } = options;
+  
+  return generateSVGBadge({
+    label: 'Authority Approved',
+    message: `${authority} v${version}`,
+    color: BADGE_COLORS.PROCEED.background,
+    textColor: BADGE_COLORS.PROCEED.text,
+    logo: 'vibecheck',
+    style,
+  });
+}
+
+/**
+ * Generate a Safe Consolidation badge
+ */
+function generateSafeConsolidationBadge(verdict, options = {}) {
+  const {
+    style = 'flat',
+  } = options;
+  
+  const action = verdict.action || 'PROCEED';
+  const confidence = verdict.confidence || 0.95;
+  const colors = BADGE_COLORS[action] || BADGE_COLORS.PROCEED;
+  
+  return generateSVGBadge({
+    label: 'Safe Consolidation',
+    message: `${action} ${Math.round(confidence * 100)}%`,
+    color: colors.background,
+    textColor: colors.text,
+    logo: 'vibecheck',
+    style,
+  });
+}
+
+/**
+ * Generate a CI status badge
+ */
+function generateCIBadge(verdict, options = {}) {
+  const {
+    style = 'flat',
+    ciName = 'CI',
+  } = options;
+  
+  const action = verdict.action || 'UNKNOWN';
+  const exitCode = verdict.exitCode ?? (action === 'PROCEED' ? 0 : action === 'DEFER' ? 1 : 2);
+  
+  let status, color;
+  if (exitCode === 0) {
+    status = 'passing';
+    color = BADGE_COLORS.PROCEED.background;
+  } else if (exitCode === 1) {
+    status = 'review';
+    color = BADGE_COLORS.DEFER.background;
+  } else {
+    status = 'failing';
+    color = BADGE_COLORS.STOP.background;
+  }
+  
+  return generateSVGBadge({
+    label: ciName,
+    message: status,
+    color,
+    textColor: '#FFFFFF',
+    style,
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// OUTPUT FORMATTERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Format badge for markdown embedding
+ */
+function formatBadgeMarkdown(badge, options = {}) {
+  const {
+    altText = 'Authority Approved by VibeCheck',
+    link = 'https://vibecheckai.dev',
+  } = options;
+  
+  // Encode SVG for data URI
+  const encoded = encodeURIComponent(badge)
+    .replace(/'/g, '%27')
+    .replace(/"/g, '%22');
+  
+  const dataUri = `data:image/svg+xml,${encoded}`;
+  
+  if (link) {
+    return `[![${altText}](${dataUri})](${link})`;
+  }
+  
+  return `![${altText}](${dataUri})`;
+}
+
+/**
+ * Format badge for HTML embedding
+ */
+function formatBadgeHTML(badge, options = {}) {
+  const {
+    altText = 'Authority Approved by VibeCheck',
+    link = 'https://vibecheckai.dev',
+    className = 'vibecheck-badge',
+  } = options;
+  
+  // Encode SVG for data URI
+  const encoded = encodeURIComponent(badge)
+    .replace(/'/g, '%27')
+    .replace(/"/g, '%22');
+  
+  const dataUri = `data:image/svg+xml,${encoded}`;
+  
+  const img = `<img src="${dataUri}" alt="${altText}" class="${className}">`;
+  
+  if (link) {
+    return `<a href="${link}" target="_blank" rel="noopener noreferrer">${img}</a>`;
+  }
+  
+  return img;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FILE OUTPUT
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Save badge to file
+ */
+async function saveBadge(badge, filePath, format = 'svg') {
+  const dir = path.dirname(filePath);
+  
+  // Ensure directory exists
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  
+  let content = badge;
+  let ext = '.svg';
+  
+  if (format === 'markdown' || format === 'md') {
+    content = formatBadgeMarkdown(badge);
+    ext = '.md';
+  } else if (format === 'html') {
+    content = formatBadgeHTML(badge);
+    ext = '.html';
+  }
+  
+  // Ensure file has correct extension
+  let finalPath = filePath;
+  if (!filePath.endsWith(ext) && format !== 'svg') {
+    finalPath = filePath.replace(/\.[^.]+$/, ext);
+  }
+  
+  await fs.promises.writeFile(finalPath, content);
+  
+  return finalPath;
+}
+
+/**
+ * Generate and save all badge variants
+ */
+async function generateAllBadges(verdict, outputDir, options = {}) {
+  const {
+    prefix = verdict.authority || 'authority',
+  } = options;
+  
+  const badges = {};
+  
+  // Main verdict badge
+  const verdictBadge = generateVerdictBadge(verdict, options);
+  badges.verdict = await saveBadge(
+    verdictBadge,
+    path.join(outputDir, `${prefix}-badge.svg`)
+  );
+  
+  // If PROCEED, also generate approved badge
+  if (verdict.action === 'PROCEED') {
+    const approvedBadge = generateApprovedBadge({
+      authority: verdict.authority,
+      confidence: verdict.confidence,
+      version: verdict.version,
+    });
+    badges.approved = await saveBadge(
+      approvedBadge,
+      path.join(outputDir, `${prefix}-approved-badge.svg`)
+    );
+    
+    // CI badge
+    const ciBadge = generateCIBadge(verdict);
+    badges.ci = await saveBadge(
+      ciBadge,
+      path.join(outputDir, `${prefix}-ci-badge.svg`)
+    );
+  }
+  
+  // Generate markdown snippet
+  const mdContent = `# ${verdict.authority || 'Authority'} Badge
+
+${formatBadgeMarkdown(verdictBadge, { altText: \`\${verdict.authority} - \${verdict.action}\` })}
+
+## Embed Code
+
+### Markdown
+\`\`\`markdown
+${formatBadgeMarkdown(verdictBadge, { altText: \`\${verdict.authority} - \${verdict.action}\` })}
+\`\`\`
+
+### HTML
+\`\`\`html
+${formatBadgeHTML(verdictBadge, { altText: \`\${verdict.authority} - \${verdict.action}\` })}
+\`\`\`
+
+---
+Generated: ${new Date().toISOString()}
+`;
+  
+  badges.readme = await saveBadge(mdContent, path.join(outputDir, `${prefix}-BADGE.md`), 'md');
+  
+  return badges;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  // Badge generators
+  generateSVGBadge,
+  generateVerdictBadge,
+  generateApprovedBadge,
+  generateSafeConsolidationBadge,
+  generateCIBadge,
+  
+  // Formatters
+  formatBadgeMarkdown,
+  formatBadgeHTML,
+  
+  // File operations
+  saveBadge,
+  generateAllBadges,
+  
+  // Constants
+  BADGE_COLORS,
+};

package/bin/runners/lib/backup.js

@@ -0,0 +1,62 @@
+// bin/runners/lib/backup.js
+const fs = require("fs");
+const path = require("path");
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function backupFiles(repoRoot, fileRelPaths, backupRoot) {
+  ensureDir(backupRoot);
+
+  const saved = [];
+  for (const rel of fileRelPaths) {
+    const abs = path.join(repoRoot, rel);
+    if (!fs.existsSync(abs)) {
+      saved.push({ rel, existed: false });
+      continue;
+    }
+
+    const dest = path.join(backupRoot, rel);
+    ensureDir(path.dirname(dest));
+    fs.copyFileSync(abs, dest);
+    saved.push({ rel, existed: true });
+  }
+
+  fs.writeFileSync(
+    path.join(backupRoot, "_manifest.json"),
+    JSON.stringify({ saved }, null, 2),
+    "utf8"
+  );
+
+  return saved;
+}
+
+function restoreBackup(repoRoot, backupRoot) {
+  const manifestPath = path.join(backupRoot, "_manifest.json");
+  if (!fs.existsSync(manifestPath)) {
+    return { ok: false, error: "backup manifest missing" };
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  const saved = manifest.saved || [];
+
+  for (const s of saved) {
+    const abs = path.join(repoRoot, s.rel);
+    const bak = path.join(backupRoot, s.rel);
+
+    if (!s.existed) {
+      if (fs.existsSync(abs)) fs.rmSync(abs, { force: true });
+      continue;
+    }
+
+    if (fs.existsSync(bak)) {
+      ensureDir(path.dirname(abs));
+      fs.copyFileSync(bak, abs);
+    }
+  }
+
+  return { ok: true };
+}
+
+module.exports = { backupFiles, restoreBackup };

package/bin/runners/lib/billing.js

@@ -0,0 +1,107 @@
+// bin/runners/lib/billing.js
+const fg = require("fast-glob");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+function sha256(text) {
+  return "sha256:" + crypto.createHash("sha256").update(text).digest("hex");
+}
+
+function safeRead(fileAbs) {
+  return fs.readFileSync(fileAbs, "utf8");
+}
+
+function evidenceFromLine({ fileAbs, repoRoot, lineNo, reason }) {
+  const fileRel = path.relative(repoRoot, fileAbs).replace(/\\/g, "/");
+  const lines = safeRead(fileAbs).split(/\r?\n/);
+  const idx = Math.max(0, Math.min(lines.length - 1, lineNo - 1));
+  const snippet = lines[idx] || "";
+  return {
+    id: `ev_${crypto.randomBytes(4).toString("hex")}`,
+    file: fileRel,
+    lines: `${lineNo}-${lineNo}`,
+    snippetHash: sha256(snippet),
+    reason
+  };
+}
+
+function findLineMatches(code, regex) {
+  const out = [];
+  const lines = code.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    if (regex.test(lines[i])) out.push(i + 1);
+  }
+  return out;
+}
+
+function classifyStripeSignals(code) {
+  const signals = {
+    usesStripeSdk: /\bstripe\b/i.test(code) && /from\s+['"]stripe['"]|require\(['"]stripe['"]\)/.test(code),
+    webhookConstructEvent: /\bconstructEvent(Async)?\b/.test(code) || /\bstripe\.webhooks\.constructEvent\b/.test(code),
+    readsStripeSignatureHeader: /stripe-signature/i.test(code) || /\bStripe-Signature\b/.test(code),
+    rawBodySignal:
+      /\bbodyParser\s*:\s*false\b/.test(code) ||
+      /\breq\.(text|arrayBuffer)\(\)/.test(code) ||
+      /\brawBody\b/.test(code) || /\brequest\.raw\b/.test(code) || /\bcontentTypeParser\b/i.test(code),
+    idempotencySignal:
+      /\bevent\.id\b/.test(code) && /\b(prisma|db|redis|cache|processed|dedupe|idempotent)\b/i.test(code) ||
+      /\bidempotenc(y|e)\b/i.test(code)
+  };
+
+  return signals;
+}
+
+async function buildBillingTruth(repoRoot) {
+  const files = await fg(["**/*.{ts,tsx,js,jsx}"], {
+    cwd: repoRoot,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/.next/**", "**/dist/**", "**/build/**"]
+  });
+
+  const webhookCandidates = [];
+  const stripeFiles = [];
+
+  for (const fileAbs of files) {
+    const fileRel = path.relative(repoRoot, fileAbs).replace(/\\/g, "/");
+    const code = safeRead(fileAbs);
+
+    const signals = classifyStripeSignals(code);
+
+    if (signals.usesStripeSdk) stripeFiles.push(fileRel);
+
+    if (signals.webhookConstructEvent || signals.readsStripeSignatureHeader) {
+      const ev = [];
+      const lines1 = findLineMatches(code, /\bconstructEvent(Async)?\b|stripe\.webhooks\.constructEvent/);
+      const lines2 = findLineMatches(code, /stripe-signature|Stripe-Signature/i);
+      const lines3 = findLineMatches(code, /bodyParser\s*:\s*false|req\.(text|arrayBuffer)\(|rawBody|contentTypeParser/i);
+      const lines4 = findLineMatches(code, /event\.id|idempotenc(y|e)|dedupe|processed/i);
+
+      for (const ln of lines1.slice(0, 3)) ev.push(evidenceFromLine({ fileAbs, repoRoot, lineNo: ln, reason: "Stripe webhook signature constructEvent signal" }));
+      for (const ln of lines2.slice(0, 3)) ev.push(evidenceFromLine({ fileAbs, repoRoot, lineNo: ln, reason: "Stripe-Signature header usage signal" }));
+      for (const ln of lines3.slice(0, 3)) ev.push(evidenceFromLine({ fileAbs, repoRoot, lineNo: ln, reason: "Raw body handling signal (required for Stripe verification)" }));
+      for (const ln of lines4.slice(0, 3)) ev.push(evidenceFromLine({ fileAbs, repoRoot, lineNo: ln, reason: "Idempotency/dedupe signal (event replay protection)" }));
+
+      webhookCandidates.push({
+        file: fileRel,
+        signals,
+        evidence: ev
+      });
+    }
+  }
+
+  const hasStripe = stripeFiles.length > 0;
+
+  return {
+    hasStripe,
+    stripeFiles: stripeFiles.slice(0, 200),
+    webhookCandidates,
+    summary: {
+      webhookHandlersFound: webhookCandidates.length,
+      verifiedWebhookHandlers: webhookCandidates.filter(w => w.signals.webhookConstructEvent && w.signals.rawBodySignal).length,
+      idempotentWebhookHandlers: webhookCandidates.filter(w => w.signals.idempotencySignal).length
+    }
+  };
+}
+
+module.exports = { buildBillingTruth };