defense-mcp-server 0.7.2 → 0.7.3

package/build/core/command-allowlist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-allowlist.d.ts","sourceRoot":"","sources":["../../src/core/command-allowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAeH,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+EAA+E;IAC/E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,sDAAsD;AACtD,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AA8WD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAkD1C;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAsDtD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CActD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB,CA6CA;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAE7E;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;GAEG;AACH,wBAAgB,gCAAgC,IAAI,OAAO,CAE1D;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEjE;AA8CD;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAE9E;AAeD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,eAAe,CAAC,EAAE,MAAM,GACvB,wBAAwB,CA6G1B;AAiHD;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,wBAAwB,EAAE,CAAC,CA6C7E"}
+{"version":3,"file":"command-allowlist.d.ts","sourceRoot":"","sources":["../../src/core/command-allowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAeH,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+EAA+E;IAC/E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,sDAAsD;AACtD,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AA+WD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAkD1C;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAsDtD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CActD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB,CA6CA;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAE7E;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;GAEG;AACH,wBAAgB,gCAAgC,IAAI,OAAO,CAE1D;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEjE;AA8CD;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAE9E;AAeD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,eAAe,CAAC,EAAE,MAAM,GACvB,wBAAwB,CA6G1B;AAiHD;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,wBAAwB,EAAE,CAAC,CA6C7E"}

package/build/core/command-allowlist.js

@@ -241,6 +241,7 @@ const ALLOWLIST_DEFINITIONS = [
     // ── GUI askpass helpers (sudo-management.ts) ───────────────────────────
     { binary: "zenity", candidates: ["/usr/bin/zenity"] },
     { binary: "kdialog", candidates: ["/usr/bin/kdialog"] },
+    { binary: "setsid", candidates: ["/usr/bin/setsid", "/usr/sbin/setsid"] },
     { binary: "ksshaskpass", candidates: ["/usr/bin/ksshaskpass"] },
     { binary: "lxqt-sudo", candidates: ["/usr/bin/lxqt-sudo"] },
     // ── DNS security ───────────────────────────────────────────────────────

package/build/core/distro-adapter.js

@@ -396,7 +396,7 @@ function buildFirewallPersistenceConfig(distro) {
             return {
                 packageName: "iptables-persistent",
                 checkInstalledCmd: ["dpkg", "-l", "iptables-persistent"],
-                installCmd: ["DEBIAN_FRONTEND=noninteractive", "apt-get", "install", "-y", "iptables-persistent"],
+                installCmd: ["apt-get", "install", "-y", "iptables-persistent"],
                 serviceName: "netfilter-persistent",
                 enableCmd: ["systemctl", "enable", "netfilter-persistent"],
                 saveCmd: ["netfilter-persistent", "save"],

package/build/core/sudo-guard.js

@@ -135,12 +135,12 @@ export class SudoGuard {
                 if (nopasswdPattern.test(content)) {
                     logger.security("sudo-guard", "nopasswd_detected", "SECURITY CRITICAL: NOPASSWD:ALL detected in sudoers configuration. " +
                         "Authentication via sudo_elevate is NON-FUNCTIONAL — any password will be accepted. " +
-                        "Remove NOPASSWD from the sudoers file and set a real password for mcpuser. " +
+                        "Remove NOPASSWD from the sudoers file and set a real password for the user. " +
                         "See docs/SUDO-SESSION-DESIGN.md for remediation steps.", {
                         severity: "CRITICAL",
                         location: filePath,
-                        remediation: "Rebuild the Docker image with the updated Dockerfile that uses " +
-                            "etc/sudoers.d/mcpuser (scoped allowlist, no NOPASSWD).",
+                        remediation: "Update the sudoers configuration to use a scoped allowlist " +
+                            "with no NOPASSWD. See docs/SUDO-SESSION-DESIGN.md for details.",
                     });
                     return { nopasswdDetected: true, location: filePath };
                 }

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

@@ -1 +1 @@
-{"version":3,"file":"tool-dependencies.d.ts","sourceRoot":"","sources":["../../src/core/tool-dependencies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIvE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAaD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,GACb,eAAe,GAAG,SAAS,CAE7B;AAID;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,EAuL7C,CAAC;AAUF;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,GACf,cAAc,GAAG,SAAS,CAE5B;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAQjD;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAiB3E;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,cAAc,EAAE,CAE1D"}
+{"version":3,"file":"tool-dependencies.d.ts","sourceRoot":"","sources":["../../src/core/tool-dependencies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIvE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAaD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,GACb,eAAe,GAAG,SAAS,CAE7B;AAID;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,EAwL7C,CAAC;AAUF;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,GACf,cAAc,GAAG,SAAS,CAE5B;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAQjD;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAiB3E;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,cAAc,EAAE,CAE1D"}

package/build/core/tool-dependencies.js

@@ -57,7 +57,8 @@ export const TOOL_DEPENDENCIES = [
     // ── Access Control (1) ────────────────────────────────────────────────────
     {
         toolName: "access_control",
-        requiredBinaries: ["ssh", "sshd", "pam-auth-update"],
+        requiredBinaries: ["pam-auth-update"],
+        optionalBinaries: ["ssh", "sshd"],
         critical: true,
     },
     // ── Compliance (1) ────────────────────────────────────────────────────────

package/build/index.js

@@ -187,7 +187,7 @@ async function main() {
         if (nopasswdCheck.nopasswdDetected) {
             console.error(`[startup] ⚠️  SECURITY CRITICAL: NOPASSWD:ALL detected in sudoers ` +
                 `(${nopasswdCheck.location}). sudo_elevate credential validation is NON-FUNCTIONAL. ` +
-                `Rebuild the Docker image with the updated Dockerfile.`);
+                `Remove the NOPASSWD entry from sudoers and set a real password for the MCP user.`);
         }
         else {
             console.error('[startup] ✅ Sudoers check: NOPASSWD:ALL not detected — credential validation active');

package/build/tools/container-security.d.ts

@@ -9,5 +9,6 @@
  *     namespace_check, seccomp_profile, rootless_setup)
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const DESKTOP_BREAKING_PROFILES: Set<string>;
 export declare function registerContainerSecurityTools(server: McpServer): void;
 //# sourceMappingURL=container-security.d.ts.map

package/build/tools/container-security.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"container-security.d.ts","sourceRoot":"","sources":["../../src/tools/container-security.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAsBpE,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAosBtE"}
+{"version":3,"file":"container-security.d.ts","sourceRoot":"","sources":["../../src/tools/container-security.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAwBpE,eAAO,MAAM,yBAAyB,aAyBpC,CAAC;AAIH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAuvBtE"}

package/build/tools/container-security.js

@@ -20,6 +20,36 @@ import { resolve } from "node:path";
 import { secureWriteFileSync } from "../core/secure-fs.js";
 // ── TOOL-011 remediation: safe directory for seccomp profiles ──────────────
 const SECCOMP_PROFILE_DIR = "/tmp/defense-mcp/seccomp";
+// ── AppArmor profiles known to break desktop applications ─────────────────
+// These profiles ship in apparmor-profiles-extra and use ABI 4.0 default-deny
+// with only `userns` granted. In enforce mode they block shared library loading
+// for flatpak, chromium, and other GUI apps via the dynamic linker.
+export const DESKTOP_BREAKING_PROFILES = new Set([
+    "flatpak",
+    "chromium",
+    "unprivileged_userns",
+    "chrome",
+    "brave",
+    "Discord",
+    "element-desktop",
+    "firefox",
+    "signal-desktop",
+    "slack",
+    "vivaldi-bin",
+    "opera",
+    "msedge",
+    "obsidian",
+    "steam",
+    "code",
+    "epiphany",
+    "github-desktop",
+    "polypane",
+    "qutebrowser",
+    // Container runtimes — same ABI 4.0 default-deny issue breaks Docker
+    "runc",
+    "crun",
+    "rootlesskit",
+]);
 // ── Registration entry point ───────────────────────────────────────────────
 export function registerContainerSecurityTools(server) {
     // ── 1. container_docker (audit + bench + seccomp + daemon + image_scan) ─
@@ -449,11 +479,17 @@ export function registerContainerSecurityTools(server) {
                 try {
                     const sections = ["🛡️ AppArmor System Status", "=".repeat(40)];
                     const enabledResult = await executeCommand({ command: "aa-enabled", args: [], toolName: "container_isolation", timeout: 5000 });
-                    const aaEnabled = enabledResult.exitCode === 0 && enabledResult.stdout.trim() === "Yes";
-                    sections.push(`\n  AppArmor enabled: ${aaEnabled ? "✅ Yes" : "❌ No"}`);
+                    const aaEnabledBin = enabledResult.exitCode === 0 && enabledResult.stdout.trim() === "Yes";
                     const moduleResult = await executeCommand({ command: "cat", args: ["/sys/module/apparmor/parameters/enabled"], toolName: "container_isolation", timeout: 5000 });
+                    const kernelModuleLoaded = moduleResult.exitCode === 0 && moduleResult.stdout.trim() === "Y";
+                    // Also check if apparmor service is active and profiles directory is populated
+                    const svcResult = await executeCommand({ command: "systemctl", args: ["is-active", "apparmor"], toolName: "container_isolation", timeout: 5000 });
+                    const svcActive = svcResult.exitCode === 0 && svcResult.stdout.trim() === "active";
+                    // AppArmor is considered enabled if aa-enabled says "Yes", OR if kernel module is loaded AND service is active
+                    const aaEnabled = aaEnabledBin || (kernelModuleLoaded && svcActive);
+                    sections.push(`\n  AppArmor enabled: ${aaEnabled ? "✅ Yes" : "❌ No"}`);
                     if (moduleResult.exitCode === 0)
-                        sections.push(`  Kernel module: ${moduleResult.stdout.trim() === "Y" ? "✅ Loaded" : "❌ Not loaded"}`);
+                        sections.push(`  Kernel module: ${kernelModuleLoaded ? "✅ Loaded" : "❌ Not loaded"}`);
                     const pkgChecks = ["apparmor-profiles", "apparmor-profiles-extra", "apparmor-utils"];
                     sections.push("\n  Profile Packages:");
                     for (const pkg of pkgChecks) {
@@ -517,14 +553,25 @@ export function registerContainerSecurityTools(server) {
                     const baseAction = action.replace("apparmor_", "");
                     const cmdMap = { enforce: "aa-enforce", complain: "aa-complain", disable: "aa-disable" };
                     const cmd = cmdMap[baseAction];
+                    // Extract just the profile name from a potential path
+                    const profileBaseName = profile.replace(/.*\//, "");
+                    const isDesktopProfile = DESKTOP_BREAKING_PROFILES.has(profileBaseName);
+                    // SAFETY: Warn when enforcing profiles known to break desktop apps
+                    const desktopWarning = (baseAction === "enforce" && isDesktopProfile)
+                        ? `\n\n⚠️ WARNING: Profile '${profileBaseName}' is known to break desktop applications ` +
+                            `(flatpak, browsers, GUI apps) when enforced.\n` +
+                            `These profiles use ABI 4.0 default-deny and block shared library loading.\n` +
+                            `This may prevent Chromium, Firefox, Flatpak apps, and similar from launching.\n` +
+                            `Consider using complain mode instead, or test thoroughly before enforcing.`
+                        : "";
                     if (dry_run ?? getConfig().dryRun) {
-                        return { content: [createTextContent(`[DRY RUN] Would set profile '${profile}' to ${baseAction} mode.\n  Command: sudo ${cmd} ${profile}`)] };
+                        return { content: [createTextContent(`[DRY RUN] Would set profile '${profile}' to ${baseAction} mode.\n  Command: sudo ${cmd} ${profile}${desktopWarning}`)] };
                     }
                     const result = await executeCommand({ command: "sudo", args: [cmd, profile], toolName: "container_isolation", timeout: getToolTimeout("container_apparmor_manage") });
                     if (result.exitCode !== 0)
                         return { content: [createErrorContent(`Failed to ${baseAction} profile '${profile}': ${result.stderr}`)], isError: true };
-                    logChange(createChangeEntry({ tool: "container_isolation", action: baseAction, target: profile, after: `${baseAction} mode`, dryRun: false, success: true, rollbackCommand: baseAction === "disable" ? `sudo aa-enforce ${profile}` : undefined }));
-                    return { content: [createTextContent(`✅ Profile '${profile}' set to ${baseAction} mode.\n${result.stdout || result.stderr}`)] };
+                    logChange(createChangeEntry({ tool: "container_isolation", action: baseAction, target: profile, after: `${baseAction} mode`, dryRun: false, success: true, rollbackCommand: baseAction === "disable" ? `sudo aa-enforce ${profile}` : baseAction === "enforce" ? `sudo aa-complain ${profile}` : undefined }));
+                    return { content: [createTextContent(`✅ Profile '${profile}' set to ${baseAction} mode.\n${result.stdout || result.stderr}${desktopWarning}`)] };
                 }
                 catch (err) {
                     return { content: [createErrorContent(err instanceof Error ? err.message : String(err))], isError: true };
@@ -537,13 +584,39 @@ export function registerContainerSecurityTools(server) {
                     const isDryRun = dry_run ?? getConfig().dryRun;
                     const packages = ["apparmor-profiles", "apparmor-profiles-extra"];
                     if (isDryRun) {
-                        return { content: [createTextContent(`[DRY RUN] Would install: ${packages.join(", ")}\n  Command: sudo apt-get install -y ${packages.join(" ")}`)] };
+                        return { content: [createTextContent(`[DRY RUN] Would install: ${packages.join(", ")}\n` +
+                                    `  Command: sudo apt-get install -y ${packages.join(" ")}\n\n` +
+                                    `⚠️ After installation, the following profiles will be set to COMPLAIN mode\n` +
+                                    `to prevent breaking desktop applications (flatpak, browsers, etc.):\n` +
+                                    `  ${[...DESKTOP_BREAKING_PROFILES].join(", ")}\n\n` +
+                                    `Use apparmor_enforce to selectively enforce profiles after testing.`)] };
                     }
                     const installResult = await executeCommand({ command: "sudo", args: ["apt-get", "install", "-y", ...packages], toolName: "container_isolation", timeout: 120000 });
                     if (installResult.exitCode !== 0)
                         return { content: [createErrorContent(`Failed to install: ${installResult.stderr}`)], isError: true };
-                    logChange(createChangeEntry({ tool: "container_isolation", action: "install_profiles", target: packages.join(", "), after: "installed", dryRun: false, success: true, rollbackCommand: `sudo apt-get remove -y ${packages.join(" ")}` }));
-                    return { content: [createTextContent(`✅ Successfully installed: ${packages.join(", ")}`)] };
+                    // SAFETY: Set desktop-breaking profiles to complain mode to prevent
+                    // breaking flatpak, chromium, and other GUI applications.
+                    // These profiles use ABI 4.0 default-deny with only `userns` granted,
+                    // which blocks the dynamic linker from loading shared libraries.
+                    const complainResults = [];
+                    for (const profileName of DESKTOP_BREAKING_PROFILES) {
+                        const profilePath = `/etc/apparmor.d/${profileName}`;
+                        const checkResult = await executeCommand({ command: "test", args: ["-f", profilePath], toolName: "container_isolation", timeout: 5000 });
+                        if (checkResult.exitCode === 0) {
+                            const complainResult = await executeCommand({ command: "sudo", args: ["aa-complain", profilePath], toolName: "container_isolation", timeout: 10000 });
+                            if (complainResult.exitCode === 0) {
+                                complainResults.push(`  ✓ ${profileName} → complain mode`);
+                            }
+                            else {
+                                complainResults.push(`  ✗ ${profileName} → failed: ${complainResult.stderr.trim()}`);
+                            }
+                        }
+                    }
+                    const complainSection = complainResults.length > 0
+                        ? `\n\n⚠️ Desktop-safe profiles set to complain mode (prevents breaking GUI apps):\n${complainResults.join("\n")}\n\nUse apparmor_enforce to selectively enforce profiles after testing.`
+                        : "";
+                    logChange(createChangeEntry({ tool: "container_isolation", action: "install_profiles", target: packages.join(", "), after: `installed; ${complainResults.length} profiles set to complain`, dryRun: false, success: true, rollbackCommand: `sudo apt-get remove -y ${packages.join(" ")}` }));
+                    return { content: [createTextContent(`✅ Successfully installed: ${packages.join(", ")}${complainSection}`)] };
                 }
                 catch (err) {
                     return { content: [createErrorContent(err instanceof Error ? err.message : String(err))], isError: true };

package/build/tools/firewall.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firewall.d.ts","sourceRoot":"","sources":["../../src/tools/firewall.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA6EpE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA8+C7D"}
+{"version":3,"file":"firewall.d.ts","sourceRoot":"","sources":["../../src/tools/firewall.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA6EpE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAigD7D"}

package/build/tools/firewall.js

@@ -1315,14 +1315,36 @@ export function registerFirewallTools(server) {
                         const ruleCount = (output.match(/^[A-Z]+\s/gm) || []).length;
                         findings.push({ check: "iptables_rule_count", status: ruleCount > 0 ? "INFO" : "WARN", value: String(ruleCount), description: "Total iptables rules" });
                     }
-                    // Check UFW status
-                    const ufwResult = await executeCommand({ command: "sudo", args: ["ufw", "status"], timeout: 10000, toolName: "firewall" });
-                    if (ufwResult.exitCode === 0) {
-                        const active = ufwResult.stdout.includes("Status: active");
-                        findings.push({ check: "ufw_active", status: active ? "PASS" : "FAIL", value: active ? "active" : "inactive", description: "UFW firewall status" });
+                    // Check UFW status — distinguish "not installed" from "command failed"
+                    const ufwWhich = await executeCommand({ command: "which", args: ["ufw"], timeout: 5000, toolName: "firewall" });
+                    if (ufwWhich.exitCode === 0) {
+                        // UFW binary exists — try to get status
+                        const ufwResult = await executeCommand({ command: "sudo", args: ["ufw", "status"], timeout: 10000, toolName: "firewall" });
+                        if (ufwResult.exitCode === 0) {
+                            const active = ufwResult.stdout.includes("Status: active");
+                            findings.push({ check: "ufw_active", status: active ? "PASS" : "FAIL", value: active ? "active" : "inactive", description: "UFW firewall status" });
+                        }
+                        else {
+                            // UFW exists but status command failed — check nftables for UFW chains as fallback
+                            const nftFallback = await executeCommand({ command: "sudo", args: ["nft", "list", "ruleset"], timeout: 10000, toolName: "firewall" });
+                            const hasUfwChains = nftFallback.exitCode === 0 && nftFallback.stdout.includes("ufw-");
+                            if (hasUfwChains) {
+                                findings.push({ check: "ufw_active", status: "PASS", value: "active (nftables backend)", description: "UFW firewall status (detected via nftables ruleset)" });
+                            }
+                            else {
+                                findings.push({ check: "ufw_active", status: "WARN", value: "installed but status check failed", description: "UFW installed but 'ufw status' failed — may need sudo or service restart" });
+                            }
+                        }
                     }
                     else {
-                        findings.push({ check: "ufw_installed", status: "FAIL", value: "not installed", description: "UFW firewall availability" });
+                        // UFW binary not found — check if nftables has rules directly
+                        const nftDirect = await executeCommand({ command: "sudo", args: ["nft", "list", "ruleset"], timeout: 10000, toolName: "firewall" });
+                        if (nftDirect.exitCode === 0 && nftDirect.stdout.trim().length > 50) {
+                            findings.push({ check: "nftables_active", status: "PASS", value: "active (nftables native)", description: "Firewall active via nftables (no UFW)" });
+                        }
+                        else {
+                            findings.push({ check: "ufw_installed", status: "FAIL", value: "not installed", description: "No firewall detected (UFW not found, nftables empty)" });
+                        }
                     }
                     // Check ip6tables
                     const ip6Result = await executeCommand({ command: "sudo", args: ["ip6tables", "-L", "-n"], timeout: 10000, toolName: "firewall" });

package/build/tools/hardening.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hardening.d.ts","sourceRoot":"","sources":["../../src/tools/hardening.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAqTpE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAwiF9D"}
+{"version":3,"file":"hardening.d.ts","sourceRoot":"","sources":["../../src/tools/hardening.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA+TpE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAwiF9D"}

package/build/tools/hardening.js

@@ -11,6 +11,7 @@ import { createTextContent, createErrorContent, parseSysctlOutput, parseSystemct
 import { logChange, createChangeEntry, backupFile, } from "../core/changelog.js";
 import { validateServiceName, sanitizeArgs, validateSysctlKey, } from "../core/sanitizer.js";
 import { SafeguardRegistry } from "../core/safeguards.js";
+import { SudoSession } from "../core/sudo-session.js";
 import { readFileSync, existsSync } from "node:fs";
 import { execSync } from "node:child_process";
 import { spawnSafe } from "../core/spawn-safe.js";
@@ -26,7 +27,16 @@ function checkPrivileges() {
     if (typeof process.getuid === "function" && process.getuid() === 0) {
         return { ok: true };
     }
-    // Check if sudo is available and the user has passwordless sudo
+    // Check if MCP sudo session is elevated (sudo -S with cached password)
+    try {
+        if (SudoSession.getInstance().isElevated()) {
+            return { ok: true };
+        }
+    }
+    catch {
+        // SudoSession not available — fall through to sudo -n check
+    }
+    // Fallback: Check if sudo is available without password (NOPASSWD)
     try {
         execSync("sudo -n true 2>/dev/null", { timeout: 3000, stdio: "ignore" });
         return { ok: true };
@@ -34,8 +44,8 @@ function checkPrivileges() {
     catch {
         return {
             ok: false,
-            message: "Insufficient privileges. This operation requires root access or sudo. " +
-                "Run this tool as root or ensure sudo is available without a password prompt.",
+            message: "Insufficient privileges. This operation requires root access or an active sudo session. " +
+                "Use sudo_session action=elevate_gui to authenticate first.",
         };
     }
 }

package/build/tools/meta.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/tools/meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAq5BpE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAm/BzD"}
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/tools/meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAq5BpE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAohCzD"}

package/build/tools/meta.js

@@ -1123,12 +1123,46 @@ export function registerMetaTools(server) {
                     const kernelScore = assessableKernelCount > 0 ? Math.round((kernelPassed / assessableKernelCount) * 100) : -1;
                     domains.push({ domain: "kernel-hardening", score: kernelScore, maxScore: 100, checks: kernelResults.map((r) => ({ name: r.name, passed: r.passed, detail: r.detail })) });
                     const fwChecks = [];
-                    const iptResult = await executeCommand({ command: "iptables", args: ["-L", "-n"], timeout: 10000 });
-                    const hasRules = iptResult.exitCode === 0 && iptResult.stdout.split("\n").length > 8;
-                    fwChecks.push({ name: "iptables rules present", passed: hasRules, detail: `${iptResult.stdout.split("\n").length} lines` });
-                    const ufwResult = await executeCommand({ command: "ufw", args: ["status"], timeout: 5000 });
-                    const ufwActive = ufwResult.exitCode === 0 && ufwResult.stdout.includes("active");
-                    fwChecks.push({ name: "UFW active", passed: ufwActive, detail: ufwResult.stdout.slice(0, 100) });
+                    // Check iptables/nftables rules (with sudo for accurate results)
+                    const iptResult = await executeCommand({ command: "sudo", args: ["iptables", "-L", "-n"], timeout: 10000 });
+                    const hasIptRules = iptResult.exitCode === 0 && iptResult.stdout.split("\n").length > 8;
+                    fwChecks.push({ name: "iptables rules present", passed: hasIptRules, detail: `${iptResult.exitCode === 0 ? iptResult.stdout.split("\n").length : 0} lines` });
+                    // Multi-layer firewall detection: UFW → nftables fallback
+                    let fwDetected = false;
+                    const ufwResult = await executeCommand({ command: "sudo", args: ["ufw", "status"], timeout: 5000 });
+                    if (ufwResult.exitCode === 0) {
+                        const ufwActive = ufwResult.stdout.includes("active");
+                        fwChecks.push({ name: "UFW active", passed: ufwActive, detail: ufwResult.stdout.slice(0, 100) });
+                        fwDetected = ufwActive;
+                    }
+                    else {
+                        // UFW command failed — check if nftables has active rules (UFW chains or native)
+                        const nftResult = await executeCommand({ command: "sudo", args: ["nft", "list", "ruleset"], timeout: 10000 });
+                        if (nftResult.exitCode === 0) {
+                            const hasUfwChains = nftResult.stdout.includes("ufw-");
+                            const hasNftRules = nftResult.stdout.trim().length > 50;
+                            if (hasUfwChains) {
+                                fwChecks.push({ name: "UFW active", passed: true, detail: "Active via nftables backend (ufw chains detected)" });
+                                fwDetected = true;
+                            }
+                            else if (hasNftRules) {
+                                fwChecks.push({ name: "nftables active", passed: true, detail: "Native nftables ruleset loaded" });
+                                fwDetected = true;
+                            }
+                            else {
+                                fwChecks.push({ name: "UFW active", passed: false, detail: "No firewall rules detected" });
+                            }
+                        }
+                        else {
+                            // Check if binary exists to distinguish "not installed" from "error"
+                            const whichUfw = await executeCommand({ command: "which", args: ["ufw"], timeout: 3000 });
+                            const whichNft = await executeCommand({ command: "which", args: ["nft"], timeout: 3000 });
+                            const detail = whichUfw.exitCode === 0 ? "UFW installed but status check failed"
+                                : whichNft.exitCode === 0 ? "nftables installed but ruleset check failed"
+                                    : "No firewall installed";
+                            fwChecks.push({ name: "firewall detected", passed: false, detail });
+                        }
+                    }
                     const fwPassed = fwChecks.filter((c) => c.passed).length;
                     domains.push({ domain: "firewall", score: Math.round((fwPassed / fwChecks.length) * 100), maxScore: 100, checks: fwChecks });
                     const dangerousServices = ["telnet.socket", "rsh.socket", "rlogin.socket", "tftp.socket", "xinetd.service"];
@@ -1141,10 +1175,10 @@ export function registerMetaTools(server) {
                     const svcPassed = svcChecks.filter((c) => c.passed).length;
                     domains.push({ domain: "services", score: Math.round((svcPassed / svcChecks.length) * 100), maxScore: 100, checks: svcChecks });
                     const userChecks = [];
-                    const rootLogin = await executeCommand({ command: "passwd", args: ["-S", "root"], timeout: 5000 });
+                    const rootLogin = await executeCommand({ command: "sudo", args: ["passwd", "-S", "root"], timeout: 5000, toolName: "defense_mgmt" });
                     const rootLocked = rootLogin.stdout.includes(" L ") || rootLogin.stdout.includes(" LK ");
                     userChecks.push({ name: "Root account locked", passed: rootLocked, detail: rootLogin.stdout.trim().slice(0, 100) });
-                    const noPasswd = await executeCommand({ command: "awk", args: ["-F:", '($2 == "" ) { print $1 }', "/etc/shadow"], timeout: 5000 });
+                    const noPasswd = await executeCommand({ command: "sudo", args: ["awk", "-F:", '($2 == "" ) { print $1 }', "/etc/shadow"], timeout: 5000, toolName: "defense_mgmt" });
                     const noEmptyPasswd = noPasswd.stdout.trim().length === 0;
                     userChecks.push({ name: "No empty passwords", passed: noEmptyPasswd, detail: noPasswd.stdout.trim() || "none" });
                     const uidZero = await executeCommand({ command: "awk", args: ["-F:", '($3 == 0) { print $1 }', "/etc/passwd"], timeout: 5000 });

package/build/tools/sudo-management.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sudo-management.d.ts","sourceRoot":"","sources":["../../src/tools/sudo-management.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAepE,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAitBnE"}
+{"version":3,"file":"sudo-management.d.ts","sourceRoot":"","sources":["../../src/tools/sudo-management.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAgBpE,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAirBnE"}

package/build/tools/sudo-management.js

@@ -16,6 +16,7 @@ import { z } from "zod";
 import { spawnSafe } from "../core/spawn-safe.js";
 import { SudoSession } from "../core/sudo-session.js";
 import { getConfig } from "../core/config.js";
+import { resolveCommand } from "../core/command-allowlist.js";
 import { createTextContent, createErrorContent, } from "../core/parsers.js";
 import { invalidatePreflightCaches } from '../core/tool-wrapper.js';
 import { PreflightEngine } from '../core/preflight.js';
@@ -129,7 +130,7 @@ export function registerSudoManagementTools(server) {
                             `  Auth method: password (sudo -S)`,
                         ];
                         if (isHeadless) {
-                            lines.push(`  Environment: headless container (no display server)`);
+                            lines.push(`  Environment: headless (no display server)`);
                         }
                         lines.push(``);
                         lines.push(`All tools that require sudo will now work automatically.`);
@@ -156,10 +157,8 @@ export function registerSudoManagementTools(server) {
                         ? `Rate limit reached — locked out until ${rlAfter.resetAt ? new Date(rlAfter.resetAt).toLocaleTimeString() : "unknown"}.`
                         : `Attempts remaining before lockout: ${rlAfter.attemptsRemaining}`;
                     const passwordSource = isHeadless
-                        ? `\n\nNote: Running in headless container. The mcpuser password is set at\n` +
-                            `container startup via:\n` +
-                            `  • Docker secret: mcpuser-password (recommended)\n` +
-                            `  • Environment variable: MCPUSER_PASSWORD (less secure)`
+                        ? `\n\nNote: Running in a headless environment (no display server).\n` +
+                            `Use sudo_session action=elevate with your system password.`
                         : "";
                     return {
                         content: [
@@ -184,39 +183,17 @@ export function registerSudoManagementTools(server) {
             }
             // ── elevate_gui ────────────────────────────────────────────────────
             //
-            // Secure two-phase elevation flow:
-            //   Phase 1: LLM launches zenity via execute_command, password goes to temp file
-            //            (password NEVER appears in terminal output or LLM context)
-            //   Phase 2: LLM calls this action which reads file → elevates → securely wipes
+            // Single-step secure GUI elevation:
+            //   1. Detect graphical session environment (even if MCP server lacks DISPLAY)
+            //   2. Spawn a native password dialog (zenity/kdialog/ssh-askpass)
+            //   3. Capture password via secure temp file (never visible to AI)
+            //   4. Elevate and wipe the password
             //
             // The password is NEVER visible to the LLM at any point.
             case "elevate_gui": {
                 const { timeout_minutes } = params;
                 try {
-                    // ── Phase 4: Headless environment detection ───────────────────────
-                    // GUI dialogs (zenity, kdialog, ssh-askpass) require a display server.
-                    // In headless Docker containers, none of these are available.
-                    const hasDisplay = Boolean(process.env.DISPLAY) || Boolean(process.env.WAYLAND_DISPLAY);
-                    if (!hasDisplay) {
-                        return {
-                            content: [
-                                createErrorContent(`❌ GUI elevation is not available in headless environments.\n\n` +
-                                    `The Defense MCP Server is running in a Docker container without\n` +
-                                    `a display server (no DISPLAY or WAYLAND_DISPLAY is set).\n` +
-                                    `Use sudo_session action=elevate instead:\n\n` +
-                                    `  Action: elevate\n` +
-                                    `  Parameter: password = <your sudo password>\n\n` +
-                                    `The mcpuser password is set at container startup via:\n` +
-                                    `  • Docker secret (recommended): docker run --secret mcpuser-password ...\n` +
-                                    `  • Environment variable (less secure): docker run -e MCPUSER_PASSWORD='...' ...`),
-                            ],
-                            isError: true,
-                        };
-                    }
-                    const fs = await import("node:fs");
-                    const crypto = await import("node:crypto");
                     const session = SudoSession.getInstance();
-                    const SUDO_PW_FILE = "/tmp/.defense-sudo-pw";
                     // Check if already elevated
                     if (session.isElevated()) {
                         const status = session.getStatus();
@@ -229,117 +206,102 @@ export function registerSudoManagementTools(server) {
                             ],
                         };
                     }
-                    // Check if the password file exists (Phase 2 of the two-phase flow)
-                    if (fs.existsSync(SUDO_PW_FILE)) {
-                        console.error("[sudo-gui] Phase 2: Reading password from secure temp file...");
-                        // Verify file ownership and permissions for safety
-                        const stat = fs.statSync(SUDO_PW_FILE);
-                        const mode = (stat.mode & 0o777).toString(8);
-                        if (mode !== "600") {
-                            // Wipe insecure file
-                            try {
-                                const size = stat.size || 64;
-                                fs.writeFileSync(SUDO_PW_FILE, crypto.randomBytes(size));
-                                fs.unlinkSync(SUDO_PW_FILE);
-                            }
-                            catch {
-                                console.error("[sudo-gui] Failed to wipe insecure password file");
-                            }
-                            return {
-                                content: [
-                                    createErrorContent(`❌ Security error: Password file has insecure permissions (${mode}).\n` +
-                                        `Expected 600. File has been securely wiped.\n` +
-                                        `Please run the zenity command again.`),
-                                ],
-                                isError: true,
-                            };
-                        }
-                        // Read password from file
-                        let password;
-                        try {
-                            password = fs.readFileSync(SUDO_PW_FILE, "utf-8").trim();
-                        }
-                        catch (err) {
-                            return {
-                                content: [
-                                    createErrorContent(`❌ Could not read password file: ${err instanceof Error ? err.message : String(err)}`),
-                                ],
-                                isError: true,
-                            };
-                        }
-                        // Securely wipe the file IMMEDIATELY (before elevation attempt)
-                        try {
-                            const fileSize = Buffer.byteLength(password, "utf-8") + 16;
-                            fs.writeFileSync(SUDO_PW_FILE, crypto.randomBytes(fileSize));
-                            fs.writeFileSync(SUDO_PW_FILE, crypto.randomBytes(fileSize)); // Double overwrite
-                            fs.unlinkSync(SUDO_PW_FILE);
-                            console.error("[sudo-gui] Password file securely wiped (2x random overwrite + unlink)");
-                        }
-                        catch {
-                            try {
-                                fs.unlinkSync(SUDO_PW_FILE);
-                            }
-                            catch {
-                                console.error("[sudo-gui] Failed to unlink password file during wipe fallback");
-                            }
-                        }
-                        if (!password || password.length === 0) {
-                            return {
-                                content: [
-                                    createErrorContent(`❌ Empty password file. Please run the zenity command again and enter your password.`),
-                                ],
-                                isError: true,
-                            };
-                        }
-                        // Elevate using the captured password
-                        const timeoutMs = timeout_minutes * 60 * 1000;
-                        const config = getConfig();
-                        if (config.sudoSessionTimeout) {
-                            session.setDefaultTimeout(config.sudoSessionTimeout);
-                        }
-                        const result = await session.elevate(password, timeoutMs);
-                        if (result.success) {
-                            invalidatePreflightCaches();
-                            const status = session.getStatus();
-                            return {
-                                content: [
-                                    createTextContent(`🔓 Privileges elevated successfully!\n\n` +
-                                        `  User: ${status.username}\n` +
-                                        `  Expires: ${status.expiresAt ?? "never (running as root)"}\n` +
-                                        `  Timeout: ${timeout_minutes} minutes\n` +
-                                        `  Method: Secure GUI dialog (password never visible to AI)\n\n` +
-                                        `All tools that require sudo will now work automatically.\n` +
-                                        `Use sudo_session action=status to check session state, or sudo_session action=drop to end early.`),
-                                ],
-                            };
-                        }
+                    // ── Pre-flight rate-limit check ──────────────────────────────────
+                    const rlStatus = session.getRateLimitStatus();
+                    if (rlStatus.limited) {
+                        const resetAt = rlStatus.resetAt
+                            ? new Date(rlStatus.resetAt).toLocaleTimeString()
+                            : "unknown";
                         return {
                             content: [
-                                createErrorContent(`❌ Elevation failed: ${result.error}\n\n` +
-                                    `The password file was securely wiped. Please try again.`),
+                                createErrorContent(`❌ Authentication rate limit exceeded.\n\n` +
+                                    `Too many failed attempts. Please wait until ${resetAt} before retrying.`),
                             ],
                             isError: true,
                         };
                     }
-                    // Phase 1: No password file found — instruct the LLM to launch the GUI dialog
-                    // Detect which GUI tool is available for the instruction
+                    // ── Detect graphical session ──────────────────────────────────────
+                    // The MCP server process may not inherit DISPLAY/WAYLAND_DISPLAY,
+                    // so we probe the user's desktop session processes via /proc.
+                    const sessionEnv = await getGraphicalSessionEnv();
+                    const hasDisplay = Boolean(sessionEnv.DISPLAY) || Boolean(sessionEnv.WAYLAND_DISPLAY);
+                    if (!hasDisplay) {
+                        return {
+                            content: [
+                                createErrorContent(`❌ GUI elevation is not available — no graphical session detected.\n\n` +
+                                    `Could not find DISPLAY or WAYLAND_DISPLAY in the current process\n` +
+                                    `or any desktop session process (gnome-shell, plasmashell, etc.).\n\n` +
+                                    `Use sudo_session action=elevate with your password instead.`),
+                            ],
+                            isError: true,
+                        };
+                    }
+                    // ── Detect available GUI dialog tool ─────────────────────────────
                     const guiTool = await detectGuiPasswordTool();
-                    const toolCmd = guiTool
-                        ? `${guiTool.command} ${guiTool.args.map(a => `'${a}'`).join(" ")}`
-                        : "zenity --password --title='Defense — Sudo Authentication' --width=400";
+                    if (!guiTool) {
+                        return {
+                            content: [
+                                createErrorContent(`❌ No GUI password dialog tool found.\n\n` +
+                                    `Install one of: zenity, kdialog, or ssh-askpass\n` +
+                                    `  sudo apt install zenity    # GNOME/GTK\n` +
+                                    `  sudo apt install kdialog   # KDE/Qt\n\n` +
+                                    `Or use sudo_session action=elevate with your password instead.`),
+                            ],
+                            isError: true,
+                        };
+                    }
+                    console.error(`[sudo-gui] Launching ${guiTool.name} password dialog...`);
+                    // ── Launch GUI dialog and capture password ────────────────────────
+                    // openGuiPasswordDialog spawns the dialog with the correct graphical
+                    // session environment, captures the password via a secure temp file,
+                    // and wipes it immediately after reading.
+                    const password = await openGuiPasswordDialog(guiTool);
+                    if (!password) {
+                        return {
+                            content: [
+                                createErrorContent(`❌ Password dialog was cancelled or timed out.\n\n` +
+                                    `No password was entered. Try again with:\n` +
+                                    `  sudo_session action=elevate_gui\n\n` +
+                                    `Or provide your password directly with:\n` +
+                                    `  sudo_session action=elevate`),
+                            ],
+                            isError: true,
+                        };
+                    }
+                    // ── Elevate using captured password ──────────────────────────────
+                    const timeoutMs = timeout_minutes * 60 * 1000;
+                    const config = getConfig();
+                    if (config.sudoSessionTimeout) {
+                        session.setDefaultTimeout(config.sudoSessionTimeout);
+                    }
+                    const result = await session.elevate(password, timeoutMs);
+                    if (result.success) {
+                        invalidatePreflightCaches();
+                        const status = session.getStatus();
+                        return {
+                            content: [
+                                createTextContent(`🔓 Privileges elevated successfully!\n\n` +
+                                    `  User: ${status.username}\n` +
+                                    `  Expires: ${status.expiresAt ?? "never (running as root)"}\n` +
+                                    `  Timeout: ${timeout_minutes} minutes\n` +
+                                    `  Method: Secure GUI dialog (${guiTool.name}) — password never visible to AI\n\n` +
+                                    `All tools that require sudo will now work automatically.\n` +
+                                    `Use sudo_session action=status to check session state, or sudo_session action=drop to end early.`),
+                            ],
+                        };
+                    }
+                    // ── Elevation failed ─────────────────────────────────────────────
+                    const rlAfter = session.getRateLimitStatus();
+                    const attemptsLine = rlAfter.limited
+                        ? `Rate limit reached — locked out until ${rlAfter.resetAt ? new Date(rlAfter.resetAt).toLocaleTimeString() : "unknown"}.`
+                        : `Attempts remaining before lockout: ${rlAfter.attemptsRemaining}`;
                     return {
                         content: [
-                            createTextContent(`🔐 SECURE ELEVATION — Step 1 of 2\n` +
-                                `${"═".repeat(50)}\n\n` +
-                                `To elevate securely, run this command via execute_command:\n\n` +
-                                `  ${toolCmd} > /tmp/.defense-sudo-pw 2>/dev/null && chmod 600 /tmp/.defense-sudo-pw && echo "READY" || echo "CANCELLED"\n\n` +
-                                `This opens a password dialog on the user's screen.\n` +
-                                `The password goes DIRECTLY to a secure temp file — it\n` +
-                                `NEVER appears in terminal output or the AI chat.\n\n` +
-                                `After the user enters their password (output shows "READY"),\n` +
-                                `call sudo_session action=elevate_gui again to complete elevation.\n` +
-                                `The tool will read the file, elevate, and securely wipe it.`),
+                            createErrorContent(`❌ Authentication failed: ${result.error}\n\n` +
+                                `${attemptsLine}\n\n` +
+                                `The password was securely wiped. Please try again.`),
                         ],
+                        isError: true,
                     };
                 }
                 catch (err) {
@@ -631,6 +593,7 @@ export function registerSudoManagementTools(server) {
 }
 /**
  * Detect which GUI password dialog tool is available.
+ * Uses the command allowlist for resolution (no spawning `which`).
  * Preference order: zenity > kdialog > ssh-askpass
  */
 async function detectGuiPasswordTool() {
@@ -663,17 +626,15 @@ async function detectGuiPasswordTool() {
     ];
     for (const tool of candidates) {
         try {
-            const result = await new Promise((resolve) => {
-                const child = spawnSafe("which", [tool.command], {
-                    stdio: ["ignore", "pipe", "pipe"],
-                });
-                child.on("close", (code) => resolve(code === 0));
-                child.on("error", () => resolve(false));
-            });
-            if (result)
-                return tool;
+            // resolveCommand checks the allowlist and verifies the binary exists on disk
+            const resolved = resolveCommand(tool.command);
+            if (resolved) {
+                console.error(`[sudo-gui] Found GUI tool: ${tool.name} at ${resolved}`);
+                return { ...tool, command: resolved };
+            }
         }
         catch {
+            // Binary not found or not in allowlist — try next candidate
             continue;
         }
     }
@@ -688,11 +649,28 @@ async function getGraphicalSessionEnv() {
     try {
         const { readFile } = await import("node:fs/promises");
         const { execFileSafe } = await import("../core/spawn-safe.js");
-        // Find a PID from the user's graphical session (sddm-greeter, Xwayland, or the desktop itself)
+        // Find a PID from the user's graphical session.
+        // We need a process that INHERITS display vars from the compositor.
+        // The compositor itself (gnome-shell, kwin_wayland) often doesn't have
+        // DISPLAY/WAYLAND_DISPLAY in its own /proc/environ — so we prefer child
+        // processes like gjs, nautilus, plasmashell that do inherit them.
         const uid = process.getuid?.() ?? 1000;
-        // Get a graphical session process PID owned by the current user
         let pid = null;
-        const candidates = ["sddm", "kwin_wayland", "plasmashell", "gnome-shell", "Xwayland", "xfce4-session"];
+        const candidates = [
+            "gjs", // GNOME shell extensions (always has display vars)
+            "nautilus", // GNOME file manager
+            "plasmashell", // KDE
+            "kwin_wayland", // KDE compositor
+            "xfce4-panel", // XFCE
+            "xfce4-session", // XFCE
+            "cinnamon", // Cinnamon
+            "budgie-panel", // Budgie
+            "lxqt-panel", // LXQt
+            "sway", // Sway
+            "hyprland", // Hyprland
+            "Xwayland", // X11-on-Wayland bridge
+            "gnome-shell", // GNOME compositor (may lack display vars)
+        ];
         for (const proc of candidates) {
             try {
                 const result = execFileSafe("pgrep", ["-u", String(uid), "-o", proc], { encoding: "utf-8", stdio: "pipe" }).trim();
@@ -850,5 +828,3 @@ async function openGuiPasswordDialog(tool) {
         catch { /* best-effort cleanup */ }
     }
 }
-// Suppress unused warning — openGuiPasswordDialog is kept for potential future use
-void openGuiPasswordDialog;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "defense-mcp-server",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Defense MCP Server — 31 domain-grouped defensive security tools for system hardening and threat detection",
   "type": "module",
   "main": "build/index.js",
@@ -28,7 +28,13 @@
     "changelog:check": "git diff HEAD~1 --name-only | grep -q CHANGELOG.md || echo 'Warning: CHANGELOG.md not updated'",
     "license:check": "license-checker --production --failOn 'GPL-3.0;AGPL-3.0'",
     "prepare": "husky",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "release": "./scripts/release.sh patch",
+    "release:minor": "./scripts/release.sh minor",
+    "release:major": "./scripts/release.sh major",
+    "release:git": "./scripts/release.sh patch --git-only",
+    "release:npm": "./scripts/release.sh --npm-only",
+    "push": "git add -A && git commit -m 'chore: update' && git push origin $(git rev-parse --abbrev-ref HEAD)"
   },
   "keywords": [
     "mcp",