bandit-cli 1.0.0

package/dist/cli/doctor.js

@@ -0,0 +1,231 @@
+import * as clack from "@clack/prompts";
+import chalk from "chalk";
+async function fetchWithTimeout(url, options = {}, timeoutMs = 4000) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, {
+            ...options,
+            signal: controller.signal,
+        });
+        clearTimeout(id);
+        return res;
+    }
+    catch (err) {
+        clearTimeout(id);
+        throw err;
+    }
+}
+export async function runDoctorCommand(targetUrl = "http://localhost:3000") {
+    clack.intro(chalk.bold.bgBlue.white(" Bandit Live Server Doctor "));
+    clack.log.info(`Target URL: ${chalk.bold.cyan(targetUrl)}`);
+    const s = clack.spinner();
+    s.start("Connecting to target server...");
+    let rootResponse;
+    try {
+        rootResponse = await fetchWithTimeout(targetUrl);
+        s.stop("Connection established.");
+    }
+    catch (err) {
+        s.stop("Connection failed.");
+        clack.log.error(`Could not connect to ${targetUrl}: ${err.message}`);
+        clack.log.info("Make sure your backend server is running locally and listening on the specified port.");
+        clack.outro(chalk.red("Execution stopped."));
+        return;
+    }
+    const reports = [];
+    // 1. Audit Security Headers
+    s.start("Auditing response headers...");
+    const headers = rootResponse.headers;
+    // X-Powered-By
+    const xPoweredBy = headers.get("x-powered-by");
+    if (xPoweredBy) {
+        reports.push({
+            title: "Information Disclosure (X-Powered-By)",
+            status: "warn",
+            details: `Leaks software stack info: ${xPoweredBy}`,
+            suggestion: "Disable X-Powered-By header (e.g. `app.disable('x-powered-by')` in Express or use Helmet).",
+        });
+    }
+    else {
+        reports.push({
+            title: "Information Disclosure (X-Powered-By)",
+            status: "pass",
+            details: "X-Powered-By header is hidden.",
+        });
+    }
+    // X-Frame-Options
+    const xFrameOptions = headers.get("x-frame-options");
+    if (!xFrameOptions || (!xFrameOptions.toLowerCase().includes("deny") && !xFrameOptions.toLowerCase().includes("sameorigin"))) {
+        reports.push({
+            title: "Clickjacking Protection (X-Frame-Options)",
+            status: "warn",
+            details: xFrameOptions ? `Weak policy: ${xFrameOptions}` : "Header missing",
+            suggestion: "Set X-Frame-Options to DENY or SAMEORIGIN.",
+        });
+    }
+    else {
+        reports.push({
+            title: "Clickjacking Protection (X-Frame-Options)",
+            status: "pass",
+            details: `Configured: ${xFrameOptions}`,
+        });
+    }
+    // X-Content-Type-Options
+    const xContentTypeOptions = headers.get("x-content-type-options");
+    if (!xContentTypeOptions || xContentTypeOptions.toLowerCase() !== "nosniff") {
+        reports.push({
+            title: "MIME-Sniffing Protection (X-Content-Type-Options)",
+            status: "warn",
+            details: xContentTypeOptions ? `Weak policy: ${xContentTypeOptions}` : "Header missing",
+            suggestion: "Set X-Content-Type-Options to 'nosniff'.",
+        });
+    }
+    else {
+        reports.push({
+            title: "MIME-Sniffing Protection (X-Content-Type-Options)",
+            status: "pass",
+            details: "Configured: nosniff",
+        });
+    }
+    // CORS Access-Control-Allow-Origin
+    const corsOrigin = headers.get("access-control-allow-origin");
+    if (corsOrigin === "*") {
+        reports.push({
+            title: "CORS Wildcard Check",
+            status: "warn",
+            details: "Access-Control-Allow-Origin is set to wildcard '*'",
+            suggestion: "For APIs processing cookies or credentials, restrict origin to specific domains.",
+        });
+    }
+    else {
+        reports.push({
+            title: "CORS Wildcard Check",
+            status: "pass",
+            details: corsOrigin ? `Restricted to: ${corsOrigin}` : "CORS header not present on root (standard behavior for non-CORS requests).",
+        });
+    }
+    s.stop("Response headers audited.");
+    // 2. Audit Error Stack Leakage
+    s.start("Checking for error stack trace leakage...");
+    const dummyUrl = `${targetUrl.replace(/\/$/, "")}/non-existent-bandit-route-${Math.floor(Math.random() * 100000)}`;
+    try {
+        const errorResponse = await fetchWithTimeout(dummyUrl);
+        const bodyText = await errorResponse.text();
+        const stackTraceIndicators = [
+            "at ",
+            "node_modules",
+            "Stack Trace",
+            "TypeError",
+            "ReferenceError",
+            "SyntaxError",
+            "InternalServerError",
+            "sqlite3",
+            "mongodb",
+            "postgresql",
+            "sequelize",
+            "prisma",
+        ];
+        const foundIndicators = stackTraceIndicators.filter((indicator) => bodyText.includes(indicator));
+        if (foundIndicators.length > 0) {
+            reports.push({
+                title: "Stack Trace Leakage Check",
+                status: "fail",
+                details: `Server leaked stack trace/debug indicators: [${foundIndicators.join(", ")}]`,
+                suggestion: "Ensure env is set to production or capture errors globally and hide stack traces from clients.",
+            });
+        }
+        else {
+            reports.push({
+                title: "Stack Trace Leakage Check",
+                status: "pass",
+                details: "No stack traces or internal details leaked in error response.",
+            });
+        }
+    }
+    catch (err) {
+        reports.push({
+            title: "Stack Trace Leakage Check",
+            status: "warn",
+            details: `Failed to probe error response: ${err.message}`,
+        });
+    }
+    s.stop("Error leakage probe complete.");
+    // 3. Oversized Payload Handling
+    s.start("Probing oversized payload response...");
+    try {
+        // 5MB payload
+        const largePayload = "A".repeat(5 * 1024 * 1024);
+        const postOptions = {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ data: largePayload }),
+        };
+        const payloadResponse = await fetchWithTimeout(targetUrl, postOptions, 5000);
+        if (payloadResponse.status === 413) {
+            reports.push({
+                title: "Oversized Payload Protection",
+                status: "pass",
+                details: "Server rejected oversized payload with 413 Payload Too Large.",
+            });
+        }
+        else if (payloadResponse.status >= 200 && payloadResponse.status < 300) {
+            reports.push({
+                title: "Oversized Payload Protection",
+                status: "warn",
+                details: `Server accepted a 5MB JSON payload (Status: ${payloadResponse.status})`,
+                suggestion: "Set a body limit on your parser (e.g. limit json parser to '1mb' or '100kb').",
+            });
+        }
+        else {
+            reports.push({
+                title: "Oversized Payload Protection",
+                status: "pass",
+                details: `Server responded with ${payloadResponse.status} ${payloadResponse.statusText}`,
+            });
+        }
+    }
+    catch (err) {
+        if (err.name === "AbortError") {
+            reports.push({
+                title: "Oversized Payload Protection",
+                status: "fail",
+                details: "Server timed out (>5s) or hung when processing a 5MB payload.",
+                suggestion: "Add payload size limits to parser middleware (e.g., body-parser) to prevent DoS.",
+            });
+        }
+        else {
+            reports.push({
+                title: "Oversized Payload Protection",
+                status: "warn",
+                details: `Connection closed / error during payload transfer: ${err.message}`,
+            });
+        }
+    }
+    s.stop("Oversized payload probe complete.");
+    // Print results
+    console.log("\n" + chalk.bold("Diagnostic Results:"));
+    for (const report of reports) {
+        let statusPrefix = "";
+        if (report.status === "pass") {
+            statusPrefix = chalk.green("✔ [PASS]");
+        }
+        else if (report.status === "warn") {
+            statusPrefix = chalk.yellow("⚠ [WARN]");
+        }
+        else {
+            statusPrefix = chalk.red("✖ [FAIL]");
+        }
+        console.log(`${statusPrefix} ${chalk.bold(report.title)}`);
+        if (report.details) {
+            console.log(chalk.gray(`   ↳ ${report.details}`));
+        }
+        if (report.status !== "pass" && report.suggestion) {
+            console.log(chalk.cyan(`   ↳ Suggestion: ${report.suggestion}`));
+        }
+        console.log("");
+    }
+    clack.outro(chalk.bold.green("Doctor diagnostic scan completed."));
+}

