defense-mcp-server 0.6.0

package/build/core/tool-wrapper.d.ts

@@ -0,0 +1,73 @@
+/**
+ * tool-wrapper.ts — Middleware that intercepts `server.tool()` registrations
+ * to inject pre-flight validation before tool handlers execute.
+ *
+ * This is the critical integration piece of the pre-flight validation system.
+ * It creates a {@link Proxy} around {@link McpServer} that wraps every tool
+ * handler with pre-flight checks while remaining transparent to the 29
+ * existing tool registration files.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { createPreflightServer } from './core/tool-wrapper.js';
+ *
+ * const rawServer = new McpServer({ name: '...', version: '...' });
+ * const server = createPreflightServer(rawServer);
+ *
+ * registerFirewallTools(server);      // tools register on the proxy
+ * await rawServer.connect(transport); // connect uses the real server
+ * ```
+ *
+ * @module tool-wrapper
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/** Options for the pre-flight wrapper. */
+export interface WrapperOptions {
+    /** Additional tool names to bypass pre-flight. */
+    additionalBypass?: string[];
+    /**
+     * Enable/disable pre-flight globally.
+     * @default `true` (unless `KALI_DEFENSE_PREFLIGHT=false`)
+     */
+    enabled?: boolean;
+    /**
+     * Prepend status banners to successful responses that have warnings
+     * or auto-installed dependencies.
+     * @default `true` (unless `KALI_DEFENSE_PREFLIGHT_BANNERS=false`)
+     */
+    prependBanners?: boolean;
+}
+/**
+ * Create a proxied {@link McpServer} that wraps every `.tool()` registration
+ * with pre-flight validation.
+ *
+ * The proxy intercepts only the `tool` property; all other methods and
+ * properties pass through to the underlying server unchanged.  Tool handlers
+ * registered through the proxy will:
+ *
+ * 1. Check if the tool is in the bypass list (sudo management tools)
+ * 2. Run the {@link PreflightEngine} pipeline (dependencies + privileges)
+ * 3. If pre-flight **fails**, return an actionable MCP error without calling
+ *    the original handler
+ * 4. If pre-flight **passes with warnings**, optionally prepend a status
+ *    banner to the tool's response
+ * 5. If pre-flight **passes cleanly**, call the original handler directly
+ *
+ * @param server  The original `McpServer` instance
+ * @param options Configuration overrides
+ * @returns A proxied `McpServer` — callers don't need to change their types
+ */
+export declare function createPreflightServer(server: McpServer, options?: WrapperOptions): McpServer;
+/**
+ * Invalidate all pre-flight caches.
+ *
+ * Call this after events that change the system state, such as:
+ * - `sudo_elevate` (privilege level changed)
+ * - `sudo_drop` (privilege level changed)
+ * - Successful dependency installation
+ *
+ * Typically called from `sudo-management.ts` tool handlers.
+ */
+export declare function invalidatePreflightCaches(): void;
+//# sourceMappingURL=tool-wrapper.d.ts.map

package/build/core/tool-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-wrapper.d.ts","sourceRoot":"","sources":["../../src/core/tool-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAwBzE,0CAA0C;AAC1C,MAAM,WAAW,cAAc;IAC7B,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAeD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,EACjB,OAAO,GAAE,cAAmB,GAC3B,SAAS,CAkDX;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD"}

package/build/core/tool-wrapper.js

