vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/agent-firewall/policy/rules/fake-success.js

@@ -0,0 +1,79 @@
+/**
+ * Fake Success UI Rule
+ * 
+ * Only flags egregious cases of UI showing success without any backing logic.
+ * This rule is now much more lenient to reduce false positives - most success
+ * messages are legitimate (form submissions, state updates, etc.)
+ * 
+ * Only flags when:
+ * 1. Success message is in a "critical" domain (payments, auth)
+ * 2. AND there's zero HTTP/API activity in the entire file
+ * 3. AND no state management activity detected
+ */
+
+"use strict";
+
+const { CLAIM_TYPES } = require("../../claims/claim-types");
+
+/**
+ * Evaluate fake success UI rule
+ * @param {object} params
+ * @param {array} params.claims - Extracted claims
+ * @param {array} params.evidence - Evidence resolution results
+ * @param {object} params.policy - Policy configuration
+ * @returns {object|null} Violation or null
+ */
+function evaluate({ claims, evidence, policy }) {
+  const ruleConfig = policy.rules?.fake_success_ui;
+  
+  if (!ruleConfig || !ruleConfig.enabled) {
+    return null;
+  }
+  
+  // Find UI success claims
+  const successClaims = claims.filter(c => c.type === CLAIM_TYPES.UI_SUCCESS);
+  
+  if (successClaims.length === 0) {
+    return null;
+  }
+  
+  // Check if there's ANY HTTP call, route reference, or side effect in the claims
+  // If yes, the file likely has real logic and success messages are legitimate
+  const hasHttpCall = claims.some(c => 
+    c.type === CLAIM_TYPES.HTTP_CALL || c.type === CLAIM_TYPES.ROUTE
+  );
+  
+  const hasSideEffect = claims.some(c => c.type === CLAIM_TYPES.SIDE_EFFECT);
+  
+  // If there's any API activity, allow all success messages
+  if (hasHttpCall || hasSideEffect) {
+    return null;
+  }
+  
+  // Check if any success claim is in a critical domain
+  const criticalDomains = ruleConfig.block_if_domain || ["payments", "auth"];
+  const criticalSuccessClaims = successClaims.filter(claim => {
+    const domain = claim.domain || "general";
+    return criticalDomains.includes(domain);
+  });
+  
+  // Only flag if:
+  // 1. There's a success claim in a critical domain
+  // 2. AND there's zero API activity
+  // 3. AND we have multiple success claims (single success is likely legitimate)
+  if (criticalSuccessClaims.length > 0 && successClaims.length > 2) {
+    return {
+      rule: "fake_success_ui",
+      severity: ruleConfig.severity || "warn", // Default to warn, not block
+      message: `Multiple success messages (${successClaims.length}) in ${criticalSuccessClaims[0].domain} without API calls - verify logic exists`,
+      claimId: `claim_${claims.indexOf(criticalSuccessClaims[0])}`,
+      claim: criticalSuccessClaims[0]
+    };
+  }
+  
+  return null;
+}
+
+module.exports = {
+  evaluate
+};

package/bin/runners/lib/agent-firewall/policy/rules/ghost-env.js

