token-goat 2.9.26 → 2.9.29

package/dist/{token-goat-chunk-E3K3BTEQ.mjs → token-goat-chunk-S4VSXURL.mjs}

@@ -2,7 +2,7 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   clearModuleCaches
-} from "./token-goat-chunk-EEIDFMEM.mjs";
+} from "./token-goat-chunk-YZAAZU2S.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -44,7 +44,7 @@ function captureOutput() {
     }
   };
 }
-async function serveOne(req, runFn) {
+async function serveOne(req, runFn, reset = clearModuleCaches) {
   const cwdBefore = process.cwd();
   const restoreEnv = swapEnv(req.env ?? { ...process.env });
   const cap = captureOutput();
@@ -65,7 +65,7 @@ async function serveOne(req, runFn) {
       process.chdir(cwdBefore);
     } catch {
     }
-    clearModuleCaches();
+    reset();
     return { id: req.id, status, stdout: captured.out, stderr: captured.err };
   }
   cap.restore();
@@ -77,7 +77,7 @@ async function serveOne(req, runFn) {
     process.chdir(cwdBefore);
   } catch {
   }
-  clearModuleCaches();
+  reset();
   return { id: req.id, status, stdout, stderr };
 }
 function serveBatch(token, runFn) {
@@ -106,7 +106,9 @@ function serveBatch(token, runFn) {
     });
   });
 }
+
 export {
-  serveBatch,
-  serveOne
+  swapEnv,
+  serveOne,
+  serveBatch
 };

package/dist/{token-goat-chunk-LKSXAMJB.mjs → token-goat-chunk-SE6E4BKJ.mjs}

@@ -9,7 +9,7 @@ import {
 } from "./token-goat-chunk-Y4AFKTHK.mjs";
 import {
   compileGuardedRegex
-} from "./token-goat-chunk-GMOUBOX4.mjs";
+} from "./token-goat-chunk-JTKCQMQA.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";

package/dist/token-goat-chunk-TCQANXYC.mjs

