# Install the Wiz MCP server package
npm install @modelcontextprotocol/server-wiz
Or using yarn
yarn add @modelcontextprotocol/server-wiz
Install required dependencies
npm install dotenv axios express
For TypeScript projects
npm install --save-dev @types/node typescript ts-node

# .env file configuration for Wiz MCP
WIZ_CLIENT_ID=your_wiz_client_id_here
WIZ_CLIENT_SECRET=your_wiz_client_secret_here
WIZ_API_ENDPOINT=https://api.wiz.io
WIZ_AUTH_ENDPOINT=https://auth.wiz.io/oauth/token
MCP Server Configuration
MCP_SERVER_PORT=3000
MCP_SERVER_HOST=localhost
MCP_LOG_LEVEL=info
Security Settings
MCP_ENABLE_AUDIT_LOG=true
MCP_SESSION_TIMEOUT=3600
MCP_MAX_REQUESTS_PER_MINUTE=100

const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
const axios = require('axios');
require('dotenv').config();
class WizMCPServer {
constructor() {
this.server = new Server(
{
name: 'wiz-security-mcp',
version: '1.0.0',
},
{
capabilities: {
tools: {},
resources: {},
},
}
);
this.accessToken = null;
this.tokenExpiry = null;
this.setupHandlers();
}
async authenticate() {
try {
if (this.accessToken && this.tokenExpiry > Date.now()) {
return this.accessToken;
}
  const response = await axios.post(
    process.env.WIZ_AUTH_ENDPOINT,
    {
      grant_type: 'client_credentials',
      client_id: process.env.WIZ_CLIENT_ID,
      client_secret: process.env.WIZ_CLIENT_SECRET,
      audience: 'wiz-api'
    }
  );

  this.accessToken = response.data.access_token;
  this.tokenExpiry = Date.now() + (response.data.expires_in * 1000);
  
  return this.accessToken;
} catch (error) {
  throw new Error(`Authentication failed: ${error.message}`);
}
}
setupHandlers() {
// Tool: Query Vulnerabilities
this.server.setRequestHandler('tools/list', async () => ({
tools: [
{
name: 'query_vulnerabilities',
description: 'Search for vulnerabilities in your cloud infrastructure',
inputSchema: {
type: 'object',
properties: {
severity: {
type: 'string',
enum: ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW'],
description: 'Filter by vulnerability severity'
},
resource_type: {
type: 'string',
description: 'Cloud resource type (e.g., EC2, S3, RDS)'
},
limit: {
type: 'number',
description: 'Maximum number of results',
default: 50
}
}
}
},
{
name: 'get_security_graph',
description: 'Retrieve security relationships between cloud resources',
inputSchema: {
type: 'object',
properties: {
resource_id: {
type: 'string',
description: 'Starting resource identifier'
},
depth: {
type: 'number',
description: 'Graph traversal depth',
default: 2
}
},
required: ['resource_id']
}
},
{
name: 'generate_compliance_report',
description: 'Generate compliance report for specified framework',
inputSchema: {
type: 'object',
properties: {
framework: {
type: 'string',
enum: ['SOC2', 'ISO27001', 'GDPR', 'HIPAA', 'PCI-DSS'],
description: 'Compliance framework'
},
include_evidence: {
type: 'boolean',
description: 'Include supporting evidence',
default: false
}
},
required: ['framework']
}
}
]
}));
// Handle tool execution
this.server.setRequestHandler('tools/call', async (request) => {
  const token = await this.authenticate();
  
  switch (request.params.name) {
    case 'query_vulnerabilities':
      return await this.queryVulnerabilities(
        token,
        request.params.arguments
      );
    
    case 'get_security_graph':
      return await this.getSecurityGraph(
        token,
        request.params.arguments
      );
    
    case 'generate_compliance_report':
      return await this.generateComplianceReport(
        token,
        request.params.arguments
      );
    
    default:
      throw new Error(`Unknown tool: ${request.params.name}`);
  }
});
}
async queryVulnerabilities(token, params) {
try {
const query =         query GetVulnerabilities($severity: String, $resourceType: String, $limit: Int) {           vulnerabilities(             filterBy: {               severity: $severity               resourceType: $resourceType             }             first: $limit           ) {             nodes {               id               name               severity               cvssScore               description               affectedResources {                 id                 name                 type               }               remediationSteps               detectedAt             }           }         }      ;
  const response = await axios.post(
    `${process.env.WIZ_API_ENDPOINT}/graphql`,
    {
      query,
      variables: {
        severity: params.severity,
        resourceType: params.resource_type,
        limit: params.limit || 50
      }
    },
    {
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      }
    }
  );

  const vulnerabilities = response.data.data.vulnerabilities.nodes;
  
  return {
    content: [
      {
        type: 'text',
        text: JSON.stringify(vulnerabilities, null, 2)
      }
    ]
  };
} catch (error) {
  throw new Error(`Failed to query vulnerabilities: ${error.message}`);
}
}
async getSecurityGraph(token, params) {
try {
const query =         query GetSecurityGraph($resourceId: ID!, $depth: Int) {           securityGraph(resourceId: $resourceId, depth: $depth) {             nodes {               id               name               type               riskScore             }             edges {               source               target               relationship               riskImpact             }           }         }      ;
  const response = await axios.post(
    `${process.env.WIZ_API_ENDPOINT}/graphql`,
    {
      query,
      variables: {
        resourceId: params.resource_id,
        depth: params.depth || 2
      }
    },
    {
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      }
    }
  );

  return {
    content: [
      {
        type: 'text',
        text: JSON.stringify(response.data.data.securityGraph, null, 2)
      }
    ]
  };
} catch (error) {
  throw new Error(`Failed to retrieve security graph: ${error.message}`);
}
}
async generateComplianceReport(token, params) {
try {
const query =         query GenerateComplianceReport($framework: String!, $includeEvidence: Boolean) {           complianceReport(framework: $framework, includeEvidence: $includeEvidence) {             frameworkName             overallScore             passedControls             failedControls             totalControls             controls {               id               name               status               description               evidence {                 type                 details               }             }             generatedAt           }         }      ;
  const response = await axios.post(
    `${process.env.WIZ_API_ENDPOINT}/graphql`,
    {
      query,
      variables: {
        framework: params.framework,
        includeEvidence: params.include_evidence || false
      }
    },
    {
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      }
    }
  );

  return {
    content: [
      {
        type: 'text',
        text: JSON.stringify(response.data.data.complianceReport, null, 2)
      }
    ]
  };
} catch (error) {
  throw new Error(`Failed to generate compliance report: ${error.message}`);
}
}
async run() {
const transport = new StdioServerTransport();
await this.server.connect(transport);
console.error('Wiz MCP Server running on stdio');
}
}
// Initialize and start the server
const wizServer = new WizMCPServer();
wizServer.run().catch(console.error);