package/dist/cli/env.js

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+import * as clack from "@clack/prompts";
+import chalk from "chalk";
+function parseEnvContent(content) {
+    const map = new Map();
+    const lines = content.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const firstEqual = trimmed.indexOf("=");
+        if (firstEqual === -1)
+            continue;
+        const key = trimmed.slice(0, firstEqual).trim();
+        let val = trimmed.slice(firstEqual + 1).trim();
+        // Strip quotes if any
+        if ((val.startsWith('"') && val.endsWith('"')) ||
+            (val.startsWith("'") && val.endsWith("'"))) {
+            val = val.slice(1, -1);
+        }
+        map.set(key, val);
+    }
+    return map;
+}
+export async function runEnvCommand(projectPath = ".") {
+    clack.intro(chalk.bold.bgBlue.white(" Bandit Environment Auditor "));
+    const absoluteProjectPath = path.resolve(projectPath);
+    const examplePath = path.join(absoluteProjectPath, ".env.example");
+    if (!fs.existsSync(examplePath)) {
+        clack.log.warn(`No ${chalk.cyan(".env.example")} file found in the root of the project.`);
+        clack.log.info("Create a .env.example containing your environment variable keys as placeholders.");
+        clack.outro(chalk.red("Failed to audit environment variables."));
+        return;
+    }
+    let exampleKeysMap;
+    try {
+        const exampleContent = fs.readFileSync(examplePath, "utf-8");
+        exampleKeysMap = parseEnvContent(exampleContent);
+    }
+    catch (err) {
+        clack.log.error(`Failed to read .env.example: ${err.message}`);
+        clack.outro(chalk.red("Failed to audit environment variables."));
+        return;
+    }
+    const exampleKeys = Array.from(exampleKeysMap.keys());
+    clack.log.info(`Found ${chalk.bold.cyan(exampleKeys.length)} keys in .env.example`);
+    // Scan for active .env files
+    const files = fs.readdirSync(absoluteProjectPath);
+    const envFiles = files.filter((f) => f === ".env" || (f.startsWith(".env.") && !f.endsWith(".example")));
+    if (envFiles.length === 0) {
+        clack.log.warn("No active environment configuration files (like `.env`, `.env.local`, etc.) detected.");
+        clack.outro(chalk.yellow("Done."));
+        return;
+    }
+    for (const envFile of envFiles) {
+        const envFilePath = path.join(absoluteProjectPath, envFile);
+        clack.log.step(`Auditing ${chalk.bold.magenta(envFile)}...`);
+        try {
+            const content = fs.readFileSync(envFilePath, "utf-8");
+            const currentKeysMap = parseEnvContent(content);
+            const missingKeys = [];
+            const emptyKeys = [];
+            const extraKeys = [];
+            // Check for missing or empty keys
+            for (const expectedKey of exampleKeys) {
+                if (!currentKeysMap.has(expectedKey)) {
+                    missingKeys.push(expectedKey);
+                }
+                else {
+                    const val = currentKeysMap.get(expectedKey);
+                    if (val === "" || val === "your_key_here" || val === "placeholder" || val.includes("TODO")) {
+                        emptyKeys.push(expectedKey);
+                    }
+                }
+            }
+            // Check for extra keys (not defined in .env.example)
+            for (const currentKey of currentKeysMap.keys()) {
+                if (!exampleKeysMap.has(currentKey)) {
+                    extraKeys.push(currentKey);
+                }
+            }
+            // Output report for this file
+            if (missingKeys.length === 0 && emptyKeys.length === 0 && extraKeys.length === 0) {
+                clack.log.success(chalk.green(`  ✔ ${envFile} is perfectly in sync with .env.example!`));
+            }
+            else {
+                if (missingKeys.length > 0) {
+                    clack.log.error(`  ❌ Missing keys (required by .env.example):\n` +
+                        missingKeys.map((k) => `     - ${chalk.red(k)}`).join("\n"));
+                }
+                if (emptyKeys.length > 0) {
+                    clack.log.warn(`  ⚠ Placeholder/Empty values detected:\n` +
+                        emptyKeys.map((k) => `     - ${chalk.yellow(k)}`).join("\n"));
+                }
+                if (extraKeys.length > 0) {
+                    clack.log.info(`  ℹ Extra keys (not declared in .env.example):\n` +
+                        extraKeys.map((k) => `     - ${chalk.cyan(k)}`).join("\n"));
+                }
+            }
+        }
+        catch (err) {
+            clack.log.error(`  ❌ Failed to read ${envFile}: ${err.message}`);
+        }
+        console.log("");
+    }
+    clack.outro(chalk.bold.green("Environment audit finished."));
+}