@@ -0,0 +1,351 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  MSYS_PATH_RE,
+  WSL_PATH_RE,
+  expandShortPath,
+  isUncOrDevicePath,
+  lowercaseDriveLetter,
+  normalizeDarwinSystemAlias
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/path_containment.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isCaseInsensitiveFs() {
+  const o = process.env["TOKEN_GOAT_CASE_INSENSITIVE_FS"];
+  if (o === "1") return true;
+  if (o === "0") return false;
+  return process.platform === "win32" || process.platform === "darwin";
+}
+function foldPath(p) {
+  return isCaseInsensitiveFs() ? foldCase(p) : p;
+}
+function isNodeModulesPath(p) {
+  const check = foldPath(p);
+  return check.includes("/node_modules/") || check.includes("\\node_modules\\");
+}
+function foldCase(s) {
+  return s.toLowerCase();
+}
+function foldCaseForContainment(s) {
+  return s.replace(/[A-Z]/g, (c) => c.toLowerCase());
+}
+function foldPathForContainment(p) {
+  return isCaseInsensitiveFs() ? foldCaseForContainment(p) : p;
+}
+var CYGWIN_PREFIX_RE = /^\/cygdrive\/([a-zA-Z])\/(.*)$/s;
+function normalizeShellDrivePrefix(posixStr) {
+  let m = WSL_PATH_RE.exec(posixStr);
+  if (m) {
+    return `${m[1].toLowerCase()}:/${m[2]}`;
+  }
+  m = CYGWIN_PREFIX_RE.exec(posixStr);
+  if (m) {
+    return `${m[1].toLowerCase()}:/${m[2]}`;
+  }
+  m = MSYS_PATH_RE.exec(posixStr);
+  if (m) {
+    return `${m[1].toLowerCase()}:${m[2] ?? "/"}`;
+  }
+  return posixStr;
+}
+function canonicalize(inputPath, baseDir) {
+  const pathStr = typeof inputPath === "string" ? inputPath : inputPath.pathname;
+  const isWin32 = process.platform === "win32";
+  const base = baseDir ?? process.cwd();
+  const slashed = pathStr.replace(/\\/g, "/");
+  let pre = isWin32 ? normalizeShellDrivePrefix(slashed) : slashed;
+  if (pre !== slashed) {
+    pre = (isWin32 ? path.win32.resolve : path.resolve)(base, pre);
+  } else {
+    pre = (isWin32 ? path.win32.resolve : path.resolve)(base, pathStr);
+  }
+  let normalized = pre.replace(/\\/g, "/");
+  if (isWin32) {
+    normalized = normalizeShellDrivePrefix(normalized);
+  }
+  normalized = expandShortPath(normalized);
+  normalized = normalizeDarwinSystemAlias(normalized);
+  normalized = lowercaseDriveLetter(normalized);
+  return normalized;
+}
+var UNRESOLVABLE_PATH = "unresolvable-link-chain";
+var MAX_LINK_HOPS = 40;
+var MAX_RESOLVE_PATH_BYTES = 4096;
+var MAX_WALK_SEGMENTS = MAX_RESOLVE_PATH_BYTES * (MAX_LINK_HOPS + 1);
+function rootAndSegments(p) {
+  const parts = p.replace(/\\/g, "/").split("/");
+  const up = parts.indexOf("..");
+  const head = up === -1 ? parts.join("/") : parts.slice(0, up).join("/");
+  const canon = canonicalize(head === "" ? "." : head);
+  const m = /^(\/\/[^/]+\/[^/]+|[a-z]:\/|\/)/i.exec(canon);
+  const root = m === null ? "/" : m[1];
+  const rest = canon.slice(root.length).split("/");
+  return { root, segs: up === -1 ? rest : [...rest, ...parts.slice(up)] };
+}
+function joinSegment(base, seg) {
+  return base.endsWith("/") ? base + seg : `${base}/${seg}`;
+}
+function parentSegment(base, root) {
+  const cut = base.lastIndexOf("/");
+  return cut < root.length ? root : base.slice(0, cut);
+}
+var DRIVE_RELATIVE_PATH = /^[a-z]:(?![\\/])/i;
+function linkTarget(link) {
+  const raw = link.replace(/\\/g, "/").replace(/^\/\/\?\/(UNC\/)?/i, (_m, unc) => unc === void 0 ? "" : "//");
+  if (!/^(\/\/[^/]+\/|[a-z]:\/|\/)/i.test(raw)) return { root: null, segs: raw.split("/") };
+  const abs = rootAndSegments(raw);
+  return { root: abs.root, segs: abs.segs };
+}
+function resolveThroughLinks(p) {
+  if (Buffer.byteLength(p, "utf8") > MAX_RESOLVE_PATH_BYTES) return UNRESOLVABLE_PATH;
+  const start = rootAndSegments(p);
+  let root = start.root;
+  let base = root;
+  const stack = start.segs.slice().reverse();
+  let hops = 0;
+  let walked = 0;
+  while (stack.length > 0) {
+    if (++walked > MAX_WALK_SEGMENTS) return UNRESOLVABLE_PATH;
+    const seg = stack.pop();
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      base = parentSegment(base, root);
+      continue;
+    }
+    const candidate = joinSegment(base, seg);
+    if (Buffer.byteLength(candidate, "utf8") > MAX_RESOLVE_PATH_BYTES) return UNRESOLVABLE_PATH;
+    let link = null;
+    try {
+      if (fs.lstatSync(candidate).isSymbolicLink()) link = fs.readlinkSync(candidate);
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") return UNRESOLVABLE_PATH;
+      link = null;
+    }
+    if (link === null) {
+      base = candidate;
+      continue;
+    }
+    if (++hops > MAX_LINK_HOPS) return UNRESOLVABLE_PATH;
+    if (DRIVE_RELATIVE_PATH.test(link)) return UNRESOLVABLE_PATH;
+    const target = linkTarget(link);
+    if (target.root !== null) {
+      if (!isUncOrDevicePath(root) && isUncOrDevicePath(target.root)) return UNRESOLVABLE_PATH;
+      root = target.root;
+      base = target.root;
+    }
+    for (let i = target.segs.length - 1; i >= 0; i--) stack.push(target.segs[i]);
+  }
+  return base;
+}
+function normalizeForFs(p) {
+  return process.platform === "darwin" ? p.normalize("NFC") : p;
+}
+function escapesOntoNetworkThroughLinks(target, cwd) {
+  if (isUncOrDevicePath(target)) return true;
+  let absolute;
+  try {
+    absolute = path.resolve(cwd ?? process.cwd(), target);
+  } catch {
+    return true;
+  }
+  if (isUncOrDevicePath(absolute)) return true;
+  const resolved = resolveThroughLinks(absolute);
+  return resolved === UNRESOLVABLE_PATH || isUncOrDevicePath(resolved);
+}
+function isInsideRoot(target, root) {
+  if (reachesForeignShare(target, root)) return false;
+  const rt = resolveThroughLinks(target);
+  const rr = resolveThroughLinks(root);
+  if (rt === UNRESOLVABLE_PATH || rr === UNRESOLVABLE_PATH) return false;
+  const nt = normalizeForFs(rt);
+  const nr = normalizeForFs(rr);
+  const t = foldPathForContainment(nt);
+  const r = foldPathForContainment(nr);
+  if (t !== r && !t.startsWith(r.endsWith("/") ? r : r + "/")) return false;
+  if (nt.slice(0, nr.length) === nr) return true;
+  return sameDirectory(nt.slice(0, nr.length), nr);
+}
+function isNetworkPath(p, platform = process.platform) {
+  return networkShareRoot(p, platform) !== null;
+}
+function networkShareRoot(p, platform = process.platform) {
+  if (platform !== "win32") return null;
+  const device = /^[\\/]{2}([?.][\\/])?/.exec(p);
+  if (device === null) return null;
+  let rest = p.slice(device[0].length);
+  if (device[1] !== void 0) {
+    const unc = /^UNC[\\/]/i.exec(rest);
+    if (unc === null) return null;
+    rest = rest.slice(unc[0].length);
+  }
+  const [host = "", share = ""] = rest.split(/[\\/]/);
+  return `//${foldCase(host)}/${foldCase(share)}`;
+}
+function reachesForeignShare(target, root, platform = process.platform) {
+  const share = networkShareRoot(target, platform);
+  return share !== null && share !== networkShareRoot(root, platform);
+}
+function sameDirectory(a, b, platform = process.platform) {
+  if (isNetworkPath(a, platform) || isNetworkPath(b, platform)) return false;
+  let canonicalRoot;
+  try {
+    canonicalRoot = fs.realpathSync.native(b);
+  } catch {
+    return true;
+  }
+  try {
+    return fs.realpathSync.native(a) === canonicalRoot;
+  } catch {
+    return false;
+  }
+}
+
+// src/process_util.ts
+init_define_import_meta_env();
+import { existsSync, realpathSync as realpathSync2, statSync } from "node:fs";
+import * as path2 from "node:path";
+function sleepSync(ms) {
+  if (ms <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function isWindows() {
+  return process.platform === "win32";
+}
+function windowsCmdQuoteArg(arg) {
+  if (arg === "") return '""';
+  if (arg[0] === '"' && arg[arg.length - 1] === '"') {
+    throw new Error(`windowsCmdQuoteArg: cannot faithfully encode an argument that both starts and ends with a literal double quote for cmd.exe: ${JSON.stringify(arg)}`);
+  }
+  let out = "";
+  let inQuote = false;
+  let backslashes = 0;
+  const flushBackslashesPlain = () => {
+    if (backslashes > 0) {
+      out += "\\".repeat(backslashes);
+      backslashes = 0;
+    }
+  };
+  const flushBackslashesDoubled = () => {
+    out += "\\".repeat(backslashes * 2);
+    backslashes = 0;
+  };
+  const ensureQuoteOpen = () => {
+    if (!inQuote) {
+      flushBackslashesDoubled();
+      out += '"';
+      inQuote = true;
+    } else {
+      flushBackslashesPlain();
+    }
+  };
+  const ensureQuoteClosed = () => {
+    if (inQuote) {
+      flushBackslashesDoubled();
+      out += '"';
+      inQuote = false;
+    } else {
+      flushBackslashesPlain();
+    }
+  };
+  for (const ch of arg) {
+    if (ch === "\\") {
+      backslashes++;
+      continue;
+    }
+    if (ch === '"') {
+      flushBackslashesDoubled();
+      if (inQuote) {
+        out += '"';
+        inQuote = false;
+      }
+      out += '\\^"';
+      continue;
+    }
+    if (ch === "%" || ch === "!") {
+      ensureQuoteClosed();
+      out += `^${ch}`;
+      continue;
+    }
+    ensureQuoteOpen();
+    out += ch;
+  }
+  ensureQuoteClosed();
+  return out;
+}
+function quoteShellPath(value) {
+  if (process.platform === "win32") return `"${value}"`;
+  return `"${value.replace(/[\\$`"]/g, "\\$&")}"`;
+}
+function quotePowershellPath(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function resolveOnPath(label) {
+  if (path2.isAbsolute(label)) return existsSync(label) ? label : null;
+  if (label.includes("/") || label.includes("\\")) return null;
+  const onWindows = process.platform === "win32";
+  const exts = onWindows ? (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((e) => e.trim() !== "") : [""];
+  let cwd;
+  try {
+    cwd = realpathSync2(process.cwd());
+  } catch {
+    cwd = path2.resolve(process.cwd());
+  }
+  for (const rawDir of (process.env["PATH"] ?? "").split(path2.delimiter)) {
+    const dir = rawDir.trim().replace(/^"|"$/g, "");
+    if (dir === "" || dir === ".") continue;
+    let resolvedDir;
+    try {
+      resolvedDir = realpathSync2(path2.resolve(dir));
+    } catch {
+      continue;
+    }
+    if (foldPath(resolvedDir) === foldPath(cwd)) continue;
+    for (const ext of exts) {
+      const candidate = path2.join(resolvedDir, label + ext);
+      try {
+        if (statSync(candidate).isFile()) return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function installEpipeGuard(streams) {
+  const targets = (streams ?? [process.stdout, process.stderr]).filter((s) => s !== void 0);
+  for (const stream of targets) {
+    stream.on("error", (err) => {
+      if (err.code === "EPIPE") {
+        process.exitCode = 0;
+        return;
+      }
+      throw err;
+    });
+  }
+  return targets;
+}
+
+export {
+  isCaseInsensitiveFs,
+  foldPath,
+  isNodeModulesPath,
+  foldCase,
+  foldCaseForContainment,
+  foldPathForContainment,
+  canonicalize,
+  escapesOntoNetworkThroughLinks,
+  isInsideRoot,
+  sleepSync,
+  isWindows,
+  windowsCmdQuoteArg,
+  quoteShellPath,
+  quotePowershellPath,
+  resolveOnPath,
+  installEpipeGuard
+};