@ai-ecoverse/slicc-kernel 1.180.0 → 1.182.0

package/dist/kernel-worker.js

@@ -652,8 +652,8 @@ function dirsChannel(metadata) {
 function noticeOf(data) {
   if (Array.isArray(data)) return { paths: data.filter((p) => typeof p === "string"), trees: [] };
   const notice = data ?? {};
-  const strings = (list) => Array.isArray(list) ? list.filter((p) => typeof p === "string") : [];
-  return { paths: strings(notice.paths), trees: strings(notice.trees), outside: true };
+  const strings2 = (list) => Array.isArray(list) ? list.filter((p) => typeof p === "string") : [];
+  return { paths: strings2(notice.paths), trees: strings2(notice.trees), outside: true };
 }
 
 // src/fs/types.ts
@@ -4825,10 +4825,10 @@ var CdpFacade = class {
       );
       return;
     }
-    await this.write(conn, json(await this.list(runtime)));
+    await this.write(conn, json(await this.list(runtime, conn.peerStamp)));
   }
-  async list(runtime) {
-    const conn = await this.host(runtime);
+  async list(runtime, stamp) {
+    const conn = await this.host(runtime, stamp);
     try {
       const reply = await new Promise(
         (resolve2, reject) => {
@@ -4863,12 +4863,15 @@ var CdpFacade = class {
       conn.close();
     }
   }
-  host(runtime) {
-    return this.options.hosts.connect(runtime ? { runtime } : {});
+  host(runtime, stamp) {
+    return this.options.hosts.connect({
+      ...runtime ? { runtime } : {},
+      ...stamp ? { stamp } : {}
+    });
   }
   async upgrade(conn, incoming, req, runtime) {
     const accept2 = await acceptKey(req.headers);
-    const host = await this.host(runtime);
+    const host = await this.host(runtime, conn.peerStamp);
     const limits = {
       max: this.options.maxMessage ?? MAX_MESSAGE,
       closeWaitMs: this.options.closeWaitMs ?? CLOSE_WAIT_MS
@@ -4948,6 +4951,7 @@ function enableCdp(net, hosts) {
   let facade;
   net.kernelOnly(CDP_PORT, true);
   net.reserve(CDP_PORT);
+  net.stampPeers(CDP_PORT);
   net.activate({ family: "inet", host: "127.0.0.1", port: CDP_PORT }, () => {
     const started = new CdpFacade({ net, hosts });
     facade = started;
@@ -4990,7 +4994,7 @@ var CdpHosts = class {
     if (!entry) throw new HttpError(503, NO_CDP_HOST);
     let conn;
     try {
-      conn = await entry.hook(request3.runtime ? { runtime: request3.runtime } : {});
+      conn = await entry.hook(hookRequest(request3));
     } catch (e) {
       throw new HttpError(502, `CDP host: ${e instanceof Error ? e.message : String(e)}`);
     }
@@ -5010,6 +5014,12 @@ var CdpHosts = class {
     for (const entry of [this.embedder, ...this.clients]) if (entry) closeAll(entry);
   }
 };
+function hookRequest({ runtime, stamp }) {
+  return {
+    ...runtime ? { runtime } : {},
+    ...stamp ? { stamp: structuredClone(stamp) } : {}
+  };
+}
 function closeAll(entry) {
   for (const conn of [...entry.open]) {
     conn.close();
@@ -7158,6 +7168,7 @@ var LoopbackNet = class {
   reserved = /* @__PURE__ */ new Set();
   facades = /* @__PURE__ */ new Map();
   proxyStamped;
+  stamped = /* @__PURE__ */ new Set();
   nextEphemeral = EPHEMERAL_FIRST;
   route;
   origins;
@@ -7232,6 +7243,9 @@ var LoopbackNet = class {
     this.kernelOnly(port, true);
     this.facades.set(port, name2);
   }
+  stampPeers(port) {
+    this.stamped.add(port);
+  }
   stampProxy(port) {
     this.proxyStamped = port;
   }
@@ -7240,7 +7254,7 @@ var LoopbackNet = class {
   }
   stampsPeers(addr) {
     if (addr.family !== "inet" || !isLoopback(canonicalHost(addr.host))) return false;
-    return this.facades.has(addr.port) || this.proxyStamped === addr.port;
+    return this.facades.has(addr.port) || this.stamped.has(addr.port) || this.proxyStamped === addr.port;
   }
   activate(addr, start2) {
     this.activators.set(keyOf(addr), start2);
@@ -8206,7 +8220,7 @@ var UserDb = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 15];
+var PROTOCOL = [1, 17];
 var FS_METHODS = [
   "readFile",
   "writeFile",
@@ -8362,9 +8376,9 @@ async function accountOf(l, user) {
   if (!found) throw fsError("ENOENT", `no user ${String(user)}`);
   return found;
 }
-async function runAs(l, self, requested) {
-  if (requested === void 0) return self;
-  const target = await accountOf(l, requested);
+async function runAs(l, self, requested2) {
+  if (requested2 === void 0) return self;
+  const target = await accountOf(l, requested2);
   if (self.uid !== 0 && target.uid !== self.uid) {
     throw fsError("EPERM", `${self.name} may not run as ${target.name}`);
   }
@@ -8373,21 +8387,9 @@ async function runAs(l, self, requested) {
 function clientCred(self) {
   return self ? credOf(self) : copyCred(ROOT);
 }
-var MAX_SPAWN_TAGS = 8;
-function spawnTags(value2) {
-  if (!Array.isArray(value2)) {
-    tagOption(value2);
-    return value2 === void 0 ? [] : [value2];
-  }
-  if (value2.length > MAX_SPAWN_TAGS) {
-    throw new TypeError(`a spawn adds at most ${MAX_SPAWN_TAGS} tags`);
-  }
-  for (const each of value2) tagOption(each ?? 0);
-  return value2;
-}
 async function runTagged(l, self, options, tag, session = -1) {
   let tags = withTag(void 0, tag);
-  for (const added of spawnTags(options.tag)) tags = withTag(tags, added);
+  for (const added of tagList(options.tag)) tags = withTag(tags, added);
   return {
     user: await runAs(l, self, options.user),
     tag,
@@ -8572,6 +8574,20 @@ function requestBinding(send2, port) {
     close: () => unbind?.()
   };
 }
+async function sudoRunAs(l, self, host, req, reply) {
+  if (self.uid !== 0) throw sudoFailure("EPERM", "sudo: only a root client may run a sudo request");
+  const { stdout, stderr, tag } = req.options;
+  const running = await l.sudoRun(req.replay, {
+    stdout,
+    stderr,
+    tag,
+    base: host.tag,
+    session: host.session
+  });
+  reply(req.id, { started: running.pid });
+  const { status, signal } = await running.ended;
+  return { result: status, ...signalField(signal) };
+}
 function answered(pending, req, reply, detach) {
   pending.then(
     ({ result, signal, transfer }) => {
@@ -8721,6 +8737,8 @@ function serveClient(port, host) {
       case "trace":
       case "untrace":
         return traces.answer(l, self, req);
+      case "sudo-run":
+        return sudoRunAs(l, self, host, req, reply);
       case "detach":
         return { result: true };
       default:
@@ -8904,7 +8922,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.180.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.182.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -9769,27 +9787,27 @@ function hashId(text) {
   return hex4(a) + hex4(b);
 }
 function split2(text, count2) {
-  const words2 = [];
+  const words3 = [];
   let rest2 = text;
   for (let i = 0; i < count2; i++) {
     const match = /^(\S+)\s+/.exec(rest2);
     if (!match) return void 0;
-    words2.push(match[1]);
+    words3.push(match[1]);
     rest2 = rest2.slice(match[0].length);
   }
-  return [words2, rest2.trim()];
+  return [words3, rest2.trim()];
 }
 function jobOf(content, pending, ctx, env) {
   const fields = content.startsWith("@") ? 1 : 5;
   const parts2 = split2(content, fields + (ctx.system ? 1 : 0));
   if (!parts2 || parts2[1] === "") throw new Error("no command");
-  const [words2, command] = parts2;
-  const schedule = words2.slice(0, fields).join(" ");
+  const [words3, command] = parts2;
+  const schedule = words3.slice(0, fields).join(" ");
   const when = parseWhen(schedule);
   const zone = env.CRON_TZ;
   if (zone && !when.reboot && canonicalZone(zone) === void 0)
     throw new Error(`CRON_TZ: unknown time zone "${zone}"`);
-  const user = ctx.system ? words2[fields] : void 0;
+  const user = ctx.system ? words3[fields] : void 0;
   if (user !== void 0 && !USER_NAME.test(user)) throw new Error(`bad user name ${user}`);
   if (pending !== void 0 && !JOB_NAME.test(pending))
     throw new Error(`bad job name "${pending}"`);
@@ -12770,9 +12788,11 @@ var SpawnError = class extends Error {
 };
 var ChangedError = class extends SpawnError {
   notice;
-  constructor(notice) {
+  file;
+  constructor(notice, file) {
     super("EPERM");
     this.notice = notice;
+    this.file = file;
   }
 };
 function interrupted(signal) {
@@ -19818,21 +19838,21 @@ function unescaped(double) {
 }
 function splitWords(text) {
   const piece = /'([^']*)'|"((?:[^"\\]|\\[\s\S])*)"|\\([\s\S])|([^\s'"\\]+)|(\s+)/y;
-  const words2 = [];
+  const words3 = [];
   let word;
   while (piece.lastIndex < text.length) {
     const m = piece.exec(text);
     if (!m) return void 0;
     const [, single, double, escaped, plain3, space] = m;
     if (space !== void 0) {
-      if (word !== void 0) words2.push(word);
+      if (word !== void 0) words3.push(word);
       word = void 0;
       continue;
     }
     word = (word ?? "") + (single ?? (double !== void 0 ? unescaped(double) : escaped ?? plain3));
   }
-  if (word !== void 0) words2.push(word);
-  return words2;
+  if (word !== void 0) words3.push(word);
+  return words3;
 }
 function quoteWord(word) {
   const text = hasControl(word) ? withoutControl(word) : word;
@@ -19853,14 +19873,14 @@ function addPlain(word, plain3) {
 }
 function splitPatterns(text) {
   const piece = /'([^']*)'|"((?:[^"\\]|\\[\s\S])*)"|\\([\s\S])|([^\s'"\\]+)|(\s+)/y;
-  const words2 = [];
+  const words3 = [];
   let word;
   while (piece.lastIndex < text.length) {
     const m = piece.exec(text);
     if (!m) return void 0;
     const [, single, double, escaped, plain3, space] = m;
     if (space !== void 0) {
-      if (word !== void 0) words2.push(word);
+      if (word !== void 0) words3.push(word);
       word = void 0;
       continue;
     }
@@ -19868,8 +19888,8 @@ function splitPatterns(text) {
     if (plain3 !== void 0) addPlain(word, plain3);
     else addPart(word, single ?? (double !== void 0 ? unescaped(double) : escaped));
   }
-  if (word !== void 0) words2.push(word);
-  return words2;
+  if (word !== void 0) words3.push(word);
+  return words3;
 }
 var literal = (pattern) => pattern.map((p) => p ?? "*").join("");
 var isAny = (pattern) => pattern?.length === 1 && pattern[0] === null;
@@ -19942,14 +19962,14 @@ function whoError(who) {
   return `expected a user name, %group or ALL first, not ${shown(who)}`;
 }
 function cwdOf(word) {
-  const words2 = splitWords(word);
-  const path = words2?.length === 1 ? words2[0] : "";
+  const words3 = splitWords(word);
+  const path = words3?.length === 1 ? words3[0] : "";
   return path.startsWith("/") ? normalizePath(path) : "";
 }
 function commandOf2(text, after) {
-  const words2 = splitPatterns(text);
-  if (words2 === void 0) return "a quote in the command is not closed, or it ends in a \\";
-  const [first, ...args] = words2;
+  const words3 = splitPatterns(text);
+  if (words3 === void 0) return "a quote in the command is not closed, or it ends in a \\";
+  const [first, ...args] = words3;
   const path = first ? literal(first) : "";
   if (path === "") return `expected a command after ${after}`;
   if (!path.startsWith("/")) return `expected an absolute command path, not ${shown(path)}`;
@@ -20262,6 +20282,9 @@ function recordable(cwd, argv) {
 function changedText(file) {
   return `sudo: ${file} changed since it was approved`;
 }
+function requestedText(file) {
+  return `sudo: ${file} changed since it was requested`;
+}
 function changedFile(approved, now) {
   const files = /* @__PURE__ */ new Set([...Object.keys(approved), ...Object.keys(now)]);
   return [...files].find((file) => approved[file] !== now[file]);
@@ -20269,6 +20292,67 @@ function changedFile(approved, now) {
 function pinned(rule, bound3) {
   return rule.sha256 === void 0 || changedFile(rule.sha256, bound3) === void 0;
 }
+var REPLAY_ID = /^[!-~]{1,256}$/;
+var REPLAY_TAGS_MAX = 64;
+var REPLAY_ARGV_MAX = 4096;
+var REPLAY_BYTES_MAX = 1024 * 1024;
+var NOT_A_REQUEST = "sudo: that isn't a sudo request this kernel can run";
+function strings(value2, max) {
+  return Array.isArray(value2) && value2.length <= max && value2.every((s) => typeof s === "string");
+}
+function words(value2) {
+  if (!strings(value2, REPLAY_ARGV_MAX) || value2.length === 0) return false;
+  const bytes = value2.reduce((n, s) => n + s.length + 1, 0);
+  return bytes <= REPLAY_BYTES_MAX && !value2.some((s) => s.includes("\0"));
+}
+function filesOf(value2) {
+  if (value2 === void 0) return {};
+  if (!Array.isArray(value2) || value2.length > OPERANDS_MAX) return void 0;
+  const files = {};
+  for (const file of value2) {
+    const { path, sha256: hex4 } = file ?? {};
+    if (typeof path !== "string" || typeof hex4 !== "string") return void 0;
+    files[path] = hex4;
+  }
+  return files;
+}
+function flagsOf(value2) {
+  if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) return void 0;
+  const entries = Object.entries(value2);
+  if (entries.length > ROOT_ONLY_MAX || entries.some(([, v]) => typeof v !== "boolean")) {
+    return void 0;
+  }
+  return Object.fromEntries(entries);
+}
+function replayOf(value2) {
+  if (typeof value2 !== "object" || value2 === null) return failed2("EINVAL", NOT_A_REQUEST);
+  const r = value2;
+  if (r.validate === true) return failed2("EINVAL", "sudo: a sudo -v request runs no command");
+  if (r.stdin === "pipe" || r.stdin === "file") {
+    return failed2("EINVAL", `sudo: the request read a ${r.stdin}, and that input is gone`);
+  }
+  const { id: id2, user, uid, target, argv, path, cwd, stdin, tag, tags } = r;
+  const rootOnly2 = flagsOf(r.rootOnly);
+  const bound3 = filesOf(r.userWritable);
+  const named = (s) => typeof s === "string" && s !== "";
+  const absolute2 = (s) => typeof s === "string" && s.startsWith("/") && s.length <= PATH_MAX && !s.includes("\0");
+  const valid = typeof id2 === "string" && REPLAY_ID.test(id2) && named(user) && named(target) && Number.isInteger(uid) && uid >= 0 && words(argv) && absolute2(path) && absolute2(cwd) && (stdin === "tty" || stdin === "none") && (tag === void 0 || typeof tag === "string") && (tags === void 0 || strings(tags, REPLAY_TAGS_MAX)) && rootOnly2 !== void 0 && bound3 !== void 0;
+  if (!valid) return failed2("EINVAL", NOT_A_REQUEST);
+  const all = tags ?? (tag === void 0 ? [] : [tag]);
+  return {
+    id: id2,
+    user,
+    uid,
+    target,
+    argv,
+    path,
+    cwd,
+    stdin,
+    rootOnly: rootOnly2,
+    bound: bound3,
+    tags: [...new Set(all)]
+  };
+}
 var VISUDO_FILES_MAX = 64;
 var VISUDO_TEXT_MAX = 1024 * 1024;
 function visudoCall(req) {
@@ -20670,6 +20754,61 @@ var Sudo = class {
     if (parsed2.validate) return this.validate(session, root, mine, call.cwd);
     return this.command(session, root, mine, call);
   }
+  async replay(value2) {
+    const r = replayOf(value2);
+    if ("error" in r) return r;
+    if (this.o.mode !== "enforce") {
+      return failed2("EINVAL", `sudo: users are '${this.o.mode}', so no request needed approval`);
+    }
+    const self = await this.o.users.lookup(r.user);
+    if (!self) return failed2("ENOENT", `sudo: unknown user ${r.user}`);
+    if (self.uid !== r.uid) return failed2("EPERM", `sudo: ${self.name} is no longer uid ${r.uid}`);
+    const target = await this.lookup(r.target);
+    if (!target) return failed2("ENOENT", `sudo: unknown user ${r.target}`);
+    const cred = credOf(self);
+    const [word = "", ...args] = r.argv;
+    const argv = [r.path, ...args];
+    if (!await this.mayAsk(self, target, r, argv)) {
+      const quoted = argv.map(quoteWord).join(" ");
+      return failed2(
+        "EACCES",
+        `sudo: ${self.name} may no longer ask to run ${quoted} as ${target.name}`
+      );
+    }
+    if (await this.canonical(r.cwd) !== r.cwd) {
+      return failed2("EACCES", `sudo: ${r.cwd} changed since it was requested`);
+    }
+    if (!await this.reachable(cred, r.cwd)) {
+      return failed2(
+        "EACCES",
+        `sudo: cannot run in ${r.cwd}: it isn't a directory ${self.name} can enter`
+      );
+    }
+    const path = await this.locate(word, r.cwd);
+    if (!path) return failed2("ENOENT", `sudo: ${word}: command not found`);
+    if (path !== r.path) return failed2("EPERM", `sudo: ${word} now runs ${path}, not ${r.path}`);
+    const bound3 = await this.bound(path, r.cwd);
+    if (!bound3) return failed2("ENOENT", `sudo: ${word}: command not found`);
+    const changed = changedFile(r.bound, bound3);
+    if (changed !== void 0) return failed2("EPERM", requestedText(changed));
+    const now = await this.rootOnly(r.cwd, args);
+    const flipped = Object.keys(r.rootOnly).find((at) => r.rootOnly[at] && now[at] !== true);
+    if (flipped !== void 0) return failed2("EPERM", `sudo: ${flipped} is no longer root-only`);
+    const { grant } = this.grant(self, target, cred, r.argv, path, r.cwd, void 0, bound3);
+    (this.o.warn ?? console.warn)(
+      `sudo: ${self.name} : TTY=unknown ; PWD=${quoteWord(r.cwd)} ; USER=${target.name} ; REPLAY=${r.id} ; COMMAND=${argv.map(quoteWord).join(" ")}`
+    );
+    return { grant, caller: self, target, tags: r.tags };
+  }
+  async mayAsk(self, target, r, argv) {
+    if (self.uid === 0) return true;
+    const cred = credOf(self);
+    const { rules } = await this.policyRules({ cred, pid: 0, stdin: r.stdin });
+    const applies = await this.applies(self, cred);
+    return rules.some(
+      (rule) => applies(rule.who) && (rule.target === "ALL" || rule.target === target.name) && (rule.cwd === void 0 || rule.cwd === r.cwd) && stdinMatches(rule, r.stdin) && commandMatches(rule.cmnd, argv) && pinned(rule, r.bound)
+    );
+  }
   async command(s, root, mine, call) {
     const { caller, self, target, parsed: parsed2 } = s;
     const { cred } = caller;
@@ -20849,8 +20988,8 @@ ${lines2}
       const st = await fs.lstat(path).catch(() => void 0);
       if (st && !await this.trusted(path)) return false;
       const old = st ? await fs.readFile(path) : "";
-      const words2 = recordedCommand(argv);
-      const line = `NOPASSWD ${self.name} (${target.name}) Cwd ${quoteWord(cwd)} Stdin none ${sha256Text(bound3)}Cmnd ${words2}
+      const words3 = recordedCommand(argv);
+      const line = `NOPASSWD ${self.name} (${target.name}) Cwd ${quoteWord(cwd)} Stdin none ${sha256Text(bound3)}Cmnd ${words3}
 `;
       const text = old === "" || old.endsWith("\n") ? `${old}${line}` : `${old}
 ${line}`;
@@ -22155,8 +22294,8 @@ function ipv6(host) {
   const head = groups(halves[0]);
   const back = halves.length === 2 ? groups(halves[1]) : [];
   if (![...head, ...back].every((g) => /^[0-9A-Fa-f]{1,4}$/.test(g))) return void 0;
-  const words2 = [...head, ...back].map((g) => Number.parseInt(g, 16));
-  const missing6 = 8 - words2.length - tail2.length;
+  const words3 = [...head, ...back].map((g) => Number.parseInt(g, 16));
+  const missing6 = 8 - words3.length - tail2.length;
   if (halves.length === 2 ? missing6 < 1 : missing6 !== 0) return void 0;
   const all = [
     ...head.map((g) => Number.parseInt(g, 16)),
@@ -25797,7 +25936,7 @@ function selectFlag(req) {
     throw new KernelError("EINVAL", "ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS: alpn with select");
   return TLS_SERVER_SELECT;
 }
-function flagsOf(req) {
+function flagsOf2(req) {
   return certFlags(req) | selectFlag(req) | (req.keylog ? TLS_KEYLOG : 0);
 }
 async function engineOf(proc, { select, keylog }) {
@@ -25848,7 +25987,7 @@ async function serverOf(proc, req) {
   let mine;
   try {
     mine = req.ca && req.ca.length > 0 ? storeOf(engine, req.ca) : void 0;
-    const flags2 = flagsOf(req);
+    const flags2 = flagsOf2(req);
     const store = mine ?? (flags2 & CERT_FLAGS ? await defaultStore(engine, supportOf(proc.net).roots) : void 0);
     return {
       engine,
@@ -27737,7 +27876,7 @@ var WRITE_ACCESS = 3;
 var KEYBOARD = /* @__PURE__ */ new Set([SIG.INT, SIG.QUIT, SIG.TSTP]);
 var STUCK_ESCAPES = /* @__PURE__ */ new Set([SIG.INT, SIG.TERM, SIG.QUIT, SIG.HUP]);
 var DEFAULT_UMASK2 = 18;
-function words(value2) {
+function words2(value2) {
   if (!Array.isArray(value2) || !value2.every((w) => typeof w === "string")) {
     throw new KernelError("EINVAL");
   }
@@ -29190,7 +29329,7 @@ var WasmProcess = class {
     if (!sudo) throw new KernelError("ENOSYS");
     const call = {
       op: "proc-sudo",
-      args: words(req.args),
+      args: words2(req.args),
       cwd: typeof req.cwd === "string" && req.cwd.startsWith("/") ? req.cwd : "/",
       ...typeof req.term === "string" ? { term: req.term } : {}
     };
@@ -33800,7 +33939,40 @@ function describe(req, tty) {
 }
 function refuseChanged(approved, now) {
   const changed = changedFile(approved, now);
-  if (changed !== void 0) throw new ChangedError(changedText(changed));
+  if (changed !== void 0) throw new ChangedError(changedText(changed), changed);
+}
+var O_WRONLY2 = 1;
+var OUTPUT_MODE = 384;
+var ERRNO_TEXT = {
+  EACCES: "Permission denied",
+  EISDIR: "Is a directory",
+  ENOENT: "No such file or directory",
+  ENOTDIR: "Not a directory",
+  EROFS: "Read-only file system"
+};
+function sudoFailure(errno3, message3) {
+  return Object.assign(new Error(message3), { code: errno3 });
+}
+function sudoCause(err) {
+  const code = codeOf8(err);
+  if (typeof code !== "string") throw err;
+  return code;
+}
+function requested(err) {
+  if (err instanceof ChangedError) throw sudoFailure(err.code, requestedText(err.file));
+  throw err;
+}
+var MAX_SPAWN_TAGS = 8;
+function tagList(value2) {
+  if (!Array.isArray(value2)) {
+    tagOption(value2);
+    return value2 === void 0 ? [] : [value2];
+  }
+  if (value2.length > MAX_SPAWN_TAGS) {
+    throw new TypeError(`a spawn adds at most ${MAX_SPAWN_TAGS} tags`);
+  }
+  for (const each of value2) tagOption(each ?? 0);
+  return value2;
 }
 function linksOf2(req) {
   return req.links === void 0 ? {} : { links: req.links };
@@ -33926,27 +34098,27 @@ function appendedRoots(given) {
   }
   return [...roots];
 }
-function plainEnv(words2) {
-  const next3 = words2[1];
-  if (baseName2(words2[0] ?? "") !== "env" || next3 === void 0) return false;
+function plainEnv(words3) {
+  const next3 = words3[1];
+  if (baseName2(words3[0] ?? "") !== "env" || next3 === void 0) return false;
   return next3 === "-S" || !next3.startsWith("-") && !next3.includes("=");
 }
-function shebangCommand(words2) {
-  if (!plainEnv(words2)) {
-    const arg2 = words2.slice(1).join(" ");
-    return { interp: words2[0], args: arg2 ? [arg2] : [] };
+function shebangCommand(words3) {
+  if (!plainEnv(words3)) {
+    const arg2 = words3.slice(1).join(" ");
+    return { interp: words3[0], args: arg2 ? [arg2] : [] };
   }
-  const split3 = words2[1] === "-S";
-  const [interp, ...rest2] = words2.slice(split3 ? 2 : 1);
+  const split3 = words3[1] === "-S";
+  const [interp, ...rest2] = words3.slice(split3 ? 2 : 1);
   const arg = rest2.join(" ");
   return { interp, args: split3 ? rest2 : arg ? [arg] : [] };
 }
 function interpreter(head) {
-  const words2 = shebang(head);
-  if (!words2) return "node";
-  if (baseName2(words2[0]) === "env") words2.shift();
-  if (words2[0] === "-S") words2.shift();
-  return baseName2(words2[0] ?? "");
+  const words3 = shebang(head);
+  if (!words3) return "node";
+  if (baseName2(words3[0]) === "env") words3.shift();
+  if (words3[0] === "-S") words3.shift();
+  return baseName2(words3[0] ?? "");
 }
 function expandDefaults(defaults2, env) {
   const out = {};
@@ -34721,9 +34893,9 @@ var Launcher = class {
     const head = await this.head(script);
     if (!head) return void 0;
     const binfmt = isWasm(head) ? void 0 : binfmtOf(await this.interpreters(scope), script);
-    const words2 = shebang(head) ?? (binfmt ? [binfmt] : void 0);
-    if (!words2) return void 0;
-    const { interp, args } = shebangCommand(words2);
+    const words3 = shebang(head) ?? (binfmt ? [binfmt] : void 0);
+    if (!words3) return void 0;
+    const { interp, args } = shebangCommand(words3);
     const passed = [...args, command ? script : file, ...argv.slice(1)];
     if (!interp) return void 0;
     const found = await this.resolve(interp, interp, cwd, scope);
@@ -34954,7 +35126,7 @@ var Launcher = class {
     const hex4 = pinned2[real];
     if (hex4 !== void 0) return { [real]: hex4 };
     if (await this.sudoer.trusted(real)) return {};
-    throw new ChangedError(changedText(real));
+    throw new ChangedError(changedText(real), real);
   }
   async pinnedBytes(pin, bytes) {
     const [real = ""] = Object.keys(pin);
@@ -35233,6 +35405,10 @@ var Launcher = class {
   }
   async launch(asked, req) {
     const cwd = await physicalPathAsync(this.base, req.cwd);
+    if (req.exactCwd && cwd !== req.cwd) {
+      await req.fds.closeAll();
+      throw sudoFailure("EACCES", `sudo: ${req.cwd} changed since it was requested`);
+    }
     const seen = { ...req.env, HOSTNAME: this.hostname, cwd };
     await this.pnpmReady();
     let loaded;
@@ -36928,6 +37104,96 @@ var Launcher = class {
     const signal = handle.termsig();
     return { status, ...signal ? { signal } : {}, stdout: concat7(out), stderr: concat7(err) };
   }
+  async sudoRun(replay, options = {}) {
+    const added = tagList(options.tag);
+    const replayed = await this.sudoer.replay(replay);
+    if ("error" in replayed) throw sudoFailure(replayed.errno, replayed.error);
+    const { grant, caller, target } = replayed;
+    let tags = withTag(void 0, options.base);
+    for (const tag of [...replayed.tags, ...added]) tags = withTag(tags, tag);
+    const tagged = { tags, tagBase: options.base === void 0 ? 0 : 1 };
+    await this.swaps.settled();
+    this.resetCatalogs();
+    const req = { file: grant.file, argv: grant.argv, env: grant.env, cwd: grant.cwd };
+    const ctx = { ppid: 0, cred: grant.cred, scope: "" };
+    const planned = await this.planOne(req, ctx).catch((err2) => {
+      const code = sudoCause(err2);
+      const word = grant.argv[0] ?? grant.file;
+      if (code === "ENOENT") throw sudoFailure(code, `sudo: ${word}: command not found`);
+      throw sudoFailure(code, `sudo: ${grant.file}: ${ERRNO_TEXT[code] ?? code}`);
+    });
+    const pin = await this.unchanged(planned, grant.file, grant.cwd, grant).catch(requested);
+    const fds = await this.sudoOutputs(options, caller, this.stackFor(tags, tagged.tagBase));
+    const err = fds.get(2).file;
+    const report = (message3) => void Promise.resolve(err.write?.(encoder10.encode(`${message3}
+`))).catch(() => void 0);
+    const replan = () => this.planOne(req, ctx);
+    if (!await this.grantedCwd(grant.caller, grant.cwd)) {
+      await fds.closeAll();
+      throw sudoFailure("EACCES", `sudo: ${grant.cwd} changed since it was requested`);
+    }
+    const handle = await this.launch(
+      { ...planned, replan },
+      {
+        ...pin,
+        env: grant.env,
+        cwd: grant.cwd,
+        fds,
+        report,
+        ...this.identity(target, tagged, options.session),
+        ...caller.umask !== void 0 ? { umask: caller.umask } : {},
+        links: grant.cred.euid,
+        exactCwd: true
+      }
+    ).catch(requested);
+    const ended = handle.exited.then((status) => {
+      const signal = handle.termsig();
+      return { status, ...signal ? { signal } : {} };
+    });
+    return { pid: handle.pid, ended };
+  }
+  async sudoOutputs(options, caller, stack) {
+    const fds = new FdTable();
+    const opened2 = /* @__PURE__ */ new Map();
+    fds.installAt(0, deviceFile("null"));
+    try {
+      fds.installAt(1, await this.sudoOutput(options.stdout, caller, stack, opened2));
+      fds.installAt(2, await this.sudoOutput(options.stderr, caller, stack, opened2));
+    } catch (err) {
+      await fds.closeAll();
+      throw err;
+    }
+    return fds;
+  }
+  async sudoOutput(path, caller, stack, opened2) {
+    if (path === void 0) return deviceFile("null");
+    if (typeof path !== "string" || !path.startsWith("/")) {
+      throw sudoFailure("EINVAL", `sudo: ${String(path)} is not an absolute path`);
+    }
+    const cred = credOf(caller);
+    const walked = await walk(this.fs, cred, normalizePath(path), true, caller.uid);
+    const real = walked.path;
+    const same3 = opened2.get(real);
+    if (same3) return same3.retain();
+    try {
+      if (walked.denied !== void 0) throw fsError("EACCES", path);
+      await writable({ ...this.execGuard(cred, 0), links: caller.uid }, "open", real);
+      const owner = { uid: caller.uid, gid: caller.gid, mode: OUTPUT_MODE };
+      await stack.noLinks.writeFile(real, new Uint8Array(0), owner);
+    } catch (err) {
+      const code = sudoCause(err);
+      throw sudoFailure(code, `sudo: ${path}: ${ERRNO_TEXT[code] ?? code}`);
+    }
+    const file = vfsFile(stack.fs, { path: real, flags: O_WRONLY2, position: 0 }, stack.nodes);
+    const again = await walk(this.fs, cred, real, true, caller.uid);
+    const st = await stack.noLinks.lstat(real).catch(() => void 0);
+    if (again.path !== real || again.denied !== void 0 || !st?.isFile) {
+      await file.release();
+      throw sudoFailure("EACCES", `sudo: ${path} changed while it was opened`);
+    }
+    opened2.set(real, file);
+    return file;
+  }
 };
 function cronLocks() {
   return globalThis.navigator?.locks;
@@ -37393,11 +37659,38 @@ function policyAsker(port) {
     }
   };
 }
+function processOps(ready2, reply) {
+  const terminals = /* @__PURE__ */ new Map();
+  async function terminal(req) {
+    const onData = (bytes) => reply(req.id, { fd: 1, bytes });
+    const session = await (await ready2()).openTerminal(req.argv, { ...req.options, onData });
+    terminals.set(req.id, session);
+    reply(req.id, { started: session.pid });
+    try {
+      const status = await session.exited;
+      const signal = session.termsig();
+      return signal ? { status, signal } : status;
+    } finally {
+      terminals.delete(req.id);
+    }
+  }
+  async function sudoRun(req) {
+    const running = await (await ready2()).sudoRun(req.replay, req.options);
+    reply(req.id, { started: running.pid });
+    return running.ended;
+  }
+  function onTerminal(req) {
+    const session = terminals.get(req.terminal);
+    if (!session) throw new Error(`no terminal ${req.terminal}`);
+    act2(session, req);
+    return true;
+  }
+  return { terminal, sudoRun, act: onTerminal };
+}
 function serveKernel(port, deps) {
   let launcher;
   let remote;
   let uplink;
-  const terminals = /* @__PURE__ */ new Map();
   const reply = (id2, body, transfer) => port.postMessage({ id: id2, ...body }, transfer);
   const clients = /* @__PURE__ */ new Set();
   const sealed = sealedAsker(port);
@@ -37426,19 +37719,7 @@ function serveKernel(port, deps) {
     if (!launcher) throw new Error("the kernel is not initialized");
     return launcher;
   }
-  async function terminal(req) {
-    const onData = (bytes) => reply(req.id, { fd: 1, bytes });
-    const session = await (await ready2()).openTerminal(req.argv, { ...req.options, onData });
-    terminals.set(req.id, session);
-    reply(req.id, { started: session.pid });
-    try {
-      const status = await session.exited;
-      const signal = session.termsig();
-      return signal ? { status, signal } : status;
-    } finally {
-      terminals.delete(req.id);
-    }
-  }
+  const processes2 = processOps(ready2, reply);
   async function init(req) {
     launcher = rootOf(deps, req).then(async (root) => {
       req = await rootNamed(deps, req, root);
@@ -37493,7 +37774,8 @@ function serveKernel(port, deps) {
     if (req.op === "init") return init(req);
     if (isAttestRequest(req)) return attestOp(await ready2(), req);
     if (req.op === "sealed-placeholders") return (await ready2()).setPlaceholders(req.list);
-    if (req.op === "open-terminal") return terminal(req);
+    if (req.op === "open-terminal") return processes2.terminal(req);
+    if (req.op === "sudo-run") return processes2.sudoRun(req);
     if (req.op === "connect") return connect2(req.user, req.tag, req.requests);
     if (isUsersRequest(req)) return usersOp(await ready2(), req);
     if (req.op === "routes" || req.op === "transport-traits") {
@@ -37502,12 +37784,7 @@ function serveKernel(port, deps) {
     if (req.op === "dial") return dial(await ready2(), req);
     if (req.op === "mount" || req.op === "umount" || req.op === "mounts" || req.op === "insert")
       return mountOp(req);
-    if (req.op === "terminal") {
-      const session = terminals.get(req.terminal);
-      if (!session) throw new Error(`no terminal ${req.terminal}`);
-      act2(session, req);
-      return true;
-    }
+    if (req.op === "terminal") return processes2.act(req);
     return (await ready2()).run(req.argv, {
       ...req.options,
       onStdout: (bytes) => reply(req.id, { fd: 1, bytes }),