{
"mcpServers": {
"wiz-security": {
"command": "node",
"args": [
"/path/to/your/wiz-mcp-server/server.js"
],
"env": {
"WIZ_CLIENT_ID": "your_client_id",
"WIZ_CLIENT_SECRET": "your_client_secret",
"WIZ_API_ENDPOINT": "https://api.wiz.io",
"WIZ_AUTH_ENDPOINT": "https://auth.wiz.io/oauth/token"
}
}
}
}

const { WizMCPClient } = require('./wizMcpClient');
const { SlackNotifier } = require('./notifiers/slack');
const { JiraIntegration } = require('./integrations/jira');
class SecurityIncidentResponder {
constructor() {
this.wizClient = new WizMCPClient();
this.slack = new SlackNotifier();
this.jira = new JiraIntegration();
}
async monitorAndRespond() {
// Query for critical vulnerabilities detected in last hour
const criticalFindings = await this.wizClient.queryVulnerabilities({
severity: 'CRITICAL',
detectedSince: Date.now() - (60 * 60 * 1000),
exploitable: true
});
for (const finding of criticalFindings) {
  await this.handleCriticalFinding(finding);
}
}
async handleCriticalFinding(finding) {
// Step 1: Analyze blast radius using security graph
const impactAnalysis = await this.wizClient.getSecurityGraph({
resource_id: finding.affectedResources[0].id,
depth: 3
});
const affectedAssets = impactAnalysis.nodes.length;
const exposureLevel = this.calculateExposureLevel(impactAnalysis);

// Step 2: Determine response action based on severity
const response = await this.determineResponseAction(
  finding,
  exposureLevel,
  affectedAssets
);

// Step 3: Execute automated remediation if approved
if (response.autoRemediate) {
  await this.executeRemediation(finding, response.actions);
}

// Step 4: Create incident ticket and notify team
await this.createIncidentTicket(finding, impactAnalysis, response);
await this.notifySecurityTeam(finding, response);
}
calculateExposureLevel(graph) {
const publiclyExposed = graph.nodes.filter(n =>
n.riskScore > 80 && n.hasPublicAccess
).length;
const criticalAssets = graph.nodes.filter(n => 
  n.type === 'DATABASE' || n.type === 'SECRETS_MANAGER'
).length;

if (publiclyExposed > 0 && criticalAssets > 0) return 'EXTREME';
if (publiclyExposed > 0 || criticalAssets > 2) return 'HIGH';
return 'MODERATE';
}
async determineResponseAction(finding, exposure, assetCount) {
// Use AI to determine best response strategy
const aiDecision = await this.wizClient.analyzeIncident({
finding: finding,
exposureLevel: exposure,
affectedAssetCount: assetCount,
organizationContext: {
industry: 'fintech',
complianceRequirements: ['PCI-DSS', 'SOC2']
}
});
return {
  autoRemediate: exposure !== 'EXTREME', // Require manual approval for extreme cases
  actions: aiDecision.recommendedActions,
  priority: aiDecision.priority,
  estimatedResolutionTime: aiDecision.eta
};
}
async executeRemediation(finding, actions) {
for (const action of actions) {
try {
await this.wizClient.executeRemediationAction({
action_type: action.type,
resource_id: finding.affectedResources[0].id,
parameters: action.parameters
});
    console.log(`Executed remediation: ${action.type}`);
  } catch (error) {
    console.error(`Remediation failed: ${error.message}`);
    await this.slack.sendAlert({
      level: 'error',
      message: `Automated remediation failed for ${finding.id}`
    });
  }
}
}
async createIncidentTicket(finding, impact, response) {
const ticket = await this.jira.createIssue({
project: 'SEC',
issueType: 'Security Incident',
summary: Critical Vulnerability: ${finding.name},
description: `
Vulnerability: ${finding.name}
CVSS Score: ${finding.cvssScore}
Affected Assets: ${impact.nodes.length}
Exposure Level: ${response.priority}
    Recommended Actions:
    ${response.actions.map(a => `- ${a.description}`).join('\n')}
    
    Wiz Finding ID: ${finding.id}
  `,
  priority: response.priority,
  labels: ['security', 'automated-detection', 'wiz-mcp']
});

return ticket;
}
async notifySecurityTeam(finding, response) {
await this.slack.sendMessage({
channel: '#security-incidents',
message: {
text: 🚨 Critical Security Finding Detected,
blocks: [
{
type: 'header',
text: {
type: 'plain_text',
text: ${finding.name}
}
},
{
type: 'section',
fields: [
{
type: 'mrkdwn',
text: *Severity:*\n${finding.severity}
},
{
type: 'mrkdwn',
text: *CVSS Score:*\n${finding.cvssScore}
},
{
type: 'mrkdwn',
text: *Auto-Remediation:*\n${response.autoRemediate ? 'Yes' : 'Manual Approval Required'}
},
{
type: 'mrkdwn',
text: *Priority:*\n${response.priority}
}
]
}
]
}
});
}
}
// Run continuous monitoring
const responder = new SecurityIncidentResponder();
setInterval(() => responder.monitorAndRespond(), 5 * 60 * 1000); // Every 5 minutes

