omen-sec-cli 1.0.16 → 1.0.17

package/bin/index.js

@@ -15,7 +15,7 @@ async function main() {
   }
 
   if (args.flags.version) {
-    console.log('1.0.16');
+    console.log('1.0.17');
     return;
   }
 

package/core/generator.js

@@ -18,6 +18,11 @@ export async function generateOutputs(scanData) {
   }
 
   const jsonContent = JSON.stringify(scanData, null, 2);
+
+  // Simple Schema Validation
+  if (!scanData.schema_version || !scanData.scan_id || !Array.isArray(scanData.vulnerabilities)) {
+    console.error(chalk.red('\n[Error] Report data validation failed. Schema 1.0 requirements not met.'));
+  }
   
   // JSON Report
   const jsonReportPath = path.join(outputDir, 'omen-report.json');
@@ -26,7 +31,28 @@ export async function generateOutputs(scanData) {
   
   // TXT Report
   const txtReportPath = path.join(outputDir, 'omen-report.txt');
-  const txtContent = `OMEN SECURITY REPORT\n\nTarget: ${scanData.target}\nScore: ${scanData.score}\nRisk: ${scanData.riskLevel}\n\nVulnerabilities:\n${scanData.vulnerabilities.map(v => `- ${v.description}`).join('\n')}`;
+  let txtContent = `OMEN SECURITY REPORT\n`;
+  txtContent += `====================\n`;
+  txtContent += `Target: ${scanData.target}\n`;
+  txtContent += `Scan ID: ${scanData.scan_id}\n`;
+  txtContent += `Date: ${scanData.timestamp}\n`;
+  txtContent += `Score: ${scanData.score}/100\n`;
+  txtContent += `Risk Level: ${scanData.riskLevel}\n\n`;
+
+  txtContent += `VULNERABILITIES FOUND:\n`;
+  txtContent += `----------------------\n`;
+  
+  if (scanData.vulnerabilities.length === 0) {
+    txtContent += `No vulnerabilities detected.\n`;
+  } else {
+    scanData.vulnerabilities.forEach(v => {
+      txtContent += `[${v.severity.toUpperCase()}] ${v.title || v.description}\n`;
+      txtContent += `Category: ${v.category} | Confidence: ${v.confidence}\n`;
+      txtContent += `Description: ${v.description}\n`;
+      if (v.remediation) txtContent += `Remediation: ${v.remediation}\n`;
+      txtContent += `----------------------\n`;
+    });
+  }
   await fs.writeFile(txtReportPath, txtContent);
   console.log(` /omen-reports/omen-report.txt`);
   

package/core/local-scanner.js

@@ -45,10 +45,15 @@ export async function scanLocalProject() {
           osvRes.data.vulns.forEach(vuln => {
             vulnerabilities.push({
               id: vuln.id,
-              type: 'Vulnerable Component (OSV.dev)',
-              severity: 'High',
+              kind: 'tech',
+              category: 'confirmed',
+              confidence: 'high',
+              severity: 'high',
+              title: `Vulnerable Dependency: ${name}`,
               description: `Real CVE found for ${name}@${cleanVersion}: ${vuln.summary || vuln.details}`,
-              cwe: vuln.database_specific?.cwe_ids?.[0] || 'N/A'
+              cwe: vuln.database_specific?.cwe_ids?.[0] || 'N/A',
+              evidence: { package: name, version: cleanVersion, vuln_id: vuln.id },
+              remediation: `Update ${name} to a secure version as recommended by OSV/NVD.`
             });
           });
         }
@@ -57,27 +62,33 @@ export async function scanLocalProject() {
       }
     }
 