@@ -0,0 +1,227 @@
+/**
+ * Ghost Env Rule
+ * 
+ * Blocks if process.env.X used but not declared.
+ * Includes smart whitelisting to reduce false positives.
+ */
+
+"use strict";
+
+const { CLAIM_TYPES } = require("../../claims/claim-types");
+
+/**
+ * Common environment variables that are safe to use without explicit declaration.
+ * These are well-known Node.js, Next.js, and common deployment platform vars.
+ * 
+ * NOTE: Be generous with this list - most env vars are set by the user's deployment
+ * environment and aren't hallucinations. We only want to flag truly phantom vars
+ * that the agent invented with no basis.
+ */
+const SAFE_ENV_VARS = new Set([
+  // Node.js core
+  "NODE_ENV",
+  "NODE_OPTIONS",
+  "NODE_PATH",
+  "NODE_DEBUG",
+  "NODE_TLS_REJECT_UNAUTHORIZED",
+  
+  // Next.js / React
+  "NEXT_PUBLIC_",      // Prefix pattern
+  "REACT_APP_",        // Prefix pattern
+  "VERCEL",
+  "VERCEL_ENV",
+  "VERCEL_URL",
+  "NEXT_RUNTIME",
+  "ANALYZE",
+  
+  // Common deployment
+  "PORT",
+  "HOST",
+  "HOSTNAME",
+  "CI",
+  "DEBUG",
+  "LOG_LEVEL",
+  "TZ",
+  "LANG",
+  "HOME",
+  "USER",
+  "PATH",
+  "PWD",
+  "SHELL",
+  "TERM",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  
+  // Testing
+  "TEST",
+  "JEST_WORKER_ID",
+  "VITEST",
+  "PLAYWRIGHT_TEST_BASE_URL",
+  
+  // Build tools
+  "npm_package_name",
+  "npm_package_version",
+  "npm_lifecycle_event",
+  
+  // Database (common naming patterns)
+  "DATABASE_URL",
+  "DB_HOST",
+  "DB_PORT",
+  "DB_USER",
+  "DB_PASSWORD",
+  "DB_NAME",
+  "POSTGRES_URL",
+  "MYSQL_URL",
+  "REDIS_URL",
+  "MONGODB_URI",
+  
+  // Auth (common naming patterns)
+  "JWT_SECRET",
+  "SESSION_SECRET",
+  "AUTH_SECRET",
+  "NEXTAUTH_SECRET",
+  "NEXTAUTH_URL",
+  
+  // API keys (generic patterns)
+  "API_KEY",
+  "API_SECRET",
+  "SECRET_KEY",
+  
+  // Email
+  "SMTP_HOST",
+  "SMTP_PORT",
+  "SMTP_USER",
+  "SMTP_PASSWORD",
+  "MAIL_HOST",
+  "MAIL_PORT",
+  "RESEND_API_KEY",
+  "SENDGRID_API_KEY",
+  
+  // Payments
+  "STRIPE_SECRET_KEY",
+  "STRIPE_PUBLISHABLE_KEY",
+  "STRIPE_WEBHOOK_SECRET",
+]);
+
+/**
+ * Prefix patterns that are safe - these are from known platforms/tools
+ */
+const SAFE_ENV_PREFIXES = [
+  "NEXT_PUBLIC_",
+  "REACT_APP_",
+  "VITE_",
+  "VUE_APP_",
+  "NUXT_",
+  "npm_",
+  "GITHUB_",
+  "CI_",
+  "VERCEL_",
+  "RAILWAY_",
+  "RENDER_",
+  "HEROKU_",
+  "AWS_",
+  "AZURE_",
+  "GOOGLE_",
+  "FIREBASE_",
+  "SUPABASE_",
+  "CLERK_",
+  "AUTH0_",
+  "SENTRY_",
+  "DATADOG_",
+  "NEW_RELIC_",
+  "OPENAI_",
+  "ANTHROPIC_",
+  "VIBECHECK_",
+];
+
+/**
+ * Check if an env var is in the safe list
+ * @param {string} varName - Environment variable name
+ * @returns {boolean} Is safe
+ */
+function isSafeEnvVar(varName) {
+  if (!varName || typeof varName !== 'string') return false;
+  
+  const normalized = varName.toUpperCase();
+  
+  // Direct match
+  if (SAFE_ENV_VARS.has(normalized)) return true;
+  
+  // Prefix match
+  for (const prefix of SAFE_ENV_PREFIXES) {
+    if (normalized.startsWith(prefix)) return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Evaluate ghost env rule
+ * @param {object} params
+ * @param {array} params.claims - Extracted claims
+ * @param {array} params.evidence - Evidence resolution results
+ * @param {object} params.policy - Policy configuration
+ * @returns {object|null} Violation or null
+ */
+function evaluate({ claims, evidence, policy }) {
+  const ruleConfig = policy.rules?.ghost_env;
+  
+  if (!ruleConfig || !ruleConfig.enabled) {
+    return null;
+  }
+  
+  // Get custom whitelist from policy
+  const customWhitelist = new Set(ruleConfig.whitelist || []);
+  
+  // Find env claims with UNPROVEN evidence
+  for (let i = 0; i < claims.length; i++) {
+    const claim = claims[i];
+    
+    if (claim.type === CLAIM_TYPES.ENV) {
+      const ev = evidence.find(e => e.claimId === `claim_${i}`);
+      
+      if (ev && ev.result === "UNPROVEN") {
+        const envVar = String(claim.value || claim.key || "");
+        
+        // Skip if it's a known safe env var
+        if (isSafeEnvVar(envVar)) {
+          continue;
+        }
+        
+        // Skip if in custom whitelist
+        if (customWhitelist.has(envVar)) {
+          continue;
+        }
+        
+        // Skip if it's a fallback pattern (e.g., process.env.X || 'default')
+        if (claim.hasFallback) {
+          // Downgrade to warning instead of block
+          return {
+            rule: "ghost_env",
+            severity: "warn",
+            message: `Env var ${envVar} is used with fallback but not declared`,
+            claimId: `claim_${i}`,
+            claim
+          };
+        }
+        
+        // Default to "warn" - only block if explicitly configured
+        // Most env vars are real, just not in .env.example
+        return {
+          rule: "ghost_env",
+          severity: ruleConfig.severity || "warn",
+          message: `Env var ${envVar} used but not found in .env.example`,
+          claimId: `claim_${i}`,
+          claim
+        };
+      }
+    }
+  }
+  
+  return null;
+}
+
+module.exports = {
+  evaluate
+};

package/bin/runners/lib/agent-firewall/policy/rules/ghost-route.js

@@ -0,0 +1,191 @@
+/**
+ * Ghost Route Rule
+ * 
+ * Blocks if UI references route not registered in truthpack.
+ * Includes smart detection of external APIs and common patterns.
+ */
+
+"use strict";
+
+const { CLAIM_TYPES } = require("../../claims/claim-types");
+
+/**
+ * Patterns that indicate an external API (not a local route)
+ */
+const EXTERNAL_API_PATTERNS = [
+  // Full URLs
+  /^https?:\/\//i,
+  /^\/\/[a-z]/i,
+  
+  // Common external API domains
+  /api\.github\.com/i,
+  /api\.stripe\.com/i,
+  /api\.openai\.com/i,
+  /api\.anthropic\.com/i,
+  /api\.twilio\.com/i,
+  /api\.sendgrid\.com/i,
+  /graph\.facebook\.com/i,
+  /api\.twitter\.com/i,
+  /googleapis\.com/i,
+  /aws\.amazon\.com/i,
+  /cloudflare\.com/i,
+  /api\.clerk\.dev/i,
+  /api\.auth0\.com/i,
+  /api\.supabase\.co/i,
+  /api\.vercel\.app/i,
+  
+  // GraphQL endpoints
+  /graphql/i,
+  
+  // Webhook patterns
+  /webhook/i,
+  /hook\//i,
+];
+
+/**
+ * Path patterns that are safe to skip (dynamic or template)
+ */
+const SAFE_ROUTE_PATTERNS = [
+  // Dynamic segments
+  /\$\{/,                    // Template literals
+  /\[.*\]/,                  // Dynamic route segments [id]
+  /:\w+/,                    // URL params :id
+  /\{\{.*\}\}/,              // Template syntax
+  
+  // Hash-only routes
+  /^#/,
+  
+  // Query-only
+  /^\?/,
+  
+  // Empty or undefined
+  /^undefined$/i,
+  /^null$/i,
+];
+
+/**
+ * Check if a route is external
+ * @param {string} route - Route path
+ * @returns {boolean} Is external
+ */
+function isExternalRoute(route) {
+  if (!route || typeof route !== 'string') return true;
+  
+  const trimmed = route.trim();
+  
+  // Check external patterns
+  for (const pattern of EXTERNAL_API_PATTERNS) {
+    if (pattern.test(trimmed)) return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Check if a route should be skipped
+ * @param {string} route - Route path
+ * @returns {boolean} Should skip
+ */
+function shouldSkipRoute(route) {
+  if (!route || typeof route !== 'string') return true;
+  
+  const trimmed = route.trim();
+  
+  // Skip empty routes
+  if (trimmed.length === 0) return true;
+  
+  // Check safe patterns
+  for (const pattern of SAFE_ROUTE_PATTERNS) {
+    if (pattern.test(trimmed)) return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Check if route is a local API route
+ * @param {string} route - Route path
+ * @returns {boolean} Is local API
+ */
+function isLocalApiRoute(route) {
+  if (!route || typeof route !== 'string') return false;
+  
+  const trimmed = route.trim().toLowerCase();
+  
+  // Must start with /api/ to be a local Next.js API route
+  return trimmed.startsWith('/api/');
+}
+
+/**
+ * Evaluate ghost route rule
+ * @param {object} params
+ * @param {array} params.claims - Extracted claims
+ * @param {array} params.evidence - Evidence resolution results
+ * @param {object} params.policy - Policy configuration
+ * @returns {object|null} Violation or null
+ */
+function evaluate({ claims, evidence, policy }) {
+  const ruleConfig = policy.rules?.ghost_route;
+  
+  if (!ruleConfig || !ruleConfig.enabled) {
+    return null;
+  }
+  
+  // Get custom whitelist from policy
+  const customWhitelist = new Set(ruleConfig.whitelist || []);
+  
+  // Find route claims with UNPROVEN evidence
+  for (let i = 0; i < claims.length; i++) {
+    const claim = claims[i];
+    
+    if (claim.type === CLAIM_TYPES.ROUTE || claim.type === CLAIM_TYPES.HTTP_CALL) {
+      const ev = evidence.find(e => e.claimId === `claim_${i}`);
+      
+      // Skip if evidence shows it's already proven
+      if (ev && ev.result === "PROVEN") {
+        continue;
+      }
+      
+      if (ev && ev.result === "UNPROVEN") {
+        const routePath = String(claim.value || "").trim();
+        
+        // Skip dynamic or template routes
+        if (shouldSkipRoute(routePath)) {
+          continue;
+        }
+        
+        // Skip external API calls
+        if (isExternalRoute(routePath)) {
+          continue;
+        }
+        
+        // Only flag local API routes
+        if (!isLocalApiRoute(routePath)) {
+          // Not a local API route - could be page navigation, skip
+          continue;
+        }
+        
+        // Skip if in custom whitelist
+        if (customWhitelist.has(routePath)) {
+          continue;
+        }
+        
+        // Default to "warn" - only block if explicitly configured
+        // Route references are often correct, just not in truthpack yet
+        return {
+          rule: "ghost_route",
+          severity: ruleConfig.severity || "warn",
+          message: `Route ${routePath} not found in truthpack - verify it exists`,
+          claimId: `claim_${i}`,
+          claim
+        };
+      }
+    }
+  }
+  
+  return null;
+}
+
+module.exports = {
+  evaluate
+};

package/bin/runners/lib/agent-firewall/policy/rules/scope.js

@@ -0,0 +1,93 @@
+/**
+ * Scope Explosion Rule
+ * 
+ * Blocks if too many files touched.
+ */
+
+"use strict";
+
+/**
+ * Evaluate scope explosion rule
+ * @param {object} params
+ * @param {array} params.files - Changed files
+ * @param {string} params.intent - Agent intent message
+ * @param {object} params.policy - Policy configuration
+ * @returns {object|null} Violation or null
+ */
+function evaluate({ files, intent, policy }) {
+  const ruleConfig = policy.rules?.scope_explosion;
+  
+  if (!ruleConfig || !ruleConfig.enabled) {
+    return null;
+  }
+  
+  const scope = policy.scope || {};
+  const maxFiles = scope.max_files_touched || 10;
+  const maxLines = scope.max_lines_changed || 600;
+  const requireIntent = scope.require_intent_for_expand_scope || false;
+  
+  const totalFiles = files.length;
+  const totalLines = files.reduce((sum, f) => sum + (f.linesChanged || 0), 0);
+  
+  // Check file count
+  if (totalFiles > maxFiles) {
+    const hasIntent = intent && intent.trim().length > 0;
+    
+    if (requireIntent && !hasIntent) {
+      return {
+        rule: "scope_explosion",
+        severity: ruleConfig.severity || "block",
+        message: `Scope explosion: ${totalFiles} files touched (max: ${maxFiles}). Intent required for scope expansion.`,
+        metadata: {
+          totalFiles,
+          maxFiles,
+          hasIntent
+        }
+      };
+    } else if (!requireIntent) {
+      return {
+        rule: "scope_explosion",
+        severity: ruleConfig.severity || "block",
+        message: `Scope explosion: ${totalFiles} files touched (max: ${maxFiles})`,
+        metadata: {
+          totalFiles,
+          maxFiles
+        }
+      };
+    }
+  }
+  
+  // Check line count
+  if (totalLines > maxLines) {
+    const hasIntent = intent && intent.trim().length > 0;
+    
+    if (requireIntent && !hasIntent) {
+      return {
+        rule: "scope_explosion",
+        severity: ruleConfig.severity || "block",
+        message: `Scope explosion: ${totalLines} lines changed (max: ${maxLines}). Intent required for scope expansion.`,
+        metadata: {
+          totalLines,
+          maxLines,
+          hasIntent
+        }
+      };
+    } else if (!requireIntent) {
+      return {
+        rule: "scope_explosion",
+        severity: ruleConfig.severity || "block",
+        message: `Scope explosion: ${totalLines} lines changed (max: ${maxLines})`,
+        metadata: {
+          totalLines,
+          maxLines
+        }
+      };
+    }
+  }
+  
+  return null;
+}
+
+module.exports = {
+  evaluate
+};

package/bin/runners/lib/agent-firewall/policy/rules/unsafe-side-effect.js

@@ -0,0 +1,57 @@
+/**
+ * Unsafe Side Effect Rule
+ * 
+ * Blocks unverified side effects.
+ */
+
+"use strict";
+
+const { CLAIM_TYPES } = require("../../claims/claim-types");
+
+/**
+ * Evaluate unsafe side effect rule
+ * @param {object} params
+ * @param {array} params.claims - Extracted claims
+ * @param {array} params.evidence - Evidence resolution results
+ * @param {object} params.policy - Policy configuration
+ * @returns {object|null} Violation or null
+ */
+function evaluate({ claims, evidence, policy }) {
+  const ruleConfig = policy.rules?.unsafe_side_effect;
+  
+  if (!ruleConfig || !ruleConfig.enabled) {
+    return null;
+  }
+  
+  const verification = policy.verification || {};
+  const requireForDomains = verification.require_for_domains || [];
+  
+  // Find side effect claims
+  for (let i = 0; i < claims.length; i++) {
+    const claim = claims[i];
+    
+    if (claim.type === CLAIM_TYPES.SIDE_EFFECT) {
+      const ev = evidence.find(e => e.claimId === `claim_${i}`);
+      
+      // Check if domain requires verification
+      const claimDomain = claim.domain || "general";
+      const requiresVerification = requireForDomains.includes(claimDomain);
+      
+      if (requiresVerification && ev && ev.result === "UNPROVEN") {
+        return {
+          rule: "unsafe_side_effect",
+          severity: ruleConfig.severity || "block",
+          message: `Unsafe side effect: ${claim.value} requires verification (test coverage or reality proof)`,
+          claimId: `claim_${i}`,
+          claim
+        };
+      }
+    }
+  }
+  
+  return null;
+}
+
+module.exports = {
+  evaluate
+};