package/dist/cli/output.js

@@ -0,0 +1,138 @@
+import chalk from "chalk";
+function icon(status) {
+    if (status === "pass")
+        return chalk.green("✔");
+    if (status === "fail")
+        return chalk.red("✖");
+    return chalk.gray("-");
+}
+function sevColor(sev, text) {
+    if (sev === "error")
+        return chalk.red(text);
+    if (sev === "warn")
+        return chalk.yellow(text);
+    return chalk.blue(text);
+}
+function sevLabel(sev) {
+    if (sev === "error")
+        return "ERROR";
+    if (sev === "warn")
+        return "WARN";
+    return "INFO";
+}
+function printSeparator() {
+    console.log(chalk.gray("─".repeat(80)));
+}
+function printItem(item) {
+    const statusIcon = icon(item.status);
+    const line = `${statusIcon} ${chalk.bold(item.title)}`;
+    console.log(line);
+    // Show details for pass/fail/skip
+    if (item.details) {
+        console.log(chalk.gray(`  ↳ ${item.details}`));
+    }
+    // Show suggestion only for failures
+    if (item.status === "fail" && item.suggestion) {
+        console.log(chalk.gray(`  ↳ Suggestion: ${item.suggestion}`));
+    }
+}
+function printSection(title, items, color) {
+    if (items.length === 0)
+        return;
+    console.log("");
+    console.log(color(chalk.bold(`● ${title}`)));
+    printSeparator();
+    for (const item of items) {
+        printItem(item);
+    }
+}
+export function printHuman(report) {
+    // Header
+    console.log("");
+    console.log(chalk.bold.blue(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`));
+    console.log(chalk.bold.white(`                           Backend Audit Report`));
+    console.log(chalk.bold.blue(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`));
+    console.log(chalk.gray(`Project: ${report.projectPath}`));
+    console.log(chalk.gray(`Summary: ${chalk.green(`pass=${report.summary.pass}`)} ${chalk.red(`fail=${report.summary.fail}`)} ${chalk.gray(`skip=${report.summary.skip}`)}`));
+    // Severity Legend
+    console.log("");
+    console.log(chalk.bold("Severity Legend:"));
+    console.log(chalk.red("  ● ERROR  ") +
+        chalk.gray("- Critical issues that must be fixed"));
+    console.log(chalk.yellow("  ● WARN   ") +
+        chalk.gray("- Important issues that should be addressed"));
+    console.log(chalk.blue("  ● INFO   ") +
+        chalk.gray("- Informational items or best practices"));
+    // Group items by status first
+    const passedItems = report.items.filter((item) => item.status === "pass");
+    const failedItems = report.items.filter((item) => item.status === "fail");
+    const skippedItems = report.items.filter((item) => item.status === "skip");
+    // Print PASSED section
+    if (passedItems.length > 0) {
+        console.log("");
+        console.log(chalk.bold.green(`✓ PASSED CHECKS (${passedItems.length})`));
+        printSeparator();
+        for (const item of passedItems) {
+            printItem(item);
+        }
+    }
+    // Print FAILED sections grouped by severity
+    if (failedItems.length > 0) {
+        console.log("");
+        console.log(chalk.bold.red(`✖ FAILED CHECKS (${failedItems.length})`));
+        printSeparator();
+        // Group failed items by severity
+        const failedErrors = failedItems.filter((item) => item.severity === "error");
+        const failedWarns = failedItems.filter((item) => item.severity === "warn");
+        const failedInfos = failedItems.filter((item) => item.severity === "info");
+        // Print failed ERRORS
+        if (failedErrors.length > 0) {
+            console.log("");
+            console.log(chalk.red(chalk.bold(`  ● ERRORS (${failedErrors.length})`)));
+            for (const item of failedErrors) {
+                console.log("");
+                printItem(item);
+            }
+        }
+        // Print failed WARNINGS
+        if (failedWarns.length > 0) {
+            console.log("");
+            console.log(chalk.yellow(chalk.bold(`  ● WARNINGS (${failedWarns.length})`)));
+            for (const item of failedWarns) {
+                console.log("");
+                printItem(item);
+            }
+        }
+        // Print failed INFO
+        if (failedInfos.length > 0) {
+            console.log("");
+            console.log(chalk.blue(chalk.bold(`  ● INFO (${failedInfos.length})`)));
+            for (const item of failedInfos) {
+                console.log("");
+                printItem(item);
+            }
+        }
+    }
+    // Print SKIPPED section (if any)
+    if (skippedItems.length > 0) {
+        console.log("");
+        console.log(chalk.bold.gray(`- SKIPPED CHECKS (${skippedItems.length})`));
+        printSeparator();
+        for (const item of skippedItems) {
+            printItem(item);
+        }
+    }
+    // Footer
+    console.log("");
+    console.log(chalk.bold.blue(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`));
+    // Summary message
+    const failCount = report.summary.fail;
+    if (failCount === 0) {
+        console.log(chalk.green.bold(`✓ All checks passed!`));
+    }
+    else {
+        console.log(chalk.yellow(`                         ⚠ ${failCount} check${failCount > 1 ? "s" : ""} need${failCount === 1 ? "s" : ""} attention.`));
+    }
+    console.log(chalk.bold.blue(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`));
+    console.log("");
+}

