vibecheck-mcp-server 2.0.1

package/test-mcp.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * MCP Server Test Script
+ * Tests that all tools are properly registered and can be invoked
+ */
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+console.log('🧪 Testing Guardrail MCP Server...\n');
+
+// Test 1: Import all modules
+async function testImports() {
+  console.log('1️⃣ Testing module imports...');
+  try {
+    const { INTELLIGENCE_TOOLS } = await import('./intelligence-tools.js');
+    const { GUARDRAIL_TOOLS } = await import('./guardrail-tools.js');
+    const { AGENT_CHECKPOINT_TOOLS } = await import('./agent-checkpoint.js');
+    const { ARCHITECT_TOOLS } = await import('./architect-tools.js');
+    const { CODEBASE_ARCHITECT_TOOLS } = await import('./codebase-architect-tools.js');
+    const { GUARDRAIL_2_TOOLS } = await import('./guardrail-2.0-tools.js');
+    const { intentDriftTools } = await import('./intent-drift-tools.js');
+    const { mdcGeneratorTool } = await import('./mdc-generator.js');
+    
+    console.log(`   ✅ Intelligence tools: ${INTELLIGENCE_TOOLS.length}`);
+    console.log(`   ✅ Guardrail tools: ${GUARDRAIL_TOOLS.length}`);
+    console.log(`   ✅ Checkpoint tools: ${AGENT_CHECKPOINT_TOOLS.length}`);
+    console.log(`   ✅ Architect tools: ${ARCHITECT_TOOLS.length}`);
+    console.log(`   ✅ Codebase Architect tools: ${CODEBASE_ARCHITECT_TOOLS.length}`);
+    console.log(`   ✅ Guardrail 2.0 tools: ${GUARDRAIL_2_TOOLS.length}`);
+    console.log(`   ✅ Intent Drift tools: ${intentDriftTools.length}`);
+    console.log(`   ✅ MDC Generator tool: ${mdcGeneratorTool.name}`);
+    
+    const totalTools = INTELLIGENCE_TOOLS.length + GUARDRAIL_TOOLS.length + 
+      AGENT_CHECKPOINT_TOOLS.length + ARCHITECT_TOOLS.length + 
+      CODEBASE_ARCHITECT_TOOLS.length + GUARDRAIL_2_TOOLS.length + 
+      intentDriftTools.length + 1;
+    
+    console.log(`\n   📊 Total tools available: ${totalTools}\n`);
+    return true;
+  } catch (error) {
+    console.log(`   ❌ Import failed: ${error.message}`);
+    return false;
+  }
+}
+
+// Test 2: Verify tier auth
+async function testTierAuth() {
+  console.log('2️⃣ Testing tier authentication...');
+  try {
+    const tierAuth = await import('./tier-auth.js');
+    console.log(`   ✅ Tiers available: ${Object.keys(tierAuth.TIERS).join(', ')}`);
+    console.log(`   ✅ Tier auth module loaded successfully`);
+    return true;
+  } catch (error) {
+    console.log(`   ❌ Tier auth failed: ${error.message}`);
+    return false;
+  }
+}
+
+// Test 3: Verify audit trail
+async function testAudit() {
+  console.log('3️⃣ Testing audit trail...');
+  try {
+    const { emitToolInvoke, emitToolComplete } = await import('./audit-mcp.js');
+    console.log(`   ✅ Audit functions available`);
+    return true;
+  } catch (error) {
+    console.log(`   ❌ Audit failed: ${error.message}`);
+    return false;
+  }
+}
+
+// Run all tests
+async function runTests() {
+  const results = [];
+  
+  results.push(await testImports());
+  results.push(await testTierAuth());
+  results.push(await testAudit());
+  
+  console.log('\n' + '='.repeat(50));
+  const passed = results.filter(r => r).length;
+  const total = results.length;
+  
+  if (passed === total) {
+    console.log(`✅ All ${total} tests passed!`);
+    console.log('\n🎉 MCP Server is ready for use!\n');
+    console.log('To use with Claude Desktop, add to claude_desktop_config.json:');
+    console.log(`{
+  "mcpServers": {
+    "guardrail": {
+      "command": "node",
+      "args": ["${__dirname.replace(/\\/g, '/')}/index.js"]
+    }
+  }
+}`);
+  } else {
+    console.log(`❌ ${total - passed}/${total} tests failed`);
+    process.exit(1);
+  }
+}
+
+runTests().catch(console.error);

