@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/ProcessReaper.d.ts

@@ -0,0 +1,457 @@
+/**
+ * Reaping the processes a dead host incarnation abandoned.
+ *
+ * Scope closure cleans up work a live host still owns. On POSIX, a prepared
+ * supervisor also receives private-channel EOF when its host disappears and
+ * independently requests group cleanup. The durable ledger remains the fallback
+ * when that cleanup is incomplete or cannot be verified; the next incarnation
+ * uses this module to examine the recorded process identities before acting.
+ *
+ * The rules are narrow on purpose, because the input is a durable record that
+ * outlived the process that wrote it and a pid is reused. A record is signalled
+ * only when ALL of these hold:
+ *
+ * - it belongs to a DIFFERENT incarnation of the SAME `hostId`
+ *   ({@link ProcessLedger.Service.orphans} already filters that);
+ * - its owner is gone. A pid that exists but belongs to another user counts as
+ *   alive, exactly as {@link HostLiveness} counts it, so only `ESRCH` reads as
+ *   dead and every other answer keeps the record;
+ * - it names a target the platform can actually signal. On POSIX that is a
+ *   process group the child leads itself, so `pgid` has to be a safe integer
+ *   above 1 and equal to `pid`; on Windows it is a pid, so `pgid` has to be
+ *   absent. The check is made against the DURABLE record rather than trusted
+ *   from it: `process.kill(-0, "SIGKILL")` signals this host's own process
+ *   group, and `@smthrs/kernel`'s ledger schema admits zero;
+ * - that group is not THIS process's group, and its pid is not this process's
+ *   pid. The host's real process group is read from the operating system,
+ *   because a stored number can claim anything and the shell that started this
+ *   host shares its group. A host that cannot read its own group keeps the
+ *   record rather than signalling it on a guard that did not run;
+ * - the number still names the process the record describes. A record written
+ *   before this machine booted names a pid from a pid space that no longer
+ *   exists, and within one boot the recorded start time has to match the start
+ *   time the operating system reports for that pid. A host that cannot ASK the
+ *   question answers {@link StartTime} `unavailable`, which refuses the kill
+ *   and keeps the record; no evidence never authorizes a signal.
+ *
+ * The outcome of the signal is part of the record. A kill that succeeds, or
+ * that reports the group is already gone, retires the record through
+ * {@link ProcessLedger.Service.reaped}; a kill that FAILS for any other reason
+ * leaves the record inherited so the next incarnation tries again. A record
+ * refused on grounds the operating system will not revisit — a number no
+ * platform can signal, a pid that is gone, a start time that does not match — is
+ * retired through {@link ProcessLedger.Service.skipped}, which says in the
+ * journal that nothing was signalled and stops every later incarnation
+ * re-examining a number the operating system has moved on from. The three
+ * refusals a later incarnation CAN answer differently — `owner-alive`,
+ * `identity-unverified`, and `own-group-unknown` — retire nothing.
+ *
+ * @since 0.1.0
+ */
+import * as ContainedSpawner from "@smthrs/kernel/ContainedSpawner";
+import * as ProcessLedger from "@smthrs/kernel/ProcessLedger";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Metric from "effect/Metric";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import * as ProcessCleanup from "./internal/ProcessCleanup.ts";
+/**
+ * What the operating system can say about a pid.
+ *
+ * `unknown` is not `dead`. A pid this host may not signal answers `EPERM`, and
+ * a reaper that read that as "gone" would kill another user's children on the
+ * strength of a record it cannot verify.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Liveness = "alive" | "dead" | "unknown";
+/**
+ * What happened when a process group was signalled.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type KillOutcome = 
+/** The signal was delivered. */
+"signalled"
+/** There was nothing left to signal, which is the same end state. */
+ | "already-gone"
+/** The signal was refused, and the record must be tried again later. */
+ | "failed";
+/**
+ * What the operating system can say about when a pid started.
+ *
+ * The three negative answers are deliberately distinct, because they authorize
+ * three different decisions. `gone` is evidence — the pid does not exist, so
+ * the record describes nothing and is retired unsignalled. `unavailable` is the
+ * ABSENCE of evidence: `ps` is missing, unanswerable, or printed something no
+ * clock can read, so the record is kept for an incarnation that can ask.
+ * `unsupported` is a platform that has no such column at all, which falls back
+ * to the boot-time comparison alone.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type StartTime = 
+/** The operating system reports this start time, in epoch milliseconds. */
+{
+    readonly _tag: "started";
+    readonly startedAtMs: number;
+}
+/** The pid names no process. */
+ | {
+    readonly _tag: "gone";
+}
+/** The question could not be asked on this host. */
+ | {
+    readonly _tag: "unavailable";
+}
+/** The platform has no start-time column at all. */
+ | {
+    readonly _tag: "unsupported";
+};
+/**
+ * The operating-system operations reaping needs.
+ *
+ * It is a seam, not an abstraction: `flows` ships exactly the two
+ * implementations below and a test drives the Windows one on a POSIX host,
+ * which is the only way that path is ever exercised in this repository.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface System {
+    /** Whether a pid names a process that still exists. */
+    readonly isAlive: (pid: number) => Liveness;
+    /** When the process behind a pid started. */
+    readonly startedAtMs: (pid: number) => StartTime;
+    /** The process group THIS process belongs to, or `null` where there are none. */
+    readonly ownGroup: () => number | null;
+    /** When this machine booted, in epoch milliseconds. */
+    readonly bootedAtMs: () => number;
+    /**
+     * Whether the numbers in a record name something this platform may signal,
+     * checked before any other guard consults them.
+     */
+    readonly refuseTarget: (record: ProcessLedger.ProcessRecord) => Refusal | undefined;
+    /** Ends an abandoned process and everything below it. */
+    readonly killTree: (record: ProcessLedger.ProcessRecord) => KillOutcome;
+}
+/**
+ * The absolute path the process probe is run from.
+ *
+ * Never a `PATH` lookup. The inherited environment belongs to whoever started
+ * this host, and a planted `ps` that prints a fabricated start time — or none
+ * at all — would decide whether a `SIGKILL` is authorized.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const defaultPsExecutable = "/bin/ps";
+/**
+ * The observation the supervisor polls, from the source that platform has.
+ *
+ * Linux publishes the whole process table as files under `/proc`, which is
+ * where `ps` itself reads it, so the kernel is asked directly. That needs no
+ * `procps` in the image, cannot be answered by a planted binary, and costs no
+ * fork on a poll that runs every 10ms. A missing `/bin/ps` is not a
+ * hypothetical: `procps` is not in `debian:bookworm-slim`, and on Cloud CI run
+ * 11727 every spawned target in every task finished its work and then failed
+ * cleanup verification with `Unknown: ChildProcess.kill`, because this
+ * observation could not be made.
+ *
+ * Every other POSIX host keeps the `ps` reading, which is the only portable
+ * spelling of this question off Linux.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const groupSnapshotFor: (platform: string) => (pgid: number) => ProcessCleanup.Snapshot | undefined;
+/**
+ * Whether the kernel reports no process at all in a group.
+ *
+ * Signal 0 delivers nothing; it only asks the kernel whether the group has a
+ * member. `ESRCH` is the one answer that proves the group empty, with no fork
+ * and no process table to parse, so it still answers on a loaded host where a
+ * `ps` snapshot cannot be taken. A live member, a zombie (macOS answers
+ * `EPERM`, Linux succeeds), another user's member or any other error answers
+ * `false`, which leaves the question to the snapshot.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const groupVacant: (pgid: number) => boolean;
+/**
+ * Live cleanup for Node and Bun contained spawners.
+ *
+ * A trusted supervisor remains the group owner after the target exits. It
+ * enforces cleanup on target completion, parent loss and explicit release; the
+ * target starts only after its owner is durably recorded. Host observations
+ * never signal a pid: they only shorten the owner's deadline or verify an empty
+ * group before retiring its record. Failed verification retains the record.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const processLifecycle: ContainedSpawner.Lifecycle;
+/**
+ * The default grace period for a contained host spawner.
+ *
+ * The platform is always the running platform; callers cannot describe a
+ * Windows ledger identity for a process that actually leads a POSIX group.
+ * @category models
+ * @since 1.0.0
+ */
+export type SpawnerOptions = Omit<ContainedSpawner.Options, "platform">;
+/**
+ * Provides a ledger-backed spawner with this platform's prepared cleanup.
+ *
+ * Native pipe listeners live until their descriptors close, including writes
+ * interrupted by owner loss. The kernel expands pipelines before this private
+ * standard-command adapter is called. Windows owners join a native job before
+ * activation; POSIX owners enforce their process-group cleanup deadline.
+ *
+ * The caller supplies the durable or in-memory ledger. This layer records new
+ * owners; {@link layer} separately reaps
+ * records inherited from a previous host incarnation.
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layerSpawner: (options?: SpawnerOptions) => Layer.Layer<ChildProcessSpawner, never, ProcessLedger.ProcessLedger>;
+/**
+ * How a {@link System} asks the operating system its questions, and whose
+ * identity it must never signal.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface SystemOptions {
+    /**
+     * The absolute `ps` the identity probe runs. Default
+     * {@link defaultPsExecutable}. It is configuration for a host that installs
+     * `ps` somewhere else, and the seam the probe's own parsing is driven
+     * through; it is never a `PATH` lookup. Windows has no such probe and
+     * ignores it.
+     */
+    readonly psExecutable?: string | undefined;
+    /** Absolute native helper for Windows process identity queries; never a PATH lookup. */
+    readonly processExecutable?: string | undefined;
+    /**
+     * The pid this system must never signal, nor signal the group of. Default
+     * `process.pid`. {@link Options.ownerPid} is the same identity at the sweep
+     * level; this one is what {@link System.killTree} enforces on its own,
+     * because that function is exported and a caller can reach it without going
+     * through {@link reap}.
+     */
+    readonly ownerPid?: number | undefined;
+}
+/**
+ * Reaping on a POSIX host, with the identity probe configured.
+ *
+ * The group is killed outright rather than asked politely first. `SIGTERM`
+ * buys a graceful shutdown only when someone is left to wait for it, and the
+ * incarnation that owned these processes is by definition gone.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const posixSystemWith: (options?: SystemOptions) => System;
+/**
+ * Where a Linux {@link System} reads the process table, and whose identity it
+ * must never signal.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export interface ProcSystemOptions {
+    /** The `/proc` mount the probes read. Default `/proc`. */
+    readonly procRoot?: string | undefined;
+    /** The pid this system must never signal, nor signal the group of. Default `process.pid`. */
+    readonly ownerPid?: number | undefined;
+}
+/**
+ * Reaping on Linux, with every identity question read from `/proc` rather
+ * than from `ps`.
+ *
+ * `procps` is not in `debian:bookworm-slim` (Cloud CI run 11727), and a
+ * `ps`-based reaper on such a host can read neither its own group nor any
+ * start time, so it refuses every orphan as `own-group-unknown` on every
+ * restart. The live-cleanup observation ({@link groupSnapshotFor}) already
+ * reads `/proc` for the same reason; this is the crash-recovery half.
+ *
+ * A pid with no `/proc/<pid>/stat` is `gone` only when the kernel also says so,
+ * because a `hidepid` mount hides another user's live process the same way.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.1
+ */
+export declare const procSystemWith: (options?: ProcSystemOptions) => System;
+/**
+ * Reaping on a POSIX host: one `SIGKILL` to the abandoned process group, with
+ * the identity probe at {@link defaultPsExecutable}.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const posixSystem: System;
+/**
+ * Reaping on Windows, with the identity the sweep must never signal
+ * configured.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const windowsSystemWith: (options?: SystemOptions) => System;
+/**
+ * Reaping on Windows, which has no process groups: `taskkill /T /F` by pid.
+ *
+ * **Windows is outside the 1.0.0-rc.0 support contract**
+ * (`docs/pages/installation.md`). Full Windows process containment remains
+ * under verification. It is kept — and reachable through {@link reap} rather than only
+ * by calling it directly — because a reaper that silently retired every win32
+ * record would be the "excluded feature that appears to work partially" the
+ * release policy forbids. Treat it as unsupported best-effort.
+ *
+ * The packaged native helper reads creation time from a pinned process handle.
+ * A missing helper, malformed reply, or denied query keeps the durable record
+ * for retry. Windows has no process groups, so own-group refusal uses the pid.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const windowsSystem: System;
+/**
+ * Reaping on Linux from the kernel's own `/proc`.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.1
+ */
+export declare const procSystem: System;
+/**
+ * Selects the reaping implementation a platform needs.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const systemFor: (platform: string) => System;
+/**
+ * How far apart a recorded start time and the operating system's may be and
+ * still describe the same process.
+ *
+ * `lstart` has one-second granularity and the ledger writes its record just
+ * after the spawn returns, so the two never agree exactly. Two seconds covers
+ * the gap; a pid the operating system handed to somebody else is minutes or
+ * hours away from it, not milliseconds.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const identityToleranceMs = 2000;
+/**
+ * Reaper configuration.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Options {
+    /** The pid this host must never signal a group for. Default `process.pid`. */
+    readonly ownerPid?: number | undefined;
+    /** The operating-system seam. Default {@link systemFor} of `process.platform`. */
+    readonly system?: System | undefined;
+}
+/**
+ * Why a record was not signalled.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Refusal = 
+/** The incarnation that started it is still running and will contain it. */
+"owner-alive"
+/** It shared its owner's process group, so there is no group to signal. */
+ | "no-group"
+/** It named this host's own process group or pid. */
+ | "own-group"
+/** This host could not read its OWN process group, so it cannot rule that out. */
+ | "own-group-unknown"
+/** Its numbers do not name anything this platform may signal. */
+ | "invalid-record"
+/** It was written before this machine booted, so the pid space is not the same. */
+ | "pre-boot"
+/** The pid it names does not exist, so there is no identity to confirm. */
+ | "process-gone"
+/** The pid exists but did not start when the record says it did. */
+ | "identity-mismatch"
+/** This host could not ask when the pid started, so it must not signal it. */
+ | "identity-unverified"
+/** The signal was refused, so the record stays for the next incarnation. */
+ | "kill-failed";
+/**
+ * One record, and what the reaper decided about it.
+ *
+ * The two outcomes are a union rather than one shape with an optional field so
+ * that `killed` narrows the reason: after `if (!entry.killed)` the
+ * {@link Refusal} is there to read, and a killed record cannot be built
+ * carrying a reason it never had. The runtime objects are unchanged — a killed
+ * entry simply omits `refusal`.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Reaped = {
+    readonly record: ProcessLedger.ProcessRecord;
+    readonly killed: true;
+    /** Never present when `killed` is `true`. */
+    readonly refusal?: never;
+} | {
+    readonly record: ProcessLedger.ProcessRecord;
+    readonly killed: false;
+    /** Present exactly when `killed` is `false`. */
+    readonly refusal: Refusal;
+};
+/**
+ * Kills the process groups a previous incarnation of this host abandoned.
+ *
+ * Returns one entry per inherited record so a caller can log what it decided;
+ * `killed: false` carries the {@link Refusal} that produced it. Fails with
+ * {@link ProcessLedger.ProcessLedgerReplayError} when the inherited history
+ * cannot be read to its end: nothing is signalled or retired, so the next
+ * sweep inherits every record again.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const reap: (options?: Options) => Effect.Effect<ReadonlyArray<Reaped>, ProcessLedger.ProcessLedgerReplayError, ProcessLedger.ProcessLedger>;
+/**
+ * Counter over inherited records the reaper did not kill, with a `refusal`
+ * attribute naming why.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.1
+ */
+export declare const refusals: Metric.Counter<number>;
+/**
+ * Reports one sweep: a counter update per refusal and one summary line. The
+ * line is a warning when a record stays inherited (a retained refusal) or a
+ * signal failed, because either leaves a crashed incarnation's processes
+ * running with nothing else to say so.
+ *
+ * @category layers
+ * @since 1.0.0-rc.1
+ */
+export declare const report: (decided: ReadonlyArray<Reaped>) => Effect.Effect<void>;
+/**
+ * Runs {@link reap} once while the layer is built.
+ *
+ * Compose it into a host layer so standing a host up is also what cleans up
+ * after the incarnation that crashed. A history that cannot be read refuses
+ * the sweep with an error log and leaves every record inherited; the host
+ * still starts, because the processes it will spawn are recorded and
+ * contained regardless. Every decision is {@link report}ed.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: (options?: Options) => Layer.Layer<never, never, ProcessLedger.ProcessLedger>;
+//# sourceMappingURL=ProcessReaper.d.ts.map

package/dist/cjs/ProcessReaper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessReaper.d.ts","sourceRoot":"","sources":["../../src/ProcessReaper.ts"],"names":[],"mappings":"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"}