package/dist/cli/ports.js

@@ -0,0 +1,177 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import * as clack from "@clack/prompts";
+import chalk from "chalk";
+const execAsync = promisify(exec);
+// Windows helper: map PIDs to process names
+async function getWindowsProcessMap() {
+    const map = new Map();
+    try {
+        const { stdout } = await execAsync("tasklist /FO CSV /NH");
+        const lines = stdout.split("\n");
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            // CSV format: "Image Name","PID","Session Name","Session#","Mem Usage"
+            // e.g. "node.exe","22064","Console","1","53,284 K"
+            const parts = line.split(`","`).map((p) => p.replace(/"/g, "").trim());
+            if (parts.length >= 2) {
+                const name = parts[0];
+                const pid = parseInt(parts[1], 10);
+                if (!isNaN(pid)) {
+                    map.set(pid, name);
+                }
+            }
+        }
+    }
+    catch (err) {
+        // Ignore and return empty map
+    }
+    return map;
+}
+// Windows port scanner
+async function scanWindowsPorts() {
+    const processMap = await getWindowsProcessMap();
+    const list = [];
+    const seenKeys = new Set();
+    try {
+        // netstat -ano lists all connections and listening ports with PIDs
+        const { stdout } = await execAsync("netstat -ano");
+        const lines = stdout.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("TCP") && !trimmed.startsWith("UDP"))
+                continue;
+            // TCP    0.0.0.0:3000           0.0.0.0:0              LISTENING       12345
+            // Split by whitespace
+            const tokens = trimmed.split(/\s+/);
+            if (tokens.length < 5)
+                continue;
+            const state = tokens[3];
+            if (state !== "LISTENING")
+                continue;
+            const localAddress = tokens[1];
+            const pidStr = tokens[4];
+            const pid = parseInt(pidStr, 10);
+            if (isNaN(pid))
+                continue;
+            // Extract port from localAddress (e.g. 0.0.0.0:3000 or [::]:3000)
+            const lastColon = localAddress.lastIndexOf(":");
+            if (lastColon === -1)
+                continue;
+            const portStr = localAddress.slice(lastColon + 1);
+            const port = parseInt(portStr, 10);
+            if (isNaN(port))
+                continue;
+            const key = `${port}-${pid}`;
+            if (seenKeys.has(key))
+                continue;
+            seenKeys.add(key);
+            const name = processMap.get(pid) || "Unknown";
+            list.push({ port, pid, name });
+        }
+    }
+    catch (err) {
+        throw new Error(`Failed to scan Windows ports: ${err.message}`);
+    }
+    return list.sort((a, b) => a.port - b.port);
+}
+// Unix port scanner (Linux / macOS)
+async function scanUnixPorts() {
+    const list = [];
+    const seenKeys = new Set();
+    try {
+        // lsof -i -P -n -sTCP:LISTEN
+        const { stdout } = await execAsync("lsof -i -P -n -sTCP:LISTEN");
+        const lines = stdout.split("\n");
+        // Command headers: COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
+        // e.g. node      22064  user   22u  IPv6 0x...      0t0  TCP *:3000 (LISTEN)
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            const tokens = line.split(/\s+/);
+            if (tokens.length < 9)
+                continue;
+            const name = tokens[0];
+            const pid = parseInt(tokens[1], 10);
+            const nameCol = tokens[8]; // e.g. *:3000 or 127.0.0.1:3000 or [::1]:3000
+            const lastColon = nameCol.lastIndexOf(":");
+            if (lastColon === -1)
+                continue;
+            const portStr = nameCol.slice(lastColon + 1);
+            const port = parseInt(portStr, 10);
+            if (isNaN(pid) || isNaN(port))
+                continue;
+            const key = `${port}-${pid}`;
+            if (seenKeys.has(key))
+                continue;
+            seenKeys.add(key);
+            list.push({ port, pid, name });
+        }
+    }
+    catch (err) {
+        throw new Error(`Failed to scan Unix ports (make sure lsof is installed): ${err.message}`);
+    }
+    return list.sort((a, b) => a.port - b.port);
+}
+export async function runPortsCommand() {
+    clack.intro(chalk.bold.bgBlue.white(" Bandit Port Inspector "));
+    const isWin = process.platform === "win32";
+    const s = clack.spinner();
+    s.start("Scanning for active listening ports...");
+    let ports = [];
+    try {
+        ports = isWin ? await scanWindowsPorts() : await scanUnixPorts();
+        s.stop(`Scan complete. Found ${ports.length} listening process(es).`);
+    }
+    catch (err) {
+        s.stop("Scan failed.");
+        clack.log.error(err.message);
+        clack.outro(chalk.red("Execution stopped."));
+        return;
+    }
+    if (ports.length === 0) {
+        clack.log.info("No active local listening processes detected on common backend ports.");
+        clack.outro(chalk.green("Done."));
+        return;
+    }
+    const options = ports.map((p) => ({
+        value: p,
+        label: `Port ${chalk.bold.green(p.port)} ➜ PID ${p.pid} (${chalk.cyan(p.name)})`,
+    }));
+    const selected = (await clack.select({
+        message: "Select a process to inspect or terminate:",
+        options: [
+            ...options,
+            { value: "cancel", label: chalk.gray("Cancel / Exit") },
+        ],
+    }));
+    if (clack.isCancel(selected) || selected === "cancel") {
+        clack.outro("No action taken.");
+        return;
+    }
+    const confirmKill = await clack.confirm({
+        message: `Are you sure you want to terminate PID ${selected.pid} (${selected.name}) listening on Port ${selected.port}?`,
+    });
+    if (clack.isCancel(confirmKill) || !confirmKill) {
+        clack.outro("Aborted.");
+        return;
+    }
+    s.start(`Terminating process ${selected.name} (PID ${selected.pid})...`);
+    try {
+        if (isWin) {
+            await execAsync(`taskkill /F /PID ${selected.pid}`);
+        }
+        else {
+            await execAsync(`kill -9 ${selected.pid}`);
+        }
+        s.stop(`Process terminated successfully.`);
+        clack.outro(chalk.bold.green(`✔ Port ${selected.port} has been freed!`));
+    }
+    catch (err) {
+        s.stop(`Failed to terminate process.`);
+        clack.log.error(`Error details: ${err.message}`);
+        clack.outro(chalk.bold.red("❌ Process termination failed. You might need administrative/root privileges."));
+    }
+}

package/dist/core/auditor.js

@@ -0,0 +1,32 @@
+// File: src/core/auditor.ts
+import { makeContext } from "./context.js";
+import { rules } from "../rules/index.js";
+export async function runAudit(projectPath) {
+    const ctx = makeContext(projectPath);
+    const items = [];
+    for (const rule of rules) {
+        try {
+            const result = await rule.run(ctx);
+            items.push(result);
+        }
+        catch (err) {
+            items.push({
+                id: rule.id,
+                title: rule.title,
+                severity: rule.severity,
+                status: "fail",
+                details: `Rule crashed: ${err?.message ?? String(err)}`,
+                suggestion: "Fix the rule implementation.",
+            });
+        }
+    }
+    const summary = items.reduce((acc, item) => {
+        acc[item.status] += 1;
+        return acc;
+    }, { pass: 0, fail: 0, skip: 0 });
+    return {
+        projectPath,
+        summary,
+        items,
+    };
+}