package/test-tools.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Test individual MCP tools
+ */
+
+import { GUARDRAIL_TOOLS } from './guardrail-tools.js';
+import { INTELLIGENCE_TOOLS } from './intelligence-tools.js';
+
+console.log('🔧 Testing MCP Server Tools...\n');
+
+// List all available tools
+console.log('Available Guardrail Tools:');
+GUARDRAIL_TOOLS.forEach(tool => {
+  console.log(`  - ${tool.name}: ${tool.description}`);
+});
+
+console.log('\nAvailable Intelligence Tools:');
+INTELLIGENCE_TOOLS.forEach(tool => {
+  console.log(`  - ${tool.name}: ${tool.description}`);
+});
+
+// Test a simple tool function
+console.log('\n🧪 Testing tool execution...');
+
+// Test guardrail.mdc function
+try {
+  const { handleGuardrailTool } = await import('./guardrail-tools.js');
+  const result = await handleGuardrailTool('guardrail.mdc', {
+    path: process.cwd(),
+    output: 'test-output.mdc'
+  });
+  console.log('✅ guardrail.mdc tool executed successfully');
+  console.log('Result:', JSON.stringify(result, null, 2));
+} catch (error) {
+  console.log('❌ Tool execution failed:', error.message);
+}

package/tier-auth.js

@@ -0,0 +1,147 @@
+/**
+ * MCP Server Tier Authentication & Authorization
+ * 
+ * Provides tier checking for MCP tools based on API keys
+ */
+
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+// Tier definitions
+export const TIERS = {
+  free: {
+    name: 'Free',
+    features: ['verify', 'quality', 'hallucination'],
+    limits: { scans: 10, projects: 1 }
+  },
+  starter: {
+    name: 'Starter', 
+    features: ['verify', 'quality', 'hallucination', 'smells', 'breaking'],
+    limits: { scans: 100, projects: 3 }
+  },
+  pro: {
+    name: 'Professional',
+    features: ['verify', 'quality', 'hallucination', 'smells', 'breaking', 'mdc'],
+    limits: { scans: 1000, projects: 10 }
+  },
+  enterprise: {
+    name: 'Enterprise',
+    features: ['verify', 'quality', 'hallucination', 'smells', 'breaking', 'mdc'],
+    limits: { scans: -1, projects: -1 } // unlimited
+  }
+};
+
+/**
+ * Load user configuration from ~/.guardrail/credentials.json
+ */
+async function loadUserConfig() {
+  try {
+    const configPath = path.join(os.homedir(), '.guardrail', 'credentials.json');
+    const configData = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(configData);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Determine tier from API key
+ */
+function getTierFromApiKey(apiKey) {
+  if (!apiKey) return 'free';
+  
+  if (apiKey.startsWith('gr_starter_')) return 'starter';
+  if (apiKey.startsWith('gr_pro_')) return 'pro';
+  if (apiKey.startsWith('gr_ent_')) return 'enterprise';
+  if (apiKey.startsWith('gr_free_')) return 'free';
+  
+  return 'free'; // default for unknown keys
+}
+
+/**
+ * Check if user has access to a specific feature
+ */
+export async function checkFeatureAccess(featureName, providedApiKey = null) {
+  // Try to load user config
+  const userConfig = await loadUserConfig();
+  const apiKey = providedApiKey || userConfig?.apiKey;
+  
+  if (!apiKey) {
+    return {
+      hasAccess: false,
+      tier: 'free',
+      reason: 'No API key provided. Run: guardrail auth --key YOUR_API_KEY',
+      upgradeUrl: 'https://guardrail.dev/pricing'
+    };
+  }
+  
+  const tier = getTierFromApiKey(apiKey);
+  const tierConfig = TIERS[tier];
+  
+  if (!tierConfig.features.includes(featureName)) {
+    const requiredTier = Object.entries(TIERS).find(([_, config]) => 
+      config.features.includes(featureName)
+    )?.[0];
+    
+    return {
+      hasAccess: false,
+      tier,
+      reason: `${featureName} requires ${requiredTier} tier or higher`,
+      upgradeUrl: 'https://guardrail.dev/pricing'
+    };
+  }
+  
+  return {
+    hasAccess: true,
+    tier,
+    reason: 'Access granted'
+  };
+}
+
+/**
+ * Middleware for MCP tool handlers
+ */
+export function withTierCheck(featureName, handler) {
+  return async (args) => {
+    const access = await checkFeatureAccess(featureName, args?.apiKey);
+    
+    if (!access.hasAccess) {
+      return {
+        content: [{
+          type: "text",
+          text: `🚫 UPGRADE REQUIRED\n\n${access.reason}\n\nUpgrade at: ${access.upgradeUrl}`
+        }],
+        isError: true
+      };
+    }
+    
+    // Add tier info to args for the handler
+    args._tier = access.tier;
+    return handler(args);
+  };
+}
+
+/**
+ * Get current user info
+ */
+export async function getUserInfo() {
+  const config = await loadUserConfig();
+  if (!config) {
+    return {
+      authenticated: false,
+      tier: 'free',
+      message: 'Not authenticated. Run: guardrail auth --key YOUR_API_KEY'
+    };
+  }
+  
+  const tier = getTierFromApiKey(config.apiKey);
+  return {
+    authenticated: true,
+    tier,
+    email: config.email,
+    authenticatedAt: config.authenticatedAt,
+    features: TIERS[tier].features,
+    limits: TIERS[tier].limits
+  };
+}