@ai-ecoverse/slicc-spectrum 1.109.0 → 1.109.1

package/README.md

@@ -682,6 +682,7 @@ It takes a sudo request's command (without `sudo` and its options) and working f
 
 - `certain` is an absolute path when the command names a file or folder holding SLICC's secret rules (`/etc/fnox`, `/etc/fnox/config.toml`, `/etc/slicc/secrets-policy.toml`), a folder above them it changes as a whole (`/`, `/etc`, `/etc/slicc`), a glob or brace that matches one, or a file named like them (`fnox`, `secrets-policy`) anywhere, as `/tmp/fnox/config.toml`.
   It sees through quotes, backslashes, `$'…'` and `$"…"`, `cd` and `pushd` (also inside `bash -c`), relative paths and `..`, extglobs, `/proc/self/root` and `/proc/self/cwd`, option clusters like `-t/etc/fnox`, and comma lists.
+  When every command in it is read-only and nothing in it expands, quoted text is data: a jq or yq program such as `'.a // .b | {x: .y}'` isn't split into paths, and `*`, `?`, `[` and `{` in quotes (and `$` in single quotes) are literal, as the shell treats them. Other commands, such as `sh -c '…'`, are still looked into.
 - `maybe` is the token when the command may reach one of them and the check can't tell where it leads: an expansion (`$X`, `$(…)`, backticks), a `~user/..`, `~+` or `~-` path, a `/proc/<pid>/cwd` or `/dev/fd` path, or a command over 4096 characters (its first 40 followed by `…`).
 
 Both are `null` for a clean command, and at most one is set.
