@sjawhar/pi-legion-envoy 5.17.4 → 5.17.5

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.4",
+  version: "5.17.5",
   type: "module",
   omp: {
     extensions: [
@@ -34780,6 +34780,7 @@ import {
   opendirSync,
   openSync,
   readFileSync as readFileSync3,
+  readlinkSync,
   readSync,
   realpathSync,
   statSync
@@ -41624,6 +41625,70 @@ function realish(abs, followFinal) {
     return realExisting(resolved);
   return path4.join(realExisting(path4.dirname(resolved)), path4.basename(resolved));
 }
+function readlinkTarget(link) {
+  try {
+    return readlinkSync(link);
+  } catch {
+    return "a target the guard cannot read";
+  }
+}
+function physical(cwd, text, followFinal) {
+  const joined = text.startsWith("/") ? text : `${cwd}/${text}`;
+  const parts = joined.split("/");
+  const last = parts.findLastIndex((part) => part !== "" && part !== ".");
+  const pending = [];
+  let real = "/";
+  for (let i = 0;i < parts.length; i += 1) {
+    const part = parts[i];
+    if (part === "" || part === ".")
+      continue;
+    if (pending.length > 0) {
+      if (part === "..") {
+        return {
+          unknown: `\`${path4.join(real, ...pending)}\`, which does not exist yet, so the guard ` + "cannot know where the `..` after it leads"
+        };
+      }
+      pending.push(part);
+      continue;
+    }
+    if (part === "..") {
+      real = path4.dirname(real);
+      continue;
+    }
+    const candidate = real === "/" ? `/${part}` : `${real}/${part}`;
+    if (!followFinal && i === last) {
+      return { real: candidate };
+    }
+    let link;
+    try {
+      link = lstatSync(candidate).isSymbolicLink();
+    } catch (error48) {
+      if (error48.code !== "ENOENT") {
+        return { unknown: `\`${candidate}\`, which the guard cannot read (${messageFor(error48)})` };
+      }
+      pending.push(part);
+      continue;
+    }
+    if (!link) {
+      real = candidate;
+      continue;
+    }
+    try {
+      real = realpathSync(candidate);
+    } catch (error48) {
+      const code = error48.code;
+      const why = code === "ENOENT" ? `points at \`${readlinkTarget(candidate)}\`, which is not there` : `cannot be followed (${messageFor(error48)})`;
+      return { unknown: `the link \`${candidate}\` ${why}, so the guard cannot resolve this path` };
+    }
+  }
+  return { real: pending.length === 0 ? real : path4.join(real, ...pending) };
+}
+function kernelPath(from, text) {
+  if (from === undefined && !text.startsWith("/"))
+    return;
+  const resolved = physical(from ?? "/", text, true);
+  return "unknown" in resolved ? undefined : resolved.real;
+}
 function isProtectedScratchComponent(component, roots, partial2 = false) {
   return roots.protectedScratch.some((name) => component.startsWith(name) || partial2 && name.startsWith(component)) || roots.protectedDirectories.some((name) => component === name || partial2 && name.startsWith(component));
 }
@@ -41656,12 +41721,16 @@ function judgePath(exp, st, ctx, options) {
         resolution: `relative to a working directory unknown after ${st.cwdWhy}`
       };
     }
-    const abs = path4.resolve(st.cwd ?? "/", text);
-    const real2 = realish(abs, options.follow || text.endsWith("/"));
+    const resolved2 = physical(st.cwd ?? "/", text, options.follow || text.endsWith("/"));
+    if ("unknown" in resolved2) {
+      return { ok: false, resolution: resolved2.unknown, unresolved: true };
+    }
+    const real2 = resolved2.real;
     if (inWorkspace(real2, roots) || inScratch(real2, roots))
       return { ok: true };
     if (options.overwrite && !existsSync(real2))
       return { ok: true };
+    const abs = path4.resolve(st.cwd ?? "/", text);
     return { ok: false, resolution: real2 === abs ? real2 : `${abs}, which resolves to ${real2}` };
   }
   const piece = exp[open];
@@ -41676,11 +41745,13 @@ function judgePath(exp, st, ctx, options) {
     return { ok: false, resolution: `relative to a working directory unknown after ${st.cwdWhy}` };
   }
   const component = prefix.slice(slash + 1);
-  let stem = path4.resolve(st.cwd ?? "/", slash === -1 ? "." : slash === 0 ? "/" : prefix.slice(0, slash));
-  if (piece.kind === "glob" && (component === "" ? piece.text : component).startsWith(".")) {
-    stem = path4.dirname(stem);
+  const stemText = slash === -1 ? "." : slash === 0 ? "/" : prefix.slice(0, slash);
+  const resolved = physical(st.cwd ?? "/", stemText, true);
+  if ("unknown" in resolved) {
+    return { ok: false, resolution: resolved.unknown, unresolved: true };
   }
-  const real = realish(stem, true);
+  const dotGlob = piece.kind === "glob" && (component === "" ? piece.text : component).startsWith(".");
+  const real = dotGlob ? path4.dirname(resolved.real) : resolved.real;
   const allowed = inWorkspace(real, roots) || inScratch(real, roots) || real === roots.scratch && component !== "" && !isProtectedScratchComponent(component, roots, true);
   if (allowed)
     return { ok: true };
@@ -42014,12 +42085,13 @@ function patternExpansion(part, quoted, st, ctx) {
   return [unquotedLiteral(result.replaceAll("\\", "\\\\"), undefined, st, ctx)];
 }
 function substitution(script, text, st, ctx) {
-  const pidRead = /^\$\(<(.+)\)$/.exec(text);
-  const variableRead = /^\$\(<"?\$([A-Za-z_][A-Za-z0-9_]*)"?\)$/.exec(text);
+  const pidRead = /^\$\(<\s*(.+?)\s*\)$/.exec(text);
+  const variableRead = /^\$\(<\s*"?\$([A-Za-z_][A-Za-z0-9_]*)"?\s*\)$/.exec(text);
   const directFile = pidRead?.[1]?.includes("$") === true ? undefined : pidRead?.[1];
   const file2 = directFile ?? (variableRead === null ? undefined : literalText(lookup(variableRead[1], st, ctx)));
-  if (file2 !== undefined && st.cwd !== undefined) {
-    const pid = st.pidFiles.get(path4.resolve(st.cwd, file2));
+  const pidFile = file2 === undefined ? undefined : kernelPath(st.cwd, file2);
+  if (pidFile !== undefined) {
+    const pid = st.pidFiles.get(pidFile);
     if (pid !== undefined)
       return [[...pid]];
   }
@@ -42073,22 +42145,70 @@ function substitutionInvocation(node, st, ctx) {
     return;
   return { base: path4.basename(name), command: node, rest: argv.slice(1) };
 }
+function gnuDirname(text) {
+  const trimmed = text.replace(/\/+$/, "");
+  if (trimmed === "")
+    return "/";
+  const cut = trimmed.replace(/\/+[^/]+$/, "");
+  if (cut === trimmed)
+    return ".";
+  return cut === "" ? "/" : cut;
+}
+function gnuBasename(text) {
+  const trimmed = text.replace(/\/+$/, "");
+  if (trimmed === "")
+    return text === "" ? "" : "/";
+  return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+}
 function substitutionPath(base, list, st) {
   if (!["dirname", "basename", "realpath", "readlink"].includes(base))
     return;
-  const target = literalText(operands(list, "").operands.at(-1)?.exp);
-  if (target === undefined || st.cwd === undefined)
+  const found = operands(list, "");
+  if (base === "basename" && found.options.some((option) => option === "--multiple" || option.startsWith("--suffix") || /^-[^-]*[as]/.test(option))) {
+    return;
+  }
+  const suffixed = base === "basename" && found.operands.length === 2;
+  if (found.operands.length !== 1 && !suffixed)
+    return;
+  const target = literalText(found.operands[0]?.exp);
+  const suffix = suffixed ? literalText(found.operands[1]?.exp) : "";
+  if (target === undefined || suffix === undefined || st.cwd === undefined)
     return;
   if (target === "")
     return base === "dirname" ? "." : "";
-  const abs = path4.resolve(st.cwd, target);
   if (base === "dirname")
-    return path4.dirname(abs);
-  if (base === "basename")
-    return path4.basename(abs);
-  if (base === "readlink" && !list.some((arg) => literalText(arg.exp)?.includes("f")))
-    return;
-  return realExisting(abs);
+    return gnuDirname(target);
+  if (base === "basename") {
+    const name = gnuBasename(target);
+    return suffix !== "" && name !== suffix && name.endsWith(suffix) ? name.slice(0, -suffix.length) : name;
+  }
+  if (base === "readlink") {
+    const mode = lastModeFlag(found.options, "fem", {
+      "--canonicalize": "f",
+      "--canonicalize-existing": "e",
+      "--canonicalize-missing": "m"
+    });
+    if (mode !== "f" && mode !== "m")
+      return;
+  }
+  if (base === "realpath") {
+    if (found.options.some((option) => option.startsWith("--relative")))
+      return;
+    const mode = lastModeFlag(found.options, "sLP", {
+      "--strip": "s",
+      "--no-symlinks": "s",
+      "--logical": "L",
+      "--physical": "P"
+    });
+    if (mode === "s" || mode === "L") {
+      const here = kernelPath("/", st.cwd);
+      if (here === undefined)
+        return;
+      const lexical = path4.resolve(here, target);
+      return mode === "s" ? lexical : kernelPath("/", lexical);
+    }
+  }
+  return kernelPath(st.cwd, target);
 }
 function mktempPath(command, st, ctx) {
   const words = command.suffix;
@@ -42107,7 +42227,7 @@ function mktempPath(command, st, ctx) {
     else if (value.startsWith("-p") && value.length > 2)
       directory = [literal2(value.slice(2))];
     else if (!value.startsWith("-") && value.includes("/")) {
-      directory = [literal2(path4.resolve(st.cwd ?? "/", path4.dirname(value)))];
+      directory = [literal2(path4.dirname(value))];
     }
   }
   const base = directory ?? [literal2(ctx.env.TMPDIR ?? "/tmp")];
@@ -42553,6 +42673,10 @@ function modelPidFile(st, ctx, file2, pid) {
     model.set(file2, [unknown2("a pid a branch or loop body wrote to this file", true)]);
   }
 }
+function forgetFileModels(st, ctx, why) {
+  st.pidFiles.clear();
+  ctx.unnameableWrite.why ??= why;
+}
 function handlerVars(trap, vars) {
   const { vars: branch, merged } = trap;
   if (branch === undefined || merged === undefined)
@@ -42944,13 +43068,15 @@ function checkRedirects(redirects, command, site, st, ctx) {
       if (writes || operator === ">&") {
         const verdict = judgePath(exp, st, ctx, { follow: true, overwrite: true });
         if (!verdict.ok) {
-          throw refusal(site, `the redirection \`${operator}\` would overwrite \`${redirect.target.text}\` (${verdict.resolution})`, ctx);
+          throw refusal(site, `the redirection \`${operator}\` would overwrite \`${redirect.target.text}\` (${verdict.resolution})`, ctx, verdict.unresolved);
         }
       }
       const target = literalText(exp);
-      if (target === undefined || st.cwd === undefined && !target.startsWith("/"))
+      const file2 = target === undefined ? undefined : kernelPath(st.cwd, target);
+      if (file2 === undefined) {
+        forgetFileModels(st, ctx, `the redirection \`${operator} ${redirect.target.text}\``);
         continue;
-      const file2 = path4.resolve(st.cwd ?? "/", target);
+      }
       let content = null;
       if (command?.name === "cat" && command.args.length === 0) {
         if (heredoc !== undefined)
@@ -42984,9 +43110,9 @@ function groupOutputFile(statement, st, ctx) {
   }
   const targets = expandWord(redirect.target, st, ctx);
   const target = targets.length === 1 ? literalText(targets[0]) : undefined;
-  if (target === undefined || st.cwd === undefined && !target.startsWith("/"))
+  if (target === undefined)
     return;
-  return path4.resolve(st.cwd ?? "/", target);
+  return kernelPath(st.cwd, target);
 }
 function walkRenderingGroup(group, st, ctx) {
   let content = "";
@@ -43105,8 +43231,10 @@ function printfText(list, limit, script = false) {
   } while (conversions > 0 && index < values.length);
   return out;
 }
-function refusal(site, detail, ctx) {
-  return new Refusal(site.snippet, site.line, `${detail}, outside ${describeRoots(ctx.roots)}. ${HINT}`);
+function refusal(site, detail, ctx, unresolved = false) {
+  const where = unresolved ? `. Every target is resolved as the kernel resolves it, against ${describeRoots(ctx.roots)}` : `, outside ${describeRoots(ctx.roots)}`;
+  const hint = unresolved ? "Make the unresolved path component resolvable in an earlier command \u2014 create it, make " + "it readable, or fix a dangling or looping symlink \u2014 then run this command." : HINT;
+  return new Refusal(site.snippet, site.line, `${detail}${where}. ${hint}`);
 }
 function handleCommand(command, st, ctx, pipeIn) {
   const site = siteOf(command, st);
@@ -43204,6 +43332,16 @@ function operands(list, valued, longValued = []) {
   }
   return { options, operands: found };
 }
+function lastModeFlag(options, letters, long = {}) {
+  return options.flatMap((option) => {
+    const named = long[option];
+    if (named !== undefined)
+      return [named];
+    if (!/^-[a-zA-Z]+$/.test(option))
+      return [];
+    return [...option.slice(1)].filter((letter) => letters.includes(letter));
+  }).at(-1);
+}
 function unwrap2(argv, st, ctx, site) {
   const alts = [];
   let list = argv;
@@ -43287,10 +43425,10 @@ function unwrap2(argv, st, ctx, site) {
           i += 1;
         } else if (text === "-C" || text === "--chdir") {
           const dir = literalText(rest[i + 1]?.exp);
-          cwd = dir === undefined || state.cwd === undefined ? undefined : path4.resolve(state.cwd, dir);
+          cwd = dir === undefined ? undefined : kernelPath(state.cwd, dir);
           i += 1;
         } else if (text?.startsWith("--chdir=")) {
-          cwd = state.cwd === undefined ? undefined : path4.resolve(state.cwd, text.slice(8));
+          cwd = kernelPath(state.cwd, text.slice(8));
         } else if (text === "-S" || text === "--split-string") {
           const split = literalText(rest[i + 1]?.exp);
           const tail = rest.slice(i + 2);
@@ -43457,10 +43595,25 @@ function dispatch(invocation, outer, ctx) {
         outer.output = rest.length === 1 && rest[0] !== undefined ? [...outer.output, rest[0].exp] : undefined;
       }
       return;
-    case "cd":
+    case "cd": {
+      const found = operands(rest, "");
+      if (found.options.some((option) => !/^-[LPe]+$/.test(option))) {
+        outer.cwd = undefined;
+        outer.cwdWhy = "`cd` with an option the guard does not model";
+        return;
+      }
+      changeDirectory(found.operands[0], lastModeFlag(found.options, "LP") === "P", outer, ctx);
+      return;
+    }
     case "pushd": {
-      const target = operands(rest, "").operands[0];
-      changeDirectory(target, outer, ctx);
+      const found = operands(rest, "");
+      const operand = literalText(found.operands[0]?.exp);
+      if (found.options.length > 0 || found.operands[0] === undefined || operand?.startsWith("+") === true) {
+        outer.cwd = undefined;
+        outer.cwdWhy = "`pushd` with a directory stack or option the guard does not model";
+        return;
+      }
+      changeDirectory(found.operands[0], false, outer, ctx);
       return;
     }
     case "popd":
@@ -43812,16 +43965,18 @@ function dispatch(invocation, outer, ctx) {
         if (!append) {
           const verdict = judgePath(arg.exp, st, ctx, { follow: true, overwrite: true });
           if (!verdict.ok) {
-            throw refusal(site, `tee would overwrite \`${arg.text}\` (${verdict.resolution})`, ctx);
+            throw refusal(site, `tee would overwrite \`${arg.text}\` (${verdict.resolution})`, ctx, verdict.unresolved);
           }
         }
         const target = literalText(arg.exp);
-        if (target !== undefined && st.cwd !== undefined) {
-          const file2 = path4.resolve(st.cwd, target);
-          st.pidFiles.delete(file2);
-          const text = heredoc === undefined ? null : heredocText(heredoc);
-          modelWrite(st, ctx, file2, append ? UNREAD_FILE : text === null ? UNRENDERED_WRITE : readable(text) ?? OVERLONG_WRITE);
+        const file2 = target === undefined ? undefined : kernelPath(st.cwd, target);
+        if (file2 === undefined) {
+          forgetFileModels(st, ctx, `\`tee ${arg.text}\``);
+          continue;
         }
+        st.pidFiles.delete(file2);
+        const text = heredoc === undefined ? null : heredocText(heredoc);
+        modelWrite(st, ctx, file2, append ? UNREAD_FILE : text === null ? UNRENDERED_WRITE : readable(text) ?? OVERLONG_WRITE);
       }
       return;
     }
@@ -43946,7 +44101,7 @@ function dispatch(invocation, outer, ctx) {
     runFile(argv[0], rest, childState(st, invocation.overlay), ctx, site, "auto");
   }
 }
-function changeDirectory(target, st, ctx) {
+function changeDirectory(target, physicalMode, st, ctx) {
   if (target === undefined) {
     const home = literalText(lookup("HOME", st, ctx));
     st.cwd = home;
@@ -43959,7 +44114,13 @@ function changeDirectory(target, st, ctx) {
     st.cwdWhy = `\`cd ${target.text}\``;
     return;
   }
-  st.cwd = path4.resolve(st.cwd, text);
+  if (!physicalMode) {
+    st.cwd = path4.resolve(st.cwd, text);
+    return;
+  }
+  st.cwd = kernelPath(st.cwd, text);
+  if (st.cwd === undefined)
+    st.cwdWhy = `\`cd -P ${target.text}\``;
 }
 function declaration(builtin, list, st, ctx, site) {
   const options = list.map((arg) => literalText(arg.exp) ?? "").filter((text) => /^[-+][a-zA-Z]+$/.test(text));
@@ -44155,13 +44316,13 @@ function checkTargets(program, verb, targets, reach, st, ctx, site) {
         continue;
       const verdict = judgePath(target.exp, st, ctx, { follow, overwrite: reach.overwrite });
       if (!verdict.ok) {
-        throw refusal(site, `${program} would ${verb} \`${target.text}\` (${verdict.resolution})`, ctx);
+        throw refusal(site, `${program} would ${verb} \`${target.text}\` (${verdict.resolution})`, ctx, verdict.unresolved);
       }
     }
     const text = literalText(target.exp);
-    if (text !== undefined && (text.startsWith("/") || st.cwd !== undefined)) {
-      st.pidFiles.delete(path4.resolve(st.cwd ?? "/", text));
-    }
+    const file2 = text === undefined ? undefined : kernelPath(st.cwd, text);
+    if (file2 !== undefined)
+      st.pidFiles.delete(file2);
   }
 }
 function completeName(prefix, names) {
@@ -44917,7 +45078,14 @@ function runFile(file2, positional, st, ctx, site, kind, source = false) {
   if (text === undefined || !text.startsWith("/") && st.cwd === undefined) {
     throw new Refusal(site.snippet, site.line, `the guard cannot resolve the script \`${file2.text}\` (${file2.exp.find((p) => p.kind !== "literal")?.why ?? `a working directory unknown after ${st.cwdWhy}`}), so it cannot read what it runs`);
   }
-  const abs = path4.resolve(st.cwd ?? "/", text);
+  if (ctx.unnameableWrite.why !== undefined) {
+    throw new Refusal(site.snippet, site.line, `${ctx.unnameableWrite.why} writes a file the guard cannot name, so it cannot tell whether \`${file2.text}\` is the file that was written`);
+  }
+  const resolved = physical(st.cwd ?? "/", text, true);
+  if ("unknown" in resolved) {
+    throw new Refusal(site.snippet, site.line, `the guard cannot resolve the script \`${file2.text}\` (${resolved.unknown}), so it cannot read what it runs`);
+  }
+  const abs = resolved.real;
   let content;
   if (st.files.has(abs)) {
     const written = st.files.get(abs);
@@ -45045,7 +45213,7 @@ function checkCode(language, code, st, ctx, ipython = false) {
         overwrite: verb === "overwrite"
       });
       if (!verdict.ok) {
-        throw refusal({ snippet: call, line: 1 }, `${call} would ${verb} ${verdict.resolution}`, ctx);
+        throw refusal({ snippet: call, line: 1 }, `${call} would ${verb} ${verdict.resolution}`, ctx, verdict.unresolved);
       }
     },
     signal: (call, pid, group) => {
@@ -45116,6 +45284,7 @@ function createPaneGuard(options) {
     ompPid: options.ompPid,
     parentOf: options.parentOf ?? procParent,
     steps: { count: 0 },
+    unnameableWrite: { why: undefined },
     uncertain: { depth: 0 }
   });
   const initial = (cwd, source) => ({

package/package.json

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