@ai-ecoverse/slicc-kernel 1.178.1 → 1.178.2

package/dist/kernel-worker.js

@@ -8777,7 +8777,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.178.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.178.2" : "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
@@ -10059,9 +10059,9 @@ var UnlinkedKeeper = class {
         if (kept.whole) return kept.undoing(async () => void 0);
         await kept.undoing(
           () => replace(target, async (gated, sealed) => {
-            const pinned = await keeper.pin(target, gated, sealed);
-            if (pinned.moved.has(target)) pinned.commit();
-            else await keeper.settle(pinned, () => fs.rm(path, options));
+            const pinned2 = await keeper.pin(target, gated, sealed);
+            if (pinned2.moved.has(target)) pinned2.commit();
+            else await keeper.settle(pinned2, () => fs.rm(path, options));
           })
         );
       },
@@ -10074,8 +10074,8 @@ var UnlinkedKeeper = class {
           () => keeper.marks.around(
             [source],
             () => replace(target, async (gated, sealed) => {
-              const pinned = await keeper.pin(target, gated, sealed);
-              await keeper.settle(pinned, () => fs.rename(from, to));
+              const pinned2 = await keeper.pin(target, gated, sealed);
+              await keeper.settle(pinned2, () => fs.rename(from, to));
             })
           )
         );
@@ -10110,14 +10110,14 @@ var UnlinkedKeeper = class {
     }
     return false;
   }
