@wrongstack/tools 0.291.0 → 0.291.1

package/dist/bash-kill-guard.d.ts

@@ -11,7 +11,14 @@
  * - Shell -c wrapped: bash -c "kill -9 12345" (any shell path — see P2 #10)
  * - Full path kills: /bin/kill -9 12345
  * - Name-based kills: pkill, killall, pgrep
- * - Windows equivalents: taskkill
+ * - Windows equivalents: taskkill, tskill
+ * - PowerShell Stop-Process / kill alias: Stop-Process -Name node, kill -Id 12345
+ * - WMIC process termination: wmic process where "name='node.exe'" delete
+ * - Script-based kill (script is named kill*.sh, kill*.ps1, kill*.bat)
+ *
+ * Security contract: every "Handles" bullet must map to both a detector
+ * AND a block path in isKillRelatedCommand + parseKillCommand + isKillProtected.
+ * Script-based kills are blocked conservatively (can't inspect script content).
  *
  * Known bypasses (NOT handled — this is a static regex parser, not a shell):
  * Static analysis of shell strings is inherently defeatable by obfuscation.
@@ -25,6 +32,8 @@
  * - String concatenation / quote-splitting: `ki''ll -9 12345`, `k"i"ll 12345`
  * - Aliases and functions: `alias x=kill; x -9 12345`
  * - eval / source: `eval "ki""ll -9 12345"`
+ * - node -e eval: `node -e "process.kill(12345)"` (handled by exec-kill-guard.ts)
+ * - Scripts not named kill/terminate/stop*: `runkill.sh`, `/tmp/cleanup.bat`
  *
  * Mitigation: rely on the permission policy (confirm/deny gate) and YOLO
  * destructive detection as the primary controls; this guard is a best-effort

package/dist/bash-kill-guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bash-kill-guard.d.ts","sourceRoot":"","sources":["../src/bash-kill-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAOH,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAwED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CA6FpE;AAqBD;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAqCzE;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CA2CxF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAK1E"}
+{"version":3,"file":"bash-kill-guard.d.ts","sourceRoot":"","sources":["../src/bash-kill-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAqBH,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA+ED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAkPpE;AAqBD;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CA0CzE;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAqDxF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAK1E"}

package/dist/bash.js

@@ -1199,17 +1199,18 @@ function getPersistentProcessRegistry() {
 
 // src/bash-kill-guard.ts
 var isWin = os3.platform() === "win32";
+var SCRIPT_KILL_RE = /^(?:\.\\|\.\/)?(?:kill|terminate|stop)\S*\.(?:ps1|bat|cmd|sh)(?:\s|$)/i;
+var SCRIPT_KILL_RE_POSIX = /^(?:\.\/)?(?:kill|terminate|stop)\S*\.sh(?:\s|$)/i;
+var SCRIPT_KILL_FALLBACK_RE = /^\S*(?:kill|terminate|stop)\S*\.(?:ps1|bat|cmd|sh)\b/i;
 function extractKillCommand(command) {
   const normalized = command.replace(/\s+/g, " ").trim();
-  const shellCMatch = normalized.match(
-    /^(?:\S+(?:\s+\S+)?)?\s+-c\s+['"](.+?)['"]$/
-  );
-  if (shellCMatch?.[1]) {
-    const inner = shellCMatch[1].trim();
+  const shellCMatch = normalized.match(/^.+?\s+-c\s+(['"])([\s\S]+)\1$/);
+  if (shellCMatch?.[2]) {
+    const inner = shellCMatch[2].trim();
     return isKillRelatedCommand(inner) ? inner : null;
   }
   const shellCUnquoted = normalized.match(
-    /^(?:\S+(?:\s+\S+)?)?\s+-c\s+(kill(?:\s+-[a-zA-Z]+)?(?:\s+\d+)+)$/
+    /^.+?\s+-c\s+(kill(?:\s+-s\s+[a-zA-Z0-9]+|\s+-[a-zA-Z0-9]+)?\s+\d+)$/
   );
   if (shellCUnquoted?.[1]) {
     return shellCUnquoted[1];
@@ -1221,22 +1222,47 @@ function isKillRelatedCommand(cmd) {
   if (isWin) {
     if (/^taskkill\s/i.test(normalized)) return true;
     if (/^tskill\s/i.test(normalized)) return true;
+    if (/^(stop-process|kill|stop)\s/i.test(normalized)) return true;
+    if (/^wmic\s+process\s/i.test(normalized) && /\bdelete\b/i.test(normalized)) return true;
+    if (SCRIPT_KILL_RE.test(normalized)) return true;
     return false;
   }
   if (/^kill(\s|$)/.test(normalized)) return true;
   if (/^(pkill|killall|pgrep|skill)\s/.test(normalized)) return true;
   if (/^\/proc\/\d+\/(?:kill|fd)/.test(normalized)) return true;
+  if (SCRIPT_KILL_RE_POSIX.test(normalized)) return true;
   return false;
 }
 function parseKillCommand(command) {
   const normalized = command.replace(/\s+/g, " ").trim();
   if (isWin) {
-    const taskkillMatch = normalized.match(/^taskkill\s+(?:\/[a-zA-Z]+\s+)*\/PID\s+(\d+)/i);
-    if (taskkillMatch?.[1]) {
-      const pidStr = taskkillMatch[1];
+    const hasTaskkillForce = /(?:^|\s)\/F(?=\s|$)/i.test(normalized);
+    const isSimpleTaskkill = /^taskkill\s+/i.test(normalized) && !/[|&<>]/.test(normalized);
+    const taskkillPidMatch = isSimpleTaskkill ? normalized.match(/(?:^|\s)\/PID\s+(\d+)(?=\s|$)/i) : null;
+    if (taskkillPidMatch?.[1]) {
+      return {
+        pid: parseInt(taskkillPidMatch[1], 10),
+        signal: hasTaskkillForce ? "FORCE" : "TERM",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const taskkillImMatch = isSimpleTaskkill ? normalized.match(/(?:^|\s)\/IM\s+([^\s/]+)(?=\s|$)/i) : null;
+    if (taskkillImMatch?.[1]) {
+      return {
+        name: taskkillImMatch[1],
+        signal: hasTaskkillForce ? "FORCE" : "TERM",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const taskkillFiMatch = isSimpleTaskkill ? normalized.match(/(?:^|\s)\/FI\s+"IMAGENAME\s+eq\s+([^"]+)"(?=\s|$)/i) : null;
+    if (taskkillFiMatch?.[1]) {
       return {
-        pid: parseInt(pidStr, 10),
-        signal: normalized.includes("/F") ? "FORCE" : "TERM",
+        name: taskkillFiMatch[1],
+        signal: hasTaskkillForce ? "FORCE" : "TERM",
         isGroupKill: false,
         isAllKill: false,
         originalCommand: command
@@ -1244,18 +1270,109 @@ function parseKillCommand(command) {
     }
     const tskillMatch = normalized.match(/^tskill\s+(\d+)/i);
     if (tskillMatch?.[1]) {
-      const pidStr = tskillMatch[1];
       return {
-        pid: parseInt(pidStr, 10),
+        pid: parseInt(tskillMatch[1], 10),
         signal: "TERM",
         isGroupKill: false,
         isAllKill: false,
         originalCommand: command
       };
     }
+    const isStopProcIdCommand = /^(?:stop-process|kill)(?:\s+-(?:id|pid)\s+\d+|\s+-[a-zA-Z]+)+$/i.test(normalized);
+    const stopProcIdMatch = normalized.match(/(?:^|\s)-(?:id|pid)\s+(\d+)(?=\s|$)/i);
+    if (isStopProcIdCommand && stopProcIdMatch?.[1]) {
+      return {
+        pid: parseInt(stopProcIdMatch[1], 10),
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const killSignalOptionMatch = normalized.match(/^kill\s+-s\s+([a-zA-Z0-9]+)\s+(\d+)$/i);
+    if (killSignalOptionMatch?.[1] && killSignalOptionMatch[2]) {
+      return {
+        pid: parseInt(killSignalOptionMatch[2], 10),
+        signal: killSignalOptionMatch[1].toUpperCase(),
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const killPosixMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z0-9]+)\s+)?(\d+)$/);
+    if (killPosixMatch?.[2]) {
+      const sig = killPosixMatch[1] ? killPosixMatch[1].slice(1).toUpperCase() : "TERM";
+      return {
+        pid: parseInt(killPosixMatch[2], 10),
+        signal: sig,
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const stopProcNameMatch = normalized.match(
+      /^(?:stop-process|kill)\s+-(?:name|n)\s+(?:['"]([a-zA-Z0-9_.-]+)['"]|([a-zA-Z0-9_.-]+))(?:\s|$)/i
+    );
+    const stopProcName = stopProcNameMatch?.[1] ?? stopProcNameMatch?.[2];
+    if (stopProcName) {
+      return {
+        name: stopProcName,
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const stopProcStandalone = normalized.match(
+      /^(?:stop-process|kill)\s+['"]?([a-zA-Z][a-zA-Z0-9_.-]+)['"]?$/i
+    );
+    if (stopProcStandalone?.[1]) {
+      return {
+        name: stopProcStandalone[1],
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const wmicMatch = normalized.match(
+      /^wmic\s+process\s+where\s+['"]?(?:name\s*=\s*['"]?)([a-zA-Z0-9_.-]+)/i
+    );
+    if (wmicMatch?.[1]) {
+      return {
+        name: wmicMatch[1],
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const killScriptMatch = normalized.match(SCRIPT_KILL_RE);
+    if (killScriptMatch) {
+      return {
+        name: "kill-script",
+        // sentinel — isKillProtected always blocks "kill-script"
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
     return null;
   }
-  const simpleMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z]+)\s+)?(\d+|-?\d+)$/);
+  const signalOptionMatch = normalized.match(/^kill\s+-s\s+([a-zA-Z0-9]+)\s+(\d+|-?\d+)$/i);
+  if (signalOptionMatch?.[1] && signalOptionMatch[2]) {
+    const pidOrGroup = signalOptionMatch[2];
+    const isGroupKill = pidOrGroup.startsWith("-");
+    return {
+      pid: parseInt(isGroupKill ? pidOrGroup.slice(1) : pidOrGroup, 10),
+      signal: signalOptionMatch[1].toUpperCase(),
+      isGroupKill,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const simpleMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z0-9]+)\s+)?(\d+|-?\d+)$/);
   if (simpleMatch) {
     const signal = simpleMatch[1] ?? "-TERM";
     const pidOrGroup = simpleMatch[2];
@@ -1315,6 +1432,9 @@ async function getProtectedEntries() {
 }
 async function isKillProtected(kill) {
   const registry = getPersistentProcessRegistry();
+  if (kill.name === "kill-script") {
+    return true;
+  }
   if (kill.name) {
     const entries = await getProtectedEntries();
     const killNameLower = kill.name.toLowerCase();
@@ -1354,6 +1474,12 @@ async function checkAndBlockKillCommand(command) {
         reason: `Blocked: complex kill pipeline detected \u2014 "${killCmd.slice(0, 50)}..."`
       };
     }
+    if (SCRIPT_KILL_FALLBACK_RE.test(killCmd)) {
+      return {
+        blocked: true,
+        reason: `Blocked: script-based kill detected \u2014 "${killCmd.slice(0, 80)}" may target protected WrongStack processes (cannot inspect script body).`
+      };
+    }
     return { blocked: false };
   }
   if (await isKillProtected(parsed)) {