name: Wiz MCP Security Scan
on:
push:
branches: [main, develop]
pull_request:
branches: [main]
schedule:
- cron: '0 2 * * *'  # Daily at 2 AM
jobs:
security-scan:
runs-on: ubuntu-latest
steps:
  - name: Checkout code
    uses: actions/checkout@v3

  - name: Setup Node.js
    uses: actions/setup-node@v3
    with:
      node-version: '18'

  - name: Install Wiz MCP CLI
    run: |
      npm install -g @wiz/mcp-cli
      wiz-mcp configure --api-key ${{ secrets.WIZ_API_KEY }}

  - name: Scan Infrastructure as Code
    run: |
      wiz-mcp scan-iac \
        --path ./infrastructure \
        --format json \
        --output scan-results.json

  - name: Check for Critical Vulnerabilities
    id: vulnerability-check
    run: |
      CRITICAL_COUNT=$(wiz-mcp analyze \
        --input scan-results.json \
        --severity CRITICAL \
        --count-only)
      
      echo "critical_vulns=$CRITICAL_COUNT" >> $GITHUB_OUTPUT
      
      if [ "$CRITICAL_COUNT" -gt 0 ]; then
        echo "❌ Found $CRITICAL_COUNT critical vulnerabilities"
        exit 1
      fi

  - name: Generate Security Report
    if: always()
    run: |
      wiz-mcp report \
        --input scan-results.json \
        --format markdown \
        --output security-report.md

  - name: Upload Security Report
    if: always()
    uses: actions/upload-artifact@v3
    with:
      name: security-report
      path: security-report.md

  - name: Comment on PR
    if: github.event_name == 'pull_request'
    uses: actions/github-script@v6
    with:
      script: |
        const fs = require('fs');
        const report = fs.readFileSync('security-report.md', 'utf8');
        
        github.rest.issues.createComment({
          issue_number: context.issue.number,
          owner: context.repo.owner,
          repo: context.repo.repo,
          body: `## 🔒 Wiz MCP Security Scan Results\n\n${report}`
        });

