@sjawhar/pi-legion-envoy 5.17.2 → 5.17.3

package/dist/legion.js

@@ -33473,7 +33473,7 @@ import { logger } from "@oh-my-pi/pi-utils";
 // package.json
 var package_default = {
   name: "@sjawhar/pi-legion-envoy",
-  version: "5.17.2",
+  version: "5.17.3",
   type: "module",
   omp: {
     extensions: [
@@ -41507,6 +41507,51 @@ var FILE_COMMANDS = new Set([
   "chgrp"
 ]);
 var SIGNAL_COMMANDS = new Set(["kill", "pkill", "killall", "killall5"]);
+var FIND_VALUED_PREDICATES = new Set([
+  "-amin",
+  "-anewer",
+  "-atime",
+  "-cmin",
+  "-cnewer",
+  "-ctime",
+  "-fls",
+  "-fprint",
+  "-fprint0",
+  "-fprintf",
+  "-fstype",
+  "-gid",
+  "-group",
+  "-ilname",
+  "-iname",
+  "-inum",
+  "-ipath",
+  "-iregex",
+  "-iwholename",
+  "-links",
+  "-lname",
+  "-maxdepth",
+  "-mindepth",
+  "-mmin",
+  "-mtime",
+  "-name",
+  "-newer",
+  "-newerat",
+  "-newerct",
+  "-newermt",
+  "-path",
+  "-perm",
+  "-printf",
+  "-regex",
+  "-regextype",
+  "-samefile",
+  "-size",
+  "-type",
+  "-uid",
+  "-used",
+  "-user",
+  "-wholename",
+  "-xtype"
+]);
 var FUNCTION_OUTPUT_SILENT = {
   ":": true,
   break: true,
@@ -42166,6 +42211,43 @@ function literalText(exp) {
     return;
   return exp.map((piece) => piece.text).join("");
 }
+function readableWord(arg) {
+  const whole = literalText(arg.exp);
+  if (whole !== undefined)
+    return { text: whole, whole: true };
+  let text = "";
+  for (const piece of arg.exp) {
+    if (piece.kind !== "literal")
+      break;
+    text += piece.text;
+  }
+  return { text, whole: false };
+}
+function mayBeOption(arg, matches) {
+  const { text, whole } = readableWord(arg);
+  if (whole)
+    return matches(text);
+  return text === "" || /^--?[a-zA-Z-]*$/.test(text);
+}
+function valueInWord(arg, count) {
+  const pieces = [];
+  let dropped = 0;
+  for (const piece of arg.exp) {
+    if (dropped >= count) {
+      pieces.push(piece);
+      continue;
+    }
+    if (piece.kind !== "literal")
+      return;
+    if (piece.text.length + dropped <= count) {
+      dropped += piece.text.length;
+      continue;
+    }
+    pieces.push({ ...piece, text: piece.text.slice(count - dropped) });
+    dropped = count;
+  }
+  return dropped < count || pieces.length === 0 ? undefined : pieces;
+}
 function visitParts(parts, st, ctx) {
   for (const part of parts ?? []) {
     switch (part.type) {
@@ -43087,6 +43169,7 @@ function operands(list, valued, longValued = []) {
   return { options, operands: found };
 }
 function unwrap2(argv, st, ctx, site) {
+  const alts = [];
   let list = argv;
   let state = st;
   for (let guard = 0;guard < 16; guard += 1) {
@@ -43095,13 +43178,19 @@ function unwrap2(argv, st, ctx, site) {
       break;
     const base = path4.basename(name);
     const rest = list.slice(1);
-    const skip = (valued, longValued = []) => {
+    const skip = (valued, longValued = [], positional = false) => {
       let i = 0;
       for (;i < rest.length; i += 1) {
-        const text = literalText(rest[i]?.exp);
+        const arg = rest[i];
+        const text = literalText(arg.exp);
         if (text === "--")
           return rest.slice(i + 1);
-        if (text === undefined || !text.startsWith("-") || text === "-")
+        if (text === undefined) {
+          if (positional || !mayBeOption(arg, (option) => option.startsWith("-")))
+            break;
+          continue;
+        }
+        if (!text.startsWith("-") || text === "-")
           break;
         if (text.startsWith("--")) {
           if (!text.includes("=") && longValued.includes(text))
@@ -43115,8 +43204,10 @@ function unwrap2(argv, st, ctx, site) {
       }
       return rest.slice(i);
     };
-    if ((base === "busybox" || base === "toybox") && rest[0] !== undefined)
+    if ((base === "busybox" || base === "toybox") && rest[0] !== undefined && literalText(rest[0].exp) !== undefined) {
       list = rest;
+      continue;
+    }
     if (base === "sudo" || base === "doas")
       list = skip("ughpCDrtUT", ["--user", "--group"]);
     else if (base === "nice")
@@ -43128,15 +43219,23 @@ function unwrap2(argv, st, ctx, site) {
     else if (base === "command") {
       const flags = rest.map((arg) => literalText(arg.exp));
       if (flags[0] === "-v" || flags[0] === "-V")
-        return { argv: [], st: state };
+        return { argv: [], st: state, alts };
       list = skip("");
     } else if (base === "stdbuf")
       list = skip("ioe", ["--input", "--output", "--error"]);
     else if (base === "ionice")
       list = skip("cnt", ["--class", "--classdata"]);
     else if (base === "timeout") {
-      const after = skip("sk", ["--signal", "--kill-after"]);
-      list = after.slice(1);
+      const stopped = skip("sk", ["--signal", "--kill-after"], true);
+      list = stopped.slice(1);
+      for (let at = rest.length - stopped.length;at < rest.length; at += 1) {
+        if (literalText(rest[at]?.exp) !== undefined)
+          break;
+        alts.push(rest.slice(at + 1));
+      }
+      const read = skip("sk", ["--signal", "--kill-after"]);
+      if (read.length !== stopped.length)
+        alts.push(read.slice(1));
     } else if (base === "env") {
       let i = 0;
       const overlay = new Map;
@@ -43176,7 +43275,7 @@ function unwrap2(argv, st, ctx, site) {
           overlay.set(arg.exp[0].text.slice(0, arg.exp[0].text.indexOf("=")), [
             unknown2("an `env` assignment")
           ]);
-        } else
+        } else if (text === undefined && mayBeOption(arg, (option) => option.startsWith("-"))) {} else
           break;
       }
       if (i !== -1)
@@ -43193,7 +43292,7 @@ function unwrap2(argv, st, ctx, site) {
     } else
       break;
   }
-  return { argv: list, st: state };
+  return { argv: list, st: state, alts };
 }
 function runFunction(name, definition, args2, outer, ctx) {
   if (outer.runningFunctions.has(name))
@@ -43278,6 +43377,9 @@ function dispatch(invocation, outer, ctx) {
   const unwrapped = unwrap2(invocation.args, outer, ctx, invocation.site);
   const argv = unwrapped.argv;
   const st = unwrapped.st;
+  for (const other of unwrapped.alts) {
+    dispatch({ ...invocation, args: other }, clone2(outer), ctx);
+  }
   const name = literalText(argv[0]?.exp);
   if (name === undefined)
     return;
@@ -43425,15 +43527,21 @@ function dispatch(invocation, outer, ctx) {
       const leading = head[0];
       const spaced = literalText(head) === "-v";
       const joined = !spaced && leading?.kind === "literal" && leading.text.startsWith("-v") && (leading.text.length > 2 || head.length > 1);
-      if (spaced || joined) {
-        const variable = spaced ? literalText(rest[1]?.exp) : literalText([
+      const first = rest[0];
+      const mayBeV = !spaced && !joined && first !== undefined && rest[1] !== undefined && mayBeOption(first, (text) => text.startsWith("-v"));
+      if (spaced || joined || mayBeV) {
+        const variable = spaced || mayBeV ? literalText(rest[1]?.exp) : literalText([
           { ...leading, text: leading?.text.slice(2) ?? "" },
           ...head.slice(1)
         ]);
-        const printed = rest.slice(spaced ? 2 : 1);
+        const printed = rest.slice(spaced || mayBeV ? 2 : 1);
         const [format, value, ...others] = printed;
         let assigned;
-        if (literalText(format?.exp) === "%s" && value !== undefined && others.length === 0) {
+        if (mayBeV) {
+          assigned = [
+            unknown2(`\`$${variable ?? "?"}\` (printf with an option word the guard cannot read, which may be \`-v\`)`)
+          ];
+        } else if (literalText(format?.exp) === "%s" && value !== undefined && others.length === 0) {
           assigned = value.exp;
         } else {
           const text = printfText(printed, MAX_VALUE_LENGTH);
@@ -43564,22 +43672,29 @@ function dispatch(invocation, outer, ctx) {
     case "tar":
     case "unzip": {
       const extracting = base === "unzip" || rest.some((arg, index) => {
-        const text = literalText(arg.exp);
-        return text === "--extract" || text === "--get" || text?.startsWith("-") === true && !text.startsWith("--") && text.includes("x") || index === 0 && /^[A-Za-z]*x[A-Za-z]*$/.test(text ?? "");
+        const { text, whole } = readableWord(arg);
+        if (!whole && index === 0 && /^[A-Za-z]*$/.test(text))
+          return true;
+        return mayBeOption(arg, (mode) => mode === "--extract" || mode === "--get" || mode.startsWith("-") && !mode.startsWith("--") && mode.includes("x") || index === 0 && /^[A-Za-z]*x[A-Za-z]*$/.test(mode));
       });
       if (!extracting)
         return;
       const targetDirectories = [];
       const short = base === "tar" ? "-C" : "-d";
       const long = base === "tar" ? "--directory" : "--destination";
+      const letter = short.slice(1);
       for (const [index, arg] of rest.entries()) {
-        const text = literalText(arg.exp);
-        if (text === short || text === long) {
+        const { text, whole } = readableWord(arg);
+        const clusterAt = text.startsWith("-") && !text.startsWith("--") ? text.indexOf(letter, 1) : -1;
+        const carried = text.startsWith(`${long}=`) ? valueInWord(arg, long.length + 1) : clusterAt !== -1 && (!whole || text.length > clusterAt + 1) ? valueInWord(arg, clusterAt + 1) : undefined;
+        if (carried !== undefined) {
+          targetDirectories.push({ text: arg.text, exp: carried });
+          continue;
+        }
+        if (clusterAt !== -1 || mayBeOption(arg, (option) => option === short || option === long)) {
           const target = rest[index + 1];
           if (target !== undefined)
             targetDirectories.push(target);
-        } else if (text?.startsWith(`${long}=`)) {
-          targetDirectories.push({ text: arg.text, exp: [literal2(text.slice(long.length + 1))] });
         }
       }
       checkTargets(base, "extract and overwrite in", targetDirectories, true, st, ctx, site);
@@ -43627,41 +43742,73 @@ function dispatch(invocation, outer, ctx) {
     case "killall":
     case "killall5":
       throw new Refusal(site.snippet, site.line, `${base} selects processes by name or pattern, which reaches other agents' processes on a ` + "shared machine; a pane signals only processes it started. Stop a process you started " + 'with the hub tool (`op: "stop"`), or `kill` the pid of a child you started from this pane');
-    case "fuser":
-      if (rest.some((arg) => /^-[a-zA-Z]*k/.test(literalText(arg.exp) ?? ""))) {
+    case "fuser": {
+      const kills = rest.some((arg) => mayBeOption(arg, (text) => /^-[a-zA-Z]*k/.test(text) || text === "--kill"));
+      const readable2 = rest.every((arg) => literalText(arg.exp) !== undefined);
+      const mayBeSeveral = rest.some((arg) => arg.fields === "unknown");
+      if (kills && (readable2 || mayBeSeveral || rest.length > 1)) {
         throw new Refusal(site.snippet, site.line, "`fuser -k` kills every process using a file, other agents' included; a pane signals only " + "processes it started");
       }
       return;
+    }
     case "tmux": {
       let socket;
       let socketIsPath = false;
-      for (let i = 0;i < rest.length; i += 1) {
-        const text = literalText(rest[i]?.exp);
-        if (text === "-L" || text === "-S" || text === "--socket") {
-          socket = rest[i + 1];
-          socketIsPath = text !== "-L";
-          i += 1;
-        } else if (text?.startsWith("--socket=")) {
-          socket = { text, exp: [literal2(text.slice(9))] };
-          socketIsPath = true;
+      let current = { words: [], speculative: false };
+      const segments = [current];
+      for (const arg of rest) {
+        const word = literalText(arg.exp);
+        const trailing = word !== ";" && word !== undefined && word.endsWith(";");
+        if (trailing)
+          current.words.push({ text: arg.text, exp: [literal2(word.slice(0, -1))] });
+        else if (word !== ";")
+          current.words.push(arg);
+        if (word === ";" || trailing) {
+          current = { words: [], speculative: false };
+          segments.push(current);
+        } else if (word === undefined || arg.fields === "unknown") {
+          current = { words: [], speculative: true };
+          segments.push(current);
         }
       }
       const killCommands = ["kill-server", "kill-session", "kill-window", "kill-pane"];
       const respawnCommands = ["respawn-pane", "respawn-window"];
-      const respawning = rest.some((arg) => {
-        const text = literalText(arg.exp);
-        if (text === undefined)
+      const names = (word, commands) => {
+        if (word === undefined)
           return false;
+        const { text, whole } = readableWord(word);
         const compact = text.replace("-", "");
-        return respawnCommands.filter((command) => command.replace("-", "").startsWith(compact)).length === 1;
-      }) && rest.some((arg) => literalText(arg.exp) === "-k");
-      const killing = rest.find((arg) => {
-        const text = literalText(arg.exp);
-        if (text === undefined)
-          return false;
-        const compact = text.replace("-", "");
-        return killCommands.filter((command) => command.replace("-", "").startsWith(compact)).length === 1 || respawning;
-      });
+        const reachable = commands.filter((command) => command.replace("-", "").startsWith(compact));
+        return whole ? reachable.length === 1 : reachable.length > 0;
+      };
+      let killing;
+      for (const segment of segments) {
+        const words = segment.words;
+        let subcommand;
+        for (let i = 0;i < words.length; i += 1) {
+          const arg = words[i];
+          const { text, whole } = readableWord(arg);
+          const attached = (option) => text.startsWith(option) && (!whole || text.length > option.length) ? valueInWord(arg, option.length) : undefined;
+          const carried = attached("-L") ?? attached("-S") ?? attached("--socket=");
+          if (carried !== undefined) {
+            socket = { text: arg.text, exp: carried };
+            socketIsPath = !text.startsWith("-L");
+          } else if (text === "-L" || text === "-S" || text === "--socket") {
+            socket = words[i + 1];
+            socketIsPath = text !== "-L";
+            i += 1;
+          } else if (text === "-f" || text === "-T") {
+            i += 1;
+          } else if (subcommand === undefined && !text.startsWith("-")) {
+            subcommand = arg;
+          }
+        }
+        if (segment.speculative && (subcommand === undefined || readableWord(subcommand).text === ""))
+          continue;
+        const respawning = names(subcommand, respawnCommands) && words.some((arg) => mayBeOption(arg, (text) => text === "-k"));
+        if (names(subcommand, killCommands) || respawning)
+          killing ??= subcommand;
+      }
       if (killing === undefined)
         return;
       let resolvedSocket;
@@ -43685,13 +43832,19 @@ function dispatch(invocation, outer, ctx) {
       if (resolvedSocket !== undefined && judgePath(resolvedSocket, st, ctx, { follow: true, overwrite: false }).ok) {
         return;
       }
-      throw new Refusal(site.snippet, site.line, `\`tmux ${literalText(killing.exp)}\` needs a socket path inside this pane's roots; the ` + "resolved socket can end panes and processes this pane did not start");
+      throw new Refusal(site.snippet, site.line, `\`tmux ${killing.text}\` needs a socket path inside this pane's roots; the ` + "resolved socket can end panes and processes this pane did not start");
+    }
+    case "busybox":
+    case "toybox": {
+      if (rest.length === 0)
+        return;
+      throw new Refusal(site.snippet, site.line, `the guard cannot read the applet \`${rest[0].text}\` ${base} would run, and the ` + "applets it carries include `rm`, `sh` and `killall`, which reach paths and processes " + `this pane did not start; name the applet (\`${base} rm \u2026\`) so it can be checked`);
     }
     default:
       break;
   }
-  if (SHELLS.has(base) || base === "busybox" && SHELLS.has(literalText(rest[0]?.exp) ?? "")) {
-    runShell(base === "busybox" ? rest.slice(1) : rest, invocation, st, ctx);
+  if (SHELLS.has(base)) {
+    runShell(rest, invocation, st, ctx);
     return;
   }
   const interpreter = interpreterLanguage(base);
@@ -43721,8 +43874,9 @@ function changeDirectory(target, st, ctx) {
 function declaration(builtin, list, st, ctx, site) {
   const options = list.map((arg) => literalText(arg.exp) ?? "").filter((text) => /^[-+][a-zA-Z]+$/.test(text));
   const option = (letter) => options.some((text) => text.startsWith("-") && text.includes(letter));
-  if (builtin !== "export" && option("n")) {
-    throw new Refusal(site.snippet, site.line, "the guard does not follow a nameref (`declare -n`), whose writes land in the variable it names");
+  const mayBeNameref = list.some((arg) => mayBeOption(arg, (text) => /^-[a-zA-Z]*n/.test(text)));
+  if (builtin !== "export" && mayBeNameref) {
+    throw new Refusal(site.snippet, site.line, option("n") ? "the guard does not follow a nameref (`declare -n`), whose writes land in the variable it names" : `an option word \`${builtin}\` carries that the guard cannot read may be \`-n\`, a nameref ` + "whose writes land in the variable it names and which the guard does not follow; write " + "the option as a literal");
   }
   if (option("f") || option("F"))
     return;
@@ -43907,11 +44061,20 @@ function checkRecursiveMode(program, list, st, ctx, site) {
     }
     found.push(arg);
   }
-  if (!recursive)
-    return;
-  const targets = reference ? found : found.slice(1);
   const verb = program === "chmod" ? "recursively change the mode of" : "recursively change the owner of";
-  checkTargets(`${program} -R`, verb, targets, true, st, ctx, site);
+  if (recursive) {
+    checkTargets(`${program} -R`, verb, reference ? found : found.slice(1), true, st, ctx, site);
+    return;
+  }
+  for (const [index, arg] of found.entries()) {
+    if (!mayBeOption(arg, (text) => /^-[A-Za-z]*R/.test(text)))
+      continue;
+    const others = arg.fields === "unknown" ? found : found.filter((_, at) => at !== index);
+    const targets = reference || arg.fields === "unknown" ? others : others.slice(1);
+    if (targets.length === 0)
+      continue;
+    checkTargets(`${program} -R`, verb, targets, true, st, ctx, site);
+  }
 }
 function checkFind(list, st, ctx, site) {
   let i = 0;
@@ -43926,17 +44089,27 @@ function checkFind(list, st, ctx, site) {
     break;
   }
   const starts = [];
+  let rootsBeforePredicate;
   for (;i < list.length; i += 1) {
-    const text = literalText(list[i]?.exp);
+    const arg = list[i];
+    const text = literalText(arg.exp);
     if (text !== undefined && (text.startsWith("-") || text === "(" || text === "!" || text === ")"))
       break;
-    starts.push(list[i]);
+    if (rootsBeforePredicate === undefined && mayBeOption(arg, (option) => option.startsWith("-"))) {
+      rootsBeforePredicate = [...starts];
+    }
+    starts.push(arg);
   }
   const targets = starts.length > 0 ? starts : [{ text: ".", exp: [literal2(".")] }];
   const expression = list.slice(i).map((arg) => literalText(arg.exp));
   let action;
   let shell;
+  let consumedByPredicate = false;
   for (const [index, word] of expression.entries()) {
+    const isValue = consumedByPredicate;
+    consumedByPredicate = word !== undefined && FIND_VALUED_PREDICATES.has(word);
+    if (word === undefined && !isValue)
+      action ??= "find with a predicate the guard cannot read";
     if (word === "-delete")
       action = "find -delete";
     if (word !== "-exec" && word !== "-execdir" && word !== "-ok" && word !== "-okdir")
@@ -43953,8 +44126,13 @@ function checkFind(list, st, ctx, site) {
       shell = inner.argv;
     }
   }
-  if (action === undefined)
+  if (action === undefined) {
+    if (rootsBeforePredicate === undefined)
+      return;
+    const under = rootsBeforePredicate.length > 0 ? rootsBeforePredicate : [{ text: ".", exp: [literal2(".")] }];
+    checkTargets("find with a root the guard cannot read, which may be a predicate", "delete or change what it finds under", under, false, st, ctx, site);
     return;
+  }
   checkTargets(action, "delete or change what it finds under", targets, false, st, ctx, site);
   if (shell === undefined)
     return;
@@ -44231,7 +44409,7 @@ function runInterpreter(base, language, list, invocation, st, ctx) {
   for (;i < words.length; i += 1) {
     const word = words[i];
     if (word === undefined)
-      return;
+      continue;
     if (codeFlags.includes(word)) {
       runCode(language, list[i + 1], invocation, st, ctx, site);
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-legion-envoy",
-  "version": "5.17.2",
+  "version": "5.17.3",
   "type": "module",
   "omp": {
     "extensions": [