@smthrs/platform-node 1.0.0-rc.3 → 1.0.0-rc.4

package/src/ProcessConfinement.ts

@@ -299,14 +299,21 @@ export const make = (options: Options = {}): KernelProcessConfinement.Service =>
     // installed outside its ordinary runtime paths.
     const originalArgv = argvOf(command)
     const launch = ProcessSandbox.launcher(
-      originalArgv[0]!, targetEnvironment.PATH,
+      originalArgv[0]!,
+      targetEnvironment.PATH,
       [...confinement.reads, ...confinement.writes, ...confinement.externalReads],
-      confinement.workspaceRoot, hostFacts
+      confinement.workspaceRoot,
+      hostFacts
     )
     const targetArgv = ["/usr/bin/env", "-i", "/bin/sh", script, launch.program, ...originalArgv.slice(1)]
     const wrapped = yield* Effect.try({
       try: () =>
-        ProcessSandbox.wrap({ ...confinement, externalReads: [...confinement.externalReads, ...launch.reads, script] }, targetArgv, targetEnvironment, hostFacts),
+        ProcessSandbox.wrap(
+          { ...confinement, externalReads: [...confinement.externalReads, ...launch.reads, script] },
+          targetArgv,
+          targetEnvironment,
+          hostFacts
+        ),
       catch: (cause) => failure("Unknown", command, `could not render the confinement: ${messageOf(cause)}`, cause)
     })
     let [executable, ...args] = wrapped.argv

package/src/ProcessSandbox.ts

@@ -135,6 +135,12 @@ export interface Host {
    * paths. Read aliases are only collected when this probe is supplied.
    */
   readonly realpath?: ((path: string) => string | undefined) | undefined
+  /**
+   * The program a package-manager shim script runs: the absolute path on the
+   * `# cmd-shim-target=` line pnpm's cmd-shim writes, or `undefined` for any
+   * other file. Optional: a host without it treats a shim as the program.
+   */
+  readonly shimTarget?: ((path: string) => string | undefined) | undefined
   readonly uid: number | undefined
   readonly gid: number | undefined
 }
@@ -301,11 +307,27 @@ export const host = (env: Readonly<Record<string, string | undefined>> = ambient
         return undefined
       }
     },
+    shimTarget,
     uid: typeof process.getuid === "function" ? process.getuid() : undefined,
     gid: typeof process.getgid === "function" ? process.getgid() : undefined
   }
 }
 
