tesseract-agent 0.11.39 → 0.11.41

package/dist-bundle/codex-rm-hook.js

@@ -0,0 +1,518 @@
+import { createRequire as __cr } from 'module';
+import { dirname as __dn } from 'path';
+import { fileURLToPath as __fu } from 'url';
+const require = __cr(import.meta.url);
+const __dirname = __dn(__fu(import.meta.url));
+
+// ../../packages/agent-core/dist/rm-guard.js
+import { lstatSync } from "node:fs";
+import { homedir } from "node:os";
+var RM_RULES = [
+  "Rules for deleting in this app (they hold in every mode and cannot be switched off):",
+  "1. rm, rmdir and unlink take only exact absolute paths \u2014 starting with / or ~/. Never a relative path, never . or .., never $VARIABLES, $(\u2026) or backticks.",
+  "2. A wildcard is allowed only inside an absolute folder that exists \u2014 rm -f /full/path/to/folder/* \u2014 never in /, a top-level folder, a mounted volume or the home folder.",
+  "3. The path must exist. Check it first (ls -d /full/path) instead of deleting blind.",
+  "4. find \u2026 -delete (or -exec rm) needs an absolute start folder under the same rules. xargs rm is refused: pass the exact paths to rm instead."
+].join("\n");
+var DELETERS = /* @__PURE__ */ new Set(["rm", "rmdir", "unlink"]);
+function checkRmCommand(command, env = {}) {
+  const ctx = { home: env.home ?? homedir(), exists: env.exists ?? existsOnDisk };
+  return checkScript(command, ctx, 0);
+}
+function existsOnDisk(p) {
+  try {
+    lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var SEPARATORS = /* @__PURE__ */ new Set([";", "&", "|", "\n", "(", ")"]);
+function newWord() {
+  return { text: "", glob: false, brace: false, dynamic: false, tilde: false };
+}
+function balanced(src, i) {
+  let depth = 1;
+  let quote = null;
+  const start = i;
+  for (; i < src.length; i++) {
+    const ch = src[i];
+    if (quote) {
+      if (ch === "\\" && quote === '"') {
+        i++;
+        continue;
+      }
+      if (ch === quote)
+        quote = null;
+      continue;
+    }
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "(")
+      depth++;
+    else if (ch === ")" && --depth === 0)
+      return { body: src.slice(start, i), end: i + 1 };
+  }
+  return { body: src.slice(start), end: src.length };
+}
+function parse(src) {
+  const commands = [];
+  const inner = [];
+  let words = [];
+  let w = null;
+  let redirectTarget = false;
+  const heredocs = [];
+  let pendingHeredoc = null;
+  const endWord = () => {
+    if (!w)
+      return;
+    if (pendingHeredoc)
+      heredocs.push({ tag: w.text, strip: pendingHeredoc.strip });
+    else if (!redirectTarget)
+      words.push(w);
+    pendingHeredoc = null;
+    redirectTarget = false;
+    w = null;
+  };
+  const endCommand = () => {
+    endWord();
+    if (words.length)
+      commands.push(words);
+    words = [];
+  };
+  const word = () => w ??= newWord();
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "\n") {
+      endCommand();
+      i++;
+      while (heredocs.length) {
+        const { tag, strip } = heredocs.shift();
+        for (; ; ) {
+          if (i >= src.length)
+            break;
+          const nl = src.indexOf("\n", i);
+          const line = src.slice(i, nl < 0 ? src.length : nl);
+          i = nl < 0 ? src.length : nl + 1;
+          if ((strip ? line.replace(/^\t+/, "") : line) === tag)
+            break;
+        }
+      }
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      endWord();
+      i++;
+      continue;
+    }
+    if (ch === "#" && !w) {
+      const nl = src.indexOf("\n", i);
+      i = nl < 0 ? src.length : nl;
+      continue;
+    }
+    if (ch === "\\") {
+      if (src[i + 1] === "\n") {
+        i += 2;
+        continue;
+      }
+      if (i + 1 < src.length)
+        word().text += src[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === "'") {
+      const close = src.indexOf("'", i + 1);
+      word().text += src.slice(i + 1, close < 0 ? src.length : close);
+      i = close < 0 ? src.length : close + 1;
+      continue;
+    }
+    if (ch === '"') {
+      const cur2 = word();
+      i++;
+      while (i < src.length && src[i] !== '"') {
+        const c = src[i];
+        if (c === "\\" && i + 1 < src.length && '$`"\\\n'.includes(src[i + 1])) {
+          if (src[i + 1] !== "\n")
+            cur2.text += src[i + 1];
+          i += 2;
+          continue;
+        }
+        if (c === "$" && src[i + 1] === "(") {
+          cur2.dynamic = true;
+          const b = balanced(src, i + 2);
+          inner.push(b.body);
+          i = b.end;
+          continue;
+        }
+        if (c === "$" && /[A-Za-z_{0-9@*#?$!-]/.test(src[i + 1] ?? "")) {
+          cur2.dynamic = true;
+          cur2.text += c;
+          i++;
+          continue;
+        }
+        if (c === "`") {
+          cur2.dynamic = true;
+          const close = src.indexOf("`", i + 1);
+          inner.push(src.slice(i + 1, close < 0 ? src.length : close));
+          i = close < 0 ? src.length : close + 1;
+          continue;
+        }
+        cur2.text += c;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "$") {
+      const next = src[i + 1];
+      if (next === "'") {
+        const close = src.indexOf("'", i + 2);
+        word().text += src.slice(i + 2, close < 0 ? src.length : close);
+        i = close < 0 ? src.length : close + 1;
+        continue;
+      }
+      if (next === "(") {
+        const cur2 = word();
+        cur2.dynamic = true;
+        if (src[i + 2] === "(") {
+          const b2 = balanced(src, i + 3);
+          i = Math.min(src.length, b2.end + 1);
+          continue;
+        }
+        const b = balanced(src, i + 2);
+        inner.push(b.body);
+        i = b.end;
+        continue;
+      }
+      if (next !== void 0 && /[A-Za-z_{0-9@*#?$!-]/.test(next)) {
+        const cur2 = word();
+        cur2.dynamic = true;
+        cur2.text += "$";
+        i++;
+        continue;
+      }
+      word().text += "$";
+      i++;
+      continue;
+    }
+    if (ch === "`") {
+      const cur2 = word();
+      cur2.dynamic = true;
+      const close = src.indexOf("`", i + 1);
+      inner.push(src.slice(i + 1, close < 0 ? src.length : close));
+      i = close < 0 ? src.length : close + 1;
+      continue;
+    }
+    if (ch === "<" || ch === ">" || ch === "&" && src[i + 1] === ">") {
+      if ((ch === "<" || ch === ">") && src[i + 1] === "(") {
+        endWord();
+        const b = balanced(src, i + 2);
+        inner.push(b.body);
+        i = b.end;
+        continue;
+      }
+      const before = w;
+      if (before && /^\d+$/.test(before.text) && !before.dynamic)
+        w = null;
+      else
+        endWord();
+      if (ch === "<" && src.startsWith("<<<", i)) {
+        i += 3;
+        redirectTarget = true;
+        continue;
+      }
+      if (ch === "<" && src[i + 1] === "<") {
+        const strip = src[i + 2] === "-";
+        i += strip ? 3 : 2;
+        pendingHeredoc = { strip };
+        continue;
+      }
+      i++;
+      while (i < src.length && "<>&|".includes(src[i]))
+        i++;
+      redirectTarget = true;
+      continue;
+    }
+    if (SEPARATORS.has(ch)) {
+      endCommand();
+      i++;
+      continue;
+    }
+    const cur = word();
+    if (ch === "*" || ch === "?" || ch === "[")
+      cur.glob = true;
+    if (ch === "~" && cur.text === "" && !cur.dynamic)
+      cur.tilde = true;
+    if (ch === "{") {
+      const close = src.indexOf("}", i);
+      const body = close < 0 ? "" : src.slice(i + 1, close);
+      if (body.includes(",") || body.includes(".."))
+        cur.brace = true;
+    }
+    cur.text += ch;
+    i++;
+  }
+  endCommand();
+  return { commands, inner };
+}
+var KEYWORDS = /* @__PURE__ */ new Set(["{", "}", "!", "then", "do", "else", "elif", "if", "while", "until", "fi", "done", "esac"]);
+var WRAPPERS = {
+  sudo: /* @__PURE__ */ new Set(["-u", "-g", "-C", "-h", "-p", "-r", "-t", "-U", "-D", "-T"]),
+  doas: /* @__PURE__ */ new Set(["-u", "-C"]),
+  env: /* @__PURE__ */ new Set(["-u", "-C", "-S", "-P"]),
+  command: /* @__PURE__ */ new Set(),
+  builtin: /* @__PURE__ */ new Set(),
+  exec: /* @__PURE__ */ new Set(["-a"]),
+  nohup: /* @__PURE__ */ new Set(),
+  nice: /* @__PURE__ */ new Set(["-n"]),
+  ionice: /* @__PURE__ */ new Set(["-c", "-n", "-p"]),
+  stdbuf: /* @__PURE__ */ new Set(["-i", "-o", "-e"]),
+  time: /* @__PURE__ */ new Set(["-f", "-o"]),
+  timeout: /* @__PURE__ */ new Set(["-s", "-k"]),
+  caffeinate: /* @__PURE__ */ new Set(["-t", "-w"]),
+  xargs: /* @__PURE__ */ new Set(["-n", "-P", "-I", "-L", "-d", "-E", "-s", "-a", "-J", "-R", "-S"])
+};
+var ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+function baseName(text) {
+  const slash = text.lastIndexOf("/");
+  return slash < 0 ? text : text.slice(slash + 1);
+}
+function commandOf(words) {
+  let k = 0;
+  let viaXargs = false;
+  while (k < words.length && (KEYWORDS.has(words[k].text) || ASSIGNMENT.test(words[k].text)))
+    k++;
+  while (k < words.length) {
+    const name = baseName(words[k].text);
+    const takesValue = WRAPPERS[name];
+    if (!takesValue)
+      break;
+    if (name === "xargs")
+      viaXargs = true;
+    k++;
+    while (k < words.length) {
+      const t = words[k].text;
+      if (t === "--") {
+        k++;
+        break;
+      }
+      if (t.startsWith("-") && t.length > 1) {
+        k += takesValue.has(t) ? 2 : 1;
+        continue;
+      }
+      if (name === "env" && ASSIGNMENT.test(t)) {
+        k++;
+        continue;
+      }
+      if (name === "timeout" && /^\d+(\.\d+)?[smhd]?$/.test(t)) {
+        k++;
+        continue;
+      }
+      break;
+    }
+  }
+  if (k >= words.length)
+    return null;
+  return { name: baseName(words[k].text), args: words.slice(k + 1), viaXargs, nameWord: words[k] };
+}
+function scriptOf(name, args) {
+  if (name === "eval")
+    return args.map((a) => a.text).join(" ");
+  if (!/^(ba|z|k|da|fi)?sh$/.test(name))
+    return void 0;
+  for (let j = 0; j < args.length; j++) {
+    const t = args[j].text;
+    if (/^-[A-Za-z]*c[A-Za-z]*$/.test(t))
+      return args[j + 1]?.text;
+    if (!t.startsWith("-"))
+      return void 0;
+  }
+  return void 0;
+}
+function checkScript(src, ctx, depth) {
+  if (depth > 4)
+    return null;
+  const { commands, inner } = parse(src);
+  for (const words of commands) {
+    const cmd = commandOf(words);
+    if (!cmd)
+      continue;
+    if (cmd.name === "cd") {
+      ctx.cdHint = literalAbsolute(cmd.args[0], ctx.home);
+      continue;
+    }
+    const script = scriptOf(cmd.name, cmd.args);
+    if (script) {
+      const r = checkScript(script, ctx, depth + 1);
+      if (r)
+        return r;
+      continue;
+    }
+    if (DELETERS.has(cmd.name) && !cmd.nameWord?.dynamic) {
+      const r = checkDeletion(cmd.name, cmd.args, cmd.viaXargs, ctx);
+      if (r)
+        return r;
+    } else if (cmd.name === "find") {
+      const r = checkFind(cmd.args, ctx);
+      if (r)
+        return r;
+    }
+  }
+  for (const s of inner) {
+    const r = checkScript(s, ctx, depth + 1);
+    if (r)
+      return r;
+  }
+  return null;
+}
+function checkDeletion(name, args, viaXargs, ctx) {
+  const operands = [];
+  let options = true;
+  for (const a of args) {
+    if (options && a.text === "--") {
+      options = false;
+      continue;
+    }
+    if (options && a.text.startsWith("-") && a.text.length > 1 && !a.dynamic)
+      continue;
+    operands.push(a);
+  }
+  if (viaXargs) {
+    return refuse("rm-unseen-targets", `xargs ${name}`, `\`xargs ${name}\` takes its targets from another command's output, so they cannot be checked before they are deleted. Pass the exact absolute paths to ${name} instead, or use \`find /absolute/folder \u2026 -delete\`.`);
+  }
+  for (const op of operands) {
+    const r = checkTarget(name, op, ctx);
+    if (r)
+      return r;
+  }
+  return null;
+}
+function checkFind(args, ctx) {
+  const deletes = args.some((a, j2) => a.text === "-delete" || /^-(exec|execdir|ok|okdir)$/.test(a.text) && DELETERS.has(baseName(args[j2 + 1]?.text ?? "")));
+  if (!deletes)
+    return null;
+  let j = 0;
+  while (j < args.length && /^-[HLP]$|^-O\d$/.test(args[j].text))
+    j++;
+  if (args[j]?.text === "-D")
+    j += 2;
+  const starts = [];
+  for (; j < args.length; j++) {
+    const t = args[j].text;
+    if (t.startsWith("-") || t === "(" || t === "!")
+      break;
+    starts.push(args[j]);
+  }
+  if (!starts.length) {
+    return refuse("rm-relative", "find (no folder)", "`find` without a start folder searches the folder it runs in, which may not be the one you expect. Give it the exact absolute folder: `find /absolute/folder \u2026 -delete`.");
+  }
+  for (const s of starts) {
+    const r = checkTarget("find", s, ctx, true);
+    if (r)
+      return r;
+  }
+  return null;
+}
+function tooBroad(path, home) {
+  const p = trimSlashes(path);
+  if (p === "" || p === "/")
+    return true;
+  const parts = p.split("/").filter(Boolean);
+  if (parts.length <= 1)
+    return true;
+  if ((parts[0] === "Volumes" || parts[0] === "mnt") && parts.length <= 2)
+    return true;
+  if (parts[0] === "media" && parts.length <= 3)
+    return true;
+  const h = trimSlashes(home);
+  return !!h && (p === h || h.startsWith(`${p}/`));
+}
+function trimSlashes(p) {
+  const t = p.replace(/\/+$/, "");
+  return t === "" && p.startsWith("/") ? "/" : t;
+}
+function literalAbsolute(w, home) {
+  if (!w || w.dynamic || w.glob || w.brace)
+    return void 0;
+  const t = w.tilde && (w.text === "~" || w.text.startsWith("~/")) ? home + w.text.slice(1) : w.text;
+  return t.startsWith("/") && !t.split("/").some((s) => s === "." || s === "..") ? trimSlashes(t) : void 0;
+}
+function checkTarget(name, op, ctx, isFindStart = false) {
+  const shown = op.text || "''";
+  const verb = isFindStart ? "find \u2026 -delete from" : name;
+  if (op.dynamic) {
+    return refuse("rm-dynamic", shown, `\`${verb} ${shown}\` uses a variable or a command's output ($VAR, $(\u2026), backticks), so what it deletes is not known until it runs \u2014 and an empty variable turns \`$DIR/*\` into \`/*\`. Write the exact absolute path instead.`);
+  }
+  let path = op.text;
+  if (op.tilde) {
+    if (path === "~" || path.startsWith("~/"))
+      path = ctx.home + path.slice(1);
+    else
+      return refuse("rm-dynamic", shown, `\`${shown}\` names another user's home folder. Write the exact absolute path instead.`);
+  }
+  if (!path.startsWith("/")) {
+    return refuse("rm-relative", shown, `\`${verb} ${shown}\` uses a relative path, which depends on the folder the command runs in \u2014 and that is not always the folder you think (a \`cd\` that went elsewhere, a different shell). Write the exact absolute path: \`${relativeFix(name, shown, ctx.cdHint)}\`${ctx.cdHint ? ` (this command \`cd\`s to ${ctx.cdHint} first \u2014 if that is the folder you mean, check it exists, then name it in full)` : ""}.`);
+  }
+  const segments = path.split("/");
+  if (segments.some((s) => s === "." || s === ".." || s.startsWith(".") && /[*?[]/.test(s) && op.glob)) {
+    return refuse("rm-dots", shown, `\`${verb} ${shown}\` has a \`.\` or \`..\` in it (or a \`.*\` wildcard, which also matches them). Write the exact absolute path with no dot segments.`);
+  }
+  const wild = op.glob || op.brace;
+  let anchor = path;
+  if (wild) {
+    const first = segments.findIndex((s) => /[*?[{]/.test(s));
+    anchor = segments.slice(0, Math.max(1, first)).join("/") || "/";
+  }
+  if (tooBroad(anchor, ctx.home)) {
+    const what = wild ? `a wildcard in \`${anchor}\`` : `\`${anchor}\``;
+    return refuse("rm-too-broad", shown, `\`${verb} ${shown}\` would delete ${what} \u2014 the disk root, a top-level folder, a mounted volume or the home folder. Name the exact folder or files to delete, deeper down.`);
+  }
+  if (!ctx.exists(trimSlashes(anchor))) {
+    return refuse("rm-missing", shown, wild ? `\`${verb} ${shown}\`: the folder \`${anchor}\` does not exist, so this is not the folder you meant. Check the path (ls -d ${anchor}) and use the one that exists.` : `\`${verb} ${shown}\`: \`${path}\` does not exist. Check the path (ls -d ${path}) \u2014 if there is nothing to delete, leave this out.`);
+  }
+  return null;
+}
+function relativeFix(name, shown, cdHint) {
+  const folder = cdHint ?? "/full/path/to";
+  const rest = shown.replace(/^\.\/+/, "");
+  if (name === "find")
+    return `find ${cdHint ?? "/full/path/to/folder"} \u2026 -delete`;
+  if (rest === "." || rest === ".." || rest.startsWith("../"))
+    return `${name} /full/path/to/folder`;
+  return `${name} ${folder === "/" ? "" : folder}/${rest}`;
+}
+function refuse(rule, target, why) {
+  return { rule, target, message: `Tesseract refused this command: ${why}
+
+${RM_RULES}` };
+}
+
+// ../host-daemon/src/codex-rm-hook.ts
+var refuse2 = (reason) => {
+  process.stderr.write(reason);
+  process.exit(2);
+};
+var input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  input += chunk;
+});
+process.stdin.on("end", () => {
+  try {
+    const call = JSON.parse(input);
+    const command = call.tool_input?.command;
+    if (typeof command !== "string") process.exit(0);
+    const refusal = checkRmCommand(command);
+    if (refusal) refuse2(refusal.message);
+    process.exit(0);
+  } catch (e) {
+    refuse2(`Tesseract could not check this command (${e instanceof Error ? e.message : String(e)}), so it was not run. Try it again.`);
+  }
+});

package/dist-bundle/mesh-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fineguide-tesseract/mesh-core",
-  "version": "0.11.39",
+  "version": "0.11.41",
   "main": "index.js",
   "types": "index.d.ts"
 }