vibecheck-mcp-server 3.2.0 → 3.2.6

package/index.js

@@ -33,6 +33,15 @@ import { fileURLToPath } from "url";
 import { execFile } from "child_process";
 import { promisify } from "util";
 
+// Import API client for dashboard integration
+const { 
+  createScan, 
+  updateScanProgress, 
+  submitScanResults, 
+  reportScanError, 
+  isApiAvailable 
+} = require("./lib/api-client");
+
 const execFileAsync = promisify(execFile);
 
 const __filename = fileURLToPath(import.meta.url);
@@ -1360,6 +1369,27 @@ class VibecheckMCP {
     const profile = args?.profile || "quick";
     const only = args?.only;
 
+    // Initialize API integration
+    let apiScan = null;
+    let apiConnected = false;
+    
+    // Try to connect to API for dashboard integration
+    try {
+      apiConnected = await isApiAvailable();
+      if (apiConnected) {
+        // Create scan record in dashboard
+        apiScan = await createScan({
+          localPath: projectPath,
+          branch: 'main',
+          enableLLM: false,
+        });
+        console.error(`[MCP] Connected to dashboard (Scan ID: ${apiScan.scanId})`);
+      }
+    } catch (err) {
+      // API connection is optional, continue without it
+      console.error(`[MCP] Dashboard integration unavailable: ${err.message}`);
+    }
+
     let output = "# 🔍 vibecheck Scan\n\n";
     output += `**Profile:** ${profile}\n`;
     output += `**Path:** ${projectPath}\n\n`;
@@ -1375,6 +1405,28 @@ class VibecheckMCP {
       const summary = await this.parseSummaryFromDisk(projectPath);
       if (summary) {
         output += this.formatScanOutput(summary, projectPath);
+        
+        // Submit results to dashboard if connected
+        if (apiConnected && apiScan) {
+          try {
+            await submitScanResults(apiScan.scanId, {
+              verdict: summary.verdict || 'UNKNOWN',
+              score: summary.score?.overall || 0,
+              findings: summary.findings || [],
+              filesScanned: summary.stats?.filesScanned || 0,
+              linesScanned: summary.stats?.linesScanned || 0,
+              durationMs: summary.timings?.total || 0,
+              metadata: {
+                profile,
+                source: 'mcp-server',
+                version: CONFIG.VERSION,
+              },
+            });
+            console.error(`[MCP] Results sent to dashboard`);
+          } catch (err) {
+            console.error(`[MCP] Failed to send results to dashboard: ${err.message}`);
+          }
+        }
       }
       output += "\n---\n_Context Enhanced by vibecheck AI_\n";
       return this.success(output);
@@ -1383,10 +1435,43 @@ class VibecheckMCP {
       const summary = await this.parseSummaryFromDisk(projectPath);
       if (summary) {
         output += this.formatScanOutput(summary, projectPath);
+        
+        // Submit results to dashboard if connected
+        if (apiConnected && apiScan) {
+          try {
+            await submitScanResults(apiScan.scanId, {
+              verdict: summary.verdict || 'UNKNOWN',
+              score: summary.score?.overall || 0,
+              findings: summary.findings || [],
+              filesScanned: summary.stats?.filesScanned || 0,
+              linesScanned: summary.stats?.linesScanned || 0,
+              durationMs: summary.timings?.total || 0,
+              metadata: {
+                profile,
+                source: 'mcp-server',
+                version: CONFIG.VERSION,
+                error: err.message,
+              },
+            });
+            console.error(`[MCP] Results sent to dashboard (with error)`);
+          } catch (err) {
+            console.error(`[MCP] Failed to send results to dashboard: ${err.message}`);
+          }
+        }
         output += `\n⚠️ Scan completed with findings (exit code ${err.code || 1})\n`;
         return this.success(output);
       }
 
+      // Report error to dashboard if connected
+      if (apiConnected && apiScan) {
+        try {
+          await reportScanError(apiScan.scanId, err);
+          console.error(`[MCP] Error reported to dashboard`);
+        } catch (err) {
+          console.error(`[MCP] Failed to report error to dashboard: ${err.message}`);
+        }
+      }
+
       return this.error(`Scan failed: ${err.message}`, {
         code: "SCAN_ERROR",
         suggestion: "Check that the project path is valid and contains scanable code",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecheck-mcp-server",
-  "version": "3.2.0",
+  "version": "3.2.6",
   "description": "Professional MCP server for vibecheck - Intelligent development environment vibechecks",
   "type": "module",
   "main": "index.js",

package/tier-auth.js

@@ -1,157 +1,162 @@
 /**
  * MCP Server Tier Authentication & Authorization
  * 
- * Provides tier checking for MCP tools based on API keys
+ * UNIFIED AUTHORITY SYSTEM for MCP tools.
+ * 
+ * Authority Rules:
+ * - FREE: May see problems, never resolve certainty. Read-only context tools.
+ * - STARTER: May fix, but not prove. Read tools + advisory actions.
+ * - PRO: May enforce reality. Full MCP access with proof generation.
+ * - ENTERPRISE: All features + compliance tools.
+ * 
+ * Verdict authority is paid. Evidence beats explanations.
  */
 
 import fs from "fs/promises";
 import path from "path";
 import os from "os";
 
-// Tier definitions - MUST MATCH CLI entitlements-v2.js
+// ═══════════════════════════════════════════════════════════════════════════════
+// TIER DEFINITIONS - UNIFIED AUTHORITY SYSTEM
+// Synchronized with packages/core/src/tier-config.ts
+// 
+// Authority Rules:
+// - FREE: May see problems, never resolve certainty
+// - STARTER: May fix, but not prove (Advisory verdicts only)
+// - PRO: May enforce reality (Full verdict authority)
+// ═══════════════════════════════════════════════════════════════════════════════
 export const TIERS = {
   free: {
     name: 'FREE',
     price: 0,
     order: 0,
-    features: [
-      // Core commands
-      'scan', 'ship', 'ship.static',
-      // Setup
-      'init', 'init.local', 'doctor', 'status', 'install', 'preflight', 'watch', 'watch.local',
-      // AI Truth
-      'ctx', 'guard', 'context', 'mdc', 'contracts',
-      // Quality
-      'verify', 'quality', 'polish', 'checkpoint', 'checkpoint.basic',
-      // Fix (plan only)
-      'fix', 'fix.plan_only',
-      // Reality (preview)
-      'reality', 'reality.preview',
-      // MCP (help only)
-      'mcp.help_only',
-      // Report (html/md only)
-      'report', 'report.html_md',
-    ],
+    // Verdict authority
+    verdictAuthority: 'NONE',
+    canIssueVerdicts: false,
+    canEnforceCI: false,
+    canGenerateProof: false,
+    // Limits
     limits: { 
-      scans: 50, 
-      shipChecks: 20, 
+      scans: -1,  // Unlimited scans
       realityMaxPages: 5, 
       realityMaxClicks: 20, 
-      fixApplyPatches: false,
-      mcpRateLimit: 10, // requests per minute
+      mcpRateLimit: 10,
     },
-    // MCP tools allowed on FREE
+    // MCP tools allowed on FREE (read-only context only)
     mcpTools: [
       'vibecheck.get_truthpack',
-      'vibecheck.validate_claim',
       'vibecheck.compile_context',
       'vibecheck.search_evidence',
     ],
   },
   starter: {
     name: 'STARTER',
-    price: 39, // Updated pricing
+    price: 39,
     order: 1,
-    features: [
-      // All FREE features plus...
-      // Init connect
-      'init.connect',
-      // Scan autofix
-      'scan.autofix',
-      // CI/CD
-      'gate', 'pr', 'badge', 'launch', 'dashboard_sync',
-      // Watch PR
-      'watch.pr',
-      // Report formats
-      'report.sarif_csv',
-      // Reality basic
-      'reality.basic',
-      // MCP read-only
-      'mcp', 'mcp.read_only',
-      // Ship full
-      'ship.full',
-    ],
+    // Verdict authority - ADVISORY (verdicts not enforced)
+    verdictAuthority: 'ADVISORY',
+    canIssueVerdicts: true,  // SHIP, WARN only
+    canEnforceCI: false,     // Cannot block builds
+    canGenerateProof: false, // Cannot generate proof
+    // Limits
     limits: { 
-      scans: -1, 
-      shipChecks: -1, 
-      realityMaxPages: 50, 
-      realityMaxClicks: 200, 
-      fixApplyPatches: false,
-      mcpRateLimit: 60, // requests per minute
+      scans: -1,           // Unlimited scans
+      realityMaxPages: -1, // Unlimited browser testing
+      realityMaxClicks: -1,
+      mcpRateLimit: 60,
     },
-    // MCP tools allowed on STARTER (curated)
+    // MCP tools allowed on STARTER (read + advisory actions)
     mcpTools: [
       'vibecheck.ctx',
       'vibecheck.scan',
-      'vibecheck.ship',
+      'vibecheck.ship',      // Advisory verdicts only
       'vibecheck.get_truthpack',
       'vibecheck.validate_claim',
       'vibecheck.compile_context',
       'vibecheck.search_evidence',
       'vibecheck.find_counterexamples',
       'vibecheck.check_invariants',
+      'vibecheck.fix',       // Plan mode only
     ],
   },
   pro: {
     name: 'PRO',
     price: 99,
     order: 2,
-    features: [
-      // All STARTER features plus...
-      // Prove
-      'prove',
-      // Fix apply
-      'fix.apply_patches', 'fix.loop',
-      // Checkpoint advanced
-      'checkpoint.hallucination',
-      // Reality advanced
-      'reality.full', 'reality.advanced_auth_boundary',
-      // Premium
-      'replay', 'share', 'ai-test', 'permissions', 'graph',
-      // MCP full
-      'mcp.full',
-    ],
+    // Verdict authority - ENFORCED (verdicts block CI/PRs)
+    verdictAuthority: 'ENFORCED',
+    canIssueVerdicts: true,  // SHIP, WARN, BLOCK
+    canEnforceCI: true,      // Can block builds
+    canGenerateProof: true,  // Can generate cryptographic proof
+    // Limits
     limits: { 
-      scans: -1, 
-      shipChecks: -1, 
-      realityMaxPages: -1, 
-      realityMaxClicks: -1, 
-      fixApplyPatches: true,
-      mcpRateLimit: -1, // unlimited
+      scans: -1,
+      realityMaxPages: -1,
+      realityMaxClicks: -1,
+      mcpRateLimit: -1,  // Unlimited
     },
-    // MCP tools allowed on PRO (curated)
-    mcpTools: [
-      'vibecheck.ctx',
-      'vibecheck.scan',
-      'vibecheck.ship',
-      'vibecheck.get_truthpack',
-      'vibecheck.validate_claim',
-      'vibecheck.compile_context',
-      'vibecheck.search_evidence',
-      'vibecheck.find_counterexamples',
-      'vibecheck.check_invariants',
-    ],
+    // MCP tools - FULL ACCESS
+    mcpTools: ['*'],  // All tools unlocked
   },
-  compliance: {
-    name: 'COMPLIANCE',
-    price: 0, // Enterprise/on-prem
+  enterprise: {
+    name: 'ENTERPRISE',
+    price: 0, // Custom pricing
     order: 3,
-    features: [
-      // All PRO features plus...
-      'report.compliance_packs',
-    ],
+    // Verdict authority - ENFORCED + Compliance
+    verdictAuthority: 'ENFORCED',
+    canIssueVerdicts: true,
+    canEnforceCI: true,
+    canGenerateProof: true,
+    // Limits
     limits: { 
-      scans: -1, 
-      shipChecks: -1, 
-      realityMaxPages: -1, 
-      realityMaxClicks: -1, 
-      fixApplyPatches: true,
+      scans: -1,
+      realityMaxPages: -1,
+      realityMaxClicks: -1,
       mcpRateLimit: -1,
     },
-    mcpTools: ['*'], // All tools
+    // MCP tools - FULL ACCESS + Compliance
+    mcpTools: ['*'],
   }
 };
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// MCP TOOL → TIER MAPPING (Unified Authority System)
+// Aligned with packages/core/src/features.ts
+// ═══════════════════════════════════════════════════════════════════════════════
+export const MCP_TOOL_TIERS = {
+  // FREE - Read-only context tools ONLY
+  // Free users may see problems, never resolve certainty
+  'vibecheck.get_truthpack': 'free',
+  'vibecheck.compile_context': 'free',
+  'vibecheck.search_evidence': 'free',
+  
+  // STARTER - Advisory verdict authority
+  // Starter users may fix, but not prove
+  'vibecheck.ctx': 'starter',
+  'vibecheck.scan': 'starter',
+  'vibecheck.ship': 'starter',          // SHIP/WARN (advisory, not enforced)
+  'vibecheck.fix': 'starter',           // Plan mode only (no apply)
+  'vibecheck.validate_claim': 'starter',
+  'vibecheck.find_counterexamples': 'starter',
+  'vibecheck.check_invariants': 'starter',
+  'vibecheck.gate': 'starter',          // Advisory gates
+  'vibecheck.badge': 'starter',         // Unverified badges
+  
+  // PRO - Full verdict authority & enforcement
+  // Pro users may enforce reality
+  'vibecheck.prove': 'pro',             // Cryptographic proof generation
+  'vibecheck.fix.apply': 'pro',         // Apply fixes
+  'vibecheck.fix.verify': 'pro',        // Verify fixes with proof
+  'vibecheck.reality': 'pro',           // Full browser testing
+  'vibecheck.reality.prove': 'pro',     // Prove runtime behavior
+  'vibecheck.enforce': 'pro',           // Enforce verdicts in CI
+  'vibecheck.ai_test': 'pro',           // AI agent testing
+  'vibecheck.autopilot': 'pro',         // Autonomous protection
+  'vibecheck.report': 'pro',            // Advanced reporting
+  'vibecheck.allowlist': 'pro',         // Manage allowlists
+  'vibecheck.status': 'pro',            // Advanced status
+};
+
 /**
  * Load user configuration from ~/.vibecheck/credentials.json
  */
@@ -175,7 +180,7 @@ async function getTierFromApiKey(apiKey) {
   // Check API key prefix patterns (matches CLI)
   if (apiKey.startsWith('gr_starter_')) return 'starter';
   if (apiKey.startsWith('gr_pro_')) return 'pro';
-  if (apiKey.startsWith('gr_compliance_') || apiKey.startsWith('gr_ent_')) return 'compliance';
+  if (apiKey.startsWith('gr_enterprise_') || apiKey.startsWith('gr_ent_')) return 'enterprise';
   if (apiKey.startsWith('gr_free_')) return 'free';
   
   // Try to validate with API
@@ -199,8 +204,8 @@ async function getTierFromApiKey(apiKey) {
         return 'starter';
       case 'pro':
         return 'pro';
-      case 'compliance':
-        return 'compliance';
+      case 'enterprise':
+        return 'enterprise';
       default:
         return 'free';
     }