-  async settle(pinned, op) {
+  async settle(pinned2, op) {
     try {
       await op();
     } catch (err) {
-      await pinned.rollback();
+      await pinned2.rollback();
       throw err;
     }
-    pinned.commit();
+    pinned2.commit();
   }
   heldWithin(target) {
     const held = /* @__PURE__ */ new Map();
@@ -12641,6 +12641,13 @@ var SpawnError = class extends Error {
     this.code = code;
   }
 };
+var ChangedError = class extends SpawnError {
+  notice;
+  constructor(notice) {
+    super("EPERM");
+    this.notice = notice;
+  }
+};
 function interrupted(signal) {
   const { promise, reject } = Promise.withResolvers();
   const fail2 = () => reject(new KernelError("EINTR"));
@@ -19620,8 +19627,10 @@ var SUDOERS_D = "/etc/sudoers.d";
 var NAME4 = /^[a-z_][a-z0-9_.-]*$/;
 var WORD = String.raw`(?:'[^']*'|"(?:[^"\\]|\\[\s\S])*"|\\[\s\S]|[^\s'"\\])+`;
 var KERNEL_FORM = new RegExp(
-  String.raw`^(NOPASSWD\s+)?(\S+)\s+(?:\(([^()]*)\)\s+)?(?:Cwd\s+(${WORD})\s+)?(?:Stdin\s+(\S+)\s+)?Cmnd(?:\s+(.*))?$`
+  String.raw`^(NOPASSWD\s+)?(\S+)\s+(?:\(([^()]*)\)\s+)?(?:Cwd\s+(${WORD})\s+)?(?:Stdin\s+(\S+)\s+)?((?:Sha256\s+${WORD}\s+)*)Cmnd(?:\s+(.*))?$`
 );
+var SHA256_CLAUSE = new RegExp(String.raw`Sha256\s+(${WORD})`, "g");
+var HEX = /^[0-9a-f]{64}$/;
 var SUDOERS_FORM = /^(\S+)\s+([^\s=]+)\s*=\s*(.*)$/;
 var RUNAS = /^\(([^()]*)\)\s*/;
 var TAG = /^([A-Z_]+)\s*:\s*/;
@@ -19630,7 +19639,7 @@ var PLAIN2 = /^[A-Za-z0-9_@%+=:,./-]+$/;
 var CONTROL2 = /[\p{Cc}\u2028\u2029]/u;
 var CONTROLS = /[\p{Cc}\u2028\u2029]/gu;
 var SHOWN_MAX = 60;
-var KERNEL_SYNTAX = "[NOPASSWD] <user|%group|ALL> [(<target>)] [Cwd <dir>] [Stdin none] Cmnd <command\u2026|*>";
+var KERNEL_SYNTAX = "[NOPASSWD] <user|%group|ALL> [(<target>)] [Cwd <dir>] [Stdin none] [Sha256 <file>=<sha256>\u2026] Cmnd <command\u2026|*>";
 var SUDOERS_SYNTAX = "<user|%group|ALL> ALL=[(<target>[,<target>\u2026])] [NOPASSWD:] <command\u2026|ALL>";
 var EXPECTED = `expected '${KERNEL_SYNTAX}' or '${SUDOERS_SYNTAX}'`;
 var TIMESTAMP_TIMEOUT = 5;
@@ -19797,6 +19806,23 @@ function commandOf2(text, after) {
   if (only && /\s""$/.test(text)) return { path, args: [] };
   return args.length === 0 ? { path } : { path, args };
 }
+function sha256Of(clauses) {
+  const files = {};
+  for (const [, word = ""] of clauses.matchAll(SHA256_CLAUSE)) {
+    const [text = ""] = splitWords(word) ?? [];
+    const at = text.lastIndexOf("=");
+    const path = text.slice(0, at);
+    const hex4 = text.slice(at + 1).toLowerCase();
+    if (!path.startsWith("/") || !HEX.test(hex4)) {
+      return `Sha256 expects <absolute file>=<sha256 in hex>, not ${shown(word)}`;
+    }
+    files[normalizePath(path)] = hex4;
+  }
+  return files;
+}
+function sha256Text(files) {
+  return Object.entries(files).map(([path, hex4]) => `Sha256 ${quoteWord(`${path}=${hex4}`)} `).join("");
+}
 function targetError(list) {
   if (list.includes(",")) {
     return `(${list}) names one user in this form: write one line per user, or use '${SUDOERS_SYNTAX}'`;
@@ -19804,19 +19830,22 @@ function targetError(list) {
   return `expected one user name or ALL in (\u2026), not ${shown(`(${list})`)}`;
 }
 function kernelRules(m) {
-  const [, nopasswd, who = "", target = "root", dir, stdin, rest2 = ""] = m;
+  const [, nopasswd, who = "", target = "root", dir, stdin, sums = "", rest2 = ""] = m;
   const bad = whoError(who);
   if (bad !== void 0) return bad;
   if (target !== "ALL" && !NAME4.test(target)) return targetError(target);
   const cwd = dir === void 0 ? void 0 : cwdOf(dir);
   if (cwd === "") return `Cwd expects one absolute directory, not ${shown(dir)}`;
   if (stdin !== void 0 && stdin !== "none") return `Stdin takes none, not ${shown(stdin)}`;
+  const sha2564 = sha256Of(sums);
+  if (typeof sha2564 === "string") return sha2564;
   const rule = {
     nopasswd: !!nopasswd,
     who,
     target,
     ...cwd !== void 0 ? { cwd } : {},
-    ...stdin === "none" ? { stdin: "none" } : {}
+    ...stdin === "none" ? { stdin: "none" } : {},
+    ...sums === "" ? {} : { sha256: sha2564 }
   };
   const text = rest2.trim();
   if (text === "*") return [{ ...rule, cmnd: "*" }];
@@ -20069,12 +20098,26 @@ var RAN_ONCE = "sudo: ran once; this command line can't be recorded as always";
 var ROOT_ONLY_MAX = 64;
 var OPERANDS_MAX = 256;
 var PATH_MAX = 4096;
+function userWritable(bound3) {
+  const files = Object.entries(bound3).map(([path, hex4]) => ({ path, sha256: hex4 }));
+  return files.length > 0 ? { userWritable: files } : {};
+}
 function stdinMatches(rule, stdin) {
   return rule.stdin === void 0 || stdin === "tty" || stdin === "none";
 }
 function recordable(cwd, argv) {
   return !hasControl(cwd) && !argv.some(hasControl);
 }
+function changedText(file) {
+  return `sudo: ${file} changed since it was approved`;
+}
+function changedFile(approved, now) {
+  const files = /* @__PURE__ */ new Set([...Object.keys(approved), ...Object.keys(now)]);
+  return [...files].find((file) => approved[file] !== now[file]);
+}
+function pinned(rule, bound3) {
+  return rule.sha256 === void 0 || changedFile(rule.sha256, bound3) === void 0;
+}
 var VISUDO_FILES_MAX = 64;
 var VISUDO_TEXT_MAX = 1024 * 1024;
 function visudoCall(req) {
@@ -20205,11 +20248,13 @@ function usable(parsed2) {
 function policyOf(settings) {
   return { type: settings.timestampType, minutes: settings.timestampTimeout };
 }
-function described(rule) {
+function described(rule, writable2) {
   const cmnd = rule.cmnd === "*" ? "ALL" : commandText(rule.cmnd);
   const cwd = rule.cwd === void 0 ? "" : `CWD=${quoteWord(rule.cwd)} `;
   const stdin = rule.stdin === void 0 ? "" : "STDIN=none ";
-  return `    (${rule.target}) ${cwd}${stdin}${rule.nopasswd ? "NOPASSWD: " : ""}${cmnd}`;
+  const sums = Object.entries(rule.sha256 ?? {}).map(([path, hex4]) => `SHA256=${quoteWord(path)}:${hex4} `).join("");
+  const flag = writable2 ? "  # user-writable command" : "";
+  return `    (${rule.target}) ${cwd}${stdin}${sums}${rule.nopasswd ? "NOPASSWD: " : ""}${cmnd}${flag}`;
 }
 var Sudo = class {
   o;
@@ -20400,15 +20445,31 @@ var Sudo = class {
     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, word) {
-    const files = this.o.backing ? await this.o.backing(path, cwd) : [];
-    if (!files) return failed2("ENOENT", `sudo: ${word}: command not found`);
-    for (const file of [path, ...files]) {
-      if (!await this.trusted(file)) {
-        return failed2("EPERM", `sudo: ${file} must be root's, and writable by root only`);
-      }
+  async real(file) {
+    const { fs } = this.o;
+    return await fs.realpath?.(file, true).catch(() => file) ?? file;
+  }
+  async digests(files) {
+    const { fs } = this.o;
+    const found = {};
+    for (const file of new Set(files)) {
+      if (await this.trusted(file)) continue;
+      const real = await this.real(file);
+      found[real] = await fs.readFileBuffer(real).then(sha256, () => "");
     }
-    return void 0;
+    return found;
+  }
+  async bound(path, cwd) {
+    const files = this.o.backing ? await this.o.backing(path, cwd) : [];
+    const bound3 = files && await this.digests([path, ...files]);
+    return bound3 && !Object.values(bound3).includes("") ? bound3 : void 0;
+  }
+  async writable(rule) {
+    if (rule.cmnd === "*") return false;
+    const { path } = rule.cmnd;
+    const bound3 = await this.bound(path, "/");
+    if (bound3) return Object.keys(bound3).length > 0;
+    return !await this.trusted(await this.existing(path));
   }
   async locate(word, cwd) {
     const { fs } = this.o;
@@ -20453,7 +20514,7 @@ var Sudo = class {
     const root = cred.euid === 0;
     const rules = root ? [] : policy.rules;
     const mine = rules.filter((rule) => applies(rule.who));
-    if (parsed2.list) return this.listed(self, root, mine, settings.matching);
+    if (parsed2.list) return await this.listed(self, root, mine, settings.matching);
     const session = { caller, self, target, owner, policy: policyOf(settings), parsed: parsed2, signal };
     if (parsed2.validate) return this.validate(session, root, mine, call.cwd);
     return this.command(session, root, mine, call);
@@ -20470,14 +20531,13 @@ var Sudo = class {
       );
     }
     const path = await this.locate(word, cwd);
-    if (!path) return failed2("ENOENT", `sudo: ${word}: command not found`);
-    const untrusted2 = await this.untrusted(path, cwd, word);
-    if (untrusted2) return untrusted2;
+    const bound3 = path && await this.bound(path, cwd);
+    if (!path || !bound3) return failed2("ENOENT", `sudo: ${word}: command not found`);
     const argv = [path, ...args];
     const matching = mine.filter(
-      (rule) => (rule.target === "ALL" || rule.target === target.name) && (rule.cwd === void 0 || rule.cwd === cwd) && stdinMatches(rule, caller.stdin) && commandMatches(rule.cmnd, argv)
+      (rule) => (rule.target === "ALL" || rule.target === target.name) && (rule.cwd === void 0 || rule.cwd === cwd) && stdinMatches(rule, caller.stdin) && commandMatches(rule.cmnd, argv) && pinned(rule, bound3)
     );
-    const grant = () => this.grant(self, target, cred, parsed2.command, path, cwd, call.term);
+    const grant = () => this.grant(self, target, cred, parsed2.command, path, cwd, call.term, bound3);
     if (root || matching.some((rule) => rule.nopasswd)) return grant();
     const quoted = argv.map(quoteWord).join(" ");
     if (matching.length === 0) {
@@ -20493,14 +20553,15 @@ var Sudo = class {
     }
     if (parsed2.nonInteractive) return failed2("EPERM", "sudo: a password is required");
     return this.pendingFor(cred.ruid, async () => {
-      const answer2 = await this.ask(s, { argv: parsed2.command, path, cwd });
+      const answer2 = await this.ask(s, { argv: parsed2.command, path, cwd, bound: bound3 });
       if ("error" in answer2) return answer2;
       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, word);
-      if (changed) return changed;
-      const result = answer2.answer === "once" ? grant() : await this.always(self, target, cwd, argv, recordable(cwd, parsed2.command), grant);
+      const now = await this.bound(path, cwd);
+      if (!now) return failed2("ENOENT", `sudo: ${word}: command not found`);
+      const shown2 = recordable(cwd, [...parsed2.command, ...Object.keys(bound3)]);
+      const result = answer2.answer === "once" ? grant() : await this.always(self, target, { cwd, argv, bound: bound3 }, now, shown2, grant);
       if (!("error" in result)) this.stamped(s, answer2);
       return result;
     });
@@ -20519,7 +20580,7 @@ var Sudo = class {
     if (parsed2.nonInteractive) return failed2("EPERM", "sudo: a password is required");
     const cwd = await this.canonical(dir) ?? normalizePath(dir);
     return this.pendingFor(s.caller.cred.ruid, async () => {
-      const answer2 = await this.ask(s, { argv: [], path: "", cwd, validate: true });
+      const answer2 = await this.ask(s, { argv: [], path: "", cwd, bound: {}, validate: true });
       if ("error" in answer2) return answer2;
       if (!answer2.person) await s.caller.report?.(NOT_STAMPED);
       this.stamped(s, answer2);
@@ -20547,14 +20608,17 @@ var Sudo = class {
       `sudo: ${self.name} : TTY=${tty} ; PWD=${quoteWord(cwd)} ; USER=${target.name} ; TIMESTAMP=${type} ; COMMAND=${command}`
     );
   }
-  async always(self, target, cwd, argv, shown2, grant) {
+  async always(self, target, line, now, shown2, grant) {
+    const { cwd, argv, bound: bound3 } = line;
     if (!shown2 || !recordable(cwd, argv)) return { ...grant(), notice: RAN_ONCE };
-    if (!await this.remember(self, target, cwd, argv)) {
+    const changed = changedFile(bound3, now);
+    if (changed !== void 0) return failed2("EPERM", changedText(changed));
+    if (!await this.remember(self, target, line)) {
       return failed2("EIO", "sudo: the rule could not be recorded");
     }
     return grant();
   }
-  listed(self, root, rules, defaults2) {
+  async listed(self, root, rules, defaults2) {
     const host = this.o.hostname;
     if (root) {
       return {
@@ -20566,7 +20630,9 @@ var Sudo = class {
     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");
+    const shown2 = [];
+    for (const rule of rules) shown2.push(described(rule, await this.writable(rule)));
+    const lines2 = shown2.join("\n");
     const params = defaults2.flatMap((d) => d.params).join(", ");
     const matching = params === "" ? "" : `Matching Defaults entries for ${self.name} on ${host}:
     ${params}
@@ -20599,9 +20665,10 @@ ${lines2}
       ...caller.tty ? { tty: caller.tty } : {},
       createdAt,
       expiresAt: createdAt + timeout,
-      always: asked.validate ? false : recordable(cwd, [path, ...argv]),
+      always: asked.validate ? false : recordable(cwd, [path, ...argv, ...Object.keys(asked.bound)]),
       stdin: caller.stdin,
       rootOnly: asked.validate ? {} : await this.rootOnly(cwd, argv.slice(1)),
+      ...userWritable(asked.bound),
       ...asked.validate ? { validate: true } : {},
       timestamp: true
     };
@@ -20621,7 +20688,7 @@ ${lines2}
       requester.removeEventListener("abort", withdraw);
     }
   }
-  async remember(self, target, cwd, argv) {
+  async remember(self, target, { cwd, argv, bound: bound3 }) {
     const { fs } = this.o;
     const path = `${SUDOERS_D}/${self.name}`;
     if (!NAME4.test(self.name)) return false;
@@ -20632,7 +20699,7 @@ ${lines2}
       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 Cmnd ${words2}
+      const line = `NOPASSWD ${self.name} (${target.name}) Cwd ${quoteWord(cwd)} Stdin none ${sha256Text(bound3)}Cmnd ${words2}
 `;
       const text = old === "" || old.endsWith("\n") ? `${old}${line}` : `${old}
 ${line}`;
@@ -20643,7 +20710,7 @@ ${line}`;
       return false;
     }
   }
-  grant(self, target, cred, argv, file, cwd, term) {
+  grant(self, target, cred, argv, file, cwd, term, files) {
     const env = {
       ...this.o.env(),
       ...userEnv(target, this.o.pnpmHome),
@@ -20656,7 +20723,9 @@ ${line}`;
       SUDO_GID: String(cred.rgid),
       SUDO_COMMAND: [file, ...argv.slice(1)].join(" ")
     };
-    return { grant: { file, argv: [...argv], env, cwd, cred: credOf(target), caller: cred } };
+    return {
+      grant: { file, argv: [...argv], env, cwd, cred: credOf(target), caller: cred, files }
+    };
   }
 };
 
@@ -28983,14 +29052,20 @@ var WasmProcess = class {
     if (!("grant" in answer2)) return answer2;
     if (this.dying) throw new KernelError("EINTR");
     if (answer2.notice !== void 0) await this.complainLine(answer2.notice);
-    const { file, argv, env, cwd, cred, caller } = answer2.grant;
+    const { file, argv, env, cwd, cred, caller, files } = answer2.grant;
     const stdio = [{ fd: 0 }, { fd: 1 }, { fd: 2 }];
-    return {
-      pid: await this.children.spawn({ file, argv, env, cwd, pgid: 0 }, stdio, [], {
-        cred,
-        caller
-      })
-    };
+    try {
+      return {
+        pid: await this.children.spawn({ file, argv, env, cwd, pgid: 0 }, stdio, [], {
+          cred,
+          caller,
+          files
+        })
+      };
+    } catch (err) {
+      if (err instanceof ChangedError) return { error: err.notice, errno: err.code };
+      throw err;
+    }
   }
   stdinKind() {
     if (!this.fds.has(0)) return "none";
@@ -33569,6 +33644,10 @@ function describe(req, tty) {
   };
   return { argv: [req.argv0, ...req.args], tty, started: Date.now(), ...exe };
 }
+function refuseChanged(approved, now) {
+  const changed = changedFile(approved, now);
+  if (changed !== void 0) throw new ChangedError(changedText(changed));
+}
 function linksOf2(req) {
   return req.links === void 0 ? {} : { links: req.links };
 }
@@ -34702,6 +34781,27 @@ var Launcher = class {
     }
     return true;
   }
+  async unchanged(planned, file, cwd, grant) {
+    const approved = grant?.files;
+    if (!approved) return {};
+    const files = await this.backingOf(planned, file, cwd, "");
+    refuseChanged(approved, await this.sudoer.digests([file, ...files]));
+    return { pinned: approved };
+  }
+  async pinOf(path, caller) {
+    const { pinned: pinned2 } = caller;
+    if (!pinned2) return {};
+    const real = await this.sudoer.real(path);
+    const hex4 = pinned2[real];
+    if (hex4 !== void 0) return { [real]: hex4 };
+    if (await this.sudoer.trusted(real)) return {};
+    throw new ChangedError(changedText(real));
+  }
+  async pinnedBytes(pin, bytes) {
+    const [real = ""] = Object.keys(pin);
+    refuseChanged(pin, { [real]: await sha256(bytes) });
+    return bytes;
+  }
   async grantedCwd(caller, cwd) {
     const real = await physicalPathAsync(this.base, cwd).catch(() => void 0);
     return real === cwd && await this.sudoer.reachable(caller, cwd);
@@ -34790,13 +34890,19 @@ var Launcher = class {
     return found;
   }
   async module(path, caller, asked) {
-    const key = await this.cacheKey(path, asked);
+    const pin = await this.pinOf(path, caller);
+    const sum = Object.values(pin)[0];
+    const key = sum === void 0 ? await this.cacheKey(path, asked) : `${path}:sha256:${sum}`;
     return this.cached(this.compiled, key, async () => {
-      const { bytes, key: read } = await this.keyed(path, caller, asked);
+      const { bytes: read, key: readKey } = await this.keyed(path, caller, asked);
+      const bytes = sum === void 0 ? read : await this.pinnedBytes(pin, read);
       const memory = importedMemory(bytes);
       const foreign = foreignImports(bytes);
       const compiled = await WebAssembly.compile(bytes);
-      return { value: { module: compiled, ...memory ? { memory } : {}, foreign }, key: read };
+      return {
+        value: { module: compiled, ...memory ? { memory } : {}, foreign },
+        key: sum === void 0 ? readKey : key
+      };
     });
   }
   async checkedSources(planned, caller) {
@@ -34821,6 +34927,11 @@ var Launcher = class {
     }
   }
   async text(path, caller, asked) {
+    const pin = await this.pinOf(path, caller);
+    if (Object.keys(pin).length > 0) {
+      const { bytes } = await this.keyed(path, caller, asked);
+      return new TextDecoder().decode(await this.pinnedBytes(pin, bytes));
+    }
     if (!this.integrity) return this.base.readFile(path);
     const key = await this.cacheKey(path, asked);
     return this.cached(this.texts, key, async () => {
@@ -35009,7 +35120,12 @@ var Launcher = class {
     const own = env.HOSTNAME;
     if (asked.target.abi === "wasi") env.HOSTNAME = this.hostname;
     const planned = chosen2(asked, env);
-    const caller = { pid: req.ppid ?? 0, uid: req.cred.euid, tag: req.tags?.[0] };
+    const caller = {
+      pid: req.ppid ?? 0,
+      uid: req.cred.euid,
+      tag: req.tags?.[0],
+      pinned: req.pinned
+    };
     if (this.integrity) await this.checkedSources(planned, caller);
     const [program, exeId] = await this.loaded(planned.target, env, caller);
     if (readsEtcHostname(program)) setOrDrop(env, "HOSTNAME", own);
@@ -35524,6 +35640,7 @@ var Launcher = class {
       const scope = grant ? "" : await this.scopeOf(cred.euid);
       const file = booked === void 0 ? req.file : await this.ticketFile(req, fds);
       const planned = await this.checkedPlan({ ...req, file }, { ppid, cred, scope }, fds);
+      const pin = await this.unchanged(planned, file, req.cwd, grant);
       const { recheck, ...redeemed } = await this.redeemed(
         { ...req, file },
         { ppid, cred, scope, booked },
@@ -35535,6 +35652,7 @@ var Launcher = class {
       const replan = () => this.planOrSearch({ ...req, file }, { ppid, cred, scope });
       const again = { ...planned, replan, recheck };
       const handle = await this.launch(again, {
+        ...pin,
         ...deciding ? { decided: deciding.promise } : {},
         cwd: req.cwd,
         cwdFrom: inheritedCwd(req.chdir, this.cwdSlots.get(ppid)),