claude-warden 2.10.0 → 2.10.1

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "warden",
       "description": "Auto-approves safe commands, blocks dangerous ones, prompts for the rest",
-      "version": "2.10.0",
+      "version": "2.10.1",
       "author": {
         "name": "banyudu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "warden",
-  "version": "2.10.0",
+  "version": "2.10.1",
   "description": "Smart command safety filter for Claude Code — parses shell pipelines and evaluates per-command safety rules to auto-approve safe commands and block dangerous ones",
   "author": {
     "name": "banyudu"

package/dist/cli.cjs

@@ -18214,6 +18214,19 @@ function convertCommand(node) {
   const raw = rawParts.join(" ");
   return { command, originalCommand, args: args2, envPrefixes, raw };
 }
+function collectExpansionsFromWord(word, result) {
+  if (!word?.expansion) return;
+  for (const exp of word.expansion) {
+    if (exp.type === "CommandExpansion" && exp.command) {
+      result.hasSubshell = true;
+      result.subshellCommands.push(exp.command);
+    }
+  }
+}
+function walkCompoundList(list, result) {
+  if (!list?.commands) return;
+  for (const cmd of list.commands) walkNode(cmd, result);
+}
 function collectCommandExpansions(node) {
   const commands = [];
   if (node.type === "Command") {
@@ -18288,15 +18301,47 @@ function walkNode(node, result) {
       }
       break;
     }
-    // Complex constructs — flag as subshell for safety
-    case "If":
-    case "For":
+    // Control constructs mirror the Subshell handler above: their bodies are
+    // walked into result.commands so each inner command is evaluated normally.
+    // hasSubshell stays false unless a head expression (`for f in $(...)`,
+    // `case $(...) in ...`) introduces a real command substitution.
+    case "For": {
+      const f = node;
+      if (f.wordlist) {
+        for (const w of f.wordlist) collectExpansionsFromWord(w, result);
+      }
+      walkCompoundList(f.do, result);
+      break;
+    }
     case "While":
-    case "Until":
-    case "Case":
-    case "Function":
-      result.hasSubshell = true;
+    case "Until": {
+      const w = node;
+      walkCompoundList(w.clause, result);
+      walkCompoundList(w.do, result);
       break;
+    }
+    case "If": {
+      const i = node;
+      walkCompoundList(i.clause, result);
+      walkCompoundList(i.then, result);
+      if (i.else) {
+        if (i.else.type === "If") walkNode(i.else, result);
+        else walkCompoundList(i.else, result);
+      }
+      break;
+    }
+    case "Case": {
+      const cs = node;
+      collectExpansionsFromWord(cs.clause, result);
+      if (cs.cases) {
+        for (const item of cs.cases) walkCompoundList(item.body, result);
+      }
+      break;
+    }
+    case "Function": {
+      walkCompoundList(node.body, result);
+      break;
+    }
     default:
       break;
   }

package/dist/codex-export.cjs

@@ -18218,6 +18218,19 @@ function convertCommand(node) {
   const raw = rawParts.join(" ");
   return { command, originalCommand, args: args2, envPrefixes, raw };
 }
+function collectExpansionsFromWord(word, result) {
+  if (!word?.expansion) return;
+  for (const exp of word.expansion) {
+    if (exp.type === "CommandExpansion" && exp.command) {
+      result.hasSubshell = true;
+      result.subshellCommands.push(exp.command);
+    }
+  }
+}
+function walkCompoundList(list, result) {
+  if (!list?.commands) return;
+  for (const cmd of list.commands) walkNode(cmd, result);
+}
 function collectCommandExpansions(node) {
   const commands = [];
   if (node.type === "Command") {
@@ -18292,15 +18305,47 @@ function walkNode(node, result) {
       }
       break;
     }
-    // Complex constructs — flag as subshell for safety
-    case "If":
-    case "For":
+    // Control constructs mirror the Subshell handler above: their bodies are
+    // walked into result.commands so each inner command is evaluated normally.
+    // hasSubshell stays false unless a head expression (`for f in $(...)`,
+    // `case $(...) in ...`) introduces a real command substitution.
+    case "For": {
+      const f = node;
+      if (f.wordlist) {
+        for (const w of f.wordlist) collectExpansionsFromWord(w, result);
+      }
+      walkCompoundList(f.do, result);
+      break;
+    }
     case "While":
-    case "Until":
-    case "Case":
-    case "Function":
-      result.hasSubshell = true;
+    case "Until": {
+      const w = node;
+      walkCompoundList(w.clause, result);
+      walkCompoundList(w.do, result);
       break;
+    }
+    case "If": {
+      const i = node;
+      walkCompoundList(i.clause, result);
+      walkCompoundList(i.then, result);
+      if (i.else) {
+        if (i.else.type === "If") walkNode(i.else, result);
+        else walkCompoundList(i.else, result);
+      }
+      break;
+    }
+    case "Case": {
+      const cs = node;
+      collectExpansionsFromWord(cs.clause, result);
+      if (cs.cases) {
+        for (const item of cs.cases) walkCompoundList(item.body, result);
+      }
+      break;
+    }
+    case "Function": {
+      walkCompoundList(node.body, result);
+      break;
+    }
     default:
       break;
   }

package/dist/copilot.cjs

@@ -18214,6 +18214,19 @@ function convertCommand(node) {
   const raw = rawParts.join(" ");
   return { command, originalCommand, args: args2, envPrefixes, raw };
 }
+function collectExpansionsFromWord(word, result) {
+  if (!word?.expansion) return;
+  for (const exp of word.expansion) {
+    if (exp.type === "CommandExpansion" && exp.command) {
+      result.hasSubshell = true;
+      result.subshellCommands.push(exp.command);
+    }
+  }
+}
+function walkCompoundList(list, result) {
+  if (!list?.commands) return;
+  for (const cmd of list.commands) walkNode(cmd, result);
+}
 function collectCommandExpansions(node) {
   const commands = [];
   if (node.type === "Command") {
@@ -18288,15 +18301,47 @@ function walkNode(node, result) {
       }
       break;
     }
-    // Complex constructs — flag as subshell for safety
-    case "If":
-    case "For":
+    // Control constructs mirror the Subshell handler above: their bodies are
+    // walked into result.commands so each inner command is evaluated normally.
+    // hasSubshell stays false unless a head expression (`for f in $(...)`,
+    // `case $(...) in ...`) introduces a real command substitution.
+    case "For": {
+      const f = node;
+      if (f.wordlist) {
+        for (const w of f.wordlist) collectExpansionsFromWord(w, result);
+      }
+      walkCompoundList(f.do, result);
+      break;
+    }
     case "While":
-    case "Until":
-    case "Case":
-    case "Function":
-      result.hasSubshell = true;
+    case "Until": {
+      const w = node;
+      walkCompoundList(w.clause, result);
+      walkCompoundList(w.do, result);
       break;
+    }
+    case "If": {
+      const i = node;
+      walkCompoundList(i.clause, result);
+      walkCompoundList(i.then, result);
+      if (i.else) {
+        if (i.else.type === "If") walkNode(i.else, result);
+        else walkCompoundList(i.else, result);
+      }
+      break;
+    }
+    case "Case": {
+      const cs = node;
+      collectExpansionsFromWord(cs.clause, result);
+      if (cs.cases) {
+        for (const item of cs.cases) walkCompoundList(item.body, result);
+      }
+      break;
+    }
+    case "Function": {
+      walkCompoundList(node.body, result);
+      break;
+    }
     default:
       break;
   }

package/dist/index.cjs

@@ -18214,6 +18214,19 @@ function convertCommand(node) {
   const raw = rawParts.join(" ");
   return { command, originalCommand, args: args2, envPrefixes, raw };
 }
+function collectExpansionsFromWord(word, result) {
+  if (!word?.expansion) return;
+  for (const exp of word.expansion) {
+    if (exp.type === "CommandExpansion" && exp.command) {
+      result.hasSubshell = true;
+      result.subshellCommands.push(exp.command);
+    }
+  }
+}
+function walkCompoundList(list, result) {
+  if (!list?.commands) return;
+  for (const cmd of list.commands) walkNode(cmd, result);
+}
 function collectCommandExpansions(node) {
   const commands = [];
   if (node.type === "Command") {
@@ -18288,15 +18301,47 @@ function walkNode(node, result) {
       }
       break;
     }
-    // Complex constructs — flag as subshell for safety
-    case "If":
-    case "For":
+    // Control constructs mirror the Subshell handler above: their bodies are
+    // walked into result.commands so each inner command is evaluated normally.
+    // hasSubshell stays false unless a head expression (`for f in $(...)`,
+    // `case $(...) in ...`) introduces a real command substitution.
+    case "For": {
+      const f = node;
+      if (f.wordlist) {
+        for (const w of f.wordlist) collectExpansionsFromWord(w, result);
+      }
+      walkCompoundList(f.do, result);
+      break;
+    }
     case "While":
-    case "Until":
-    case "Case":
-    case "Function":
-      result.hasSubshell = true;
+    case "Until": {
+      const w = node;
+      walkCompoundList(w.clause, result);
+      walkCompoundList(w.do, result);
       break;
+    }
+    case "If": {
+      const i = node;
+      walkCompoundList(i.clause, result);
+      walkCompoundList(i.then, result);
+      if (i.else) {
+        if (i.else.type === "If") walkNode(i.else, result);
+        else walkCompoundList(i.else, result);
+      }
+      break;
+    }
+    case "Case": {
+      const cs = node;
+      collectExpansionsFromWord(cs.clause, result);
+      if (cs.cases) {
+        for (const item of cs.cases) walkCompoundList(item.body, result);
+      }
+      break;
+    }
+    case "Function": {
+      walkCompoundList(node.body, result);
+      break;
+    }
     default:
       break;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-warden",
-  "version": "2.10.0",
+  "version": "2.10.1",
   "description": "Smart command safety filter for Claude Code — auto-approves safe commands, blocks dangerous ones",
   "type": "module",
   "main": "dist/index.cjs",