@zivis/mcp 0.1.8 → 0.1.11

package/dist/sanitize.js

@@ -1,37 +1,18 @@
-/**
- * Response Sanitization — Prompt Injection Defense
- *
- * Sanitizes API response data before returning it to the AI assistant.
- * Finding content (titles, descriptions, code snippets, remediation text)
- * is untrusted data from automated scanners and external vulnerability
- * databases. This layer strips common injection patterns.
- *
- * Defense layers:
- * 1. Strip non-printable / control characters
- * 2. Truncate field lengths
- * 3. Strip common LLM prompt injection patterns
- * 4. Encode suspicious formatting
- */
-// Maximum field lengths (characters)
 const MAX_LENGTHS = {
     title: 500,
     description: 2000,
     codeSnippet: 500,
     code_snippet: 500,
     remediation: 1000,
-    // Scan & test case result fields
     attackPayload: 500,
     targetResponse: 500,
     analysisNarrative: 1000,
     remediationGuidance: 1000,
     failureRationale: 1000,
-    // Scan output fields (allow longer for narrative content)
     reconMarkdown: 50000,
     attackSurfaceBrief: 5000,
 };
-// Patterns that look like LLM prompt injection attempts
 const INJECTION_PATTERNS = [
-    // Common LLM instruction delimiters
     /\[INST\]/gi,
     /\[\/INST\]/gi,
     /<\|system\|>/gi,
@@ -40,16 +21,13 @@ const INJECTION_PATTERNS = [
     /<\|im_start\|>/gi,
     /<\|im_end\|>/gi,
     /<\|endoftext\|>/gi,
-    // Role injection attempts
     /^Human:/gim,
     /^Assistant:/gim,
     /^System:/gim,
-    // XML-like tags that mimic prompt formatting
     /<system>/gi,
     /<\/system>/gi,
     /<instruction>/gi,
     /<\/instruction>/gi,
-    // Common injection prefixes
     /ignore (?:all )?previous instructions/gi,
     /disregard (?:all )?(?:previous |above )?instructions/gi,
     /you are now/gi,
@@ -57,17 +35,16 @@ const INJECTION_PATTERNS = [
     /override:/gi,
     /IMPORTANT: from now on/gi,
 ];
-/**
- * Strip non-printable and control characters, preserving newlines and tabs
- */
 function stripControlChars(text) {
-    // Allow printable ASCII, newlines, tabs, and common Unicode
-    // Strip C0 controls except \t \n \r, and C1 controls
     return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, "");
 }
-/**
- * Strip known LLM prompt injection patterns
- */
+const INVISIBLE_UNICODE = /[\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/g;
+export function sanitizeInboundText(value, maxLength) {
+    if (value === undefined || value === null)
+        return value;
+    const cleaned = stripControlChars(value).replace(INVISIBLE_UNICODE, "");
+    return truncate(cleaned, maxLength);
+}
 function stripInjectionPatterns(text) {
     let result = text;
     for (const pattern of INJECTION_PATTERNS) {
@@ -75,17 +52,11 @@ function stripInjectionPatterns(text) {
     }
     return result;
 }
-/**
- * Truncate a string to max length with ellipsis
- */
 function truncate(text, maxLength) {
     if (text.length <= maxLength)
         return text;
     return text.slice(0, maxLength - 3) + "...";
 }
-/**
- * Sanitize a single string field
- */
 export function sanitizeField(value, fieldName) {
     let result = stripControlChars(value);
     result = stripInjectionPatterns(result);
@@ -95,10 +66,6 @@ export function sanitizeField(value, fieldName) {
     }
     return result;
 }
-/**
- * Recursively sanitize all string fields in an object.
- * Handles nested objects and arrays.
- */
 export function sanitizeResponse(data) {
     if (data === null || data === undefined)
         return data;
@@ -122,4 +89,3 @@ export function sanitizeResponse(data) {
     }
     return data;
 }
-//# sourceMappingURL=sanitize.js.map

package/dist/scanners/index.d.ts

@@ -0,0 +1,3 @@
+export type { ScannerId, LeadSeverity, LeadLocation, NormalizedLead, ScannerRunResult, LocalScanReport, } from "./types.js";
+export { normalizeScannerOutput, normalizeGitleaks, normalizeTrivy, normalizeSemgrep, normalizeOsvScanner, } from "./normalize.js";
+export { SUPPORTED_SCANNERS, SCANNER_BINARIES, scannerCommand, runOneScanner, runLocalScanners, aggregate, defaultExecEnv, type ScannerCommand, type ScannerExecEnv, type RunLocalScannersOptions, } from "./run.js";

package/dist/scanners/index.js

@@ -0,0 +1,2 @@
+export { normalizeScannerOutput, normalizeGitleaks, normalizeTrivy, normalizeSemgrep, normalizeOsvScanner, } from "./normalize.js";
+export { SUPPORTED_SCANNERS, SCANNER_BINARIES, scannerCommand, runOneScanner, runLocalScanners, aggregate, defaultExecEnv, } from "./run.js";

package/dist/scanners/normalize.d.ts

@@ -0,0 +1,6 @@
+import type { NormalizedLead, ScannerId } from "./types.js";
+export declare function normalizeGitleaks(parsed: unknown): NormalizedLead[];
+export declare function normalizeTrivy(parsed: unknown): NormalizedLead[];
+export declare function normalizeSemgrep(parsed: unknown): NormalizedLead[];
+export declare function normalizeOsvScanner(parsed: unknown): NormalizedLead[];
+export declare function normalizeScannerOutput(source: ScannerId, parsed: unknown): NormalizedLead[];

package/dist/scanners/normalize.js

@@ -0,0 +1,181 @@
+import { redactString } from "../redact.js";
+function redact(text) {
+    if (text === undefined || text === null || text === "")
+        return undefined;
+    return redactString(String(text)).text;
+}
+function normalizeSeverity(raw) {
+    const s = String(raw ?? "").toLowerCase();
+    if (s.startsWith("crit"))
+        return "critical";
+    if (s === "high" || s === "error")
+        return "high";
+    if (s === "medium" || s === "moderate" || s === "warning" || s === "warn")
+        return "medium";
+    if (s === "low")
+        return "low";
+    if (s === "info" || s === "informational" || s === "unknown" || s === "none" || s === "") {
+        return s === "" || s === "unknown" || s === "none" ? "unknown" : "info";
+    }
+    return "unknown";
+}
+function asArray(v) {
+    return Array.isArray(v) ? v : [];
+}
+function lead(base) {
+    return { lane: "lead", ...base };
+}
+export function normalizeGitleaks(parsed) {
+    const findings = asArray(parsed);
+    return findings.map((f) => {
+        const tags = Array.isArray(f.Tags) ? f.Tags : [];
+        const sevTag = tags.find((t) => ["critical", "high", "medium", "low"].includes(String(t).toLowerCase()));
+        return lead({
+            source: "gitleaks",
+            rule_id: f.RuleID ?? "gitleaks-secret",
+            title: f.Description ?? f.RuleID ?? "Potential secret",
+            severity: sevTag ? normalizeSeverity(sevTag) : "high",
+            location: { file: f.File, start_line: f.StartLine, end_line: f.EndLine },
+            excerpt: redact(f.Match),
+            metadata: tags.length ? { tags } : undefined,
+        });
+    });
+}
+export function normalizeTrivy(parsed) {
+    const results = asArray(parsed?.Results);
+    const out = [];
+    for (const r of results) {
+        for (const v of asArray(r.Vulnerabilities)) {
+            out.push(lead({
+                source: "trivy",
+                rule_id: v.VulnerabilityID ?? "trivy-vuln",
+                title: v.Title ?? `${v.PkgName ?? "dependency"} ${v.VulnerabilityID ?? ""}`.trim(),
+                severity: normalizeSeverity(v.Severity),
+                location: { file: r.Target },
+                package: v.PkgName,
+                cwe: Array.isArray(v.CweIDs) && v.CweIDs.length ? v.CweIDs : undefined,
+                references: dedupeRefs(v.PrimaryURL, v.References),
+                metadata: {
+                    installed_version: v.InstalledVersion,
+                    fixed_version: v.FixedVersion,
+                },
+            }));
+        }
+        for (const s of asArray(r.Secrets)) {
+            out.push(lead({
+                source: "trivy",
+                rule_id: s.RuleID ?? "trivy-secret",
+                title: s.Title ?? "Potential secret",
+                severity: normalizeSeverity(s.Severity ?? "high"),
+                location: { file: r.Target, start_line: s.StartLine, end_line: s.EndLine },
+                excerpt: redact(s.Match),
+            }));
+        }
+        for (const m of asArray(r.Misconfigurations)) {
+            out.push(lead({
+                source: "trivy",
+                rule_id: m.ID ?? "trivy-misconfig",
+                title: m.Title ?? m.ID ?? "Misconfiguration",
+                severity: normalizeSeverity(m.Severity),
+                location: { file: r.Target },
+                references: dedupeRefs(m.PrimaryURL, m.References),
+            }));
+        }
+    }
+    return out;
+}
+export function normalizeSemgrep(parsed) {
+    const results = asArray(parsed?.results);
+    return results.map((r) => {
+        const meta = r.extra?.metadata ?? {};
+        return lead({
+            source: "semgrep",
+            rule_id: r.check_id ?? "semgrep-rule",
+            title: r.extra?.message ?? r.check_id ?? "Semgrep match",
+            severity: normalizeSeverity(r.extra?.severity),
+            location: { file: r.path, start_line: r.start?.line, end_line: r.end?.line },
+            cwe: toStringArray(meta.cwe),
+            owasp: toStringArray(meta.owasp),
+            references: Array.isArray(meta.references) ? meta.references : undefined,
+            excerpt: redact(r.extra?.lines),
+        });
+    });
+}
+export function normalizeOsvScanner(parsed) {
+    const results = asArray(parsed?.results);
+    const out = [];
+    for (const src of results) {
+        const file = src.source?.path;
+        for (const pkg of asArray(src.packages)) {
+            const pkgName = pkg.package?.name;
+            const groupSeverity = new Map();
+            for (const g of asArray(pkg.groups)) {
+                for (const id of asArray(g.ids)) {
+                    if (g.max_severity)
+                        groupSeverity.set(id, g.max_severity);
+                }
+            }
+            for (const v of asArray(pkg.vulnerabilities)) {
+                out.push(lead({
+                    source: "osv-scanner",
+                    rule_id: v.id ?? "osv-vuln",
+                    title: v.summary ?? `${pkgName ?? "dependency"} ${v.id ?? ""}`.trim(),
+                    severity: cvssScoreToSeverity(groupSeverity.get(v.id ?? "")),
+                    location: { file },
+                    package: pkgName,
+                    references: asArray(v.references)
+                        .map((r) => r.url)
+                        .filter((u) => typeof u === "string"),
+                    metadata: { version: pkg.package?.version, ecosystem: pkg.package?.ecosystem },
+                }));
+            }
+        }
+    }
+    return out;
+}
+function toStringArray(v) {
+    if (v === undefined || v === null)
+        return undefined;
+    const arr = Array.isArray(v) ? v : [v];
+    const out = arr.map((x) => String(x)).filter(Boolean);
+    return out.length ? out : undefined;
+}
+function dedupeRefs(primary, refs) {
+    const set = new Set();
+    if (primary)
+        set.add(primary);
+    for (const r of Array.isArray(refs) ? refs : [])
+        if (r)
+            set.add(r);
+    return set.size ? [...set] : undefined;
+}
+function cvssScoreToSeverity(score) {
+    if (!score)
+        return "unknown";
+    const n = Number.parseFloat(score);
+    if (Number.isNaN(n))
+        return "unknown";
+    if (n >= 9.0)
+        return "critical";
+    if (n >= 7.0)
+        return "high";
+    if (n >= 4.0)
+        return "medium";
+    if (n > 0)
+        return "low";
+    return "unknown";
+}
+export function normalizeScannerOutput(source, parsed) {
+    switch (source) {
+        case "gitleaks":
+            return normalizeGitleaks(parsed);
+        case "trivy":
+            return normalizeTrivy(parsed);
+        case "semgrep":
+            return normalizeSemgrep(parsed);
+        case "osv-scanner":
+            return normalizeOsvScanner(parsed);
+        default:
+            return [];
+    }
+}

package/dist/scanners/run.d.ts

@@ -0,0 +1,27 @@
+import type { LocalScanReport, ScannerId, ScannerRunResult } from "./types.js";
+export declare const SUPPORTED_SCANNERS: readonly ScannerId[];
+export declare const SCANNER_BINARIES: Record<ScannerId, string>;
+export interface ScannerCommand {
+    bin: string;
+    args: string[];
+}
+export declare function scannerCommand(source: ScannerId, dir: string, outPath: string): ScannerCommand;
+export interface ScannerExecEnv {
+    isAvailable(bin: string): Promise<boolean>;
+    execute(cmd: ScannerCommand, opts: {
+        timeoutMs: number;
+    }): Promise<{
+        reportText: string | null;
+        error?: string;
+    }>;
+}
+export declare const defaultExecEnv: ScannerExecEnv;
+export interface RunLocalScannersOptions {
+    sources?: ScannerId[];
+    timeoutMs?: number;
+    env?: ScannerExecEnv;
+    tmpDir?: string;
+}
+export declare function runOneScanner(source: ScannerId, dir: string, opts?: RunLocalScannersOptions): Promise<ScannerRunResult>;
+export declare function runLocalScanners(dir: string, opts?: RunLocalScannersOptions): Promise<LocalScanReport>;
+export declare function aggregate(results: ScannerRunResult[]): LocalScanReport;

package/dist/scanners/run.js

@@ -0,0 +1,142 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import * as crypto from "node:crypto";
+import { execFile } from "node:child_process";
+import { normalizeScannerOutput } from "./normalize.js";
+export const SUPPORTED_SCANNERS = ["gitleaks", "trivy", "semgrep", "osv-scanner"];
+export const SCANNER_BINARIES = {
+    gitleaks: "gitleaks",
+    trivy: "trivy",
+    semgrep: "semgrep",
+    "osv-scanner": "osv-scanner",
+};
+export function scannerCommand(source, dir, outPath) {
+    switch (source) {
+        case "gitleaks":
+            return {
+                bin: "gitleaks",
+                args: ["detect", "--source", dir, "--no-banner", "--report-format", "json", "--report-path", outPath, "--exit-code", "0"],
+            };
+        case "trivy":
+            return {
+                bin: "trivy",
+                args: ["fs", "--quiet", "--format", "json", "--output", outPath, "--scanners", "vuln,secret,misconfig", dir],
+            };
+        case "semgrep":
+            return {
+                bin: "semgrep",
+                args: ["scan", "--json", "--output", outPath, "--quiet", "--config", process.env.ZIVIS_SEMGREP_CONFIG || "auto", dir],
+            };
+        case "osv-scanner":
+            return {
+                bin: "osv-scanner",
+                args: ["--format", "json", "--output", outPath, "--recursive", dir],
+            };
+        default:
+            throw new Error(`unknown scanner: ${source}`);
+    }
+}
+const execFileAsync = (bin, args, timeoutMs) => new Promise((resolve) => {
+    execFile(bin, args, { timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 }, (err) => {
+        const code = err && typeof err.code === "number" ? (err.code) : err ? 1 : 0;
+        resolve({ code, stderr: err ? String(err.message ?? "") : "" });
+    });
+});
+export const defaultExecEnv = {
+    async isAvailable(bin) {
+        return new Promise((resolve) => {
+            execFile(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [bin] : ["-v", bin], { shell: true, timeout: 5000 }, (err) => {
+                resolve(!err);
+            });
+        });
+    },
+    async execute(cmd, opts) {
+        const outIdx = cmd.args.findIndex((a) => a === "--output" || a === "--report-path");
+        const outPath = outIdx >= 0 ? cmd.args[outIdx + 1] : undefined;
+        if (!outPath)
+            return { reportText: null, error: "no output path in command" };
+        try {
+            await execFileAsync(cmd.bin, cmd.args, opts.timeoutMs);
+            const text = await fs.readFile(outPath, "utf8").catch(() => null);
+            return { reportText: text };
+        }
+        catch (err) {
+            return { reportText: null, error: err instanceof Error ? err.message : String(err) };
+        }
+        finally {
+            if (outPath)
+                await fs.rm(outPath, { force: true }).catch(() => { });
+        }
+    },
+};
+export async function runOneScanner(source, dir, opts = {}) {
+    const env = opts.env ?? defaultExecEnv;
+    const bin = SCANNER_BINARIES[source];
+    const started = Date.now();
+    if (!(await env.isAvailable(bin))) {
+        return { source, status: "not_installed", leads: [] };
+    }
+    const tmpDir = opts.tmpDir ?? os.tmpdir();
+    const outPath = path.join(tmpDir, `zivis-${source}-${crypto.randomUUID()}.json`);
+    const cmd = scannerCommand(source, dir, outPath);
+    try {
+        const { reportText, error } = await env.execute(cmd, { timeoutMs: opts.timeoutMs ?? 120_000 });
+        if (error && reportText === null) {
+            return { source, status: "error", leads: [], error, duration_ms: Date.now() - started };
+        }
+        if (reportText === null || reportText.trim() === "") {
+            return { source, status: "ok", leads: [], duration_ms: Date.now() - started };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(reportText);
+        }
+        catch (e) {
+            return { source, status: "error", leads: [], error: `unparseable ${source} JSON: ${e instanceof Error ? e.message : String(e)}`, duration_ms: Date.now() - started };
+        }
+        const leads = normalizeScannerOutput(source, parsed);
+        return { source, status: "ok", leads, duration_ms: Date.now() - started };
+    }
+    catch (err) {
+        return { source, status: "error", leads: [], error: err instanceof Error ? err.message : String(err), duration_ms: Date.now() - started };
+    }
+}
+export async function runLocalScanners(dir, opts = {}) {
+    const sources = opts.sources ?? [...SUPPORTED_SCANNERS];
+    const results = [];
+    for (const source of sources) {
+        results.push(await runOneScanner(source, dir, opts));
+    }
+    return aggregate(results);
+}
+export function aggregate(results) {
+    const leads = [];
+    const bySource = {};
+    const bySeverity = {};
+    const scannersRun = [];
+    const scannersMissing = [];
+    for (const r of results) {
+        if (r.status === "not_installed")
+            scannersMissing.push(r.source);
+        else
+            scannersRun.push(r.source);
+        for (const l of r.leads) {
+            leads.push(l);
+            bySource[l.source] = (bySource[l.source] ?? 0) + 1;
+            bySeverity[l.severity] = (bySeverity[l.severity] ?? 0) + 1;
+        }
+    }
+    return {
+        ran_at: new Date().toISOString(),
+        results,
+        leads,
+        summary: {
+            total_leads: leads.length,
+            by_source: bySource,
+            by_severity: bySeverity,
+            scanners_run: scannersRun,
+            scanners_missing: scannersMissing,
+        },
+    };
+}

package/dist/scanners/types.d.ts

@@ -0,0 +1,40 @@
+export type ScannerId = "gitleaks" | "trivy" | "semgrep" | "osv-scanner";
+export type LeadSeverity = "critical" | "high" | "medium" | "low" | "info" | "unknown";
+export interface LeadLocation {
+    file?: string;
+    start_line?: number;
+    end_line?: number;
+}
+export interface NormalizedLead {
+    lane: "lead";
+    source: ScannerId;
+    rule_id: string;
+    title: string;
+    severity: LeadSeverity;
+    location?: LeadLocation;
+    package?: string;
+    cwe?: string[];
+    owasp?: string[];
+    references?: string[];
+    excerpt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ScannerRunResult {
+    source: ScannerId;
+    status: "ok" | "not_installed" | "error";
+    leads: NormalizedLead[];
+    error?: string;
+    duration_ms?: number;
+}
+export interface LocalScanReport {
+    ran_at: string;
+    results: ScannerRunResult[];
+    leads: NormalizedLead[];
+    summary: {
+        total_leads: number;
+        by_source: Record<string, number>;
+        by_severity: Record<string, number>;
+        scanners_run: ScannerId[];
+        scanners_missing: ScannerId[];
+    };
+}

package/dist/scanners/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server.d.ts

@@ -1,14 +1,2 @@
-/**
- * MCP Server
- *
- * Sets up the Model Context Protocol server using the official SDK
- * with stdio transport. Registers all ZIVIS security tools.
- *
- * IMPORTANT: This server communicates over stdout (JSON-RPC 2.0).
- * Never use console.log() — use console.error() for all logging.
- */
 import type { ZivisConfig } from "./types.js";
-/**
- * Create and start the MCP server with all tools registered
- */
-export declare function startServer(config?: ZivisConfig): Promise<void>;
+export declare function startServer(incoming?: ZivisConfig): Promise<void>;