@ai-ecoverse/slicc-kernel 1.65.1 → 1.66.0

package/dist/node.js

@@ -532,6 +532,64 @@ async function openable(g, op, path, want, create) {
   await need(g, op, path, want, { directory: st?.isDirectory ?? false });
 }
 
+// src/kernel/cred.ts
+var ROOT = Object.freeze({
+  ruid: 0,
+  euid: 0,
+  suid: 0,
+  rgid: 0,
+  egid: 0,
+  sgid: 0,
+  groups: [0]
+});
+var MAX_ID = 4294967294;
+var MAX_GROUPS = 65536;
+var UIDS = ["ruid", "euid", "suid"];
+var GIDS = ["rgid", "egid", "sgid"];
+function userCred(uid, gid, groups = [gid]) {
+  return { ruid: uid, euid: uid, suid: uid, rgid: gid, egid: gid, sgid: gid, groups: [...groups] };
+}
+function copyCred(cred) {
+  return { ...cred, groups: [...cred.groups] };
+}
+function id(value) {
+  if (value === void 0 || value === -1 || value === 4294967295) return void 0;
+  if (!Number.isInteger(value) || value < 0 || value > MAX_ID) {
+    throw fsError("EINVAL", `not a user or group id: ${String(value)}`);
+  }
+  return value;
+}
+function changeCred(cur, change) {
+  const privileged = cur.euid === 0;
+  const next2 = copyCred(cur);
+  for (const keys of [UIDS, GIDS]) {
+    const own = keys.map((key) => cur[key]);
+    for (const key of keys) {
+      const value = id(change[key]);
+      if (value === void 0) continue;
+      if (!privileged && !own.includes(value)) throw fsError("EPERM", `${key} ${value}`);
+      next2[key] = value;
+    }
+  }
+  if (change.groups !== void 0) {
+    if (!Array.isArray(change.groups) || change.groups.length > MAX_GROUPS) {
+      throw fsError("EINVAL", "not a group list");
+    }
+    const groups = change.groups.map((g) => id(g) ?? Number.NaN);
+    if (groups.some(Number.isNaN)) throw fsError("EINVAL", "not a group list");
+    if (!privileged) throw fsError("EPERM", "setgroups");
+    next2.groups = groups;
+  }
+  return next2;
+}
+function maySignal(sender, target) {
+  if (sender.euid === 0) return true;
+  return [sender.ruid, sender.euid].some((uid) => uid === target.ruid || uid === target.suid);
+}
+function maySee(viewer, target) {
+  return viewer.euid === 0 || target.ruid === viewer.euid || target.euid === viewer.euid;
+}
+
 // src/kernel/pipe.ts
 var PIPE_CAPACITY = 64 * 1024;
 var PipeError = class extends Error {
@@ -839,9 +897,9 @@ var FdTable = class _FdTable {
   closesOnExec(fd) {
     return this.cloexec.has(fd);
   }
-  setStatusFlags(fd, flags) {
+  setStatusFlags(fd, flags2) {
     this.get(fd);
-    this.status.set(fd, flags);
+    this.status.set(fd, flags2);
   }
   statusFlags(fd) {
     return this.status.get(fd);
@@ -886,7 +944,7 @@ var FdTable = class _FdTable {
     const child = new _FdTable();
     for (const [fd, file] of this.fds) child.fds.set(fd, file.retain());
     for (const fd of this.cloexec) child.cloexec.add(fd);
-    for (const [fd, flags] of this.status) child.status.set(fd, flags);
+    for (const [fd, flags2] of this.status) child.status.set(fd, flags2);
     return child;
   }
   async closeAll() {
@@ -1353,9 +1411,9 @@ var KernelSocket = class _KernelSocket {
         case SO_TYPE:
           return SOCK_STREAM;
         case SO_ERROR: {
-          const failed2 = this.failed;
+          const failed3 = this.failed;
           this.failed = void 0;
-          return failed2 ? wasiErrno(failed2) : 0;
+          return failed3 ? wasiErrno(failed3) : 0;
         }
         case SO_ACCEPTCONN:
           return this.state === "listening" ? 1 : 0;
@@ -2047,64 +2105,6 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
   };
 }
 
-// src/kernel/cred.ts
-var ROOT = Object.freeze({
-  ruid: 0,
-  euid: 0,
-  suid: 0,
-  rgid: 0,
-  egid: 0,
-  sgid: 0,
-  groups: [0]
-});
-var MAX_ID = 4294967294;
-var MAX_GROUPS = 65536;
-var UIDS = ["ruid", "euid", "suid"];
-var GIDS = ["rgid", "egid", "sgid"];
-function userCred(uid, gid, groups = [gid]) {
-  return { ruid: uid, euid: uid, suid: uid, rgid: gid, egid: gid, sgid: gid, groups: [...groups] };
-}
-function copyCred(cred) {
-  return { ...cred, groups: [...cred.groups] };
-}
-function id(value) {
-  if (value === void 0 || value === -1 || value === 4294967295) return void 0;
-  if (!Number.isInteger(value) || value < 0 || value > MAX_ID) {
-    throw fsError("EINVAL", `not a user or group id: ${String(value)}`);
-  }
-  return value;
-}
-function changeCred(cur, change) {
-  const privileged = cur.euid === 0;
-  const next2 = copyCred(cur);
-  for (const keys of [UIDS, GIDS]) {
-    const own = keys.map((key) => cur[key]);
-    for (const key of keys) {
-      const value = id(change[key]);
-      if (value === void 0) continue;
-      if (!privileged && !own.includes(value)) throw fsError("EPERM", `${key} ${value}`);
-      next2[key] = value;
-    }
-  }
-  if (change.groups !== void 0) {
-    if (!Array.isArray(change.groups) || change.groups.length > MAX_GROUPS) {
-      throw fsError("EINVAL", "not a group list");
-    }
-    const groups = change.groups.map((g) => id(g) ?? Number.NaN);
-    if (groups.some(Number.isNaN)) throw fsError("EINVAL", "not a group list");
-    if (!privileged) throw fsError("EPERM", "setgroups");
-    next2.groups = groups;
-  }
-  return next2;
-}
-function maySignal(sender, target) {
-  if (sender.euid === 0) return true;
-  return [sender.ruid, sender.euid].some((uid) => uid === target.ruid || uid === target.suid);
-}
-function maySee(viewer, target) {
-  return viewer.euid === 0 || target.ruid === viewer.euid || target.euid === viewer.euid;
-}
-
 // src/users.ts
 var PASSWD = "/etc/passwd";
 var GROUP = "/etc/group";
@@ -2438,7 +2438,7 @@ var UserDb = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 8];
+var PROTOCOL = [1, 9];
 var FS_METHODS = [
   "readFile",
   "writeFile",
@@ -2596,6 +2596,12 @@ async function runAs(l, self, requested) {
   }
   return target;
 }
+function clientCred(self) {
+  return self ? credOf(self) : copyCred(ROOT);
+}
+async function runTagged(l, self, requested, tag) {
+  return { user: await runAs(l, self, requested), tag };
+}
 function processes(l, self) {
   const viewer = credOf(self);
   return l.list(viewer).map(({ tid: _, cred = viewer, umask: _umask, ...entry }) => ({
@@ -2730,7 +2736,7 @@ function serveClient(port, host) {
   async function terminal(req, l) {
     const session = await l.openTerminal(req.argv, {
       ...req.options,
-      user: await runAs(l, self, req.options.user),
+      ...await runTagged(l, self, req.options.user, host.tag),
       onData: (bytes) => reply(req.id, { fd: 1, bytes: bytes.slice() })
     });
     if (state === "closed") {
@@ -2752,7 +2758,7 @@ function serveClient(port, host) {
     let leader;
     const result = await l.run(req.argv, {
       ...req.options,
-      user: await runAs(l, self, req.options.user),
+      ...await runTagged(l, self, req.options.user, host.tag),
       collect: false,
       onStdout: out(1),
       onStderr: out(2),
@@ -2793,9 +2799,9 @@ function serveClient(port, host) {
       case "unwatch":
         return watchOp(l, req, watches, send, guardFor(l, self));
       case "mount":
-        return { result: await l.mount(req.spec) };
+        return { result: await l.mountAs(clientCred(self), req.spec) };
       case "umount":
-        l.umount(req.target);
+        await l.umountAs(clientCred(self), req.target);
         return { result: true };
       case "mounts":
         return { result: l.mounts.list() };
@@ -2998,15 +3004,15 @@ function translate(err, path, op = "lookup", mapped = true) {
   if (typeof err?.code === "string") return err;
   const raw = err?.name;
   const name2 = typeof raw === "string" ? raw : "Error";
-  const code = mapped && ERRNO_BY_DOM_ERROR[name2] || "EIO";
+  const code = name2 === "QuotaExceededError" ? "ENOSPC" : mapped && ERRNO_BY_DOM_ERROR[name2] || "EIO";
   const error = Object.assign(fsError(code, path), { domName: name2, op, cause: err });
-  if (code !== "EIO") return error;
+  if (code !== "EIO" && code !== "ENOSPC") return error;
   const detail = err?.message;
   error.message += ` (OPFS ${op}: ${name2}${typeof detail === "string" && detail ? `: ${detail}` : ""})`;
   if (!reported.has(`${name2}/${op}`)) {
     reported.add(`${name2}/${op}`);
     console.warn(
-      `slicc-kernel: ${error.message}, reported as EIO; logged once per error and operation`
+      `slicc-kernel: ${error.message}, reported as ${code}; logged once per error and operation`
     );
   }
   return error;
@@ -3512,11 +3518,13 @@ var OpfsFs = class {
     const [file, existed, target] = await this.fileFor(path);
     if (!existed) await this.stampNew(target, owner, false);
     if (!existed && content.length === 0) return;
+    let writable2;
     try {
-      const writable2 = await file.createWritable();
+      writable2 = await file.createWritable();
       await writable2.write(content);
       await writable2.close();
     } catch (err) {
+      await writable2?.abort().catch(() => void 0);
       throw translate(err, path, "commit", false);
     }
   }
@@ -4999,9 +5007,8 @@ async function scanFilesystems(fs, modules) {
 }
 var SUFFIX = /^\.[A-Za-z0-9_+-][A-Za-z0-9._+-]*$/;
 async function scanBinfmts(fs, modules, warn = () => {
-}) {
+}, owners = /* @__PURE__ */ new Map()) {
   const found = /* @__PURE__ */ new Map();
-  const owners = /* @__PURE__ */ new Map();
   for (const pkg of await packagesIn(fs, modules)) {
     let manifest;
     try {
@@ -5026,7 +5033,7 @@ async function scanBinfmts(fs, modules, warn = () => {
   }
   return found;
 }
-function binfmtOf(binfmts, path) {
+function binfmtSuffix(binfmts, path) {
   const name2 = path.slice(path.lastIndexOf("/") + 1);
   let best;
   for (const suffix of binfmts.keys()) {
@@ -5034,6 +5041,10 @@ function binfmtOf(binfmts, path) {
       if (best === void 0 || suffix.length > best.length) best = suffix;
     }
   }
+  return best;
+}
+function binfmtOf(binfmts, path) {
+  const best = binfmtSuffix(binfmts, path);
   return best === void 0 ? void 0 : binfmts.get(best);
 }
 
@@ -5388,8 +5399,9 @@ var ChildTable = class {
     if (!this.forker) throw new SpawnError("ENOSYS");
     return this.track(state, this.parentFds.fork(), /* @__PURE__ */ new Map(), this.forker);
   }
-  async spawn(req, stdio, inherit2 = []) {
-    if (!this.spawner) throw new SpawnError("ENOSYS");
+  async spawn(req, stdio, inherit2 = [], grant) {
+    const { spawner } = this;
+    if (!spawner) throw new SpawnError("ENOSYS");
     const fds = new FdTable();
     const captured = /* @__PURE__ */ new Map();
     try {
@@ -5407,7 +5419,7 @@ var ChildTable = class {
       await fds.closeAll();
       throw e;
     }
-    return this.track(req, fds, captured, this.spawner);
+    return this.track(req, fds, captured, (r, f) => spawner(r, f, grant));
   }
   async track(req, fds, captured, start2) {
     let handle;
@@ -5454,34 +5466,34 @@ var ChildTable = class {
     }
     return deviceFile("null");
   }
-  async wait(pid, nohang, signal, flags = {}) {
+  async wait(pid, nohang, signal, flags2 = {}) {
     let interrupt;
     try {
       for (; ; ) {
-        const candidates = this.candidates(pid, flags);
+        const candidates = this.candidates(pid, flags2);
         if (candidates.length === 0) throw new KernelError("ECHILD");
         const done4 = candidates.find(([, child]) => child.code !== void 0);
         if (done4) return this.reap(done4[0], done4[1].code);
-        const changed = this.stateReport(candidates, flags);
+        const changed = this.stateReport(candidates, flags2);
         if (changed) return changed;
         if (nohang) return [0, 0];
         interrupt ??= interrupted(signal);
-        await this.nextChange(candidates, flags, interrupt.promise);
+        await this.nextChange(candidates, flags2, interrupt.promise);
       }
     } finally {
       interrupt?.done();
     }
   }
-  candidates(pid, flags) {
+  candidates(pid, flags2) {
     const all = [...this.children];
     if (pid > 0) return all.filter(([p]) => p === pid);
-    const inGroup2 = flags.inGroup;
+    const inGroup2 = flags2.inGroup;
     return pid === -1 || !inGroup2 ? all : all.filter(([p]) => inGroup2(p));
   }
-  async nextChange(candidates, flags, interrupt) {
+  async nextChange(candidates, flags2, interrupt) {
     let wake;
     const stateChange = new Promise((resolve) => wake = resolve);
-    const watching = flags.untraced || flags.continued;
+    const watching = flags2.untraced || flags2.continued;
     if (watching && wake) this.stateChanged.push(wake);
     try {
       await Promise.race([
@@ -5493,14 +5505,14 @@ var ChildTable = class {
       this.stateChanged = this.stateChanged.filter((w) => w !== wake);
     }
   }
-  stateReport(candidates, flags) {
+  stateReport(candidates, flags2) {
     for (const [p, child] of candidates) {
-      if (flags.untraced && child.stopReport !== void 0) {
+      if (flags2.untraced && child.stopReport !== void 0) {
         const sig = child.stopReport;
         child.stopReport = void 0;
         return [p, stoppedStatus(sig)];
       }
-      if (flags.continued && child.continueReport) {
+      if (flags2.continued && child.continueReport) {
         child.continueReport = false;
         return [p, CONTINUED_STATUS];
       }
@@ -8659,8 +8671,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 words = [...head, ...back].map((g) => Number.parseInt(g, 16));
-  const missing3 = 8 - words.length - tail.length;
+  const words2 = [...head, ...back].map((g) => Number.parseInt(g, 16));
+  const missing3 = 8 - words2.length - tail.length;
   if (halves.length === 2 ? missing3 < 1 : missing3 !== 0) return void 0;
   const all = [
     ...head.map((g) => Number.parseInt(g, 16)),
@@ -10809,8 +10821,8 @@ function errCode(err) {
 async function targetDir(fs, path) {
   return parentOf(await realTarget(fs, path).catch(() => path));
 }
-async function refuseReadonly(fs, path, flags, opts = {}) {
-  const writes = (flags & O_ACCMODE) !== 0 || opts.truncate === true;
+async function refuseReadonly(fs, path, flags2, opts = {}) {
+  const writes = (flags2 & O_ACCMODE) !== 0 || opts.truncate === true;
   if (!writes && !opts.create || !fs.stat) return;
   const stat = (p) => fs.stat?.(p).catch((err) => {
     const code = err?.code;
@@ -11025,6 +11037,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "proc-spawn",
   "proc-wait",
   "proc-captured",
+  "proc-sudo",
   "proc-run",
   "proc-exit",
   "proc-fork",
@@ -11057,6 +11070,12 @@ var MAX_READ = 1024 * 1024;
 var WRITE_ACCESS = 3;
 var KEYBOARD = /* @__PURE__ */ new Set([SIG.INT, SIG.QUIT, SIG.TSTP]);
 var DEFAULT_UMASK = 18;
+function words(value) {
+  if (!Array.isArray(value) || !value.every((w) => typeof w === "string")) {
+    throw new KernelError("EINVAL");
+  }
+  return [...value];
+}
 var DYING = { ok: false, errno: "EINTR", message: "the process is being killed" };
 var HOSTS_ONLY = new Resolver({ routes: new Routes() });
 var WasmProcess = class {
@@ -11249,17 +11268,17 @@ var WasmProcess = class {
     if (restart && this.options.hasPending?.()) throw new KernelError("EINTR");
   }
   async procWait(req, cancelled) {
-    const flags = {
+    const flags2 = {
       untraced: req.untraced,
       continued: req.continued,
       inGroup: this.waitGroup(req.pid)
     };
     if (this.owed && !req.nohang) {
-      const now = await this.children.wait(req.pid, true, this.interrupt.signal, flags);
+      const now = await this.children.wait(req.pid, true, this.interrupt.signal, flags2);
       if (now[0] !== 0) return now;
     }
     const signal = req.nohang ? this.interrupt.signal : this.blockingSignal(cancelled);
-    const waited = await this.children.wait(req.pid, req.nohang, signal, flags);
+    const waited = await this.children.wait(req.pid, req.nohang, signal, flags2);
     return waited;
   }
   blockingSignal(cancelled, owing = true) {
@@ -11591,13 +11610,13 @@ var WasmProcess = class {
   }
   fdInfo(fd) {
     const file = this.fds.get(fd).file;
-    const flags = this.fds.statusFlags(fd);
+    const flags2 = this.fds.statusFlags(fd);
     const terminal = (file.tty ?? file.pty?.slave)?.name;
     return {
       tty: file.tty !== void 0,
       kind: file instanceof KernelSocket ? "socket" : kernelFdKind(file),
       ...file.heldMeta ? { meta: file.heldMeta } : {},
-      ...flags !== void 0 ? { flags } : {},
+      ...flags2 !== void 0 ? { flags: flags2 } : {},
       ...this.fds.closesOnExec(fd) ? { cloexec: true } : {},
       ...file.read && !file.write ? { access: "read" } : {},
       ...file.write && !file.read ? { access: "write" } : {},
@@ -11785,7 +11804,27 @@ var WasmProcess = class {
         return { ok: true, kind: "void" };
       case "proc-captured":
         return { ok: true, kind: "bytes", bytes: this.children.captured(req.pid, req.slot) };
-    }
+      case "proc-sudo":
+        return { ok: true, kind: "json", json: await this.sudo(req, cancelled) };
+    }
+  }
+  async sudo(req, cancelled) {
+    const { sudo } = this.options;
+    if (!sudo) throw new KernelError("ENOSYS");
+    const call = {
+      op: "proc-sudo",
+      args: words(req.args),
+      cwd: typeof req.cwd === "string" && req.cwd.startsWith("/") ? req.cwd : "/",
+      ...typeof req.term === "string" ? { term: req.term } : {}
+    };
+    const answer = await sudo(call, this.blockingSignal(cancelled));
+    if (!("grant" in answer)) return answer;
+    if (this.dying) throw new KernelError("EINTR");
+    const { file, argv, env, cwd, cred, caller } = answer.grant;
+    const stdio = [{ fd: 0 }, { fd: 1 }, { fd: 2 }];
+    return {
+      pid: await this.children.spawn({ file, argv, env, cwd }, stdio, [], { cred, caller })
+    };
   }
   async mountSyscall(req, cancelled) {
     const { mount, umount } = this.options;
@@ -11793,9 +11832,9 @@ var WasmProcess = class {
     try {
       if (req.op === "umount") await umount(req.target, req.flags);
       else {
-        const { source, target, type, flags, data } = req;
+        const { source, target, type, flags: flags2, data } = req;
         const signal = this.blockingSignal(cancelled);
-        await Promise.race([mount({ source, target, type, flags, data }, signal), aborted(signal)]);
+        await Promise.race([mount({ source, target, type, flags: flags2, data }, signal), aborted(signal)]);
       }
     } catch (err) {
       const code = err?.code;
@@ -11938,14 +11977,14 @@ function descId(file) {
 function inheritedFds(fds) {
   return fds.numbers().filter((fd) => fd > 2 && !fds.get(fd).file.held).map((fd) => {
     const open = fds.get(fd);
-    const flags = fds.statusFlags(fd);
+    const flags2 = fds.statusFlags(fd);
     const kind = open.file instanceof KernelSocket ? "socket" : kernelFdKind(open.file);
     const meta = open.file.heldMeta;
     return {
       fd,
       kind,
       ...kind === "device" && meta && "device" in meta ? { device: meta } : {},
-      ...flags !== void 0 ? { flags } : {},
+      ...flags2 !== void 0 ? { flags: flags2 } : {},
       ...fds.closesOnExec(fd) ? { cloexec: true } : {},
       ...kind === "stream" ? { desc: descId(open) } : {}
     };
@@ -12098,6 +12137,7 @@ function processOptions(opts, header4, hooks, created3) {
     kill: opts.kill,
     ...opts.writesBack ? { writesBack: opts.writesBack } : {},
     processes: opts.processes,
+    ...opts.sudo ? { sudo: opts.sudo } : {},
     openFiles: opts.openFiles,
     ...opts.nodes ? { nodes: opts.nodes } : {},
     mounts: opts.mounts,
@@ -12856,12 +12896,12 @@ function kernelFsHandlers(fs) {
       const attr2 = attrOf(st);
       return [{ name: name2, kind: attr2.kind, attr: attr2 }];
     }),
-    async open(path, flags) {
+    async open(path, flags2) {
       const st = await existing(path);
-      if (st && flags.exclusive) throw fsError2("EEXIST", path);
-      if (st?.isDirectory && flags.write) throw fsError2("EISDIR", path);
-      if (!st && !flags.create) throw fsError2("ENOENT", path);
-      if (!st || flags.truncate) await fs.writeFile(path, new Uint8Array(0));
+      if (st && flags2.exclusive) throw fsError2("EEXIST", path);
+      if (st?.isDirectory && flags2.write) throw fsError2("EISDIR", path);
+      if (!st && !flags2.create) throw fsError2("ENOENT", path);
+      if (!st || flags2.truncate) await fs.writeFile(path, new Uint8Array(0));
       handles.set(++nextFh, { path });
       return nextFh;
     },
@@ -12991,24 +13031,24 @@ function absolute(target) {
   return normalizePath(target);
 }
 function mountCall(call) {
-  let flags = call.flags >>> 0;
-  if ((flags & MS_MGC_MSK) >>> 0 === MS_MGC_VAL) flags &= ~MS_MGC_MSK;
-  if (flags & ~(MS_RDONLY | IGNORED_FLAGS)) {
-    throw errnoError("EINVAL", `unsupported mount flags ${flags.toString(16)}`);
+  let flags2 = call.flags >>> 0;
+  if ((flags2 & MS_MGC_MSK) >>> 0 === MS_MGC_VAL) flags2 &= ~MS_MGC_MSK;
+  if (flags2 & ~(MS_RDONLY | IGNORED_FLAGS)) {
+    throw errnoError("EINVAL", `unsupported mount flags ${flags2.toString(16)}`);
   }
   if (!call.type) throw errnoError("EINVAL", "no file system type");
   const target = absolute(call.target);
   refusedTarget(target);
   const options = parseMountOptions(call.data);
-  if (flags & MS_RDONLY) options.ro = "";
+  if (flags2 & MS_RDONLY) options.ro = "";
   return { type: call.type, source: call.source || "none", target, options };
 }
-function umountCall(target, flags) {
+function umountCall(target, flags2) {
   const known = MNT_FORCE | MNT_DETACH | UMOUNT_NOFOLLOW;
-  if (flags >>> 0 & ~known) throw errnoError("EINVAL", `unsupported umount flags ${flags}`);
+  if (flags2 >>> 0 & ~known) throw errnoError("EINVAL", `unsupported umount flags ${flags2}`);
   const at = absolute(target);
   refusedTarget(at);
-  return { target: at, detach: (flags & (MNT_FORCE | MNT_DETACH)) !== 0 };
+  return { target: at, detach: (flags2 & (MNT_FORCE | MNT_DETACH)) !== 0 };
 }
 
 // src/mount/fstab.ts
@@ -13066,22 +13106,22 @@ async function mountFstab(lines2, mount, signal, retries = FSTAB_RETRIES, discar
   );
 }
 async function mountLine({ line, spec, invalid }, mount, signal, retries, discard) {
-  let failed2 = invalid;
+  let failed3 = invalid;
   for (let attempt = 0; !invalid && attempt <= retries.length && !signal.aborted; attempt++) {
     try {
       const entry = await mount(spec);
       if (!signal.aborted) return { line, target: spec.target, entry };
       discard(entry);
-      failed2 = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
+      failed3 = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
       break;
     } catch (err) {
-      failed2 = err;
+      failed3 = err;
       if (FINAL.has(codeOf3(err)) || attempt === retries.length) break;
       await wait(retries[attempt], signal);
     }
   }
-  const code = codeOf3(failed2);
-  return { line, target: spec.target, code, error: String(failed2?.message ?? code) };
+  const code = codeOf3(failed3);
+  return { line, target: spec.target, code, error: String(failed3?.message ?? code) };
 }
 
 // src/mount/hostfs.ts
@@ -13258,13 +13298,13 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     }, againMs);
     timer.unref?.();
   });
-  async function writable2(client, path, flags) {
-    const { ifMatch: _, ...asked } = flags;
+  async function writable2(client, path, flags2) {
+    const { ifMatch: _, ...asked } = flags2;
     const opening2 = () => client.call("open", { path: rel(path), ...asked });
     try {
       return { opened: await opening2(), restore: void 0 };
     } catch (err) {
-      if (!flags.write || codeOf4(err) !== "EACCES") throw err;
+      if (!flags2.write || codeOf4(err) !== "EACCES") throw err;
       const was = await client.call("stat", { path: rel(path) });
       const mode = was.mode ?? 0;
       if (mode & 128) throw err;
@@ -13286,11 +13326,11 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
       );
       return entries.map(({ name: name2, attr: attr2 }) => ({ name: name2, kind: attr2.kind, attr: attr2 }));
     },
-    async open(path, flags) {
+    async open(path, flags2) {
       const client = current();
       const token = client.token;
-      const { opened: opened2, restore } = await writable2(client, path, flags);
-      if (flags.ifMatch !== void 0 && opened2.attr?.etag !== flags.ifMatch) {
+      const { opened: opened2, restore } = await writable2(client, path, flags2);
+      if (flags2.ifMatch !== void 0 && opened2.attr?.etag !== flags2.ifMatch) {
         await client.call("release", { fh: opened2.fh }, true);
         throw fsError2("ESTALE", `${path} changed on the host while it was being read`);
       }
@@ -13298,7 +13338,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
         client,
         token,
         fh: opened2.fh,
-        etag: flags.write ? void 0 : opened2.attr?.etag,
+        etag: flags2.write ? void 0 : opened2.attr?.etag,
         restore
       });
       return nextFh;
@@ -13978,14 +14018,14 @@ function tmpfs() {
     if (!found) throw fsError2("EBADF", `handle ${fh}`);
     return found;
   };
-  function opened2(path, flags) {
+  function opened2(path, flags2) {
     const { dir, name: name2 } = parent(path);
     const existing = dir.children.get(name2);
-    if (existing && flags.exclusive) throw fsError2("EEXIST", path);
-    if (existing?.kind === "directory" && flags.write) throw fsError2("EISDIR", path);
+    if (existing && flags2.exclusive) throw fsError2("EEXIST", path);
+    if (existing?.kind === "directory" && flags2.write) throw fsError2("EISDIR", path);
     if (existing) return existing;
-    if (!flags.create) throw fsError2("ENOENT", path);
-    const node = make("file", 33188, dir, flags.owner);
+    if (!flags2.create) throw fsError2("ENOENT", path);
+    const node = make("file", 33188, dir, flags2.owner);
     place(dir, name2, node);
     return node;
   }
@@ -14005,13 +14045,13 @@ function tmpfs() {
         ([name2, node]) => ({ name: name2, kind: node.kind, attr: attr(node) })
       );
     },
-    async open(path, flags) {
-      const node = opened2(path, flags);
-      if (flags.truncate && node.kind === "file") {
+    async open(path, flags2) {
+      const node = opened2(path, flags2);
+      if (flags2.truncate && node.kind === "file") {
         node.data.truncate(0);
         node.mtime = Date.now();
       }
-      handles.set(++nextFh, { node, write: flags.write });
+      handles.set(++nextFh, { node, write: flags2.write });
       return nextFh;
     },
     async read(fh, offset, size) {
@@ -14127,10 +14167,10 @@ function importedMemory(bytes) {
     return s;
   };
   const limits = () => {
-    const flags = bytes[at++];
+    const flags2 = bytes[at++];
     const initial = u32();
-    const maximum = flags & 1 ? u32() : void 0;
-    return { initial, maximum, shared: (flags & 2) !== 0 };
+    const maximum = flags2 & 1 ? u32() : void 0;
+    return { initial, maximum, shared: (flags2 & 2) !== 0 };
   };
   while (at < bytes.length) {
     const id2 = bytes[at++];
@@ -14209,9 +14249,9 @@ var Reader = class {
     return code;
   }
   limits() {
-    const flags = this.byte();
+    const flags2 = this.byte();
     this.u32();
-    if (flags & 1) this.u32();
+    if (flags2 & 1) this.u32();
   }
 };
 function readTypes(r) {
@@ -14266,6 +14306,412 @@ function foreignImports(bytes) {
   return {};
 }
 
+// src/sudo.ts
+var SUDOERS = "/etc/sudoers";
+var SUDOERS_D = "/etc/sudoers.d";
+var SECURE_PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+var DEFAULT_SUDOERS = "%sudo Cmnd *\n";
+var SUDO_TIMEOUT_MS = 3e5;
+var NAME3 = /^[a-z_][a-z0-9_.-]*$/;
+var RULE = /^(NOPASSWD\s+)?(\S+)\s+(?:\(([^()\s]+)\)\s+)?Cmnd(?:\s+(.*))?$/;
+var TERM = /^[A-Za-z0-9._+-]+$/;
+var PLAIN = /^[A-Za-z0-9_@%+=:,./-]+$/;
+var USAGE = "usage: sudo [-n] [-u user] [--] command [args...]\n       sudo -l";
+function failed2(errno, error) {
+  return { error, errno };
+}
+function unescaped(double) {
+  return double.replace(/\\(["\\$`])/g, "$1");
+}
+function splitWords(text) {
+  const piece = /'([^']*)'|"((?:[^"\\]|\\[\s\S])*)"|\\([\s\S])|([^\s'"\\]+)|(\s+)/y;
+  const words2 = [];
+  let word;
+  while (piece.lastIndex < text.length) {
+    const m = piece.exec(text);
+    if (!m) return void 0;
+    const [, single, double, escaped, plain, space] = m;
+    if (space !== void 0) {
+      if (word !== void 0) words2.push(word);
+      word = void 0;
+      continue;
+    }
+    word = (word ?? "") + (single ?? (double !== void 0 ? unescaped(double) : escaped ?? plain));
+  }
+  if (word !== void 0) words2.push(word);
+  return words2;
+}
+function quoteWord(word) {
+  return PLAIN.test(word) ? word : `'${word.replaceAll("'", `'\\''`)}'`;
+}
+function validWho(who) {
+  if (who === "ALL") return true;
+  return NAME3.test(who.startsWith("%") ? who.slice(1) : who);
+}
+function parseRule(line) {
+  const text = line.trim();
+  if (text === "" || text.startsWith("#")) return null;
+  const m = RULE.exec(text);
+  if (!m) return void 0;
+  const [, nopasswd, who = "", target = "root", rest2 = ""] = m;
+  if (!validWho(who) || target !== "ALL" && !NAME3.test(target)) return void 0;
+  if (rest2.trim() === "*") return { nopasswd: !!nopasswd, who, target, cmnd: "*" };
+  const cmnd = splitWords(rest2);
+  if (!cmnd?.[0]?.startsWith("/")) return void 0;
+  return { nopasswd: !!nopasswd, who, target, cmnd };
+}
+function flags(parsed2, arg, next2) {
+  for (let j = 1; j < arg.length; j++) {
+    const flag = arg[j];
+    if (flag === "n") parsed2.nonInteractive = true;
+    else if (flag === "l") parsed2.list = true;
+    else if (flag !== "u") return `sudo: invalid option -- '${flag}'
+${USAGE}`;
+    else {
+      const user = arg.slice(j + 1) || next2;
+      if (!user) return `sudo: option requires an argument -- 'u'
+${USAGE}`;
+      parsed2.user = user;
+      return arg.slice(j + 1) ? 0 : 1;
+    }
+  }
+  return 0;
+}
+function parseArgs(args) {
+  const parsed2 = { list: false, nonInteractive: false, user: "root", command: [] };
+  let i = 0;
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      i++;
+      break;
+    }
+    if (!arg.startsWith("-") || arg === "-") break;
+    const used = flags(parsed2, arg, args[i + 1]);
+    if (typeof used === "string") return used;
+    i += used;
+  }
+  parsed2.command = args.slice(i);
+  if (parsed2.list ? parsed2.command.length > 0 : parsed2.command.length === 0) return USAGE;
+  return parsed2;
+}
+function described(rule) {
+  const cmnd = rule.cmnd === "*" ? "ALL" : rule.cmnd.map(quoteWord).join(" ");
+  return `    (${rule.target}) ${rule.nopasswd ? "NOPASSWD: " : ""}${cmnd}`;
+}
+var Sudo = class {
+  o;
+  warned = /* @__PURE__ */ new Set();
+  pending = /* @__PURE__ */ new Set();
+  next = 0;
+  constructor(options) {
+    this.o = options;
+  }
+  warn(message3) {
+    if (this.warned.has(message3)) return;
+    this.warned.add(message3);
+    (this.o.warn ?? console.warn)(message3);
+  }
+  async provision() {
+    const { fs } = this.o;
+    if (!await fs.exists(SUDOERS)) {
+      await fs.writeFile(SUDOERS, DEFAULT_SUDOERS);
+      await fs.chown?.(SUDOERS, { uid: 0, gid: 0, mode: 288, follow: false });
+    }
+    if (!await fs.exists(SUDOERS_D)) {
+      await fs.mkdir(SUDOERS_D, { recursive: true });
+      await fs.chown?.(SUDOERS_D, { uid: 0, gid: 0, mode: 488, follow: false });
+    }
+  }
+  async trusted(path) {
+    const parts2 = normalizePath(path).split("/").filter(Boolean);
+    for (let n = 0; n <= parts2.length; n++) {
+      const at = `/${parts2.slice(0, n).join("/")}`;
+      const st = await this.o.fs.lstat(at).catch(() => void 0);
+      if (!st || st.isSymbolicLink || st.uid !== 0 || (st.mode & 18) !== 0) return false;
+    }
+    return true;
+  }
+  async policyFile(path) {
+    if (!await this.trusted(path)) {
+      this.warn(`sudo: ${path} skipped: it must be root's, no symlink, and writable by root only`);
+      return [];
+    }
+    const text = await this.o.fs.readFile(path).catch(() => "");
+    const rules = [];
+    for (const [n, line] of text.split("\n").entries()) {
+      const rule = parseRule(line);
+      if (rule) rules.push(rule);
+      else if (rule === void 0) this.warn(`sudo: ${path}:${n + 1}: bad line skipped: ${line}`);
+    }
+    return rules;
+  }
+  async policy() {
+    const rules = await this.policyFile(SUDOERS);
+    const names = await this.o.fs.readdir(SUDOERS_D).catch(() => []);
+    if (names.length > 0 && !await this.trusted(SUDOERS_D)) {
+      this.warn(`sudo: ${SUDOERS_D} skipped: it must be root's and writable by root only`);
+      return rules;
+    }
+    for (const name2 of [...names].sort()) {
+      if (name2.startsWith(".") || name2.endsWith("~")) continue;
+      rules.push(...await this.policyFile(`${SUDOERS_D}/${name2}`));
+    }
+    return rules;
+  }
+  async groupIds() {
+    return new Map((await this.o.users.groups()).map((g) => [g.name, g.gid]));
+  }
+  async applies(caller, cred) {
+    const gids = await this.groupIds();
+    const mine = /* @__PURE__ */ new Set([cred.rgid, cred.egid, ...cred.groups]);
+    return (rule) => {
+      if (rule.who === "ALL" || rule.who === caller.name) return true;
+      const gid = rule.who.startsWith("%") ? gids.get(rule.who.slice(1)) : void 0;
+      return gid !== void 0 && mine.has(gid);
+    };
+  }
+  async lookup(user) {
+    const key = /^#\d+$/.test(user) ? Number(user.slice(1)) : user;
+    return this.o.users.lookup(key);
+  }
+  async canonical(cwd) {
+    const { fs } = this.o;
+    const path = normalizePath(cwd);
+    return fs.realpath ? fs.realpath(path, true).catch(() => void 0) : path;
+  }
+  async reachable(cred, cwd) {
+    const walked = await access(this.o.fs, cred, cwd, X_OK, { directory: true });
+    if (walked.denied !== void 0 || walked.missing) return false;
+    return (await this.o.fs.stat(cwd).catch(() => void 0))?.isDirectory === true;
+  }
+  async untrusted(path, cwd) {
+    const files = await this.o.backing?.(path, cwd) ?? [];
+    for (const file of [path, ...files]) if (!await this.trusted(file)) return file;
+    return void 0;
+  }
+  async locate(word, cwd) {
+    const { fs } = this.o;
+    const candidates = word.includes("/") ? [fs.resolvePath(cwd, word)] : SECURE_PATH.split(":").map((dir) => `${dir}/${word}`);
+    for (const path of candidates) {
+      const st = await fs.stat(path).catch(() => void 0);
+      if (!st?.isFile || (st.mode & 73) === 0) continue;
+      return fs.realpath ? fs.realpath(path, true).catch(() => path) : path;
+    }
+    return void 0;
+  }
+  async request(caller, call, signal) {
+    const parsed2 = parseArgs(call.args);
+    if (typeof parsed2 === "string") return failed2("EINVAL", parsed2);
+    if (this.o.mode !== "enforce") {
+      const mode = this.o.mode;
+      if (parsed2.list) return { list: `sudo: users are '${mode}': commands run as the caller
+` };
+      return { run: parsed2.command };
+    }
+    const { cred } = caller;
+    const self = await this.o.users.lookup(cred.ruid);
+    if (!self) return failed2("EPERM", `sudo: uid ${cred.ruid} is not in the passwd database`);
+    const target = await this.lookup(parsed2.user);
+    if (!target) return failed2("ENOENT", `sudo: unknown user ${parsed2.user}`);
+    const root = cred.euid === 0;
+    const rules = root ? [] : await this.policy();
+    const applies = await this.applies(self, cred);
+    if (parsed2.list) return this.listed(self, root, rules.filter(applies));
+    const [word = "", ...args] = parsed2.command;
+    const cwd = await this.canonical(call.cwd);
+    if (cwd === void 0 || !await this.reachable(cred, cwd)) {
+      return failed2(
+        "EACCES",
+        `sudo: cannot run in ${call.cwd}: it isn't a directory you can enter`
+      );
+    }
+    const path = await this.locate(word, cwd);
+    if (!path) return failed2("ENOENT", `sudo: ${word}: command not found`);
+    const untrusted = await this.untrusted(path, cwd);
+    if (untrusted) {
+      return failed2("EPERM", `sudo: ${untrusted} must be root's, and writable by root only`);
+    }
+    const argv = [path, ...args];
+    const matching = rules.filter(
+      (rule) => applies(rule) && (rule.target === "ALL" || rule.target === target.name) && (rule.cmnd === "*" || rule.cmnd.length === argv.length && rule.cmnd.every((w, i) => w === argv[i]))
+    );
+    const grant = () => this.grant(self, target, cred, parsed2.command, path, cwd, call.term);
+    if (root || matching.some((rule) => rule.nopasswd)) return grant();
+    const quoted = argv.map(quoteWord).join(" ");
+    if (matching.length === 0) {
+      return failed2(
+        "EPERM",
+        `sudo: ${self.name} is not allowed to run ${quoted} as ${target.name}`
+      );
+    }
+    if (parsed2.nonInteractive) return failed2("EPERM", "sudo: a password is required");
+    if (this.pending.has(cred.ruid)) return failed2("EBUSY", "sudo: another request is pending");
+    this.pending.add(cred.ruid);
+    try {
+      const answer = await this.ask(caller, self, target, parsed2.command, path, cwd, signal);
+      if (typeof answer !== "string") return answer;
+      if (await this.canonical(call.cwd) !== cwd || !await this.reachable(cred, cwd)) {
+        return failed2("EACCES", `sudo: ${call.cwd} changed while the request waited`);
+      }
+      const changed = await this.untrusted(path, cwd);
+      if (changed) {
+        return failed2("EPERM", `sudo: ${changed} must be root's, and writable by root only`);
+      }
+      if (answer === "always" && !await this.remember(self, target, argv)) {
+        return failed2("EIO", "sudo: the rule could not be recorded");
+      }
+      return grant();
+    } finally {
+      this.pending.delete(cred.ruid);
+    }
+  }
+  listed(self, root, rules) {
+    const host = this.o.hostname;
+    if (root) {
+      return {
+        list: `User ${self.name} may run the following commands on ${host}:
+    (ALL) NOPASSWD: ALL
+`
+      };
+    }
+    if (rules.length === 0) {
+      return failed2("EPERM", `User ${self.name} is not allowed to run sudo on ${host}.`);
+    }
+    const lines2 = rules.map(described).join("\n");
+    return { list: `User ${self.name} may run the following commands on ${host}:
+${lines2}
+` };
+  }
+  async ask(caller, self, target, argv, path, cwd, requester) {
+    const { approve } = this.o;
+    if (!approve || requester.aborted) return failed2("EACCES", "sudo: approval denied");
+    const createdAt = Date.now();
+    const timeout = this.o.timeoutMs ?? SUDO_TIMEOUT_MS;
+    const req = {
+      id: `sudo-${++this.next}-${crypto.randomUUID()}`,
+      kind: "sudo",
+      user: self.name,
+      uid: self.uid,
+      target: target.name,
+      argv: [...argv],
+      path,
+      cwd,
+      pid: caller.pid,
+      ...caller.tag !== void 0 ? { tag: caller.tag } : {},
+      ...caller.tty ? { tty: caller.tty } : {},
+      createdAt,
+      expiresAt: createdAt + timeout,
+      always: true
+    };
+    const control = new AbortController();
+    const timer = setTimeout(() => control.abort("expired"), timeout);
+    const withdraw = () => control.abort("withdrawn");
+    requester.addEventListener("abort", withdraw, { once: true });
+    const aborted2 = new Promise(
+      (resolve) => control.signal.addEventListener("abort", () => resolve("aborted"), { once: true })
+    );
+    try {
+      const answered = Promise.resolve().then(() => approve(req, { signal: control.signal })).catch(() => "deny");
+      const answer = await Promise.race([answered, aborted2]);
+      if (answer === "aborted" || control.signal.aborted) {
+        return control.signal.reason === "expired" ? failed2("ETIMEDOUT", "sudo: the request expired") : failed2("EINTR", "sudo: the request was withdrawn");
+      }
+      return answer === "once" || answer === "always" ? answer : failed2("EACCES", "sudo: approval denied");
+    } finally {
+      clearTimeout(timer);
+      requester.removeEventListener("abort", withdraw);
+    }
+  }
+  async remember(self, target, argv) {
+    const { fs } = this.o;
+    const path = `${SUDOERS_D}/${self.name}`;
+    if (!NAME3.test(self.name)) return false;
+    try {
+      await this.provision();
+      if (!await this.trusted(SUDOERS_D)) return false;
+      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 line = `NOPASSWD ${self.name} (${target.name}) Cmnd ${argv.map(quoteWord).join(" ")}
+`;
+      const text = old === "" || old.endsWith("\n") ? `${old}${line}` : `${old}
+${line}`;
+      await fs.writeFile(path, text);
+      await fs.chown?.(path, { uid: 0, gid: 0, mode: 288, follow: false });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  grant(self, target, cred, argv, file, cwd, term) {
+    const env = {
+      ...this.o.env(),
+      ...userEnv(target, this.o.pnpmHome),
+      SHELL: target.shell,
+      PATH: SECURE_PATH,
+      PWD: cwd,
+      ...term !== void 0 && TERM.test(term) ? { TERM: term } : {},
+      SUDO_USER: self.name,
+      SUDO_UID: String(cred.ruid),
+      SUDO_GID: String(cred.rgid),
+      SUDO_COMMAND: [file, ...argv.slice(1)].join(" ")
+    };
+    return { grant: { file, argv: [...argv], env, cwd, cred: credOf(target), caller: cred } };
+  }
+};
+
+// src/sudo-command.ts
+var SUDO_PATH = "/usr/bin/sudo";
+var SUDO_COMMAND = {
+  name: "sudo",
+  abi: "js",
+  glue: SUDO_PATH,
+  wasm: SUDO_PATH,
+  argv0: "sudo"
+};
+var SUDO_SOURCE = [
+  "export default async function sudo(ctx) {",
+  "  const say = (fd, text) => ctx.write(fd, text).catch(() => undefined);",
+  "  let pid;",
+  "  let held;",
+  "  const relay = (sig) => {",
+  "    if (pid === undefined) held = sig;",
+  "    else return ctx.kill(pid, sig).catch(() => undefined);",
+  "  };",
+  '  for (const sig of ["SIGTERM", "SIGHUP"]) await ctx.signals.on(sig, relay);',
+  "  const failed = () => (held === undefined ? 1 : 128 + held);",
+  "  let answer;",
+  "  try {",
+  "    answer = await ctx.sudo(ctx.argv.slice(1));",
+  "  } catch (err) {",
+  '    await say(2, "sudo: " + (err && err.code ? err.code : String(err)) + "\\n");',
+  "    return failed();",
+  "  }",
+  "  if (answer.error !== undefined) {",
+  '    await say(2, answer.error + "\\n");',
+  "    return failed();",
+  "  }",
+  "  if (answer.list !== undefined) {",
+  "    await say(1, answer.list);",
+  "    return 0;",
+  "  }",
+  '  for (const sig of ["SIGINT", "SIGQUIT"]) await ctx.signals.on(sig, () => undefined);',
+  "  if (answer.run !== undefined) {",
+  "    try {",
+  "      pid = (await ctx.spawn({ argv: answer.run })).pid;",
+  "    } catch (err) {",
+  '      const why = err && err.code === "ENOENT" ? "command not found" : String(err && err.code);',
+  '      await say(2, "sudo: " + answer.run[0] + ": " + why + "\\n");',
+  "      return failed();",
+  "    }",
+  "  } else pid = answer.pid;",
+  "  if (held !== undefined) await relay(held);",
+  "  return (await ctx.wait(pid)).status;",
+  "}",
+  ""
+].join("\n");
+
 // src/launcher.ts
 var COMMAND2 = /^\/(?:usr\/)?bin\/([^/]+)$/;
 var PACKAGE_ROOT = /^(.*\/node_modules\/(?:@[^/]+\/)?[^/]+)\//;
@@ -14293,9 +14739,21 @@ function usersMode(mode = "off") {
   if (USERS_MODES.includes(mode)) return mode;
   throw new Error(`users must be 'off', 'report' or 'enforce', not ${String(mode)}`);
 }
+function tagOption(tag) {
+  if (tag !== void 0 && typeof tag !== "string") throw new TypeError("a tag must be a string");
+}
 function baseName(path) {
   return path.slice(path.lastIndexOf("/") + 1);
 }
+function packageRootOf(path, roots) {
+  for (const root of roots) {
+    const base = normalizePath(root);
+    if (!path.startsWith(`${base}/`)) continue;
+    const [first = "", second] = path.slice(base.length + 1).split("/");
+    return first.startsWith("@") && second !== void 0 ? `${base}/${first}/${second}` : `${base}/${first}`;
+  }
+  return void 0;
+}
 function modulePath(glue) {
   return glue.endsWith(".js") ? `${glue.slice(0, -3)}.wasm` : `${glue}.wasm`;
 }
@@ -14307,11 +14765,11 @@ function shebang(head) {
   return new TextDecoder().decode(head.subarray(0, SHEBANG_MAX)).slice(2).split("\n")[0].trim().split(/[ \t]+/);
 }
 function interpreter(head) {
-  const words = shebang(head);
-  if (!words) return "node";
-  if (baseName(words[0]) === "env") words.shift();
-  if (words[0] === "-S") words.shift();
-  return baseName(words[0] ?? "");
+  const words2 = shebang(head);
+  if (!words2) return "node";
+  if (baseName(words2[0]) === "env") words2.shift();
+  if (words2[0] === "-S") words2.shift();
+  return baseName(words2[0] ?? "");
 }
 function expandDefaults(defaults, env) {
   const out = {};
@@ -14385,7 +14843,10 @@ var Launcher = class {
   orphans = /* @__PURE__ */ new Set();
   described = /* @__PURE__ */ new Map();
   creds = /* @__PURE__ */ new Map();
+  tags = /* @__PURE__ */ new Map();
+  granted = /* @__PURE__ */ new Map();
   users;
+  sudoer;
   jobs = new JobTable();
   locks = new LockTable();
   settling = new SettlingChildren((pid) => this.jobs.pgidOf(pid));
@@ -14486,6 +14947,17 @@ var Launcher = class {
     );
     this.fs = this.unlinked.wrap(keepingOpen(fs, this.nodes));
     this.users = new UserDb(this.fs, this.owners);
+    this.sudoer = new Sudo({
+      fs: this.fs,
+      users: this.users,
+      mode: this.usersMode,
+      hostname,
+      env: () => this.env,
+      pnpmHome: this.pnpmHome,
+      backing: (path, cwd) => this.backing(path, cwd),
+      approve: options.approve,
+      timeoutMs: options.sudoTimeoutMs
+    });
     void this.unlinked.sweep("/");
     this.watchers.watch(
       [this.modulesDir, this.pnpmHome],
@@ -14506,7 +14978,7 @@ var Launcher = class {
   commands(scope = "") {
     let found = this.catalogs.get(scope);
     if (!found) {
-      found = this.roots(scope).then((roots) => scanCommands(this.base, roots));
+      found = this.roots(scope).then((roots) => scanCommands(this.base, roots)).then((commands) => commands.set(SUDO_COMMAND.name, SUDO_COMMAND));
       this.catalogs.set(scope, found);
     }
     return found;
@@ -14629,10 +15101,10 @@ 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 words = shebang(head) ?? (binfmt ? [binfmt] : void 0);
-    if (!words) return void 0;
-    if (baseName(words[0]) === "env") words.shift();
-    const [interp, ...rest2] = words;
+    const words2 = shebang(head) ?? (binfmt ? [binfmt] : void 0);
+    if (!words2) return void 0;
+    if (baseName(words2[0]) === "env") words2.shift();
+    const [interp, ...rest2] = words2;
     const arg = rest2.join(" ");
     const passed = [...arg ? [arg] : [], command ? script : file, ...argv.slice(1)];
     const found = interp ? await this.resolve(interp, interp, cwd, scope) : void 0;
@@ -14669,6 +15141,41 @@ var Launcher = class {
       await need(g, "exec", this.fs.resolvePath(req.cwd, file), want);
     }
   }
+  async grantedCwd(caller, cwd) {
+    const real = await physicalPathAsync(this.base, cwd).catch(() => void 0);
+    return real === cwd && await this.sudoer.reachable(caller, cwd);
+  }
+  async binfmtManifests(scripts) {
+    const sources = /* @__PURE__ */ new Map();
+    const binfmts = await scanBinfmts(this.base, await this.roots(), void 0, sources);
+    const manifests = [];
+    for (const script of scripts) {
+      const head = await this.head(script);
+      if (!head || isWasm(head) || shebang(head)) continue;
+      const pkg = sources.get(binfmtSuffix(binfmts, script) ?? "");
+      if (pkg !== void 0) manifests.push(`${pkg}/package.json`);
+    }
+    return manifests;
+  }
+  async backing(file, cwd) {
+    const planned = await this.plan(file, [file], cwd, "");
+    if (!planned) return [];
+    const { glue, wasm, imports } = planned.target;
+    const files = [glue, wasm, ...imports ? [imports] : []];
+    const scripts = [];
+    for (const name2 of [file, ...planned.via ?? []]) {
+      if (name2.includes("/") && !COMMAND2.test(name2)) scripts.push(this.fs.resolvePath(cwd, name2));
+      const script = (await this.scriptCommand(name2, cwd, ""))?.script;
+      if (script) scripts.push(script);
+    }
+    files.push(...scripts, ...await this.binfmtManifests(scripts));
+    const roots = await this.roots();
+    for (const at of [...files]) {
+      const root = packageRootOf(at, roots) ?? PACKAGE_ROOT.exec(at)?.[1];
+      if (root !== void 0) files.push(`${root}/package.json`);
+    }
+    return [...new Set(files)].filter((path) => path !== "" && path !== SUDO_PATH);
+  }
   async unrunnable(file, cwd, scope) {
     const path = this.fs.resolvePath(cwd, file);
     const head = await this.base.readFileBuffer(path).catch(() => null);
@@ -14706,6 +15213,9 @@ var Launcher = class {
     return await this.base.exists(optional) ? optional : void 0;
   }
   async program(target, env) {
+    if (target.abi === "js" && target.wasm === SUDO_PATH) {
+      return { abi: "js", glue: SUDO_SOURCE, path: SUDO_PATH };
+    }
     if (target.abi === "js") {
       return { abi: "js", glue: await this.base.readFile(target.wasm), path: target.wasm };
     }
@@ -14792,6 +15302,7 @@ var Launcher = class {
       kill: (target, sig) => this.kill(target, sig, this.credOf(pid), pid),
       writesBack: (target) => this.processes.get(target)?.writesBack() === true,
       processes: () => ({ boot: this.boot, processes: this.list(this.credOf(pid)) }),
+      sudo: (call, signal) => this.sudo(pid, call, signal),
       openFiles: this.openFiles,
       nodes: this.nodes,
       held: this.held,
@@ -14799,7 +15310,7 @@ var Launcher = class {
       statfs: (path) => this.mounts.statfs(path),
       mounts: () => this.mounts.list(),
       mount: (call, signal) => this.processMount(pid, call, signal),
-      umount: (target, flags) => this.processUmount(pid, target, flags),
+      umount: (target, flags2) => this.processUmount(pid, target, flags2),
       jobs: this.jobs,
       ptys: this.ptys,
       net: this.net,
@@ -14813,6 +15324,7 @@ var Launcher = class {
     this.processes.set(pid, handle);
     const { cred } = req;
     this.creds.set(pid, () => handle.cred?.() ?? copyCred(cred));
+    if (req.tag !== void 0) this.tags.set(pid, req.tag);
     if (req.ppid !== void 0 && this.controlsJobs(req.ppid)) this.settling.started(pid, req.ppid);
     this.jobs.add(pid, req.ppid, (sig) => handle.signal(sig), terminal);
     if (req.exec && req.ppid !== void 0) this.jobs.exec(req.ppid, pid, true);
@@ -14840,6 +15352,8 @@ var Launcher = class {
     this.jobs.remove(pid);
     this.described.delete(pid);
     this.creds.delete(pid);
+    this.tags.delete(pid);
+    this.granted.delete(pid);
   }
   reaped(pid) {
     if (this.zombies.delete(pid)) this.forget(pid);
@@ -14861,8 +15375,8 @@ var Launcher = class {
     };
     const listed = [];
     for (const member of members.values()) {
-      const described = this.described.get(member.pid);
-      if (member.execed || !described) continue;
+      const described2 = this.described.get(member.pid);
+      if (member.execed || !described2) continue;
       const cred = this.credOf(member.pid);
       if (!maySee(viewer, cred)) continue;
       const root = rootOf(member);
@@ -14872,8 +15386,8 @@ var Launcher = class {
         ppid: shown(root.ppid),
         pgid: member.pgid,
         sid: member.sid,
-        ...described,
-        started: (this.described.get(root.pid) ?? described).started,
+        ...described2,
+        started: (this.described.get(root.pid) ?? described2).started,
         state: this.processes.has(member.pid) ? "S" : "Z",
         memory: this.processes.get(member.pid)?.memory() ?? 0,
         umask: this.umaskOf(member.pid),
@@ -14883,12 +15397,26 @@ var Launcher = class {
     }
     return listed;
   }
+  sudo(pid, call, signal) {
+    const caller = {
+      cred: this.credOf(pid),
+      pid: this.jobs.shown(pid),
+      tag: this.tagOf(pid),
+      tty: this.described.get(pid)?.tty
+    };
+    return this.sudoer.request(caller, call, signal);
+  }
   spawner(ppid, report) {
-    return async (req, fds) => {
-      const scope = await this.scopeOf(this.credOf(ppid).euid);
+    return async (req, fds, grant) => {
+      if (grant && !await this.grantedCwd(grant.caller, req.cwd)) {
+        await fds.closeAll();
+        throw new SpawnError("EACCES");
+      }
+      const cred = grant ? grant.cred : this.credOf(ppid);
+      const scope = grant ? "" : await this.scopeOf(cred.euid);
       const planned = await this.plan(req.file, req.argv, req.cwd, scope);
       try {
-        await this.mayExec(this.credOf(ppid), { ...req, pid: ppid }, planned);
+        await this.mayExec(cred, { ...req, pid: ppid }, planned);
       } catch (err) {
         await fds.closeAll();
         throw err.code === "EACCES" ? new SpawnError("EACCES") : err;
@@ -14908,10 +15436,12 @@ var Launcher = class {
         ppid,
         ignored: this.ignoredBy(ppid),
         umask: this.umaskOf(ppid),
-        cred: this.credOf(ppid),
+        cred,
+        tag: this.tagOf(ppid),
         ...exec
       });
       deciding?.attach();
+      if (grant) this.granted.set(handle.pid, ppid);
       return childHandle(handle);
     };
   }
@@ -14955,7 +15485,8 @@ var Launcher = class {
         fork: state,
         ignored: this.ignoredBy(ppid, true),
         umask: this.umaskOf(ppid),
-        cred: this.credOf(ppid)
+        cred: this.credOf(ppid),
+        tag: this.tagOf(ppid)
       })
     );
   }
@@ -14980,6 +15511,9 @@ var Launcher = class {
   credOf(pid) {
     return this.creds.get(pid)?.() ?? copyCred(ROOT);
   }
+  tagOf(pid) {
+    return this.tags.get(pid);
+  }
   released(path) {
     const at = normalizePath(path);
     this.unlinked.closed(at);
@@ -14998,7 +15532,7 @@ var Launcher = class {
   }
   kill(pid, sig, sender, from) {
     const session = from === void 0 ? void 0 : this.jobs.sidOf(from);
-    const may = (target) => !sender || maySignal(sender, this.credOf(target)) || sig === SIG.CONT && session !== void 0 && this.jobs.sidOf(target) === session || from !== void 0 && this.imageOf(from) === this.imageOf(target);
+    const may = (target) => !sender || maySignal(sender, this.credOf(target)) || sig === SIG.CONT && session !== void 0 && this.jobs.sidOf(target) === session || from !== void 0 && this.imageOf(from) === this.imageOf(target) || from !== void 0 && this.granted.get(this.jobs.shown(target)) === from;
     if (pid < 0) return this.jobs.killGroup(-pid, sig, (member) => may(this.imageOf(member)));
     const handle = this.processes.get(pid);
     if (!handle) return false;
@@ -15119,7 +15653,8 @@ var Launcher = class {
       if (fresh) await this.base.chown?.(real, { uid: 0, gid: 0, mode, follow: false });
     }
   }
-  async realLayoutPath(path) {
+  async realLayoutPath(given) {
+    const path = normalizePath(given);
     if (!await this.base.exists(path)) return void 0;
     if (path === "/") return path;
     return joinName(await realDir(this.base, parentOf(path)), baseName(path));
@@ -15130,7 +15665,8 @@ var Launcher = class {
   mountedBy(spec, cred) {
     if (!this.owners || cred.euid === 0 && cred.egid === 0) return spec;
     const ids = { uid: String(cred.euid), gid: String(cred.egid) };
-    return { ...spec, options: { ...ids, ...spec.options } };
+    const options = cred.euid === 0 ? { ...ids, ...spec.options } : { ...spec.options, ...ids };
+    return { ...spec, options };
   }
   mountRoot(path) {
     let root = "/";
@@ -15175,13 +15711,36 @@ var Launcher = class {
   async processMount(pid, call, signal) {
     const spec = mountCall(call);
     await this.permit({ op: "mount", pid, ...spec, options: { ...spec.options } });
+    await this.mountsOwn(
+      this.credOf(pid),
+      spec.target,
+      async () => (await this.fs.stat(spec.target)).uid
+    );
     const entry = await this.mount(this.mountedBy(spec, this.credOf(pid)));
     if (signal.aborted) this.umount(entry.target, true);
   }
-  async processUmount(pid, target, flags) {
-    const call = umountCall(target, flags);
+  async mountAs(cred, spec) {
+    const target = normalizePath(spec.target);
+    await this.mountsOwn(cred, target, async () => (await this.fs.stat(target)).uid);
+    return this.mount(this.mountedBy(spec, cred));
+  }
+  async umountAs(cred, target) {
+    const at = normalizePath(target);
+    await this.mountsOwn(cred, at, async () => Number(this.mounts.mounted(at)?.options.uid));
+    this.umount(at);
+  }
+  async mountsOwn(cred, target, owner) {
+    const { euid } = cred;
+    if (this.usersMode !== "enforce" || euid === 0) return;
+    if (await owner().catch(() => void 0) !== euid) {
+      throw fsError("EPERM", `${target} is not the caller's to mount or unmount`);
+    }
+  }
+  async processUmount(pid, target, flags2) {
+    const call = umountCall(target, flags2);
+    let mounted;
     for (; ; ) {
-      const mounted = this.mounts.mounted(call.target);
+      mounted = this.mounts.mounted(call.target);
       await this.permit({
         op: "umount",
         pid,
@@ -15190,6 +15749,7 @@ var Launcher = class {
       });
       if (this.mounts.mounted(call.target) === mounted) break;
     }
+    await this.mountsOwn(this.credOf(pid), call.target, async () => Number(mounted?.options.uid));
     this.umount(call.target, call.detach);
   }
   async prepare() {
@@ -15198,6 +15758,7 @@ var Launcher = class {
     await this.provisionPnpmHome();
     await this.users.ensure();
     if (this.owners) await this.stampLayout();
+    if (this.owners) await this.sudoer.provision();
     await writeCaFile(this.base, this.ca).catch(() => void 0);
     this.fstab = this.mountFstab();
   }
@@ -15235,8 +15796,9 @@ var Launcher = class {
     if (!found) throw fsError("ENOENT", `no user ${String(user)}`);
     return found;
   }
-  identity(account) {
+  identity(account, tag) {
     return {
+      tag,
       cred: credOf(account),
       ...account.umask !== void 0 ? { umask: account.umask } : {}
     };
@@ -15253,6 +15815,7 @@ var Launcher = class {
     return { cwd, file, planned };
   }
   async openTerminal(argv, options) {
+    tagOption(options.tag);
     const { account, tty: ttyGroup } = await this.terminalAccount(options.user);
     const { cwd, file, planned } = await this.starting(argv, options.cwd, account);
     if (!planned) throw new Error(`${file}: command not found`);
@@ -15281,7 +15844,13 @@ var Launcher = class {
     );
     const report = (message3) => options.onData(encoder3.encode(`${message3}\r
 `));
-    const handle = await this.launch(planned, { env, cwd, fds, report, ...this.identity(account) });
+    const handle = await this.launch(planned, {
+      env,
+      cwd,
+      fds,
+      report,
+      ...this.identity(account, options.tag)
+    });
     leader = handle.pid;
     void handle.exited.then(() => tty.hangup());
     return {
@@ -15297,6 +15866,7 @@ var Launcher = class {
     };
   }
   async run(argv, options = {}) {
+    tagOption(options.tag);
     const account = await this.account(options.user);
     const { cwd, file, planned } = await this.starting(argv, options.cwd, account);
     const env = this.environment(cwd, options.env, account);
@@ -15326,7 +15896,7 @@ var Launcher = class {
       fds,
       report,
       ...group,
-      ...this.identity(account)
+      ...this.identity(account, options.tag)
     });
     options.onStarted?.(handle.pid);
     const status = await handle.exited;
@@ -16478,7 +17048,8 @@ async function createNodeKernel(options = {}) {
     ...options.cdp ? { cdp: options.cdp } : {},
     ...options.hostname !== void 0 ? { hostname: options.hostname } : {},
     ...options.users !== void 0 ? { users: options.users } : {},
-    ...options.onDenial ? { onDenial: options.onDenial } : {}
+    ...options.onDenial ? { onDenial: options.onDenial } : {},
+    ...options.approve ? { approve: options.approve } : {}
   });
   await launcher.prepare();
   const guard2 = (work) => new Promise((resolve, reject) => {
@@ -16554,8 +17125,9 @@ async function createNodeKernel(options = {}) {
       addMember: (group, user) => guard2(() => launcher.users.addMember(group, user)),
       removeMember: (group, user) => guard2(() => launcher.users.removeMember(group, user))
     },
-    async connect({ user } = {}) {
+    async connect({ user, tag } = {}) {
       if (terminated) throw new Error(TERMINATED);
+      tagOption(tag);
       if (user !== void 0 && !await launcher.users.lookup(user)) {
         throw fsError("ENOENT", `no user ${String(user)}`);
       }
@@ -16563,7 +17135,8 @@ async function createNodeKernel(options = {}) {
       const served = serveClient(port1, {
         launcher: async () => launcher,
         signal: signalNumber,
-        ...user !== void 0 ? { user } : {}
+        ...user !== void 0 ? { user } : {},
+        ...tag !== void 0 ? { tag } : {}
       });
       clients.add(served);
       void served.closed.then(() => clients.delete(served));