const Redis = require('redis');
const crypto = require('crypto');
class WizMCPCacheManager {
constructor() {
this.redis = Redis.createClient({
host: process.env.REDIS_HOST || 'localhost',
port: process.env.REDIS_PORT || 6379,
password: process.env.REDIS_PASSWORD
});
this.defaultTTL = 300; // 5 minutes
this.enabled = process.env.CACHE_ENABLED !== 'false';
}
generateCacheKey(query, variables) {
const payload = JSON.stringify({ query, variables });
return wiz:mcp:${crypto.createHash('md5').update(payload).digest('hex')};
}
async get(query, variables) {
if (!this.enabled) return null;
try {
  const key = this.generateCacheKey(query, variables);
  const cached = await this.redis.get(key);
  
  if (cached) {
    console.log('Cache hit for query:', key);
    return JSON.parse(cached);
  }
  
  return null;
} catch (error) {
  console.error('Cache retrieval error:', error);
  return null;
}
}
async set(query, variables, data, ttl = this.defaultTTL) {
if (!this.enabled) return;
try {
  const key = this.generateCacheKey(query, variables);
  await this.redis.setex(
    key,
    ttl,
    JSON.stringify(data)
  );
  console.log('Cached query result:', key);
} catch (error) {
  console.error('Cache storage error:', error);
}
}
async invalidatePattern(pattern) {
try {
const keys = await this.redis.keys(wiz:mcp:${pattern}*);
if (keys.length > 0) {
await this.redis.del(...keys);
console.log(Invalidated ${keys.length} cache entries);
}
} catch (error) {
console.error('Cache invalidation error:', error);
}
}
// Invalidate cache for specific resource types
async invalidateForResource(resourceType) {
await this.invalidatePattern(*${resourceType}*);
}
// Smart TTL based on data volatility
determineOptimalTTL(queryType) {
const ttlMap = {
'vulnerabilities': 300,        // 5 minutes - changes frequently
'compliance': 3600,           // 1 hour - relatively stable
'resources': 600,             // 10 minutes - moderate changes
'security_graph': 900,        // 15 minutes - relationship data
'users': 1800,                // 30 minutes - user data
'policies': 7200              // 2 hours - policy data rarely changes
};
return ttlMap[queryType] || this.defaultTTL;
}
}
module.exports = WizMCPCacheManager;