-    // Exemplos de dependências conhecidas (fallback mock)
+    // Fallback mocks
     if (deps['lodash'] && deps['lodash'].match(/[~^]?4\.17\.[0-20]/)) {
       vulnerabilities.push({
         id: `LOC-VULN-${Date.now()}-1`,
-        category: 'Confirmed',
-        confidence: 'High',
-        severity: 'High',
+        kind: 'tech',
+        category: 'confirmed',
+        confidence: 'high',
+        severity: 'high',
+        title: 'Vulnerable Lodash Version',
         description: `Outdated dependency detected in package.json: lodash (${deps['lodash']}). Known Prototype Pollution risk.`,
         cwe: 'CWE-1321',
-        evidence: { file: 'package.json', finding: `lodash: ${deps['lodash']}` }
+        evidence: { file: 'package.json', finding: `lodash: ${deps['lodash']}` },
+        remediation: 'Update lodash to version 4.17.21 or higher.'
       });
     }
     if (deps['express'] && deps['express'].match(/[~^]?3\./)) {
       vulnerabilities.push({
         id: `LOC-VULN-${Date.now()}-2`,
-        category: 'Confirmed',
-        confidence: 'High',
-        severity: 'High',
+        kind: 'tech',
+        category: 'confirmed',
+        confidence: 'high',
+        severity: 'high',
+        title: 'Critical Outdated Express',
         description: `Severely outdated Express.js version (${deps['express']}) detected. Multiple CVEs exist.`,
         cwe: 'CWE-1104',
-        evidence: { file: 'package.json', finding: `express: ${deps['express']}` }
+        evidence: { file: 'package.json', finding: `express: ${deps['express']}` },
+        remediation: 'Upgrade Express.js to the latest stable version (4.x or 5.x).'
       });
     }
   } catch (err) {
@@ -98,55 +109,67 @@ export async function scanLocalProject() {
       filesScanned.push(path.basename(file));
 
       lines.forEach((line, index) => {
-        // Regra 1: Hardcoded Secrets (AWS Keys, API Keys simples)
+        // Regra 1: Hardcoded Secrets
         if (/(api_key|apikey|secret|password|token)\s*=\s*['"][a-zA-Z0-9_-]{10,}['"]/i.test(line)) {
           vulnerabilities.push({
             id: `LOC-VULN-${Date.now()}-3`,
-            category: 'Confirmed',
-            confidence: 'Medium', // Could be a test key
-            severity: 'Critical',
+            kind: 'content',
+            category: 'confirmed',
+            confidence: 'medium',
+            severity: 'critical',
+            title: 'Hardcoded Secret Detected',
             description: `Potential hardcoded secret found in ${path.basename(file)} at line ${index + 1}`,
             cwe: 'CWE-798',
-            evidence: { file: path.basename(file), line: index + 1, code: line.trim() }
+            evidence: { file: path.basename(file), line: index + 1, code: line.trim() },
+            remediation: 'Move secrets to environment variables or a secure vault.'
           });
         }
 
-        // Regra 2: Uso de Eval (Code Injection)
+        // Regra 2: Uso de Eval
         if (/eval\s*\(/.test(line)) {
           vulnerabilities.push({
             id: `LOC-VULN-${Date.now()}-4`,
-            category: 'Confirmed',
-            confidence: 'High',
-            severity: 'Critical',
+            kind: 'content',
+            category: 'confirmed',
+            confidence: 'high',
+            severity: 'critical',
+            title: 'Dangerous eval() Usage',
             description: `Dangerous use of eval() detected in ${path.basename(file)} at line ${index + 1}`,
             cwe: 'CWE-94',
-            evidence: { file: path.basename(file), line: index + 1, code: line.trim() }
+            evidence: { file: path.basename(file), line: index + 1, code: line.trim() },
+            remediation: 'Avoid using eval(). Use safer alternatives like JSON.parse() or specific logic.'
           });
         }
 
-        // Regra 3: SQLi (Concatenação crua de strings com SELECT)
+        // Regra 3: SQLi
         if (/SELECT.*FROM.*WHERE.*(\+|`|\${)/i.test(line)) {
           vulnerabilities.push({
             id: `LOC-VULN-${Date.now()}-5`,
-            category: 'Probable',
-            confidence: 'Medium',
-            severity: 'Critical',
+            kind: 'content',
+            category: 'probable',
+            confidence: 'medium',
+            severity: 'critical',
+            title: 'Potential SQL Injection',
             description: `Potential SQL Injection (raw string concatenation) in ${path.basename(file)} at line ${index + 1}.`,
             cwe: 'CWE-89',
-            evidence: { file: path.basename(file), line: index + 1, code: line.trim() }
+            evidence: { file: path.basename(file), line: index + 1, code: line.trim() },
+            remediation: 'Use parameterized queries or an ORM to prevent SQL injection.'
           });
         }
 
-        // Regra 6: Local File Inclusion (LFI) via require/import dinâmico
+        // Regra 6: LFI
         if (/(require|import)\s*\(['"]?.*(\+|`|\${)/i.test(line)) {
           vulnerabilities.push({
             id: `LOC-VULN-${Date.now()}-6`,
-            category: 'Probable',
-            confidence: 'Medium',
-            severity: 'High',
-            description: `Potential LFI detected in ${path.basename(file)} at line ${index + 1}. Dynamic loading of files based on user input can lead to sensitive data exposure.`,
+            kind: 'content',
+            category: 'probable',
+            confidence: 'medium',
+            severity: 'high',
+            title: 'Potential LFI',
+            description: `Potential Local File Inclusion (LFI) detected in ${path.basename(file)} at line ${index + 1}.`,
             cwe: 'CWE-22',
-            evidence: { file: path.basename(file), line: index + 1, code: line.trim() }
+            evidence: { file: path.basename(file), line: index + 1, code: line.trim() },
+            remediation: 'Validate and sanitize file paths before dynamic loading.'
           });
         }
 
@@ -154,12 +177,15 @@ export async function scanLocalProject() {
         if (/\.prototype\.[a-zA-Z0-9_]+\s*=\s*/.test(line)) {
           vulnerabilities.push({
             id: `LOC-VULN-${Date.now()}-7`,
-            category: 'Hardening',
-            confidence: 'Low',
-            severity: 'Medium',
-            description: `Direct prototype modification in ${path.basename(file)} at line ${index + 1}. This can lead to Prototype Pollution if user input reaches this assignment.`,
+            kind: 'content',
+            category: 'hardening',
+            confidence: 'low',
+            severity: 'medium',
+            title: 'Prototype Modification Risk',
+            description: `Direct prototype modification in ${path.basename(file)} at line ${index + 1}.`,
             cwe: 'CWE-1321',
-            evidence: { file: path.basename(file), line: index + 1, code: line.trim() }
+            evidence: { file: path.basename(file), line: index + 1, code: line.trim() },
+            remediation: 'Avoid direct prototype modification. Use Object.defineProperty if necessary.'
           });
         }
 

package/core/remote-scanner.js

@@ -36,47 +36,54 @@ export async function scanRemoteTarget(targetUrl) {
       headers_analysis["Strict-Transport-Security"] = "Missing";
       vulnerabilities.push({
         id: `REM-VULN-${Date.now()}-1`,
-        category: 'Hardening',
-        confidence: 'High',
-        severity: 'Medium',
-        description: `HSTS Header is missing. This lacks forced HTTPS enforcement for browsers that have already visited the site.`,
+        kind: 'header',
+        category: 'hardening',
+        confidence: 'high',
+        severity: 'medium',
+        title: 'HSTS Header Missing',
+        description: `HTTP Strict-Transport-Security (HSTS) header is missing. This prevents the browser from enforcing HTTPS-only connections for future visits.`,
         cwe: 'CWE-319',
         evidence: { 
           request: { headers: { ...response.request.headers } }, 
           response: { status: response.status, headers: response.headers },
           reason: 'Security header "Strict-Transport-Security" not found in server response.'
-        }
+        },
+        remediation: 'Implement the Strict-Transport-Security header with a long max-age (e.g., 31536000) and the includeSubDomains directive.'
       });
-    } else {
-      headers_analysis["Strict-Transport-Security"] = headers['strict-transport-security'];
     }
 
     if (!headers['content-security-policy']) {
       headers_analysis["Content-Security-Policy"] = "Missing";
       vulnerabilities.push({
         id: `REM-VULN-${Date.now()}-2`,
-        category: 'Confirmed',
-        confidence: 'High',
-        severity: 'High',
+        kind: 'header',
+        category: 'confirmed',
+        confidence: 'high',
+        severity: 'high',
+        title: 'Content-Security-Policy Missing',
         description: `CSP header is missing. Without a strict Content-Security-Policy, the application is highly vulnerable to Cross-Site Scripting (XSS) and data injection attacks.`,
         cwe: 'CWE-1022',
         evidence: { 
           request: { headers: { ...response.request.headers } }, 
           response: { status: response.status, headers: response.headers },
           reason: 'Security header "Content-Security-Policy" not found in server response.'
-        }
+        },
+        remediation: 'Define a strict Content-Security-Policy to restrict source domains for scripts, styles, and other resources.'
       });
     } else {
       headers_analysis["Content-Security-Policy"] = headers['content-security-policy'];
       if (headers['content-security-policy'].includes("unsafe-inline")) {
         vulnerabilities.push({
           id: `REM-VULN-${Date.now()}-3`,
-          category: 'Confirmed',
-          confidence: 'High',
-          severity: 'High',
-          description: `Weak CSP detected: 'unsafe-inline' is allowed.`,
+          kind: 'header',
+          category: 'confirmed',
+          confidence: 'high',
+          severity: 'high',
+          title: 'Insecure CSP (unsafe-inline)',
+          description: `The Content-Security-Policy allows 'unsafe-inline' for scripts or styles, significantly weakening protection against XSS.`,
           cwe: 'CWE-16',
-          evidence: { finding: `policy: ${headers['content-security-policy']}` }
+          evidence: { finding: `policy: ${headers['content-security-policy']}` },
+          remediation: 'Refactor the application to avoid inline scripts and styles, then remove "unsafe-inline" from the CSP.'
         });
       }
     }
@@ -86,19 +93,20 @@ export async function scanRemoteTarget(targetUrl) {
       headers_analysis["X-Frame-Options"] = "Missing";
       vulnerabilities.push({
         id: `REM-VULN-${Date.now()}-4`,
-        category: 'Hardening',
-        confidence: 'High',
-        severity: 'Low',
-        description: `Missing X-Frame-Options. Increases risk of Clickjacking.`,
+        kind: 'header',
+        category: 'hardening',
+        confidence: 'high',
+        severity: 'low',
+        title: 'X-Frame-Options Missing',
+        description: `Missing X-Frame-Options header. This allows the application to be embedded in an iframe on other domains, increasing Clickjacking risk.`,
         cwe: 'CWE-1021',
         evidence: { 
           request: { headers: { ...response.request.headers } }, 
           response: { status: response.status, headers: response.headers },
           reason: 'Security header "X-Frame-Options" not found. This allows the site to be embedded in iframes on third-party domains.'
-        }
+        },
+        remediation: 'Set the X-Frame-Options header to DENY or SAMEORIGIN.'
       });
-    } else {
-      headers_analysis["X-Frame-Options"] = headers['x-frame-options'];
     }
 
     // 4. Server Header Leak
@@ -106,27 +114,31 @@ export async function scanRemoteTarget(targetUrl) {
       headers_analysis["Server"] = headers['server'];
       vulnerabilities.push({
         id: `REM-VULN-${Date.now()}-5`,
-        category: 'Informational',
-        confidence: 'High',
-        severity: 'Low',
-        description: `Server header leaks technology stack: ${headers['server']}`,
+        kind: 'tech',
+        category: 'informational',
+        confidence: 'high',
+        severity: 'low',
+        title: 'Server Header Disclosure',
+        description: `Server header leaks technology stack information: ${headers['server']}`,
         cwe: 'CWE-200',
-        evidence: { finding: `Server: ${headers['server']}` }
+        evidence: { finding: `Server: ${headers['server']}` },
+        remediation: 'Configure the web server to hide or spoof the "Server" header.'
       });
-    } else {
-      headers_analysis["Server"] = "Hidden (Good)";
     }
 
     // 5. X-Powered-By Leak
     if (headers['x-powered-by']) {
       vulnerabilities.push({
         id: `REM-VULN-${Date.now()}-6`,
-        category: 'Informational',
-        confidence: 'High',
-        severity: 'Low',
-        description: `X-Powered-By header leaks framework: ${headers['x-powered-by']}`,
+        kind: 'tech',
+        category: 'informational',
+        confidence: 'high',
+        severity: 'low',
+        title: 'X-Powered-By Disclosure',
+        description: `X-Powered-By header leaks framework information: ${headers['x-powered-by']}`,
         cwe: 'CWE-200',
-        evidence: { finding: `X-Powered-By: ${headers['x-powered-by']}` }
+        evidence: { finding: `X-Powered-By: ${headers['x-powered-by']}` },
+        remediation: 'Disable the X-Powered-By header in the application framework settings.'
       });
     }
 
@@ -175,6 +187,22 @@ export async function scanRemoteTarget(targetUrl) {
       });
     }
 
+    // --- TECHNOLOGY FINGERPRINTING (Update categories) ---
+    if (techStack.length > 0) {
+      vulnerabilities.push({
+        id: `REM-TECH-${Date.now()}`,
+        kind: 'tech',
+        category: 'informational',
+        confidence: 'high',
+        severity: 'info',
+        title: 'Technology Stack Identified',
+        description: `Fingerprinting identified the following technologies: ${techStack.join(', ')}`,
+        cwe: 'CWE-200',
+        evidence: { tech_stack: techStack },
+        remediation: 'Minimal tech disclosure is recommended to prevent targeted attacks.'
+      });
+    }
+
     // --- DEEP CRAWL: robots.txt, sitemap.xml, and JS files ---
     const robotsUrl = new URL('/robots.txt', targetUrl).href;
     try {
@@ -335,22 +363,28 @@ async function validateFuzzerFinding(path, response, url) {
     if (typeof data === 'string' && !data.trim().startsWith('<html')) {
       return {
         id: `REM-CONFIRMED-FILE-${Date.now()}`,
-        category: 'Confirmed',
-        confidence: 'High',
-        severity: 'Critical',
+        kind: 'content',
+        category: 'confirmed',
+        confidence: 'high',
+        severity: 'critical',
+        title: 'Sensitive File Exposed',
         description: `CRITICAL: Sensitive file exposed at ${url}. Contents contain raw configuration data.`,
         cwe: 'CWE-538',
-        evidence: { ...evidence, reason: 'Raw sensitive file content detected (Non-HTML response on sensitive path)' }
+        evidence: { ...evidence, reason: 'Raw sensitive file content detected (Non-HTML response on sensitive path)' },
+        remediation: 'Immediately remove the file from the web server and ensure sensitive files are not publicly accessible.'
       };
     } else {
       return {
         id: `REM-POTENTIAL-FILE-${Date.now()}`,
-        category: 'Informational',
-        confidence: 'Low',
-        severity: 'Info',
+        kind: 'path',
+        category: 'informational',
+        confidence: 'low',
+        severity: 'info',
+        title: 'Potential Sensitive Path Discovered',
         description: `Potential sensitive path found at ${url}, but returned HTML content. Likely a redirect or custom error page.`,
         cwe: 'CWE-200',
-        evidence: { ...evidence, reason: 'HTML response on sensitive file path' }
+        evidence: { ...evidence, reason: 'HTML response on sensitive file path' },
+        remediation: 'Verify if this path should be accessible and ensure no sensitive information is leaked through custom error pages.'
       };
     }
   }
@@ -361,23 +395,29 @@ async function validateFuzzerFinding(path, response, url) {
     if (typeof data === 'string' && /password|login/i.test(data)) {
       return {
         id: `REM-INFO-LOGIN-${Date.now()}`,
-        category: 'Informational',
-        confidence: 'High',
-        severity: 'Info',
+        kind: 'path',
+        category: 'informational',
+        confidence: 'high',
+        severity: 'info',
+        title: 'Admin Login Page Discovered',
         description: `Admin login page discovered at ${url}.`,
         cwe: 'CWE-200',
-        evidence: { ...evidence, reason: '200 OK with login/password patterns detected in HTML.' }
+        evidence: { ...evidence, reason: '200 OK with login/password patterns detected in HTML.' },
+        remediation: 'Ensure the admin login page is protected by strong authentication and not easily discoverable if not necessary.'
       };
     }
     // If it's a 200 but not a login page, it could be an exposed panel
     return {
       id: `REM-PROBABLE-PANEL-${Date.now()}`,
-      category: 'Probable',
-      confidence: 'Low',
-      severity: 'Medium',
+      kind: 'path',
+      category: 'probable',
+      confidence: 'low',
+      severity: 'medium',
+      title: 'Potential Admin Panel Exposure',
       description: `Potential exposed admin panel or dashboard at ${url}. Manual verification required.`,
       cwe: 'CWE-284',
-      evidence: { ...evidence, reason: '200 OK on admin-like path, but no explicit login form detected. Could be an unauthorized dashboard.' }
+      evidence: { ...evidence, reason: '200 OK on admin-like path, but no explicit login form detected. Could be an unauthorized dashboard.' },
+      remediation: 'Restrict access to the admin panel using IP whitelisting or other access control mechanisms.'
     };
   }
 
@@ -385,15 +425,18 @@ async function validateFuzzerFinding(path, response, url) {
   if (status === 403) {
     return {
       id: `REM-INFO-FORBIDDEN-${Date.now()}`,
-      category: 'Informational',
-      confidence: 'Medium',
-      severity: 'Info',
+      kind: 'path',
+      category: 'informational',
+      confidence: 'medium',
+      severity: 'info',
+      title: 'Protected Path Discovered',
       description: `Potential protected path discovered (403 Forbidden): ${url}. This confirms the path exists but access is restricted.`,
       cwe: 'CWE-204',
       evidence: { 
         ...evidence, 
         reason: 'Server returned 403 Forbidden. This confirms path existence but access control is active. No immediate exposure detected.' 
-      }
+      },
+      remediation: 'None required, but ensure that the 403 response does not leak information about the internal structure.'
     };
   }
 

package/core/scanner.js

@@ -48,39 +48,49 @@ export async function runScannerSteps(target, flags) {
     spinner.succeed(`[${i + 1}/${steps.length}] ${step.text}`);
   }
 
+  const scanData = {
+    schema_version: "1.0",
+    target: target,
+    scan_id: `OMEN-${Date.now()}`,
+    timestamp: new Date().toISOString(),
+    score: 100,
+    riskLevel: 'Low',
+    attack_surface: {
+      endpoints: attack_surface.endpoints || [],
+      parameters: attack_surface.parameters || [],
+      forms: attack_surface.forms || [],
+      tech_stack: attack_surface.tech_stack || []
+    },
+    vulnerabilities: allVulnerabilities
+  };
+
   // Calculate dynamic score based on confidence and severity
-  const baseScore = 100;
-  const penalties = allVulnerabilities.reduce((acc, v) => {
+  let penalties = scanData.vulnerabilities.reduce((acc, v) => {
     // Only penalize for Confirmed or Probable issues
-    if (v.category !== 'Confirmed' && v.category !== 'Probable') return acc;
+    if (v.category !== 'confirmed' && v.category !== 'probable') return acc;
 
     let severityWeight = 0;
-    if (v.severity === 'Critical') severityWeight = 25;
-    else if (v.severity === 'High') severityWeight = 15;
-    else if (v.severity === 'Medium') severityWeight = 10;
-    else if (v.severity === 'Low') severityWeight = 5;
+    if (v.severity === 'critical') severityWeight = 25;
+    else if (v.severity === 'high') severityWeight = 15;
+    else if (v.severity === 'medium') severityWeight = 10;
+    else if (v.severity === 'low') severityWeight = 5;
+
+    // Reduzir peso de achados baseados em caminhos (potential/enumeration)
+    if (v.kind === 'path' && v.category === 'probable') severityWeight *= 0.5;
 
     let confidenceMultiplier = 1;
-    if (v.confidence === 'Medium') confidenceMultiplier = 0.6;
-    if (v.confidence === 'Low') confidenceMultiplier = 0.3;
+    if (v.confidence === 'medium') confidenceMultiplier = 0.6;
+    if (v.confidence === 'low') confidenceMultiplier = 0.3;
 
     return acc + (severityWeight * confidenceMultiplier);
   }, 0);
   
-  const finalScore = Math.max(0, Math.round(baseScore - penalties));
-  let riskLevel = 'Low';
-  if (finalScore < 50) riskLevel = 'Critical';
-  else if (finalScore < 70) riskLevel = 'High';
-  else if (finalScore < 90) riskLevel = 'Medium';
+  scanData.score = Math.max(0, Math.round(100 - penalties));
 
-  return {
-    target,
-    scan_id: `OMEN-REQ-${Date.now()}`,
-    timestamp: new Date().toISOString(),
-    score: finalScore,
-    riskLevel: riskLevel,
-    attack_surface,
-    headers_analysis,
-    vulnerabilities: allVulnerabilities.length > 0 ? allVulnerabilities : [{ id: 'INFO', type: 'Clean', severity: 'Info', description: 'No immediate vulnerabilities detected in the surface scan.' }]
-  };
+  if (scanData.score < 40) scanData.riskLevel = 'Critical';
+  else if (scanData.score < 60) scanData.riskLevel = 'High';
+  else if (scanData.score < 80) scanData.riskLevel = 'Medium';
+  else scanData.riskLevel = 'Low';
+
+  return scanData;
 }

package/core/ui-server.js

@@ -77,19 +77,19 @@ export async function startUIServer() {
                   <div class="grid grid-cols-1 md:grid-cols-4 gap-6 mb-10">
                       <div class="card p-6 rounded-xl shadow-2xl">
                           <h3 class="text-gray-500 uppercase text-xs font-bold tracking-widest mb-2">Security Score</h3>
-                          <p class="text-5xl font-black ${getSeverityClass(report.riskLevel)}">${report.score}/100</p>
+                          <p class="text-5xl font-black ${getSeverityClass(report.riskLevel)}">${report.score || 0}/100</p>
                       </div>
                       <div class="card p-6 rounded-xl shadow-2xl">
                           <h3 class="text-gray-500 uppercase text-xs font-bold tracking-widest mb-2">Risk Level</h3>
-                          <p class="text-5xl font-black ${getSeverityClass(report.riskLevel)}">${report.riskLevel}</p>
+                          <p class="text-5xl font-black ${getSeverityClass(report.riskLevel)}">${report.riskLevel || 'N/A'}</p>
                       </div>
                       <div class="card p-6 rounded-xl shadow-2xl">
                           <h3 class="text-gray-500 uppercase text-xs font-bold tracking-widest mb-2">Confirmed Issues</h3>
-                          <p class="text-5xl font-black text-white">${report.vulnerabilities.filter(v => v.category === 'Confirmed').length}</p>
+                          <p class="text-5xl font-black text-white">${(report.vulnerabilities || []).filter(v => v.category === 'confirmed').length}</p>
                       </div>
                       <div class="card p-6 rounded-xl shadow-2xl">
                           <h3 class="text-gray-500 uppercase text-xs font-bold tracking-widest mb-2">Probable Issues</h3>
-                          <p class="text-5xl font-black text-white">${report.vulnerabilities.filter(v => v.category === 'Probable').length}</p>
+                          <p class="text-5xl font-black text-white">${(report.vulnerabilities || []).filter(v => v.category === 'probable').length}</p>
                       </div>
                   </div>
 
@@ -99,13 +99,13 @@ export async function startUIServer() {
                               <span class="w-2 h-2 bg-red-500 rounded-full mr-2"></span> Top Critical Findings
                           </h2>
                           <div class="space-y-4">
-                              ${report.vulnerabilities.filter(v => v.severity === 'Critical' || v.severity === 'High').slice(0, 5).map(v => `
+                              ${(report.vulnerabilities || []).filter(v => v.severity === 'critical' || v.severity === 'high').slice(0, 5).map(v => `
                                   <div class="p-4 bg-[#1c1c22] rounded-lg border border-gray-800">
                                       <div class="flex justify-between items-start mb-2">
-                                          <span class="font-bold ${getSeverityClass(v.severity)} text-sm">${v.severity}</span>
+                                          <span class="font-bold ${getSeverityClass(v.severity)} text-sm uppercase">${v.severity}</span>
                                           <span class="px-2 py-0.5 rounded border text-[10px] uppercase font-bold ${getCategoryBadge(v.category)}">${v.category}</span>
                                       </div>
-                                      <p class="text-sm font-medium text-gray-300">${v.description}</p>
+                                      <p class="text-sm font-medium text-gray-300">${v.title || v.description}</p>
                                   </div>
                               `).join('') || '<p class="text-gray-500 italic">No critical findings discovered.</p>'}
                           </div>
@@ -115,10 +115,10 @@ export async function startUIServer() {
                               <span class="w-2 h-2 bg-blue-500 rounded-full mr-2"></span> Scan Intelligence
                           </h2>
                           <div class="space-y-4 text-sm">
-                              <div class="flex justify-between border-b border-gray-800 pb-2"> <span class="text-gray-500">Target URL</span> <span class="mono text-gray-300">${report.target}</span> </div>
-                              <div class="flex justify-between border-b border-gray-800 pb-2"> <span class="text-gray-500">Tech Stack</span> <span class="text-gray-300">${(report.attack_surface.tech_stack || []).join(', ') || 'N/A'}</span> </div>
-                              <div class="flex justify-between border-b border-gray-800 pb-2"> <span class="text-gray-500">Endpoints Discovered</span> <span class="text-gray-300">${(report.attack_surface.endpoints || []).length}</span> </div>
-                              <div class="flex justify-between border-b border-gray-800 pb-2"> <span class="text-gray-500">Forms Detected</span> <span class="text-gray-300">${(report.attack_surface.forms || []).length}</span> </div>
+                              <div class="flex justify-between border-b border-gray-800 pb-2"> <span class="text-gray-500">Target URL</span> <span class="mono text-gray-300">${report.target || 'N/A'}</span> </div>
+                              <div class="flex justify-between border-b border-gray-800 pb-2"> <span class="text-gray-500">Tech Stack</span> <span class="text-gray-300">${(report.attack_surface?.tech_stack || []).join(', ') || 'N/A'}</span> </div>
+                              <div class="flex justify-between border-b border-gray-800 pb-2"> <span class="text-gray-500">Endpoints Discovered</span> <span class="text-gray-300">${(report.attack_surface?.endpoints || []).length}</span> </div>
+                              <div class="flex justify-between border-b border-gray-800 pb-2"> <span class="text-gray-500">Forms Detected</span> <span class="text-gray-300">${(report.attack_surface?.forms || []).length}</span> </div>
                           </div>
                       </div>
                   </div>
@@ -134,26 +134,30 @@ export async function startUIServer() {
                           </div>
                       </div>
                       <div class="divide-y divide-gray-800">
-                          ${report.vulnerabilities.map((v, i) => `
+                          ${(report.vulnerabilities || []).map((v, i) => `
                               <div class="finding-row">
                                   <div class="p-4 flex items-center cursor-pointer gap-4" onclick="toggleEvidence(${i})">
                                       <div class="w-24 text-xs font-black uppercase ${getSeverityClass(v.severity)}">${v.severity}</div>
-                                      <div class="flex-1 text-sm font-semibold text-gray-300">${v.description}</div>
+                                      <div class="flex-1 text-sm font-semibold text-gray-300">${v.title || v.description}</div>
                                       <div class="px-2 py-1 rounded border text-[10px] uppercase font-bold ${getCategoryBadge(v.category)}">${v.category}</div>
-                                      <div class="text-[10px] mono text-gray-600">${v.id}</div>
+                                      <div class="text-[10px] mono text-gray-600">${v.kind || 'N/A'}</div>
                                   </div>
                                   <div id="evidence-${i}" class="evidence-panel p-6 bg-black border-t border-gray-800">
                                       <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
                                           <div>
                                               <h4 class="text-xs font-bold uppercase text-gray-500 mb-3 tracking-widest">Discovery Evidence</h4>
-                                              <pre class="mono">${JSON.stringify(v.evidence, null, 2)}</pre>
+                                              <pre class="mono">${JSON.stringify(v.evidence || {}, null, 2)}</pre>
                                           </div>
                                           <div>
                                               <h4 class="text-xs font-bold uppercase text-gray-500 mb-3 tracking-widest">Technical Details</h4>
                                               <div class="space-y-3 text-sm">
-                                                  <p><span class="text-gray-500">CWE:</span> <span class="text-blue-400 mono">${v.cwe}</span></p>
-                                                  <p><span class="text-gray-500">Confidence:</span> <span class="font-bold text-gray-300">${v.confidence}</span></p>
-                                                  <p><span class="text-gray-500">Remediation:</span> <span class="text-gray-400 italic">Consult OMEN AI Protocol for detailed fix.</span></p>
+                                                  <p><span class="text-gray-500 font-bold uppercase text-[10px]">CWE:</span> <span class="text-blue-400 mono">${v.cwe || 'N/A'}</span></p>
+                                                  <p><span class="text-gray-500 font-bold uppercase text-[10px]">Confidence:</span> <span class="font-bold text-gray-300 uppercase">${v.confidence || 'N/A'}</span></p>
+                                                  <p><span class="text-gray-500 font-bold uppercase text-[10px]">Description:</span> <span class="text-gray-300">${v.description || 'N/A'}</span></p>
+                                                  <div class="mt-4 p-3 bg-blue-900/20 border border-blue-800 rounded">
+                                                      <h5 class="text-[10px] font-bold text-blue-400 uppercase mb-1">Remediation</h5>
+                                                      <p class="text-xs text-gray-300">${v.remediation || 'Consult OMEN AI Protocol for detailed fix.'}</p>
+                                                  </div>
                                               </div>
                                           </div>
                                       </div>
@@ -170,18 +174,18 @@ export async function startUIServer() {
                       <div class="lg:col-span-2 space-y-8">
                           <div class="card p-6 rounded-xl">
                               <h3 class="text-xl font-bold mb-4">Discovered Assets</h3>
-                              <pre class="mono max-h-[600px]">${(report.attack_surface.endpoints || []).join('\n') || 'No endpoints discovered.'}</pre>
+                              <pre class="mono max-h-[600px]">${(report.attack_surface?.endpoints || []).join('\n') || 'No endpoints discovered.'}</pre>
                           </div>
                       </div>
                       <div class="space-y-8">
                           <div class="card p-6 rounded-xl">
                               <h3 class="text-xl font-bold mb-4">Forms & Inputs</h3>
-                              <pre class="mono">${JSON.stringify(report.attack_surface.forms || [], null, 2)}</pre>
+                              <pre class="mono">${JSON.stringify(report.attack_surface?.forms || [], null, 2)}</pre>
                           </div>
                           <div class="card p-6 rounded-xl">
                               <h3 class="text-xl font-bold mb-4">Tech Fingerprint</h3>
                               <div class="flex flex-wrap gap-2">
-                                  ${(report.attack_surface.tech_stack || []).map(t => `<span class="px-3 py-1 bg-gray-800 rounded-full text-xs font-bold text-blue-400 border border-gray-700">${t}</span>`).join('') || '<span class="text-gray-500 italic">No stack identified.</span>'}
+                                  ${(report.attack_surface?.tech_stack || []).map(t => `<span class="px-3 py-1 bg-gray-800 rounded-full text-xs font-bold text-blue-400 border border-gray-700">${t}</span>`).join('') || '<span class="text-gray-500 italic">No stack identified.</span>'}
                               </div>
                           </div>
                       </div>
@@ -198,7 +202,7 @@ export async function startUIServer() {
               </div>
 
               <footer class="text-center text-gray-600 mt-16 border-t border-gray-900 pt-8 mb-10">
-                  <p class="text-xs uppercase tracking-widest font-bold mb-2">OMEN Security Framework - v1.0.16</p>
+                  <p class="text-xs uppercase tracking-widest font-bold mb-2">OMEN Security Framework - v1.0.17</p>
                   <p class="text-[10px] text-gray-700 italic">"The eye that never sleeps, the code that never fails."</p>
               </footer>
           </div>

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "omen-sec-cli",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "OMEN — AI Security Engine",
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "main": "bin/index.js",
   "type": "module",
   "bin": {

package/ui/banner.js

@@ -9,7 +9,7 @@ export function showBanner() {
  ╚██████╔╝██║ ╚═╝ ██║███████╗██║ ╚████║ 
  `));
   console.log(chalk.cyan.bold(' OMEN — AI Security Engine '));
-  console.log(chalk.gray(' Version: 1.0.16 \n'));
+  console.log(chalk.gray(' Version: 1.0.17 \n'));
 }
 
 export function showHelp() {