+/** A cmd-shim is a page of shell; a larger file is some other program. */
+const shimLimit = 64 * 1024
+
+const shimTarget = (path: string): string | undefined => {
+  try {
+    if (NodeFs.statSync(path).size > shimLimit) return undefined
+    const text = NodeFs.readFileSync(path, "utf8")
+    if (!text.startsWith("#!")) return undefined
+    const target = /^# cmd-shim-target=(.+)$/m.exec(text)?.[1]
+    return target !== undefined && NodePath.isAbsolute(target) ? target : undefined
+  } catch {
+    return undefined
+  }
+}
+
 const isExecutable = (path: string): boolean => {
   try {
     NodeFs.accessSync(path, NodeFs.constants.X_OK)
@@ -810,8 +832,6 @@ const credentialPaths = (hostFacts: Host): ReadonlyArray<string> => {
 /**
  * The program a confined run execs, made reachable inside its empty root.
  *
- * @internal
- *
  * Bubblewrap resolves a bare program name with `execvp` against `PATH` inside
  * the new root, and that root holds only the runtime paths and the declared
  * sets. A package manager installed outside them — pnpm under the
@@ -828,6 +848,16 @@ const credentialPaths = (hostFacts: Host): ReadonlyArray<string> => {
  * is bound read-only, because a script like `pnpm.cjs` loads its siblings.
  * With no package directory only the real file is bound. A name that resolves
  * nowhere is left for `execvp` to report.
+ *
+ * A package-manager shim script is followed like a link. `pnpm self-update`
+ * under `pnpm/action-setup` installs pnpm as a cmd-shim in `$PNPM_HOME/bin`
+ * that runs node on a package in pnpm's global store, a path relative to the
+ * script; binding the script alone left that package missing. When the
+ * program the shim names is executable, the run execs its real file and binds
+ * its package as above.
+ *
+ * @since 1.0.0
+ * @private
  */
 export const launcher = (
   program: string,
@@ -846,8 +876,12 @@ export const launcher = (
       .map((entry) => hostFacts.executable(NodePath.join(entry, program)))
       .find((candidate) => candidate !== undefined)
   if (found === undefined || granted.some((parent) => insideRoot(parent, found))) return unchanged
-  const real = hostFacts.realpath?.(found) ?? found
-  if (insideRoot(workspaceRoot, found) || insideRoot(workspaceRoot, real)) return unchanged
+  const resolved = hostFacts.realpath?.(found) ?? found
+  const named = hostFacts.shimTarget?.(resolved)
+  const real = named === undefined || hostFacts.executable(named) === undefined
+    ? resolved
+    : hostFacts.realpath?.(named) ?? named
+  if ([found, resolved, real].some((path) => insideRoot(workspaceRoot, path))) return unchanged
   if (granted.some((parent) => insideRoot(parent, real))) return { program: real, reads: [] }
   let directory = NodePath.dirname(real)
   for (let level = 0; level < 3; level++) {

package/src/ScopedProcess.ts

@@ -41,7 +41,8 @@ export interface Handle extends ChildProcessHandle {
 /**
  * Starts a pipe-based command and contains its lifetime inside the caller's
  * scope. The returned pid names the live supervisor; exitCode reports
- * the actual target. The private parent connection stops the tree on host loss.
+ * the actual target. The private parent connection stops the tree on host loss,
+ * and the supervisor's group guardian stops the group on supervisor loss.
  * Transient commands have no durable ledger; durable hosts use NodeHost instead.
  *
  * Unconsumed output stays in bounded native buffers until it is read or the

package/src/internal/ProcessSupervisor.ts

@@ -222,6 +222,8 @@ export class Control {
   targetDone = false
   ownerCreation: unknown
   targetPid: number | undefined
+  /** The owner's group guardian: a member that is neither target nor owner. */
+  guardianPid: number | undefined
   ownerDone = false
   spawnFailed = false
   cleanupFailed = false
@@ -425,12 +427,15 @@ export class Control {
         return
       case "spawned":
         if (
-          !this.activationSent || this.receivedStarted || !Number.isSafeInteger(message.pid) || Number(message.pid) <= 1
+          !this.activationSent || this.receivedStarted || !Number.isSafeInteger(message.pid) ||
+          Number(message.pid) <= 1 ||
+          message.guardian !== undefined && (!Number.isSafeInteger(message.guardian) || Number(message.guardian) <= 1)
         ) {
           throw processFault("status_invalid", "Invalid target startup")
         }
         this.receivedStarted = true
         this.targetPid = Number(message.pid)
+        if (message.guardian !== undefined) this.guardianPid = Number(message.guardian)
         this.started.resolve()
         return
       case "spawn_error":
@@ -552,7 +557,8 @@ export const prepare = (
       if (!grouped) return control.targetDone
       const observed = snapshot()
       if (observed === undefined || observed.ownGroup === raw.pid) return false
-      const running = observed.members.filter((member) => !member.zombie)
+      // The guardian leaves with the owner's final group SIGKILL.
+      const running = observed.members.filter((member) => !member.zombie && member.pid !== control.guardianPid)
       return running.length === 1 && running[0]!.pid === raw.pid
     }
     // This observation only shortens the owner's deadline. The live owner makes

package/src/internal/SupervisorProgram.ts

@@ -44,6 +44,13 @@ const control = connect(socketPath);
 const requests = connect(socketPath.replace(/\/s$/, '/r'));
 let config;
 let target;
+// An owner killed outright (SIGKILL, the OOM killer) runs no handler, so it
+// cannot stop its group. Its guardian is a member of that group that waits on
+// a pipe only the owner holds. At EOF it kills its own group: kill 0 names the
+// caller's group, never a number that could be stale. It ignores the catchable
+// signals a stop sends the group and dies in the owner's final SIGKILL.
+let guardian;
+const guardianScript = "command trap '' HUP INT QUIT ABRT ALRM TERM USR1 USR2 PIPE TSTP TTIN TTOU; read -r line; kill -s KILL 0";
 let targetDone = false;
 let stopping = false;
 let explicitStop = false;
@@ -204,8 +211,9 @@ const settleVacantGroup = () => {
   let rows;
   try { rows = snapshot(); } catch { return; }
   for (const row of rows.values()) {
-    // The owner's only other child is the ps answering this snapshot; the
-    // exited target is already reaped and its orphans have another parent.
+    // The owner's other children are its guardian and the ps answering this
+    // snapshot; the exited target is already reaped and its orphans have
+    // another parent.
     if (row.group === process.pid && row.pid !== process.pid && row.parent !== process.pid && !row.zombie) return;
   }
   clearTimeout(timer);
@@ -251,6 +259,18 @@ requests.on('data', (data) => {
       if (config.standardFds !== undefined) {
         for (const fd of [0, 1, 2]) descriptors[fd] = config.standardFds[fd];
       }
+      if (grouped) {
+        // Started before the target, so no target outlives an owner unguarded.
+        // Every caller descriptor slot is replaced: a guardian holding a copy
+        // of the caller's output would keep that pipe from reaching EOF.
+        const guarded = descriptors.map(() => 'ignore');
+        guarded[0] = 'pipe';
+        guardian = cp.spawn('/bin/sh', ['-c', guardianScript], { cwd: '/', env: {}, detached: false, stdio: guarded });
+        // A failed launch has no pid; its later error event is the same fault.
+        guardian.once('error', () => {});
+        if (guardian.pid === undefined) throw new SupervisorFault('guardian_unavailable', 'Process group guardian unavailable');
+        guardian.stdin.on('error', () => {});
+      }
       try {
         target = cp.spawn(config.command, config.args, {
           cwd: config.cwd, env: config.env, shell: config.shell,
@@ -273,7 +293,7 @@ requests.on('data', (data) => {
           }
         }
         for (const fd of config.userFds) fs.closeSync(fd);
-        send({ type: 'spawned', pid: target.pid });
+        send({ type: 'spawned', pid: target.pid, ...(guardian === undefined ? {} : { guardian: guardian.pid }) });
       });
       target.once('error', spawnError);
       target.once('exit', (code, signal) => {