@@ -0,0 +1,296 @@
+/**
+ * tool-wrapper.ts — Middleware that intercepts `server.tool()` registrations
+ * to inject pre-flight validation before tool handlers execute.
+ *
+ * This is the critical integration piece of the pre-flight validation system.
+ * It creates a {@link Proxy} around {@link McpServer} that wraps every tool
+ * handler with pre-flight checks while remaining transparent to the 29
+ * existing tool registration files.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { createPreflightServer } from './core/tool-wrapper.js';
+ *
+ * const rawServer = new McpServer({ name: '...', version: '...' });
+ * const server = createPreflightServer(rawServer);
+ *
+ * registerFirewallTools(server);      // tools register on the proxy
+ * await rawServer.connect(transport); // connect uses the real server
+ * ```
+ *
+ * @module tool-wrapper
+ */
+import { PreflightEngine } from "./preflight.js";
+import { ToolRegistry } from "./tool-registry.js";
+import { PrivilegeManager } from "./privilege-manager.js";
+import { SudoGuard } from "./sudo-guard.js";
+import { RateLimiter } from "./rate-limiter.js";
+// ── Constants ────────────────────────────────────────────────────────────────
+/**
+ * Tools that always skip pre-flight because they manage the sudo session
+ * itself.  These are checked before manifest lookup for reliability.
+ */
+const DEFAULT_BYPASS_TOOLS = new Set([
+    "sudo_elevate",
+    "sudo_elevate_gui",
+    "sudo_status",
+    "sudo_drop",
+    "sudo_extend",
+    "preflight_batch_check",
+]);
+// ── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Create a proxied {@link McpServer} that wraps every `.tool()` registration
+ * with pre-flight validation.
+ *
+ * The proxy intercepts only the `tool` property; all other methods and
+ * properties pass through to the underlying server unchanged.  Tool handlers
+ * registered through the proxy will:
+ *
+ * 1. Check if the tool is in the bypass list (sudo management tools)
+ * 2. Run the {@link PreflightEngine} pipeline (dependencies + privileges)
+ * 3. If pre-flight **fails**, return an actionable MCP error without calling
+ *    the original handler
+ * 4. If pre-flight **passes with warnings**, optionally prepend a status
+ *    banner to the tool's response
+ * 5. If pre-flight **passes cleanly**, call the original handler directly
+ *
+ * @param server  The original `McpServer` instance
+ * @param options Configuration overrides
+ * @returns A proxied `McpServer` — callers don't need to change their types
+ */
+export function createPreflightServer(server, options = {}) {
+    const { enabled = process.env.KALI_DEFENSE_PREFLIGHT !== "false", prependBanners = process.env.KALI_DEFENSE_PREFLIGHT_BANNERS !== "false", additionalBypass = [], } = options;
+    // Short-circuit: if disabled globally, return the raw server untouched
+    if (!enabled) {
+        console.error("[preflight] Pre-flight validation DISABLED (KALI_DEFENSE_PREFLIGHT=false)");
+        return server;
+    }
+    const bypassSet = new Set([
+        ...DEFAULT_BYPASS_TOOLS,
+        ...additionalBypass,
+    ]);
+    // Eagerly initialise singletons so they're ready when tools register
+    const preflightEngine = PreflightEngine.instance();
+    const registry = ToolRegistry.instance();
+    // CICD-024: Rate limiter — configurable via env vars
+    const rateLimiter = RateLimiter.instance();
+    const ctx = {
+        enabled,
+        prependBanners,
+        bypassSet,
+        preflightEngine,
+        registry,
+        rateLimiter,
+    };
+    console.error("[preflight] Pre-flight validation enabled — wrapping server.tool()");
+    // The Proxy intercepts property access on the server.  Only the `tool`
+    // property is replaced; everything else (connect, resource, prompt, …)
+    // passes through via Reflect.get.
+    return new Proxy(server, {
+        get(target, prop, receiver) {
+            if (prop === "tool") {
+                return createWrappedToolMethod(target, ctx);
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+/**
+ * Invalidate all pre-flight caches.
+ *
+ * Call this after events that change the system state, such as:
+ * - `sudo_elevate` (privilege level changed)
+ * - `sudo_drop` (privilege level changed)
+ * - Successful dependency installation
+ *
+ * Typically called from `sudo-management.ts` tool handlers.
+ */
+export function invalidatePreflightCaches() {
+    PreflightEngine.instance().clearCache();
+    PrivilegeManager.instance().clearCache();
+}
+// ── Internals ────────────────────────────────────────────────────────────────
+/**
+ * Create a replacement `.tool()` method that wraps handlers with pre-flight.
+ *
+ * The MCP SDK `McpServer.tool()` has 6 overloads with 2–6 arguments.
+ * In **all** overloads:
+ *   - The **first** argument is always the tool name (`string`)
+ *   - The **last** argument is always the handler (`Function`)
+ *
+ * This invariant lets us handle every overload uniformly:
+ *   1. Read `args[0]` as the tool name
+ *   2. Read `args[args.length - 1]` as the original handler
+ *   3. Replace the handler with a pre-flight-wrapped version
+ *   4. Forward all args to the real `server.tool()`
+ */
+function createWrappedToolMethod(server, ctx) {
+    // Bind to preserve `this` context on the real McpServer
+    const originalTool = server.tool.bind(server);
+    return (...args) => {
+        // Sanity: need at least (name, handler)
+        if (args.length < 2) {
+            return originalTool(...args);
+        }
+        const toolName = args[0];
+        // ── Bypass check ─────────────────────────────────────────────────
+        if (shouldBypassPreflight(toolName, ctx)) {
+            return originalTool(...args);
+        }
+        // ── Wrap the handler ─────────────────────────────────────────────
+        const originalHandler = args[args.length - 1];
+        const wrappedHandler = createWrappedHandler(toolName, originalHandler, ctx);
+        // Reconstruct args with the wrapped handler in the last position
+        const wrappedArgs = [...args];
+        wrappedArgs[wrappedArgs.length - 1] = wrappedHandler;
+        return originalTool(...wrappedArgs);
+    };
+}
+/**
+ * Create a wrapped handler that runs pre-flight before the original handler.
+ *
+ * **Error safety**: if the pre-flight engine itself throws an unexpected
+ * error, we log to stderr and fall through to the original handler.
+ * Pre-flight failures must **never** prevent a tool from running when
+ * pre-flight is broken — only when pre-flight correctly identifies a
+ * blocking issue (missing binary, missing sudo session, etc.).
+ *
+ * **Sudo elevation prompts**: When a tool fails due to missing privileges
+ * (either at pre-flight or at runtime), the wrapper returns a structured
+ * elevation prompt via {@link SudoGuard} instead of a generic error.
+ * This ensures the AI client always knows to ask the user for their
+ * password and call `sudo_elevate`.
+ */
+function createWrappedHandler(toolName, originalHandler, ctx) {
+    return async (...callbackArgs) => {
+        // Extract params from callback args for safeguard checks.
+        // MCP SDK tool handler signature: (params, extra) — params is always first.
+        const toolParams = callbackArgs.length > 0 &&
+            callbackArgs[0] != null &&
+            typeof callbackArgs[0] === "object" &&
+            !Array.isArray(callbackArgs[0])
+            ? callbackArgs[0]
+            : undefined;
+        // ── CICD-024: Rate limit check ─────────────────────────────────────
+        const rateLimitResult = ctx.rateLimiter.check(toolName);
+        if (!rateLimitResult.allowed) {
+            console.error(`[rate-limiter] Tool '${toolName}' rejected: ${rateLimitResult.reason}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `⚠ Rate limit exceeded\n\n${rateLimitResult.reason}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // ── Run pre-flight with error safety ─────────────────────────────
+        try {
+            const result = await ctx.preflightEngine.runPreflight(toolName, toolParams);
+            if (!result.passed) {
+                // ── Check if failure is sudo-related → return elevation prompt ──
+                const hasSudoIssue = result.privileges.issues.some((i) => i.type === "sudo-required" ||
+                    i.type === "sudo-unavailable" ||
+                    i.type === "session-expired");
+                if (hasSudoIssue) {
+                    // Extract the sudo reason from the manifest or the first issue
+                    const manifest = ctx.registry.getManifest(toolName);
+                    const reason = manifest?.sudoReason ??
+                        result.privileges.issues[0]?.description;
+                    console.error(`[sudo-guard] Tool '${toolName}' requires elevation — returning prompt`);
+                    return SudoGuard.createElevationPrompt(toolName, reason, ctx.preflightEngine.formatSummary(result));
+                }
+                // Non-sudo failure — return the standard pre-flight error
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: ctx.preflightEngine.formatSummary(result),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Pre-flight PASSED — call the original handler
+            const toolResult = (await originalHandler(...callbackArgs));
+            // ── Post-execution: Check for runtime permission errors ────────
+            // This catches `conditional` sudo tools and edge cases where
+            // pre-flight passed but the command still failed due to permissions.
+            if (toolResult &&
+                SudoGuard.isResponsePermissionError(toolResult)) {
+                const manifest = ctx.registry.getManifest(toolName);
+                const reason = manifest?.sudoReason ??
+                    "The command failed due to insufficient privileges at runtime.";
+                const originalText = SudoGuard.extractResponseText(toolResult);
+                console.error(`[sudo-guard] Runtime permission error detected for '${toolName}' — returning elevation prompt`);
+                return SudoGuard.createElevationPrompt(toolName, reason, originalText);
+            }
+            // Optionally prepend a status banner when there are notable items
+            // (warnings about optional deps, auto-installed binaries, etc.)
+            if (ctx.prependBanners &&
+                hasNotableInfo(result) &&
+                toolResult?.content &&
+                Array.isArray(toolResult.content)) {
+                const statusMsg = ctx.preflightEngine.formatStatusMessage(result);
+                if (statusMsg) {
+                    return {
+                        ...toolResult,
+                        content: [
+                            { type: "text", text: statusMsg },
+                            ...toolResult.content,
+                        ],
+                    };
+                }
+            }
+            return toolResult;
+        }
+        catch (err) {
+            // Pre-flight itself threw — log and fall through to original handler
+            console.error(`[preflight] ⚠ Pre-flight failed unexpectedly for '${toolName}': ${err instanceof Error ? err.message : String(err)}`);
+            const toolResult = (await originalHandler(...callbackArgs));
+            // Even when pre-flight is broken, still check for runtime permission errors
+            if (toolResult &&
+                SudoGuard.isResponsePermissionError(toolResult)) {
+                const manifest = ctx.registry.getManifest(toolName);
+                const reason = manifest?.sudoReason ??
+                    "The command failed due to insufficient privileges.";
+                const originalText = SudoGuard.extractResponseText(toolResult);
+                console.error(`[sudo-guard] Runtime permission error detected for '${toolName}' (post-preflight-failure) — returning elevation prompt`);
+                return SudoGuard.createElevationPrompt(toolName, reason, originalText);
+            }
+            return toolResult;
+        }
+    };
+}
+/**
+ * Determine whether a tool should bypass pre-flight entirely.
+ *
+ * A tool bypasses pre-flight if:
+ * 1. It's in the static {@link DEFAULT_BYPASS_TOOLS} set, OR
+ * 2. Its manifest in the {@link ToolRegistry} has the `bypass-preflight` tag
+ */
+function shouldBypassPreflight(toolName, ctx) {
+    // Fast-path: static bypass set
+    if (ctx.bypassSet.has(toolName))
+        return true;
+    // Check manifest tags (secondary defence — covers tools registered
+    // in the registry with the tag but not in the static set)
+    const manifest = ctx.registry.getManifest(toolName);
+    if (manifest?.tags?.includes("bypass-preflight"))
+        return true;
+    return false;
+}
+/**
+ * Check whether a passing {@link PreflightResult} has information worth
+ * prepending to the tool output (warnings or auto-installed dependencies).
+ *
+ * When the result is clean (no warnings, no installs), returns `false`
+ * so the tool's output is returned unmodified.
+ */
+function hasNotableInfo(result) {
+    return (result.warnings.length > 0 ||
+        result.dependencies.installed.length > 0);
+}

package/build/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/build/index.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createRequire } from "node:module";
+// ── Dynamic version from package.json ────────────────────────────────────────
+const require = createRequire(import.meta.url);
+const { version: VERSION } = require("../package.json");
+// ── Core: Dependency validation & distro detection ───────────────────────────
+import { validateAllDependencies, formatValidationReport, } from "./core/dependency-validator.js";
+import { getConfig } from "./core/config.js";
+import { getDistroAdapter } from "./core/distro-adapter.js";
+import { initializeAllowlist, verifyAllBinaries } from "./core/command-allowlist.js";
+import { hardenDirPermissions } from "./core/secure-fs.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// ── Core: Pre-flight validation system ───────────────────────────────────────
+import { createPreflightServer } from './core/tool-wrapper.js';
+import { initializeRegistry } from './core/tool-registry.js';
+// ── Core: Lifecycle management ───────────────────────────────────────────────
+import { SudoSession } from "./core/sudo-session.js";
+import { logChange, createChangeEntry } from "./core/changelog.js";
+// ── Original tool modules ────────────────────────────────────────────────────
+import { registerFirewallTools } from "./tools/firewall.js";
+import { registerHardeningTools } from "./tools/hardening.js";
+import { registerIdsTools } from "./tools/ids.js";
+import { registerLoggingTools } from "./tools/logging.js";
+import { registerNetworkDefenseTools } from "./tools/network-defense.js";
+import { registerComplianceTools } from "./tools/compliance.js";
+import { registerMalwareTools } from "./tools/malware.js";
+import { registerBackupTools } from "./tools/backup.js";
+import { registerAccessControlTools } from "./tools/access-control.js";
+import { registerEncryptionTools } from "./tools/encryption.js";
+import { registerContainerSecurityTools } from "./tools/container-security.js";
+import { registerMetaTools } from "./tools/meta.js";
+import { registerPatchManagementTools } from "./tools/patch-management.js";
+import { registerSecretsTools } from "./tools/secrets.js";
+import { registerIncidentResponseTools } from "./tools/incident-response.js";
+// ── Sudo privilege management ────────────────────────────────────────────────
+import { registerSudoManagementTools } from "./tools/sudo-management.js";
+// ── New tool modules ─────────────────────────────────────────────────────────
+import { registerSupplyChainSecurityTools } from "./tools/supply-chain-security.js";
+import { registerDriftDetectionTools } from "./tools/drift-detection.js";
+import { registerZeroTrustNetworkTools } from "./tools/zero-trust-network.js";
+import { registerEbpfSecurityTools } from "./tools/ebpf-security.js";
+import { registerAppHardeningTools } from "./tools/app-hardening.js";
+// ── v0.6.0 tool modules ─────────────────────────────────────────────────────
+import { registerReportingTools } from "./tools/reporting.js";
+import { registerDnsSecurityTools } from "./tools/dns-security.js";
+import { registerVulnerabilityManagementTools } from "./tools/vulnerability-management.js";
+import { registerProcessSecurityTools } from "./tools/process-security.js";
+import { registerWafTools } from "./tools/waf.js";
+import { registerThreatIntelTools } from "./tools/threat-intel.js";
+import { registerCloudSecurityTools } from "./tools/cloud-security.js";
+import { registerApiSecurityTools } from "./tools/api-security.js";
+import { registerDeceptionTools } from "./tools/deception.js";
+import { registerWirelessSecurityTools } from "./tools/wireless-security.js";
+import { registerSiemIntegrationTools } from "./tools/siem-integration.js";
+// ── Graceful shutdown handler ────────────────────────────────────────────────
+function gracefulShutdown(signal) {
+    console.error(`\n[shutdown] Received ${signal} — cleaning up...`);
+    try {
+        // 1. Zero the sudo password buffer
+        const session = SudoSession.getInstance();
+        if (session.isElevated()) {
+            session.drop();
+            console.error("[shutdown] Sudo session dropped, password zeroed");
+        }
+    }
+    catch { /* ignore if not initialized */ }
+    try {
+        // 2. Log the shutdown to changelog
+        logChange(createChangeEntry({
+            tool: "server",
+            action: `Server shutdown via ${signal}`,
+            target: "server",
+            before: "running",
+            after: "stopped",
+            dryRun: false,
+            success: true,
+        }));
+    }
+    catch { /* ignore if changelog unavailable */ }
+    console.error("[shutdown] Cleanup complete, exiting");
+    process.exit(0);
+}
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+// SECURITY (CORE-020): uncaughtException/unhandledRejection handlers must use
+// only synchronous operations. Async operations (file writes, network, cleanup)
+// are NOT guaranteed to complete after an uncaught exception. Async cleanup is
+// handled by SIGTERM/SIGINT handlers above.
+process.on("uncaughtException", (err) => {
+    console.error(`[fatal] Uncaught exception: ${err.message}`);
+    console.error(err.stack);
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error(`[fatal] Unhandled rejection: ${reason}`);
+    process.exit(1);
+});
+// ── Main entry point ─────────────────────────────────────────────────────────
+async function main() {
+    const server = new McpServer({
+        name: "defense-mcp-server",
+        version: VERSION,
+    });
+    // ── Phase 1: Dependency Validation & Auto-Install ────────────────────────
+    //
+    // Before registering tools, validate that all required system binaries
+    // are present. If KALI_DEFENSE_AUTO_INSTALL=true, missing tools will be
+    // automatically installed via the system package manager.
+    //
+    const config = getConfig();
+    console.error(`Defense MCP Server v${VERSION} starting...`);
+    console.error(`[startup] Auto-install: ${config.autoInstall ? "ENABLED" : "DISABLED"} | ` +
+        `Dry-run: ${config.dryRun ? "YES" : "NO"}`);
+    // ── Phase 0a: Initialize command allowlist ────────────────────────────────
+    // Must run before any command execution (dependency validation, tool registration).
+    // Resolves allowlisted binary names to absolute paths on this system.
+    initializeAllowlist();
+    // ── Phase 0b: Harden existing state directories ──────────────────────────
+    // Fix permissions on any state files/dirs created before this security fix.
+    // Best-effort: silently skips if directories don't exist yet.
+    try {
+        const stateDir = join(homedir(), ".kali-defense");
+        hardenDirPermissions(stateDir);
+        // Also harden the backups subdirectory if it exists
+        hardenDirPermissions(join(stateDir, "backups"));
+    }
+    catch {
+        // Non-fatal — directories may not exist yet
+    }
+    // ── Phase 0c: Run independent async startup tasks in parallel ─────────────
+    // verifyAllBinaries(), getDistroAdapter(), and validateAllDependencies()
+    // are independent of each other — run them concurrently for faster startup.
+    const [binaryVerifyResult, distroResult, depValidationResult] = await Promise.allSettled([
+        verifyAllBinaries(),
+        getDistroAdapter(),
+        validateAllDependencies(),
+    ]);
+    // Log binary integrity results
+    if (binaryVerifyResult.status === "rejected") {
+        console.error(`[startup] ⚠️  Binary integrity verification failed (non-fatal): ${binaryVerifyResult.reason instanceof Error ? binaryVerifyResult.reason.message : String(binaryVerifyResult.reason)}`);
+    }
+    // Log distro detection results
+    if (distroResult.status === "fulfilled") {
+        console.error(`[startup] 🐧 ${distroResult.value.summary}`);
+    }
+    else {
+        console.error(`[startup] ⚠️  Distro detection failed: ${distroResult.reason instanceof Error ? distroResult.reason.message : String(distroResult.reason)}`);
+        console.error("[startup] Continuing with defaults...");
+    }
+    // Log dependency validation results
+    if (depValidationResult.status === "fulfilled") {
+        const report = depValidationResult.value;
+        console.error(formatValidationReport(report));
+        if (report.criticalMissing.length > 0 && !config.autoInstall) {
+            console.error("[startup] ⚠️  Some critical tools are missing. The server will start, " +
+                "but affected tools may fail at runtime.");
+            console.error("[startup] 💡 To auto-install: set KALI_DEFENSE_AUTO_INSTALL=true");
+        }
+        if (report.installed.length > 0) {
+            console.error(`[startup] ✅ Auto-installed ${report.installed.length} missing tools: ` +
+                report.installed.join(", "));
+        }
+    }
+    else {
+        console.error(`[startup] ⚠️  Dependency validation failed: ${depValidationResult.reason instanceof Error ? depValidationResult.reason.message : String(depValidationResult.reason)}`);
+        console.error("[startup] Continuing with server startup...");
+    }
+    // ── Phase 0.5: Initialize pre-flight validation system ───────────────────
+    console.error('[startup] Initializing pre-flight validation system...');
+    try {
+        const registry = initializeRegistry();
+        console.error(`[startup] Pre-flight registry initialized with ${registry.getAll().length} tool manifests`);
+    }
+    catch (err) {
+        console.error(`[startup] Pre-flight registry initialization failed (non-fatal): ${err}`);
+    }
+    // Wrap server with pre-flight middleware
+    const wrappedServer = createPreflightServer(server);
+    // ── Phase 2: Register all defensive tool modules (with error isolation) ──
+    let registered = 0;
+    let failed = 0;
+    const failedModules = [];
+    function safeRegister(name, fn) {
+        try {
+            fn(wrappedServer);
+            registered++;
+        }
+        catch (err) {
+            failed++;
+            failedModules.push(name);
+            console.error(`[startup] ⚠ Failed to register ${name} tools: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    // Sudo privilege management (must be registered first — prerequisite for other tools)
+    safeRegister("sudo-management", registerSudoManagementTools);
+    // Original tool modules
+    safeRegister("firewall", registerFirewallTools);
+    safeRegister("hardening", registerHardeningTools);
+    safeRegister("ids", registerIdsTools);
+    safeRegister("logging", registerLoggingTools);
+    safeRegister("network-defense", registerNetworkDefenseTools);
+    safeRegister("compliance", registerComplianceTools);
+    safeRegister("malware", registerMalwareTools);
+    safeRegister("backup", registerBackupTools);
+    safeRegister("access-control", registerAccessControlTools);
+    safeRegister("encryption", registerEncryptionTools);
+    safeRegister("container-security", registerContainerSecurityTools);
+    safeRegister("meta", registerMetaTools);
+    safeRegister("patch-management", registerPatchManagementTools);
+    safeRegister("secrets", registerSecretsTools);
+    safeRegister("incident-response", registerIncidentResponseTools);
+    // New tool modules
+    safeRegister("supply-chain-security", registerSupplyChainSecurityTools);
+    safeRegister("drift-detection", registerDriftDetectionTools);
+    safeRegister("zero-trust-network", registerZeroTrustNetworkTools);
+    safeRegister("ebpf-security", registerEbpfSecurityTools);
+    safeRegister("app-hardening", registerAppHardeningTools);
+    // v0.6.0 tool modules
+    safeRegister("api-security", registerApiSecurityTools);
+    safeRegister("cloud-security", registerCloudSecurityTools);
+    safeRegister("deception", registerDeceptionTools);
+    safeRegister("dns-security", registerDnsSecurityTools);
+    safeRegister("process-security", registerProcessSecurityTools);
+    safeRegister("reporting", registerReportingTools);
+    safeRegister("siem-integration", registerSiemIntegrationTools);
+    safeRegister("threat-intel", registerThreatIntelTools);
+    safeRegister("vulnerability-management", registerVulnerabilityManagementTools);
+    safeRegister("waf", registerWafTools);
+    safeRegister("wireless-security", registerWirelessSecurityTools);
+    // Fail hard if no modules loaded at all
+    if (registered === 0) {
+        throw new Error("No tool modules loaded — server cannot start");
+    }
+    // ── Phase 3: Connect transport ───────────────────────────────────────────
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`Defense MCP Server v${VERSION} running on stdio`);
+    console.error(`Registered ${registered} of ${registered + failed} tool modules with ~94 defensive security tools${failed > 0 ? ` (${failed} failed: ${failedModules.join(", ")})` : ""}`);
+    console.error("[startup] 💡 Use sudo_elevate to provide your password once for all privileged operations");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/build/tools/access-control.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Access control and authentication auditing tools for Kali Defense MCP Server.
+ *
+ * Registers 6 tools: access_ssh, access_pam, access_sudo_audit,
+ * access_user_audit, access_password_policy, access_restrict_shell.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerAccessControlTools(server: McpServer): void;
+//# sourceMappingURL=access-control.d.ts.map

package/build/tools/access-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access-control.d.ts","sourceRoot":"","sources":["../../src/tools/access-control.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA2LpE,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA44DlE"}