codegate-ai 0.1.0

package/dist/pipeline.js

@@ -0,0 +1,259 @@
+import { runStaticEngine, } from "./layer2-static/engine.js";
+import { createEmptyReport } from "./types/report.js";
+import { scanToolDescriptions, } from "./layer3-dynamic/tool-description-scanner.js";
+import { detectToxicFlows } from "./layer3-dynamic/toxic-flow.js";
+import { applyReportSummary } from "./report-summary.js";
+export function runStaticPipeline(input) {
+    const findings = runStaticEngine({
+        projectRoot: input.projectRoot,
+        files: input.files,
+        symlinkEscapes: input.symlinkEscapes,
+        hooks: input.hooks,
+        config: input.config,
+    });
+    const report = createEmptyReport({
+        version: input.version,
+        kbVersion: input.kbVersion,
+        scanTarget: input.scanTarget,
+        toolsDetected: input.toolsDetected,
+        exitCode: 0,
+    });
+    return applyReportSummary({
+        ...report,
+        findings,
+    });
+}
+function parseSeverity(value) {
+    if (value === "CRITICAL" || value === "HIGH" || value === "MEDIUM" || value === "LOW") {
+        return value;
+    }
+    return "INFO";
+}
+function parseConfidence(value) {
+    if (value === "HIGH" || value === "MEDIUM") {
+        return value;
+    }
+    return "LOW";
+}
+function parseCategory(value) {
+    if (value === "ENV_OVERRIDE" ||
+        value === "COMMAND_EXEC" ||
+        value === "CONSENT_BYPASS" ||
+        value === "RULE_INJECTION" ||
+        value === "IDE_SETTINGS" ||
+        value === "SYMLINK_ESCAPE" ||
+        value === "GIT_HOOK" ||
+        value === "CONFIG_PRESENT" ||
+        value === "CONFIG_CHANGE" ||
+        value === "NEW_SERVER" ||
+        value === "TOXIC_FLOW") {
+        return value;
+    }
+    return "PARSE_ERROR";
+}
+function parseLayer3Response(resourceId, metadata) {
+    if (!metadata || typeof metadata !== "object") {
+        return [];
+    }
+    const root = metadata;
+    if (!Array.isArray(root.findings)) {
+        return [];
+    }
+    return root.findings
+        .filter((item) => typeof item === "object" && item !== null)
+        .map((item, index) => {
+        const findingId = item.id ?? `L3-${resourceId}-${index}`;
+        return {
+            rule_id: item.id ?? "layer3-analysis-finding",
+            finding_id: findingId,
+            severity: parseSeverity(item.severity),
+            category: parseCategory(item.category),
+            layer: "L3",
+            file_path: item.file_path ?? resourceId,
+            location: { field: item.field },
+            description: item.description ?? "Layer 3 analysis finding",
+            affected_tools: [],
+            cve: null,
+            owasp: Array.isArray(item.owasp) ? item.owasp : [],
+            cwe: item.cwe ?? "CWE-20",
+            confidence: parseConfidence(item.confidence),
+            evidence: typeof item.evidence === "string" ? item.evidence : null,
+            fixable: item.fixable ?? false,
+            remediation_actions: item.remediation_actions ?? [],
+            source_config: item.source_config ?? null,
+            suppressed: false,
+        };
+    });
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function parseToxicClass(value) {
+    if (value === "untrusted_input" ||
+        value === "sensitive_access" ||
+        value === "exfiltration_sink") {
+        return value;
+    }
+    return null;
+}
+function parseToxicClasses(value) {
+    if (typeof value === "string") {
+        const parsed = parseToxicClass(value);
+        return parsed ? [parsed] : [];
+    }
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const classes = [];
+    for (const item of value) {
+        if (typeof item !== "string") {
+            continue;
+        }
+        const parsed = parseToxicClass(item);
+        if (parsed) {
+            classes.push(parsed);
+        }
+    }
+    return classes;
+}
+function parseToolEntries(metadata) {
+    const root = asRecord(metadata);
+    if (!root || !Array.isArray(root.tools)) {
+        return [];
+    }
+    return root.tools
+        .map((entry) => asRecord(entry))
+        .filter((entry) => entry !== null)
+        .map((entry) => {
+        const name = typeof entry.name === "string" ? entry.name : "";
+        const description = typeof entry.description === "string" ? entry.description : "";
+        const classifications = parseToxicClasses(entry.classifications ?? entry.classification);
+        return { name, description, classifications };
+    })
+        .filter((entry) => entry.name.length > 0 && entry.description.length > 0);
+}
+function parseToolClassifications(metadata, tools) {
+    const map = {};
+    const root = asRecord(metadata);
+    for (const tool of tools) {
+        if (!tool.classifications || tool.classifications.length === 0) {
+            continue;
+        }
+        map[tool.name] = tool.classifications;
+    }
+    const classificationRoot = asRecord(root?.tool_classifications ?? root?.toolClassifications);
+    if (!classificationRoot) {
+        return map;
+    }
+    for (const [toolName, value] of Object.entries(classificationRoot)) {
+        const parsed = parseToxicClasses(value);
+        if (parsed.length === 0) {
+            continue;
+        }
+        map[toolName] = parsed;
+    }
+    return map;
+}
+function deriveLayer3ToolFindings(resourceId, metadata, options = {}) {
+    const toolEntries = parseToolEntries(metadata);
+    if (toolEntries.length === 0) {
+        return [];
+    }
+    const toolDescriptions = toolEntries.map((entry) => ({
+        name: entry.name,
+        description: entry.description,
+    }));
+    const knownClassifications = parseToolClassifications(metadata, toolEntries);
+    return [
+        ...scanToolDescriptions({
+            serverId: resourceId,
+            tools: toolDescriptions,
+            unicodeAnalysis: options.unicodeAnalysis,
+        }),
+        ...detectToxicFlows({
+            scopeId: resourceId,
+            tools: toolDescriptions,
+            knownClassifications,
+        }),
+    ];
+}
+function layer3ErrorFinding(resourceId, status, description) {
+    const severity = status === "timeout" ? "MEDIUM" : status === "skipped_without_consent" ? "INFO" : "LOW";
+    return {
+        rule_id: `layer3-${status}`,
+        finding_id: `L3-${status}-${resourceId}`,
+        severity,
+        category: "PARSE_ERROR",
+        layer: "L3",
+        file_path: resourceId,
+        location: { field: "layer3" },
+        description,
+        affected_tools: [],
+        cve: null,
+        owasp: [],
+        cwe: "CWE-20",
+        confidence: "HIGH",
+        fixable: false,
+        remediation_actions: [],
+        suppressed: false,
+    };
+}
+function isRegistryMetadataResource(resourceId) {
+    return (resourceId.startsWith("npm:") || resourceId.startsWith("pypi:") || resourceId.startsWith("git:"));
+}
+export function layer3OutcomesToFindings(outcomes, options = {}) {
+    const findings = [];
+    for (const outcome of outcomes) {
+        if (!outcome.approved || outcome.status === "skipped_without_consent") {
+            findings.push(layer3ErrorFinding(outcome.resourceId, "skipped_without_consent", "Deep scan skipped because consent was not granted"));
+            continue;
+        }
+        if (outcome.status !== "ok" || !outcome.result) {
+            findings.push(layer3ErrorFinding(outcome.resourceId, outcome.status, `Deep scan failed with status: ${outcome.status}`));
+            continue;
+        }
+        const parsed = parseLayer3Response(outcome.resourceId, outcome.result.metadata);
+        const derived = deriveLayer3ToolFindings(outcome.resourceId, outcome.result.metadata, options);
+        const combined = [...parsed, ...derived];
+        if (combined.length === 0) {
+            if (isRegistryMetadataResource(outcome.resourceId)) {
+                continue;
+            }
+            findings.push(layer3ErrorFinding(outcome.resourceId, "network_error", "Deep scan response schema mismatch: expected metadata.findings[] or metadata.tools[]"));
+            continue;
+        }
+        findings.push(...combined);
+    }
+    return findings;
+}
+export function mergeLayer3Findings(baseReport, layer3Findings) {
+    return applyReportSummary({
+        ...baseReport,
+        findings: [...baseReport.findings, ...layer3Findings],
+    });
+}
+export async function runDeepScanWithConsent(resources, requestConsent, execute) {
+    const outcomes = [];
+    for (const resource of resources) {
+        const approved = await requestConsent(resource);
+        if (!approved) {
+            outcomes.push({
+                resourceId: resource.id,
+                approved: false,
+                status: "skipped_without_consent",
+            });
+            continue;
+        }
+        const result = await execute(resource);
+        outcomes.push({
+            resourceId: resource.id,
+            approved: true,
+            status: result.status,
+            result,
+        });
+    }
+    return outcomes;
+}

package/dist/report-summary.d.ts

@@ -0,0 +1,6 @@
+import type { Finding } from "./types/finding.js";
+import type { CodeGateReport, ReportSummary } from "./types/report.js";
+export type ReportThreshold = "critical" | "high" | "medium" | "low" | "info";
+export declare function computeExitCode(findings: Finding[], threshold?: ReportThreshold): number;
+export declare function summarizeFindings(findings: Finding[], threshold?: ReportThreshold): ReportSummary;
+export declare function applyReportSummary(report: CodeGateReport, threshold?: ReportThreshold): CodeGateReport;

package/dist/report-summary.js

@@ -0,0 +1,48 @@
+const SEVERITY_LEVEL = {
+    CRITICAL: 4,
+    HIGH: 3,
+    MEDIUM: 2,
+    LOW: 1,
+    INFO: 0,
+};
+const THRESHOLD_LEVEL = {
+    critical: 4,
+    high: 3,
+    medium: 2,
+    low: 1,
+    info: 0,
+};
+export function computeExitCode(findings, threshold = "high") {
+    const unsuppressed = findings.filter((finding) => !finding.suppressed);
+    if (unsuppressed.length === 0) {
+        return 0;
+    }
+    const thresholdLevel = THRESHOLD_LEVEL[threshold];
+    const hasDangerous = unsuppressed.some((finding) => SEVERITY_LEVEL[finding.severity] >= thresholdLevel);
+    return hasDangerous ? 2 : 1;
+}
+export function summarizeFindings(findings, threshold = "high") {
+    const bySeverity = {
+        CRITICAL: 0,
+        HIGH: 0,
+        MEDIUM: 0,
+        LOW: 0,
+        INFO: 0,
+    };
+    for (const finding of findings) {
+        bySeverity[finding.severity] = (bySeverity[finding.severity] ?? 0) + 1;
+    }
+    return {
+        total: findings.length,
+        by_severity: bySeverity,
+        fixable: findings.filter((finding) => finding.fixable).length,
+        suppressed: findings.filter((finding) => finding.suppressed).length,
+        exit_code: computeExitCode(findings, threshold),
+    };
+}
+export function applyReportSummary(report, threshold = "high") {
+    return {
+        ...report,
+        summary: summarizeFindings(report.findings, threshold),
+    };
+}

package/dist/reporter/html.d.ts

@@ -0,0 +1,2 @@
+import type { CodeGateReport } from "../types/report.js";
+export declare function renderHtmlReport(report: CodeGateReport): string;

package/dist/reporter/html.js

@@ -0,0 +1,103 @@
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function formatLocation(location) {
+    const parts = [];
+    if (location.field) {
+        parts.push(location.field);
+    }
+    if (typeof location.line === "number") {
+        parts.push(`line ${location.line}`);
+    }
+    if (typeof location.column === "number") {
+        parts.push(`col ${location.column}`);
+    }
+    return parts.join(", ") || "-";
+}
+function renderSummary(report) {
+    return `
+    <ul>
+      <li><strong>Total findings:</strong> ${report.summary.total}</li>
+      <li><strong>CRITICAL:</strong> ${report.summary.by_severity.CRITICAL ?? 0}</li>
+      <li><strong>HIGH:</strong> ${report.summary.by_severity.HIGH ?? 0}</li>
+      <li><strong>MEDIUM:</strong> ${report.summary.by_severity.MEDIUM ?? 0}</li>
+      <li><strong>LOW:</strong> ${report.summary.by_severity.LOW ?? 0}</li>
+      <li><strong>INFO:</strong> ${report.summary.by_severity.INFO ?? 0}</li>
+      <li><strong>Fixable:</strong> ${report.summary.fixable}</li>
+      <li><strong>Suppressed:</strong> ${report.summary.suppressed}</li>
+      <li><strong>Exit code:</strong> ${report.summary.exit_code}</li>
+    </ul>
+  `;
+}
+function renderFindings(report) {
+    if (report.findings.length === 0) {
+        return "<p>No findings.</p>";
+    }
+    const rows = report.findings
+        .map((finding) => {
+        const location = formatLocation(finding.location);
+        return `
+        <tr>
+          <td>${escapeHtml(finding.severity)}</td>
+          <td>${escapeHtml(finding.category)}</td>
+          <td>${escapeHtml(finding.file_path)}</td>
+          <td>${escapeHtml(location)}</td>
+          <td>${escapeHtml(finding.description)}</td>
+        </tr>
+      `;
+    })
+        .join("\n");
+    return `
+    <table>
+      <thead>
+        <tr>
+          <th>Severity</th>
+          <th>Category</th>
+          <th>File</th>
+          <th>Location</th>
+          <th>Description</th>
+        </tr>
+      </thead>
+      <tbody>
+        ${rows}
+      </tbody>
+    </table>
+  `;
+}
+export function renderHtmlReport(report) {
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>CodeGate Report</title>
+    <style>
+      body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; margin: 24px; color: #0f172a; }
+      h1, h2 { margin: 0 0 12px 0; }
+      .meta { margin: 0 0 20px 0; color: #334155; }
+      table { border-collapse: collapse; width: 100%; margin-top: 12px; }
+      th, td { border: 1px solid #cbd5e1; padding: 8px; text-align: left; vertical-align: top; }
+      th { background: #f1f5f9; }
+      code { background: #f8fafc; padding: 2px 4px; border-radius: 4px; }
+    </style>
+  </head>
+  <body>
+    <h1>CodeGate Report</h1>
+    <p class="meta">
+      Version <code>${escapeHtml(report.version)}</code> |
+      Target <code>${escapeHtml(report.scan_target)}</code> |
+      KB <code>${escapeHtml(report.kb_version)}</code> |
+      Generated <code>${escapeHtml(report.timestamp)}</code>
+    </p>
+    <h2>Summary</h2>
+    ${renderSummary(report)}
+    <h2>Findings</h2>
+    ${renderFindings(report)}
+  </body>
+</html>`;
+}

package/dist/reporter/json.d.ts

@@ -0,0 +1,2 @@
+import type { CodeGateReport } from "../types/report.js";
+export declare function renderJsonReport(report: CodeGateReport): string;

package/dist/reporter/json.js

@@ -0,0 +1,3 @@
+export function renderJsonReport(report) {
+    return JSON.stringify(report, null, 2);
+}

package/dist/reporter/markdown.d.ts

@@ -0,0 +1,2 @@
+import type { CodeGateReport } from "../types/report.js";
+export declare function renderMarkdownReport(report: CodeGateReport): string;

package/dist/reporter/markdown.js

@@ -0,0 +1,52 @@
+function escapePipes(value) {
+    return value.replaceAll("|", "\\|");
+}
+function formatLocation(location) {
+    const parts = [];
+    if (location.field) {
+        parts.push(location.field);
+    }
+    if (typeof location.line === "number") {
+        parts.push(`line ${location.line}`);
+    }
+    if (typeof location.column === "number") {
+        parts.push(`col ${location.column}`);
+    }
+    return parts.join(", ") || "-";
+}
+export function renderMarkdownReport(report) {
+    const lines = [];
+    lines.push("# CodeGate Report");
+    lines.push("");
+    lines.push(`- Version: \`${report.version}\``);
+    lines.push(`- Target: \`${report.scan_target}\``);
+    lines.push(`- Timestamp: \`${report.timestamp}\``);
+    lines.push(`- KB Version: \`${report.kb_version}\``);
+    lines.push(`- Exit Code: \`${report.summary.exit_code}\``);
+    lines.push("");
+    lines.push("## Summary");
+    lines.push("");
+    lines.push("| Metric | Value |");
+    lines.push("| --- | --- |");
+    lines.push(`| Total findings | ${report.summary.total} |`);
+    lines.push(`| CRITICAL | ${report.summary.by_severity.CRITICAL ?? 0} |`);
+    lines.push(`| HIGH | ${report.summary.by_severity.HIGH ?? 0} |`);
+    lines.push(`| MEDIUM | ${report.summary.by_severity.MEDIUM ?? 0} |`);
+    lines.push(`| LOW | ${report.summary.by_severity.LOW ?? 0} |`);
+    lines.push(`| INFO | ${report.summary.by_severity.INFO ?? 0} |`);
+    lines.push(`| Fixable | ${report.summary.fixable} |`);
+    lines.push(`| Suppressed | ${report.summary.suppressed} |`);
+    lines.push("");
+    lines.push("## Findings");
+    lines.push("");
+    if (report.findings.length === 0) {
+        lines.push("No findings.");
+        return lines.join("\n");
+    }
+    lines.push("| Severity | Category | File | Location | Description |");
+    lines.push("| --- | --- | --- | --- | --- |");
+    for (const finding of report.findings) {
+        lines.push(`| ${finding.severity} | ${finding.category} | \`${escapePipes(finding.file_path)}\` | ${escapePipes(formatLocation(finding.location))} | ${escapePipes(finding.description)} |`);
+    }
+    return lines.join("\n");
+}

package/dist/reporter/sarif.d.ts

@@ -0,0 +1,2 @@
+import type { CodeGateReport } from "../types/report.js";
+export declare function renderSarifReport(report: CodeGateReport): string;

package/dist/reporter/sarif.js

@@ -0,0 +1,84 @@
+function toSarifLevel(severity) {
+    if (severity === "CRITICAL" || severity === "HIGH") {
+        return "error";
+    }
+    if (severity === "MEDIUM") {
+        return "warning";
+    }
+    return "note";
+}
+function findingToLocation(finding) {
+    const region = {};
+    if (typeof finding.location.line === "number") {
+        region.startLine = finding.location.line;
+    }
+    if (typeof finding.location.column === "number") {
+        region.startColumn = finding.location.column;
+    }
+    return {
+        physicalLocation: {
+            artifactLocation: {
+                uri: finding.file_path,
+            },
+            region: Object.keys(region).length > 0 ? region : undefined,
+        },
+    };
+}
+function buildRules(findings) {
+    const byRuleId = new Map();
+    for (const finding of findings) {
+        if (byRuleId.has(finding.rule_id)) {
+            continue;
+        }
+        byRuleId.set(finding.rule_id, {
+            id: finding.rule_id,
+            shortDescription: { text: finding.description },
+            properties: {
+                category: finding.category,
+                layer: finding.layer,
+            },
+        });
+    }
+    return Array.from(byRuleId.values());
+}
+function findingToResult(finding) {
+    return {
+        ruleId: finding.rule_id,
+        level: toSarifLevel(finding.severity),
+        message: { text: finding.description },
+        locations: [findingToLocation(finding)],
+        properties: {
+            finding_id: finding.finding_id,
+            severity: finding.severity,
+            category: finding.category,
+            layer: finding.layer,
+            confidence: finding.confidence,
+            cve: finding.cve,
+            owasp: finding.owasp,
+            cwe: finding.cwe,
+            evidence: finding.evidence ?? null,
+            fixable: finding.fixable,
+            suppressed: finding.suppressed,
+            source_config: finding.source_config ?? null,
+        },
+    };
+}
+export function renderSarifReport(report) {
+    const sarif = {
+        version: "2.1.0",
+        $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: "CodeGate",
+                        semanticVersion: report.version,
+                        rules: buildRules(report.findings),
+                    },
+                },
+                results: report.findings.map(findingToResult),
+            },
+        ],
+    };
+    return JSON.stringify(sarif, null, 2);
+}