const client = require('prom-client');
const express = require('express');
class WizMCPMetrics {
constructor() {
this.register = new client.Registry();
// Request counter
this.requestCounter = new client.Counter({
  name: 'wiz_mcp_requests_total',
  help: 'Total number of MCP requests',
  labelNames: ['tool', 'status'],
  registers: [this.register]
});

// Request duration histogram
this.requestDuration = new client.Histogram({
  name: 'wiz_mcp_request_duration_seconds',
  help: 'Duration of MCP requests in seconds',
  labelNames: ['tool'],
  buckets: [0.1, 0.5, 1, 2, 5, 10],
  registers: [this.register]
});

// Active connections gauge
this.activeConnections = new client.Gauge({
  name: 'wiz_mcp_active_connections',
  help: 'Number of active MCP connections',
  registers: [this.register]
});

// Cache hit ratio
this.cacheHitRatio = new client.Gauge({
  name: 'wiz_mcp_cache_hit_ratio',
  help: 'Cache hit ratio (0-1)',
  registers: [this.register]
});

// API error rate
this.errorRate = new client.Counter({
  name: 'wiz_mcp_errors_total',
  help: 'Total number of errors',
  labelNames: ['error_type'],
  registers: [this.register]
});

// Vulnerability detection counter
this.vulnerabilitiesDetected = new client.Counter({
  name: 'wiz_mcp_vulnerabilities_detected_total',
  help: 'Total vulnerabilities detected',
  labelNames: ['severity'],
  registers: [this.register]
});

client.collectDefaultMetrics({ register: this.register });
}
recordRequest(tool, status) {
this.requestCounter.labels(tool, status).inc();
}
recordDuration(tool, duration) {
this.requestDuration.labels(tool).observe(duration);
}
setActiveConnections(count) {
this.activeConnections.set(count);
}
updateCacheHitRatio(hits, total) {
const ratio = total > 0 ? hits / total : 0;
this.cacheHitRatio.set(ratio);
}
recordError(errorType) {
this.errorRate.labels(errorType).inc();
}
recordVulnerability(severity) {
this.vulnerabilitiesDetected.labels(severity).inc();
}
startMetricsServer(port = 9090) {
const app = express();
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', this.register.contentType);
  res.end(await this.register.metrics());
});

app.get('/health', (req, res) => {
  res.json({ status: 'healthy', timestamp: new Date().toISOString() });
});

app.listen(port, () => {
  console.log(`Metrics server listening on port ${port}`);
});
}
}
module.exports = WizMCPMetrics;

const { WizMCPClient } = require('./wizMcpClient');
class WizSecurityMiddleware {
constructor(options = {}) {
this.wizClient = new WizMCPClient();
this.enabled = options.enabled !== false;
this.logOnly = options.logOnly || false;
this.excludePaths = options.excludePaths || [];
}
// Main middleware function
securityCheck() {
return async (req, res, next) => {
if (!this.enabled || this.isExcluded(req.path)) {
return next();
}
  try {
    // Check if request IP is from known malicious source
    const threatIntel = await this.wizClient.checkThreatIntelligence({
      ip_address: req.ip,
      user_agent: req.get('user-agent')
    });

    if (threatIntel.isMalicious && !this.logOnly) {
      return res.status(403).json({
        error: 'Access denied',
        reason: 'Security policy violation'
      });
    }

    // Validate API keys against compromised credentials database
    const apiKey = req.get('x-api-key');
    if (apiKey) {
      const keyStatus = await this.wizClient.validateCredential({
        credential: apiKey,
        type: 'api_key'
      });

      if (keyStatus.compromised) {
        console.error('Compromised API key detected:', keyStatus.details);
        if (!this.logOnly) {
          return res.status(401).json({
            error: 'Invalid credentials',
            message: 'Please rotate your API key'
          });
        }
      }
    }

    // Attach security context to request
    req.wizSecurity = {
      threatLevel: threatIntel.riskScore,
      recommendations: threatIntel.recommendations
    };

    next();
  } catch (error) {
    console.error('Security middleware error:', error);
    // Fail open on errors unless strictMode is enabled
    if (this.strictMode) {
      return res.status(503).json({
        error: 'Security check unavailable'
      });
    }
    next();
  }
};
}
// Rate limiting based on security risk
adaptiveRateLimit() {
const limits = new Map();
return async (req, res, next) => {
  const identifier = req.ip;
  const threatLevel = req.wizSecurity?.threatLevel || 0;

  // Adjust rate limit based on threat level
  const maxRequests = threatLevel > 70 ? 10 : threatLevel > 40 ? 50 : 100;
  const windowMs = 60000; // 1 minute

  if (!limits.has(identifier)) {
    limits.set(identifier, { count: 1, resetAt: Date.now() + windowMs });
    return next();
  }

  const limit = limits.get(identifier);
  if (Date.now() > limit.resetAt) {
    limit.count = 1;
    limit.resetAt = Date.now() + windowMs;
    return next();
  }

  if (limit.count >= maxRequests) {
    return res.status(429).json({
      error: 'Rate limit exceeded',
      retryAfter: Math.ceil((limit.resetAt - Date.now()) / 1000)
    });
  }

  limit.count++;
  next();
};
}
isExcluded(path) {
return this.excludePaths.some(excluded =>
path.startsWith(excluded)
);
}
}
// Usage example
const express = require('express');
const app = express();
const wizSecurity = new WizSecurityMiddleware({
enabled: true,
logOnly: process.env.NODE_ENV === 'development',
excludePaths: ['/health', '/metrics']
});
app.use(wizSecurity.securityCheck());
app.use(wizSecurity.adaptiveRateLimit());
app.get('/api/sensitive-data', async (req, res) => {
// Access security context
if (req.wizSecurity.threatLevel > 80) {
// Additional verification for high-risk requests
return res.status(403).json({
error: 'Additional verification required'
});
}
res.json({ data: 'Sensitive information' });
});
module.exports = WizSecurityMiddleware;