@@ -945,8 +946,9 @@ Later backed by: BIOS.
 `list()` returns waiting `Approval`s; emit `approvals` when the list changes.
 A `sudo` approval has `id`, `requester` (`kind` `agent` or `user`, `name`, optional `agentId` and `where`, such as a terminal's title), `command` (without `sudo`; bios joins the kernel's argv shell-quoted), optional `target` (the user to run as; shown as `sudo -u {target}` unless `root`), optional `cwd` and `verdict` (`{ decision: 'allow' | 'deny' | 'unsure', reason }`, the automatic check’s view), `createdAt`, `expiresAt` (epoch ms) and `always` (offer Always allow, which covers the requester's user and this exact command).
 With `decide(id, 'once' | 'always' | 'deny')`, which resolves once the decision is recorded and then drops the request from `list()`, the tab shows a warning alert dialog (`dialog[data-approval][data-kind][data-requester]`): "Allow sudo?", "{name} wants to run this with sudo[ in {where}]:" for an agent or "You ran this with sudo[ in {where}] (as {name}):" for a user, the command, "In {cwd}", a notice when the command changes secret rules, what Always allow does, "Denied automatically in m:ss." and how many more wait, with **Deny** (`data-action="deny"`, focused; Escape also denies), **Always allow** (`always`) and **Allow once** (`once`).
-A command that names `/etc/fnox` (or anything in it) or `/etc/slicc/secrets-policy.toml`, resolved against `cwd`, globs included (with quotes and backslashes removed, operands after `--` included; a path with `[`, `{` or `$` counts when the part before it could lead to them), or that names `/`, `/etc` or `/etc/slicc` in a command other than a read-only one (such as `ls`, `cat`, `stat` or `grep`), or runs with `cwd` in `/etc/fnox`, or names a relative path with `fnox` or `secrets-policy` in it wherever `cd` may have led, gets "This changes secret rules." with the path (`[data-secret-rules]`, the path in the attribute).
+A command that names `/etc/fnox` (or anything in it) or `/etc/slicc/secrets-policy.toml`, resolved against `cwd`, globs included (with quotes and backslashes removed, operands after `--` included; a path with `[`, `{` or `$` counts when the part before it could lead to them), or that names `/`, `/etc` or `/etc/slicc` in a command other than a read-only one (such as `ls`, `cat`, `stat`, `grep`, `jq`, `cut`, `od`, `sha256sum` or `md5sum`; `find` without `-exec`, `-execdir`, `-ok`, `-okdir`, `-delete` or `-fprint`/`-fls`; `sort` without `-o`, `-T` or `--compress-program`; `yq` without `-i`, `-s` or `--split-exp-file`; `base64` without `-o`; `tree` without `-o` or `-R`; `file` without `-C`; `uniq` and `xxd` with one operand at most, counting everything after `--`; a flag counts inside a short cluster, with a value attached (`-o/x`, `-i.bak`), as `--name=value` and abbreviated; `less` and other pagers aren't, since they run commands), or runs with `cwd` in `/etc/fnox`, or names a relative path with `fnox` or `secrets-policy` in it wherever `cd` may have led, gets "This changes secret rules." with the path (`[data-secret-rules]`, the path in the attribute).
 Read-only commands count only by bare name or from `/bin` and `/usr/bin`.
+In a command made only of read-only commands and with no live expansion, the quoted words count whole: `jq '.a // .b' f` doesn't name `/`, and `jq '{a: .b}' f` in `/etc` isn't a brace that could lead to the rules.
 `/proc/<pid>/root` counts as `/` and `/proc/self/cwd` as `cwd`.
 Otherwise a command with a parameter expansion or command substitution (`$…`, backticks), a `~+` or `~-` path or a `~` path that climbs with `..`, a path through another process's `/proc/<pid>/cwd`, `fd` or `map_files` or through `/dev/fd`, or more than 4096 characters, gets "This may change secret rules." with the first such part in the attribute.
 Other symlinks aren't followed.

package/dist/slicc-ui.js

@@ -10331,8 +10331,8 @@ var ranges = [
   [100, "bg", 8]
 ];
 function simple(code3) {
-  const flag = flags[code3];
-  if (flag) return flag;
+  const flag2 = flags[code3];
+  if (flag2) return flag2;
   const range2 = ranges.find(([start2]) => code3 >= start2 && code3 < start2 + 8);
   return range2 ? { [range2[1]]: code3 - range2[0] + range2[2] } : null;
 }
@@ -40184,12 +40184,12 @@ var SliccMonitor = class extends ModelElement {
     </li>`;
   }
   #section(section) {
-    const flag = attention2(section);
+    const flag2 = attention2(section);
     const surface2 = surfaces[section.id];
     const rows2 = section.rows.length > 0;
-    const open = rows2 && (this.expanded[section.id] ?? flag !== null);
+    const open = rows2 && (this.expanded[section.id] ?? flag2 !== null);
     const list6 = `rows-${section.id}`;
-    const badge = flag ? b`<swc-badge size="s" variant=${flag.variant} subtle>${flag.text}</swc-badge>` : A;
+    const badge = flag2 ? b`<swc-badge size="s" variant=${flag2.variant} subtle>${flag2.text}</swc-badge>` : A;
     return b`<li class="section" data-id=${section.id} data-open=${open ? "" : A}>
       <div class="line">
         <span class="caption">${rows2 ? b`<button class="toggle" aria-expanded=${open ? "true" : "false"} aria-controls=${open ? list6 : A} @click=${() => {
@@ -44002,14 +44002,14 @@ var directions2 = /* @__PURE__ */ new Set(["left", "right", "above", "below", "w
 function scan(parsed, rest, positional) {
   for (let index2 = 0; index2 < rest.length; index2++) {
     const arg = rest[index2];
-    const flag = arg.startsWith("--") ? arg.slice(2) : null;
-    if (flag === "json") parsed.json = true;
-    else if (flag === "section" || flag !== null && directions2.has(flag)) {
+    const flag2 = arg.startsWith("--") ? arg.slice(2) : null;
+    if (flag2 === "json") parsed.json = true;
+    else if (flag2 === "section" || flag2 !== null && directions2.has(flag2)) {
       const value = rest[++index2];
-      if (value === void 0) return `--${flag} needs a value`;
-      if (flag === "section") parsed.section = value;
+      if (value === void 0) return `--${flag2} needs a value`;
+      if (flag2 === "section") parsed.section = value;
       else if (parsed.place) return "give one place";
-      else parsed.place = { direction: flag, ref: value };
+      else parsed.place = { direction: flag2, ref: value };
     } else if (arg.startsWith("-")) return `unknown option ${arg}`;
     else positional.push(arg);
   }
@@ -49679,27 +49679,67 @@ function pattern(path2) {
 var opaque = /^\/(?:proc\/[^/]+\/(?:task\/[^/]+\/)?(?:cwd|fd|map_files)|dev\/fd)(?:\/|$)/;
 var certain = (rules) => rules.startsWith("/") && !opaque.test(rules) && !rules.endsWith("\u2026");
 var readOnly = [
+  "b2sum",
+  "base64",
   "cat",
   "cd",
+  "cksum",
+  "cut",
   "df",
   "diff",
   "du",
   "echo",
   "file",
+  "find",
   "grep",
   "head",
+  "jq",
   "ls",
+  "md5sum",
+  "nl",
+  "od",
   "pwd",
   "readlink",
   "realpath",
+  "sha1sum",
+  "sha224sum",
+  "sha256sum",
+  "sha384sum",
+  "sha512sum",
+  "sort",
   "stat",
+  "tac",
   "tail",
   "tree",
-  "wc"
+  "uniq",
+  "wc",
+  "xxd",
+  "yq"
 ];
+var flag = (short2, long) => (args2) => args2.some((arg) => {
+  if (!arg.startsWith("--")) return /^-[^-]/.test(arg) && [...short2].some((c29) => arg.includes(c29));
+  const [name] = arg.slice(2).split("=");
+  return !!name && long.some((option) => option.startsWith(name));
+});
+var operands = (args2) => {
+  const end = args2.includes("--") ? args2.indexOf("--") : args2.length;
+  const named2 = args2.slice(0, end).filter((arg) => arg === "-" || !arg.startsWith("-"));
+  return named2.length + args2.slice(end + 1).length > 1;
+};
+var writes = {
+  base64: flag("o", ["output"]),
+  file: flag("C", ["compile"]),
+  find: (args2) => args2.some((arg) => /^-(?:delete|exec|execdir|ok|okdir|fls|fprint0?|fprintf)$/.test(arg)),
+  sort: flag("oT", ["output", "temporary-directory", "compress-program"]),
+  tree: flag("oR", []),
+  uniq: operands,
+  xxd: operands,
+  yq: flag("is", ["inplace", "in-place", "split-exp", "split-exp-file"])
+};
 function candidates(word2) {
   if (word2 === "--") return [];
-  if (word2.startsWith("--")) return [word2];
+  if (word2.startsWith("--"))
+    return word2.includes("=") ? [word2, word2.split("=").slice(1).join("=")] : [word2];
   if (!word2.startsWith("-")) return [word2];
   const slash = word2.indexOf("/");
   const cluster = Array.from(word2.slice(2), (_7, index2) => word2.slice(index2 + 2));
@@ -49719,7 +49759,10 @@ function protects(path2, whole) {
   return rulePaths.some((rule) => glob.test(rule)) || top !== path2 && pattern(top).test("/etc/fnox") || whole && ruleParents.some((parent) => glob.test(parent));
 }
 var command2 = (word2) => word2.split("/").pop() ?? "";
-var trusted2 = (word2) => readOnly.includes(word2.replace(/^\/(?:usr\/)?bin\/(?=[^/]+$)/, ""));
+var trusted2 = ([word2, ...args2]) => {
+  const name = word2.replace(/^\/(?:usr\/)?bin\/(?=[^/]+$)/, "");
+  return readOnly.includes(name) && !writes[name]?.(args2);
+};
 var expansion = /\$\([^)]*\)?|\$\{[^}]*\}?|\$[\w@*#?$!-]*|`[^`]*`?/;
 function moved(cwds, word2) {
   for (const cwd of [...cwds]) {
@@ -49795,6 +49838,8 @@ function shield(text4) {
   }
   return out;
 }
+var literal = (char, quote) => /[*?[{]/.test(char) || quote === "'" && char === "$" ? String.fromCharCode(57600 + char.charCodeAt(0)) : char;
+var unmark = (path2) => path2.replace(/[\ue100-\ue17f]/g, (char) => String.fromCharCode(char.charCodeAt(0) - 57600));
 function quoted(segment2) {
   const words2 = [];
   let word2 = "";
@@ -49805,7 +49850,7 @@ function quoted(segment2) {
       word2 += segment2[++index2];
     else if (quote) {
       if (char === quote) quote = "";
-      else word2 += char;
+      else word2 += literal(char, quote);
     } else if (char === "'" || char === '"') quote = char;
     else if (char === "\\") word2 += segment2[++index2] ?? "";
     else if (/[\s<>=]/.test(char)) {
@@ -49842,8 +49887,10 @@ function reach2(command3, cwd) {
   const text4 = unglob(ansi2(command3.replace(/\\\n/g, "")));
   const plain4 = text4.split(separators).map((segment2) => commas(segment2.split(/[\s<>=]+/).map((word2) => word2.replace(/['"\\]/g, ""))));
   const aware = shield(text4).split(separators).map((segment2) => commas(quoted(unshield(segment2))));
-  const segments = JSON.stringify(aware) === JSON.stringify(plain4) ? plain4 : [...plain4, ...aware];
-  const whole = segments.some((words2) => words2.length > 0 && !trusted2(words2[0]));
+  const live = text4.includes("`") || aware.flat().some((word2) => word2.includes("$"));
+  const inert2 = !live && aware.every((words2) => !words2.length || trusted2(words2));
+  const segments = inert2 || JSON.stringify(aware) === JSON.stringify(plain4) ? aware : [...plain4, ...aware];
+  const whole = !inert2 && segments.some((words2) => words2.length > 0 && !trusted2(words2));
   for (const words2 of segments) {
     const hit = scan2(words2, cwds, whole);
     if (hit) return hit;
@@ -49855,7 +49902,8 @@ function reach2(command3, cwd) {
   return segments.flat().some((word2) => word2.includes("$")) || text4.includes("`") ? text4.match(expansion)[0] : null;
 }
 function secretRules(command3, cwd) {
-  const hit = reach2(command3, cwd);
+  const found = reach2(command3, cwd);
+  const hit = found && unmark(found);
   return hit && certain(hit) ? { certain: hit, maybe: null } : { certain: null, maybe: hit };
 }
 function origin() {
@@ -56112,7 +56160,7 @@ var bridge = `(() => {
   });
   post({ type: 'slicc-ready' });
 })();`;
-function literal(value) {
+function literal2(value) {
   try {
     return JSON.stringify(value ?? null).replace(/</g, "\\u003c");
   } catch {
@@ -56121,7 +56169,7 @@ function literal(value) {
 }
 function store(state2) {
   return `(() => {
-  let state = ${literal(state2)};
+  let state = ${literal2(state2)};
   const tag = Math.random().toString(36).slice(2);
   const pending = new Map();
   let next = 0;
@@ -75264,11 +75312,11 @@ function isDirectoryNode(node2) {
 function getNodeFlags(node2) {
   return node2.depthAndFlags & PATH_STORE_NODE_FLAGS_MASK;
 }
-function hasNodeFlag(node2, flag) {
-  return (getNodeFlags(node2) & flag) !== 0;
+function hasNodeFlag(node2, flag2) {
+  return (getNodeFlags(node2) & flag2) !== 0;
 }
-function addNodeFlag(node2, flag) {
-  node2.depthAndFlags |= flag;
+function addNodeFlag(node2, flag2) {
+  node2.depthAndFlags |= flag2;
 }
 function setNodeDepth(node2, depth) {
   node2.depthAndFlags = createNodeDepthAndFlags(depth, getNodeFlags(node2), getNodeKind(node2));