package/dist/reporter/terminal.d.ts

@@ -0,0 +1,5 @@
+import type { CodeGateReport } from "../types/report.js";
+export interface TerminalRenderOptions {
+    verbose?: boolean;
+}
+export declare function renderTerminalReport(report: CodeGateReport, options?: TerminalRenderOptions): string;

package/dist/reporter/terminal.js

@@ -0,0 +1,94 @@
+import { toAbsoluteDisplayPath } from "../path-display.js";
+function appendLabeledList(lines, label, values) {
+    if (values.length === 0) {
+        return;
+    }
+    lines.push(`  ${label}:`);
+    for (const value of values) {
+        lines.push(`    - ${value}`);
+    }
+}
+function appendLabeledText(lines, label, value) {
+    if (value.length === 0) {
+        return;
+    }
+    lines.push(`  ${label}: ${value}`);
+}
+function appendEvidence(lines, evidence) {
+    const evidenceLines = evidence.split("\n");
+    if (evidenceLines.length === 1) {
+        lines.push(`  Evidence: ${evidenceLines[0]}`);
+        return;
+    }
+    lines.push("  Evidence:");
+    for (const evidenceLine of evidenceLines) {
+        lines.push(`    ${evidenceLine}`);
+    }
+}
+function formatLocation(location) {
+    const parts = [];
+    if (location.field) {
+        parts.push(location.field);
+    }
+    if (typeof location.line === "number") {
+        const column = typeof location.column === "number" ? `:${location.column}` : "";
+        parts.push(`line ${location.line}${column}`);
+    }
+    return parts.length > 0 ? parts.join(" @ ") : null;
+}
+export function renderTerminalReport(report, options = {}) {
+    const verbose = options.verbose === true;
+    const lines = [];
+    lines.push(`CodeGate v${report.version}`);
+    lines.push(`Target: ${report.scan_target}`);
+    lines.push(`Findings: ${report.summary.total}`);
+    lines.push(`CRITICAL: ${report.summary.by_severity.CRITICAL ?? 0}`);
+    lines.push(`HIGH: ${report.summary.by_severity.HIGH ?? 0}`);
+    lines.push(`MEDIUM: ${report.summary.by_severity.MEDIUM ?? 0}`);
+    lines.push(`LOW: ${report.summary.by_severity.LOW ?? 0}`);
+    lines.push(`INFO: ${report.summary.by_severity.INFO ?? 0}`);
+    lines.push("");
+    if (report.findings.length === 0) {
+        lines.push("No findings.");
+        return lines.join("\n");
+    }
+    for (const finding of report.findings) {
+        lines.push(`[${finding.severity}] ${toAbsoluteDisplayPath(report.scan_target, finding.file_path)}`);
+        lines.push(`  ${finding.description}`);
+        if (finding.incident_title) {
+            appendLabeledText(lines, "Incident", finding.incident_title);
+        }
+        if (finding.evidence && finding.evidence.length > 0) {
+            appendEvidence(lines, finding.evidence);
+        }
+        appendLabeledList(lines, "Observed", finding.observed ?? []);
+        if (finding.inference) {
+            appendLabeledText(lines, "Inference", finding.inference);
+        }
+        appendLabeledList(lines, "Not verified", finding.not_verified ?? []);
+        if (verbose) {
+            lines.push(`  Rule: ${finding.rule_id}`);
+            lines.push(`  Finding ID: ${finding.finding_id}`);
+            lines.push(`  Category: ${finding.category} | Layer: ${finding.layer} | Confidence: ${finding.confidence}`);
+            const formattedLocation = formatLocation(finding.location);
+            if (formattedLocation) {
+                lines.push(`  Location: ${formattedLocation}`);
+            }
+            if (finding.cve) {
+                lines.push(`  CVE: ${finding.cve}`);
+            }
+            lines.push(`  CWE: ${finding.cwe}`);
+            if (finding.owasp.length > 0) {
+                lines.push(`  OWASP: ${finding.owasp.join(", ")}`);
+            }
+            if (finding.remediation_actions.length > 0) {
+                lines.push(`  Remediation: ${finding.remediation_actions.join(", ")}`);
+            }
+        }
+        if (finding.layer === "L3" && finding.source_config) {
+            const fieldSuffix = finding.source_config.field ? ` (${finding.source_config.field})` : "";
+            lines.push(`  source config: ${finding.source_config.file_path}${fieldSuffix}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/runtime/signal-handlers.d.ts

@@ -0,0 +1,10 @@
+export interface SignalProcessLike {
+    on: (event: string, listener: () => void) => unknown;
+    off: (event: string, listener: () => void) => unknown;
+}
+export interface RegisterSignalHandlersOptions {
+    processLike?: SignalProcessLike;
+    signals?: Array<"SIGINT" | "SIGTERM">;
+    onSignal: (signal: "SIGINT" | "SIGTERM") => void;
+}
+export declare function registerSignalHandlers(options: RegisterSignalHandlersOptions): () => void;