import React, { useState, useEffect } from 'react';
import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, Legend } from 'recharts';
import { AlertCircle, Shield, Activity, TrendingUp } from 'lucide-react';
const SecurityDashboard = () => {
const [securityMetrics, setSecurityMetrics] = useState(null);
const [vulnerabilities, setVulnerabilities] = useState([]);
const [loading, setLoading] = useState(true);
const [timeRange, setTimeRange] = useState('24h');
useEffect(() => {
fetchSecurityData();
const interval = setInterval(fetchSecurityData, 30000); // Refresh every 30s
return () => clearInterval(interval);
}, [timeRange]);
const fetchSecurityData = async () => {
try {
const response = await fetch('/api/wiz-mcp/dashboard', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ timeRange })
});
  const data = await response.json();
  setSecurityMetrics(data.metrics);
  setVulnerabilities(data.vulnerabilities);
  setLoading(false);
} catch (error) {
  console.error('Failed to fetch security data:', error);
  setLoading(false);
}
};
if (loading) {
return (



);
}
return (





Wiz MCP Security Dashboard

Real-time cloud security monitoring powered by AI

    {/* Key Metrics Cards */}
    

      }
        trend={securityMetrics?.scoreTrend}
        color="rose"
      />
      }
        trend={securityMetrics?.threatTrend}
        color="red"
      />
      }
        color="blue"
      />
      }
        trend={securityMetrics?.complianceTrend}
        color="green"
      />
    

    {/* Vulnerability Trend Chart */}
    

      
Vulnerability Trends
      
        
        
        
        
        

        
        
        
      
    

    {/* Recent Vulnerabilities */}
    

      
Recent Vulnerabilities
      

        {vulnerabilities.map((vuln, index) => (
          
        ))}
      
    
  

);
};
const MetricCard = ({ title, value, max, icon, trend, color }) => {
const colorClasses = {
rose: 'bg-rose-50 text-rose-600 border-rose-200',
red: 'bg-red-50 text-red-600 border-red-200',
blue: 'bg-blue-50 text-blue-600 border-blue-200',
green: 'bg-green-50 text-green-600 border-green-200'
};
return (


{title}
{icon}


{max ? ${value}% : value.toLocaleString()}

{trend && (
 0 ? 'text-green-600' : 'text-red-600'}}>
{trend > 0 ? '↑' : '↓'} {Math.abs(trend)}% from last period

)}

);
};
const VulnerabilityCard = ({ vulnerability }) => {
const severityColors = {
CRITICAL: 'bg-red-100 text-red-800 border-red-300',
HIGH: 'bg-orange-100 text-orange-800 border-orange-300',
MEDIUM: 'bg-yellow-100 text-yellow-800 border-yellow-300',
LOW: 'bg-blue-100 text-blue-800 border-blue-300'
};
return (





{vulnerability.severity}

{vulnerability.name}

{vulnerability.description}

CVSS: {vulnerability.cvssScore}
Affected: {vulnerability.affectedResources.length} resources
Detected: {new Date(vulnerability.detectedAt).toLocaleDateString()}



Remediate



);
};
export default SecurityDashboard;