@descryy/runtime-controller 0.0.0

package/dist/environment-version-check.js

@@ -0,0 +1,218 @@
+/**
+ * `DEC-NEXT-fault-layer-empirical-confirmation.md`'s `environment`
+ * mechanism: "declared/expected runner version (CI config) vs. observed
+ * runner version at execution." Same shape as `dependency-version-check.ts`'s
+ * comparison -- cheap, always available, no rerun needed.
+ *
+ * ## "Declared" is the project's own `.nvmrc`/`engines.node`, not a
+ * CI-workflow parser
+ *
+ * The ruling names "a CI config's pinned Node/language version" as one
+ * example of what "declared" can mean, not the only one -- its actual
+ * requirement is "whatever 'declared environment' already means elsewhere
+ * in this repo," checked directly rather than assumed (`environment-profile`
+ * turned out to mean something else entirely: DEC-270's safety level and
+ * credentials, not a version declaration). Nothing in this repo already
+ * parses a CI workflow file, and doing so first here would mean writing a
+ * YAML parser (or a regex sketch of one) for a signal that is, in every
+ * real Node project, already restated in `package.json` -- `.nvmrc` and
+ * `engines.node` are the actual, load-bearing declarations `nvm`/`npm`
+ * themselves read, checked directly against this repo's own root
+ * `package.json` (`engines: { node: ">=22.5" }`) and every fixture app
+ * under `fixture-apps/`, which all carry the same field. A future CI-file
+ * reader is a real, disclosed extension point, not a silent omission --
+ * this function's `declaredSource` is a closed union specifically so a
+ * third source can be added later without changing the shape callers
+ * already read.
+ *
+ * ## `satisfiesDeclaredNodeVersion`'s grammar is a real, narrower subset
+ *
+ * Supports `^x.y.z`, `~x.y.z`, `>=`/`<=`/`>`/`<` clauses, a bare version at
+ * any precision (`"20"`, `"20.11"`, `"20.11.5"`, each an x-range at that
+ * precision -- `"20"` means "any 20.x.y", matching what `actions/setup-node`
+ * itself does for a bare major), and space-separated AND clauses
+ * (`">=20.0.0 <21.0.0"`), npm's own shape for a bounded range. Does **not**
+ * support `||` (OR), hyphen ranges (`"1.2.3 - 2.3.4"`), prerelease/build
+ * tags, or the `x`/`*` wildcard tokens (`"20.x"`) -- an input using any of
+ * those parses to `null` ("cannot say") rather than a silently wrong
+ * true/false, the same "disclosed narrower scope, not a guess" pattern this
+ * repo already applies to `EnvironmentMetadata.toolchainVersions`' `null`
+ * entries.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export const DECLARED_VERSION_SOURCES = ["nvmrc", "package.json engines.node"];
+/**
+ * Reads the declared Node version for the project rooted at `cwd` and
+ * compares it against `observedVersion` (the real, already-known runtime
+ * value -- `process.version`, or `EnvironmentMetadata.nodeVersion`, the same
+ * "always known, never probed" value this repo already captures elsewhere;
+ * this function never probes for it itself).
+ *
+ * `.nvmrc` takes precedence over `package.json engines.node` when both are
+ * present -- `.nvmrc` names one exact intended version a developer actually
+ * runs locally; `engines.node` is more often a permissive range meant to
+ * describe compatibility rather than pin a single runtime. The narrower,
+ * more specific declaration wins, the same precedence
+ * `classifyFaultLayer` (`descry-core`) already applies between `dependency`
+ * and `environment` themselves ("the narrower, more specific structural
+ * fact... is checked first").
+ */
+export function checkEnvironmentVersion(cwd, observedVersion) {
+    const notApplicable = {
+        applicable: false,
+        mismatch: false,
+        declaredVersion: null,
+        declaredSource: null,
+        observedVersion,
+    };
+    const nvmrcPath = join(cwd, ".nvmrc");
+    let declaredVersion = null;
+    let declaredSource = null;
+    if (existsSync(nvmrcPath)) {
+        const raw = readFileSync(nvmrcPath, "utf8").trim();
+        if (raw.length > 0) {
+            declaredVersion = raw;
+            declaredSource = "nvmrc";
+        }
+    }
+    else {
+        const packageJsonPath = join(cwd, "package.json");
+        if (existsSync(packageJsonPath)) {
+            let parsed;
+            try {
+                parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+            }
+            catch {
+                parsed = null;
+            }
+            const node = parsed?.engines?.node;
+            if (typeof node === "string" && node.trim().length > 0) {
+                declaredVersion = node;
+                declaredSource = "package.json engines.node";
+            }
+        }
+    }
+    if (declaredVersion === null || declaredSource === null) {
+        return notApplicable;
+    }
+    const satisfies = satisfiesDeclaredNodeVersion(declaredVersion, observedVersion);
+    if (satisfies === null) {
+        // Declared with a grammar this reader does not cover (or the observed
+        // string was not parseable), so honestly "not applicable" rather than
+        // implying a comparison was actually made -- see this module's header.
+        return { applicable: false, mismatch: false, declaredVersion, declaredSource, observedVersion };
+    }
+    return { applicable: true, mismatch: !satisfies, declaredVersion, declaredSource, observedVersion };
+}
+const VERSION_PATTERN = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/;
+function parseVersion(raw) {
+    const match = VERSION_PATTERN.exec(raw.trim());
+    if (match === null)
+        return null;
+    const major = Number(match[1]);
+    if (!Number.isFinite(major))
+        return null;
+    return {
+        major,
+        minor: match[2] !== undefined ? Number(match[2]) : 0,
+        minorSpecified: match[2] !== undefined,
+        patch: match[3] !== undefined ? Number(match[3]) : 0,
+        patchSpecified: match[3] !== undefined,
+    };
+}
+/** Positive when `a` > `b`, negative when `a` < `b`, zero when equal -- major.minor.patch only. */
+function compareVersions(a, b) {
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    return a.patch - b.patch;
+}
+const CARET_PATTERN = /^\^(\d+)(?:\.(\d+))?(?:\.(\d+))?$/;
+const TILDE_PATTERN = /^~(\d+)(?:\.(\d+))?(?:\.(\d+))?$/;
+const COMPARATOR_PATTERN = /^(>=|<=|>|<|=)?(\d+)(?:\.(\d+))?(?:\.(\d+))?$/;
+/**
+ * `null` means "this clause's grammar is not one of the ones documented in
+ * this module's header" -- propagated up as `null`, never coerced to a
+ * guessed `true`/`false`.
+ */
+function satisfiesClause(clause, observed) {
+    const trimmed = clause.trim();
+    if (trimmed.length === 0)
+        return null;
+    const caret = CARET_PATTERN.exec(trimmed);
+    if (caret !== null) {
+        const base = {
+            major: Number(caret[1]),
+            minor: caret[2] !== undefined ? Number(caret[2]) : 0,
+            minorSpecified: true,
+            patch: caret[3] !== undefined ? Number(caret[3]) : 0,
+            patchSpecified: true,
+        };
+        return compareVersions(observed, base) >= 0 && observed.major === base.major;
+    }
+    const tilde = TILDE_PATTERN.exec(trimmed);
+    if (tilde !== null) {
+        const base = {
+            major: Number(tilde[1]),
+            minor: tilde[2] !== undefined ? Number(tilde[2]) : 0,
+            minorSpecified: true,
+            patch: tilde[3] !== undefined ? Number(tilde[3]) : 0,
+            patchSpecified: true,
+        };
+        return compareVersions(observed, base) >= 0 && observed.major === base.major && observed.minor === base.minor;
+    }
+    const comparator = COMPARATOR_PATTERN.exec(trimmed);
+    if (comparator === null)
+        return null;
+    const op = comparator[1];
+    const base = {
+        major: Number(comparator[2]),
+        minor: comparator[3] !== undefined ? Number(comparator[3]) : 0,
+        minorSpecified: comparator[3] !== undefined,
+        patch: comparator[4] !== undefined ? Number(comparator[4]) : 0,
+        patchSpecified: comparator[4] !== undefined,
+    };
+    const cmp = compareVersions(observed, base);
+    switch (op) {
+        case ">=":
+            return cmp >= 0;
+        case "<=":
+            return cmp <= 0;
+        case ">":
+            return cmp > 0;
+        case "<":
+            return cmp < 0;
+        case "=":
+        case undefined:
+            // Bare version: an x-range at whatever precision was actually given.
+            if (!base.minorSpecified)
+                return observed.major === base.major;
+            if (!base.patchSpecified)
+                return observed.major === base.major && observed.minor === base.minor;
+            return cmp === 0;
+        default:
+            return null;
+    }
+}
+/**
+ * Whether `observedVersion` satisfies `declaredRange` under the grammar
+ * documented in this module's header. `null` means the comparison could not
+ * be made at all (either string used a construct this reader does not
+ * cover) -- distinct from `false`, which is a real, positive "does not
+ * satisfy" answer.
+ */
+export function satisfiesDeclaredNodeVersion(declaredRange, observedVersion) {
+    const observed = parseVersion(observedVersion);
+    if (observed === null)
+        return null;
+    const clauses = declaredRange.split(/\s+/).filter((clause) => clause.length > 0);
+    if (clauses.length === 0)
+        return null;
+    const results = clauses.map((clause) => satisfiesClause(clause, observed));
+    if (results.some((result) => result === null))
+        return null;
+    return results.every((result) => result === true);
+}
+//# sourceMappingURL=environment-version-check.js.map

package/dist/environment-version-check.js.map

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

package/dist/execution-safety.d.ts

@@ -0,0 +1,154 @@
+/**
+ * §21's execution boundary (RT-070): resource limits and privilege
+ * reporting for a runtime whose declared mode is trusted-local (see
+ * DECISIONS.md RT-070) -- every spawned process runs with the invoking
+ * user's own OS privileges, no filesystem or network restriction. That
+ * declaration does not make unrestricted execution safe; it names the
+ * boundary instead of leaving it absent, which is what §38's "arbitrary
+ * application code runs without a defined safety boundary" actually bans.
+ * Real isolation (containers/namespaces) is a separate architectural
+ * decision this module does not invent (plan §29's own instruction).
+ *
+ * What this module DOES enforce, for real, via the OS: CPU time, virtual
+ * memory, and process count, through `prlimit` -- an exec wrapper, never a
+ * shell. Reintroducing `sh -c 'ulimit ...; exec ...'` to get these would
+ * undo RT-036's `tokenizeCommand` refusal of shell metacharacters. `prlimit`
+ * is util-linux and absent on macOS, so it is reported as a capability,
+ * never assumed.
+ */
+import type { CapabilityStatus, ResourceLimits } from "@descryy/runtime-contracts";
+/**
+ * Whether `prlimit` is reachable on this platform's `PATH`. Takes `env` as
+ * a parameter (defaulting to `process.env`) rather than reading it
+ * internally so the "unavailable" branch is directly testable without
+ * mutating this process's own real environment or depending on running on
+ * a platform that genuinely lacks it.
+ */
+export declare function resourceLimitCapability(env?: NodeJS.ProcessEnv): CapabilityStatus;
+/**
+ * RT-193 originally made this always `unavailable` -- no platform had any
+ * enforcement mechanism wired up. The sandbox-isolation lane changes that
+ * on Linux: `networkIsolationCapability()` (`./sandbox.ts`) is real, backed
+ * by a bwrap network namespace. This function is kept as the stable name
+ * every existing caller (`ExecutionController.run()`, this package's own
+ * tests) already imports, delegating rather than duplicating the check --
+ * exactly the seam RT-193's own comment anticipated ("if a real mechanism
+ * is ever built, this one function changes and every caller keeps working
+ * unmodified"). Still unconditionally `unavailable` on macOS/Windows, where
+ * nothing enforces it yet.
+ */
+export declare function networkPolicyCapability(env?: NodeJS.ProcessEnv): CapabilityStatus;
+/**
+ * Wraps `command`/`args` so the OS enforces `limits`, via `prlimit`.
+ * `undefined` or an empty `limits` returns `command`/`args` unchanged --
+ * every execution before RT-070 keeps behaving exactly as before unless it
+ * opts in.
+ *
+ * **Throws rather than silently spawning unconstrained** when a limit was
+ * requested and `prlimit` is unavailable. `tokenizeCommand`'s own precedent
+ * (RT-036) is refuse rather than guess; the equivalent failure here would
+ * be a caller asking for a memory cap and getting a process that can
+ * allocate without bound, silently -- exactly the "sandbox that doesn't
+ * sandbox" shape §38 bans, one row up from this one.
+ */
+export declare function applyResourceLimits(command: string, args: readonly string[], limits: ResourceLimits | undefined, env?: NodeJS.ProcessEnv): {
+    readonly command: string;
+    readonly args: readonly string[];
+};
+/**
+ * DEC-272's disclosure requirement: the sandbox boundary (RT-070) must be
+ * stated to the user directly in-product, not left as a silent gap in a
+ * doc. Fixed, not derived from `runningAsRoot` -- the boundary is the same
+ * regardless of which privilege level was found; only the observed fact
+ * changes.
+ *
+ * **Scope, corrected by the attach-mode-mitigations lane: this is the
+ * unconditional-unisolated text, not a universal one.** Written when
+ * RT-193/RT-070 landed, before `sandbox.ts` existed -- at that point it was
+ * accurate for every execution, because nothing anywhere in this runtime
+ * could isolate anything. That stopped being true the moment the
+ * sandbox-isolation lane gave spawn-mode real, bwrap-backed filesystem/
+ * network isolation (`applySandbox`, this same package): a spawned process
+ * that actually got a `FilesystemPolicy`/`NetworkPolicy` applied to it is
+ * genuinely more contained than "the same as if you started it yourself"
+ * says. Using this constant unconditionally for that process would be a
+ * real disclosure-accuracy bug -- understating a boundary is not the safe
+ * direction to be wrong in, it just happens to be a less alarming one.
+ * `sandboxBoundaryDisclosureFor()` below is the mode-aware replacement: it
+ * returns this exact string when no policy was applied (attach-mode always,
+ * and any spawn that declared none -- unchanged from before this lane), and
+ * a real, specific description of what is and is not contained when a
+ * policy genuinely was. This constant is kept, unchanged, as that function's
+ * own no-policy-applied return value and as attach-mode's own disclosure,
+ * not deprecated -- attach-mode never has anything more accurate to say.
+ */
+export declare const SANDBOX_BOUNDARY_DISCLOSURE: string;
+/**
+ * Whether a real `FilesystemPolicy`/`NetworkPolicy` was actually enforced on
+ * the process this disclosure describes -- not merely requested.
+ * `applySandbox` already refuses to spawn (throws) rather than proceed
+ * unconstrained when a declared policy cannot be enforced (see its own
+ * comment), so by the time a caller can observe a successfully spawned
+ * process, "declared" and "applied" are the same fact; this type exists so
+ * a caller states that fact explicitly rather than this function silently
+ * assuming it.
+ */
+export interface AppliedIsolationPolicies {
+    readonly filesystemPolicyApplied: boolean;
+    readonly networkPolicyApplied: boolean;
+}
+/**
+ * The mode-aware replacement for reading `SANDBOX_BOUNDARY_DISCLOSURE`
+ * unconditionally. Defaults to reporting no policy applied -- so calling
+ * this with no argument at all is identical to the pre-existing constant,
+ * the same non-regression contract every other opt-in in this file
+ * (`applyResourceLimits`, `applySandbox`) already keeps.
+ *
+ * **Still only ever true for spawn-mode.** Attach-mode has no code path
+ * that can produce `filesystemPolicyApplied: true` or
+ * `networkPolicyApplied: true` for any process it did not itself spawn --
+ * see `sandbox.ts`'s own module doc for why that is structural, not a gap
+ * in this function. A caller in attach-mode should simply never pass
+ * anything but the default here, and the default's return value is this
+ * disclosure's original, unconditional "not isolated" text, unchanged.
+ */
+export declare function sandboxBoundaryDisclosureFor(policies?: AppliedIsolationPolicies): string;
+/**
+ * Attach mode's own contractual scope guarantee -- distinct from the
+ * sandbox-*boundary* disclosure above (what is or isn't contained) because
+ * this is a claim about what an attach-mode `Collector` is even permitted
+ * to *do*, not about what OS boundary wraps it. See `Collector` in
+ * `@descryy/runtime-contracts` for the interface-level statement this
+ * mirrors, and `sandbox.ts`'s own module doc for why attach-mode can never
+ * acquire the isolation `sandboxBoundaryDisclosureFor` describes for
+ * spawn-mode. Stated once, here, so every attach-mode caller surfaces the
+ * identical sentence rather than each writing its own paraphrase.
+ */
+export declare const ATTACH_MODE_SCOPE_DISCLOSURE: string;
+export interface PrivilegeReport {
+    /** Null when this platform has no uid concept at all (`process.getuid` is undefined on Windows) -- distinct from `false`, which is a real answer, not an absent one. */
+    readonly runningAsRoot: boolean | null;
+    /** DEC-272: plain-language statement of the sandbox boundary, carried on the same result the privilege level already travels on rather than a new return path. Always populated -- the disclosure is unconditional, not dependent on `runningAsRoot`. */
+    readonly disclosure: string;
+}
+/**
+ * Reports, never enforces. §21's privilege policy for a runtime declared
+ * trusted-local (RT-070) is not "refuse to run as root" -- CI containers
+ * commonly run as root by default, and a hard refusal there would turn a
+ * documented boundary into an undocumented outage. The policy is: the real
+ * privilege level becomes an observable fact instead of an invisible one,
+ * which is what nothing before RT-070 made it.
+ *
+ * A required parameter, not a defaulted one: `undefined` is the real,
+ * meaningful value a platform with no uid concept produces
+ * (`process.getuid` is itself `undefined` on Windows), and a *default*
+ * parameter cannot tell "caller explicitly passed undefined" apart from
+ * "caller omitted the argument" -- both look identical to the function.
+ * `currentPrivilegeReport()` below is the zero-argument convenience wrapper
+ * real callers use; this is what makes both branches -- root, and no uid
+ * concept at all -- directly testable without this process actually
+ * needing to run as root or on Windows.
+ */
+export declare function privilegeReportFor(getuid: (() => number) | undefined): PrivilegeReport;
+export declare function currentPrivilegeReport(): PrivilegeReport;
+//# sourceMappingURL=execution-safety.d.ts.map

package/dist/execution-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-safety.d.ts","sourceRoot":"","sources":["../src/execution-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAGnF;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,gBAAgB,CAU9F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,gBAAgB,CAE9F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,MAAM,EAAE,cAAc,GAAG,SAAS,EAClC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAchE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,2BAA2B,QAGT,CAAC;AAEhC;;;;;;;;;GASG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;CACxC;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,GAAE,wBAA8C,GAAG,MAAM,CAwB7G;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,QAKoC,CAAC;AAE9E,MAAM,WAAW,eAAe;IAC9B,wKAAwK;IACxK,QAAQ,CAAC,aAAa,EAAE,OAAO,GAAG,IAAI,CAAC;IACvC,yPAAyP;IACzP,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,GAAG,eAAe,CAGtF;AAED,wBAAgB,sBAAsB,IAAI,eAAe,CAExD"}

package/dist/execution-safety.js

@@ -0,0 +1,194 @@
+/**
+ * §21's execution boundary (RT-070): resource limits and privilege
+ * reporting for a runtime whose declared mode is trusted-local (see
+ * DECISIONS.md RT-070) -- every spawned process runs with the invoking
+ * user's own OS privileges, no filesystem or network restriction. That
+ * declaration does not make unrestricted execution safe; it names the
+ * boundary instead of leaving it absent, which is what §38's "arbitrary
+ * application code runs without a defined safety boundary" actually bans.
+ * Real isolation (containers/namespaces) is a separate architectural
+ * decision this module does not invent (plan §29's own instruction).
+ *
+ * What this module DOES enforce, for real, via the OS: CPU time, virtual
+ * memory, and process count, through `prlimit` -- an exec wrapper, never a
+ * shell. Reintroducing `sh -c 'ulimit ...; exec ...'` to get these would
+ * undo RT-036's `tokenizeCommand` refusal of shell metacharacters. `prlimit`
+ * is util-linux and absent on macOS, so it is reported as a capability,
+ * never assumed.
+ */
+import { execFileSync } from "node:child_process";
+import { networkIsolationCapability } from "./sandbox.js";
+/**
+ * Whether `prlimit` is reachable on this platform's `PATH`. Takes `env` as
+ * a parameter (defaulting to `process.env`) rather than reading it
+ * internally so the "unavailable" branch is directly testable without
+ * mutating this process's own real environment or depending on running on
+ * a platform that genuinely lacks it.
+ */
+export function resourceLimitCapability(env = process.env) {
+    try {
+        execFileSync("prlimit", ["--version"], { env, stdio: "ignore" });
+        return { availability: "available", reason: null };
+    }
+    catch {
+        return {
+            availability: "unavailable",
+            reason: "prlimit (util-linux) is not on PATH -- CPU/memory/process limits cannot be enforced on this platform without reintroducing a shell, which this runtime refuses to do (RT-036)",
+        };
+    }
+}
+/**
+ * RT-193 originally made this always `unavailable` -- no platform had any
+ * enforcement mechanism wired up. The sandbox-isolation lane changes that
+ * on Linux: `networkIsolationCapability()` (`./sandbox.ts`) is real, backed
+ * by a bwrap network namespace. This function is kept as the stable name
+ * every existing caller (`ExecutionController.run()`, this package's own
+ * tests) already imports, delegating rather than duplicating the check --
+ * exactly the seam RT-193's own comment anticipated ("if a real mechanism
+ * is ever built, this one function changes and every caller keeps working
+ * unmodified"). Still unconditionally `unavailable` on macOS/Windows, where
+ * nothing enforces it yet.
+ */
+export function networkPolicyCapability(env = process.env) {
+    return networkIsolationCapability(env);
+}
+/**
+ * Wraps `command`/`args` so the OS enforces `limits`, via `prlimit`.
+ * `undefined` or an empty `limits` returns `command`/`args` unchanged --
+ * every execution before RT-070 keeps behaving exactly as before unless it
+ * opts in.
+ *
+ * **Throws rather than silently spawning unconstrained** when a limit was
+ * requested and `prlimit` is unavailable. `tokenizeCommand`'s own precedent
+ * (RT-036) is refuse rather than guess; the equivalent failure here would
+ * be a caller asking for a memory cap and getting a process that can
+ * allocate without bound, silently -- exactly the "sandbox that doesn't
+ * sandbox" shape §38 bans, one row up from this one.
+ */
+export function applyResourceLimits(command, args, limits, env = process.env) {
+    if (limits === undefined)
+        return { command, args };
+    const flags = [];
+    if (limits.maxMemoryBytes !== undefined)
+        flags.push(`--as=${limits.maxMemoryBytes}`);
+    if (limits.maxCpuSeconds !== undefined)
+        flags.push(`--cpu=${limits.maxCpuSeconds}`);
+    if (limits.maxProcesses !== undefined)
+        flags.push(`--nproc=${limits.maxProcesses}`);
+    if (flags.length === 0)
+        return { command, args };
+    const capability = resourceLimitCapability(env);
+    if (capability.availability !== "available") {
+        throw new Error(`resource limits were requested but cannot be enforced on this platform: ${capability.reason}`);
+    }
+    return { command: "prlimit", args: [...flags, "--", command, ...args] };
+}
+/**
+ * DEC-272's disclosure requirement: the sandbox boundary (RT-070) must be
+ * stated to the user directly in-product, not left as a silent gap in a
+ * doc. Fixed, not derived from `runningAsRoot` -- the boundary is the same
+ * regardless of which privilege level was found; only the observed fact
+ * changes.
+ *
+ * **Scope, corrected by the attach-mode-mitigations lane: this is the
+ * unconditional-unisolated text, not a universal one.** Written when
+ * RT-193/RT-070 landed, before `sandbox.ts` existed -- at that point it was
+ * accurate for every execution, because nothing anywhere in this runtime
+ * could isolate anything. That stopped being true the moment the
+ * sandbox-isolation lane gave spawn-mode real, bwrap-backed filesystem/
+ * network isolation (`applySandbox`, this same package): a spawned process
+ * that actually got a `FilesystemPolicy`/`NetworkPolicy` applied to it is
+ * genuinely more contained than "the same as if you started it yourself"
+ * says. Using this constant unconditionally for that process would be a
+ * real disclosure-accuracy bug -- understating a boundary is not the safe
+ * direction to be wrong in, it just happens to be a less alarming one.
+ * `sandboxBoundaryDisclosureFor()` below is the mode-aware replacement: it
+ * returns this exact string when no policy was applied (attach-mode always,
+ * and any spawn that declared none -- unchanged from before this lane), and
+ * a real, specific description of what is and is not contained when a
+ * policy genuinely was. This constant is kept, unchanged, as that function's
+ * own no-policy-applied return value and as attach-mode's own disclosure,
+ * not deprecated -- attach-mode never has anything more accurate to say.
+ */
+export const SANDBOX_BOUNDARY_DISCLOSURE = "This app runs with your own user permissions, the same as if you started it yourself. " +
+    "The filesystem and network are not isolated -- anything your own account could read, write, " +
+    "or reach, this run can too.";
+const NO_POLICIES_APPLIED = { filesystemPolicyApplied: false, networkPolicyApplied: false };
+/**
+ * The mode-aware replacement for reading `SANDBOX_BOUNDARY_DISCLOSURE`
+ * unconditionally. Defaults to reporting no policy applied -- so calling
+ * this with no argument at all is identical to the pre-existing constant,
+ * the same non-regression contract every other opt-in in this file
+ * (`applyResourceLimits`, `applySandbox`) already keeps.
+ *
+ * **Still only ever true for spawn-mode.** Attach-mode has no code path
+ * that can produce `filesystemPolicyApplied: true` or
+ * `networkPolicyApplied: true` for any process it did not itself spawn --
+ * see `sandbox.ts`'s own module doc for why that is structural, not a gap
+ * in this function. A caller in attach-mode should simply never pass
+ * anything but the default here, and the default's return value is this
+ * disclosure's original, unconditional "not isolated" text, unchanged.
+ */
+export function sandboxBoundaryDisclosureFor(policies = NO_POLICIES_APPLIED) {
+    const { filesystemPolicyApplied, networkPolicyApplied } = policies;
+    if (!filesystemPolicyApplied && !networkPolicyApplied)
+        return SANDBOX_BOUNDARY_DISCLOSURE;
+    if (filesystemPolicyApplied && networkPolicyApplied) {
+        return ("This process was spawned inside a real OS-level sandbox (bubblewrap): filesystem access is restricted " +
+            "to its declared allowedRoots (plus its own working directory) -- nothing else on this machine is visible " +
+            "to it, not merely unwritable -- and network access is fully denied, including this machine's own loopback. " +
+            "This is real isolation, not a name-only boundary.");
+    }
+    if (filesystemPolicyApplied) {
+        return ("This process was spawned inside a real OS-level sandbox (bubblewrap): filesystem access is restricted " +
+            "to its declared allowedRoots (plus its own working directory) -- nothing else on this machine is visible " +
+            "to it, not merely unwritable. Network access was NOT restricted for this run -- it can reach anything " +
+            "your own account's network could reach.");
+    }
+    return ("This process was spawned inside a real OS-level sandbox (bubblewrap): network access is fully denied " +
+        "for this run, including this machine's own loopback. Filesystem access was NOT restricted for this run -- " +
+        "it can read, write, or reach anything your own account's filesystem could.");
+}
+/**
+ * Attach mode's own contractual scope guarantee -- distinct from the
+ * sandbox-*boundary* disclosure above (what is or isn't contained) because
+ * this is a claim about what an attach-mode `Collector` is even permitted
+ * to *do*, not about what OS boundary wraps it. See `Collector` in
+ * `@descryy/runtime-contracts` for the interface-level statement this
+ * mirrors, and `sandbox.ts`'s own module doc for why attach-mode can never
+ * acquire the isolation `sandboxBoundaryDisclosureFor` describes for
+ * spawn-mode. Stated once, here, so every attach-mode caller surfaces the
+ * identical sentence rather than each writing its own paraphrase.
+ */
+export const ATTACH_MODE_SCOPE_DISCLOSURE = "Attach mode observes an already-running process; it never executes code in it or applies changes to it. " +
+    "This is a permanent, documented architectural limitation, not a temporary gap -- there is no honest way to " +
+    "retroactively sandbox a process that was already running, unconfined, before this tool touched it. " +
+    "Respawn-and-supervise and the cgroup resource-limit move are real alternatives next to attach mode, not " +
+    "fixes to it; see their own documentation for what each actually gets you.";
+/**
+ * Reports, never enforces. §21's privilege policy for a runtime declared
+ * trusted-local (RT-070) is not "refuse to run as root" -- CI containers
+ * commonly run as root by default, and a hard refusal there would turn a
+ * documented boundary into an undocumented outage. The policy is: the real
+ * privilege level becomes an observable fact instead of an invisible one,
+ * which is what nothing before RT-070 made it.
+ *
+ * A required parameter, not a defaulted one: `undefined` is the real,
+ * meaningful value a platform with no uid concept produces
+ * (`process.getuid` is itself `undefined` on Windows), and a *default*
+ * parameter cannot tell "caller explicitly passed undefined" apart from
+ * "caller omitted the argument" -- both look identical to the function.
+ * `currentPrivilegeReport()` below is the zero-argument convenience wrapper
+ * real callers use; this is what makes both branches -- root, and no uid
+ * concept at all -- directly testable without this process actually
+ * needing to run as root or on Windows.
+ */
+export function privilegeReportFor(getuid) {
+    if (getuid === undefined)
+        return { runningAsRoot: null, disclosure: SANDBOX_BOUNDARY_DISCLOSURE };
+    return { runningAsRoot: getuid() === 0, disclosure: SANDBOX_BOUNDARY_DISCLOSURE };
+}
+export function currentPrivilegeReport() {
+    return privilegeReportFor(process.getuid?.bind(process));
+}
+//# sourceMappingURL=execution-safety.js.map

package/dist/execution-safety.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+export { withDefaultProcessEnv } from "./env.ts";
+export type { SpawnProcessOptions, ProcessExitInfo, ManagedProcess, AttachProcessOptions } from "./process-manager.ts";
+export { spawnProcess, attachManagedProcess, isProcessAlive } from "./process-manager.ts";
+export type { ReadinessMechanism, HttpReadinessCheck, TcpPortReadinessCheck, LogPatternReadinessCheck, CommandReadinessCheck, CustomHookReadinessCheck, ReadinessCheck, ReadinessResult, AwaitReadinessOptions, } from "./readiness.ts";
+export { READINESS_MECHANISMS, awaitReadiness } from "./readiness.ts";
+export type { CreateExecutionInput, RunOptions, ProcessLifecycleEvent } from "./controller.ts";
+export { ExecutionController } from "./controller.ts";
+export type { ProcessCollector } from "./process-collector.ts";
+export { createProcessCollector } from "./process-collector.ts";
+export type { RegisteredCollectorCapabilities, CollectorCapabilityKey } from "./capability-registry.ts";
+export { buildExecutionCapabilities, bestCapabilityStatus } from "./capability-registry.ts";
+export type { PrivilegeReport, AppliedIsolationPolicies } from "./execution-safety.ts";
+export { resourceLimitCapability, applyResourceLimits, networkPolicyCapability, privilegeReportFor, currentPrivilegeReport, SANDBOX_BOUNDARY_DISCLOSURE, sandboxBoundaryDisclosureFor, ATTACH_MODE_SCOPE_DISCLOSURE, } from "./execution-safety.ts";
+export type { SandboxOptions } from "./sandbox.ts";
+export { filesystemIsolationCapability, networkIsolationCapability, unsupportedNetworkPolicyReason, resolveExecutableDirectory, applySandbox, } from "./sandbox.ts";
+export type { ContainerSandboxOptions } from "./container-sandbox.ts";
+export { containerRuntimeCapability, containerFilesystemIsolationCapability, containerNetworkIsolationCapability, unsupportedContainerNetworkPolicyReason, resolveContainerImage, applyContainerSandbox, } from "./container-sandbox.ts";
+export { captureEnvironmentMetadata } from "./environment-metadata.ts";
+export type { DependencyVersionMismatch, DependencyVersionCheckResult } from "./dependency-version-check.ts";
+export { checkDependencyVersions } from "./dependency-version-check.ts";
+export type { DeclaredVersionSource, EnvironmentVersionCheckResult } from "./environment-version-check.ts";
+export { DECLARED_VERSION_SOURCES, checkEnvironmentVersion, satisfiesDeclaredNodeVersion } from "./environment-version-check.ts";
+/**
+ * RT-073: promoted from internal-only. `tokenizeCommand`'s POSIX-style
+ * "refuse rather than guess" tokenizer is exactly what `packages/test-runner`
+ * needs to validate a declared runner command before spawning it -- the
+ * same job it already does for `ServiceConfiguration.command` here.
+ * Re-implementing a second copy for one more caller would be the "two
+ * shapes that could drift" mistake this codebase has already named and
+ * avoided elsewhere (RT-068's `BrowserConfiguration`, RT-070's
+ * `ResourceLimits`).
+ */
+export type { CommandTokenization, ServicesValidation } from "./orchestration.ts";
+export { tokenizeCommand, validateServicesConfiguration, substitutePortPlaceholders } from "./orchestration.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAEjD,YAAY,EAAE,mBAAmB,EAAE,eAAe,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACvH,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE1F,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,wBAAwB,EACxB,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,eAAe,EACf,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEtE,YAAY,EAAE,oBAAoB,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC/F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEtD,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,YAAY,EAAE,+BAA+B,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACxG,OAAO,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAE5F,YAAY,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACvF,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,8BAA8B,EAC9B,0BAA0B,EAC1B,YAAY,GACb,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EACL,0BAA0B,EAC1B,sCAAsC,EACtC,mCAAmC,EACnC,uCAAuC,EACvC,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AAEvE,YAAY,EAAE,yBAAyB,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAC7G,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAExE,YAAY,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC3G,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAEjI;;;;;;;;;GASG;AACH,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAClF,OAAO,EAAE,eAAe,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+export { withDefaultProcessEnv } from "./env.js";
+export { spawnProcess, attachManagedProcess, isProcessAlive } from "./process-manager.js";
+export { READINESS_MECHANISMS, awaitReadiness } from "./readiness.js";
+export { ExecutionController } from "./controller.js";
+export { createProcessCollector } from "./process-collector.js";
+export { buildExecutionCapabilities, bestCapabilityStatus } from "./capability-registry.js";
+export { resourceLimitCapability, applyResourceLimits, networkPolicyCapability, privilegeReportFor, currentPrivilegeReport, SANDBOX_BOUNDARY_DISCLOSURE, sandboxBoundaryDisclosureFor, ATTACH_MODE_SCOPE_DISCLOSURE, } from "./execution-safety.js";
+export { filesystemIsolationCapability, networkIsolationCapability, unsupportedNetworkPolicyReason, resolveExecutableDirectory, applySandbox, } from "./sandbox.js";
+export { containerRuntimeCapability, containerFilesystemIsolationCapability, containerNetworkIsolationCapability, unsupportedContainerNetworkPolicyReason, resolveContainerImage, applyContainerSandbox, } from "./container-sandbox.js";
+export { captureEnvironmentMetadata } from "./environment-metadata.js";
+export { checkDependencyVersions } from "./dependency-version-check.js";
+export { DECLARED_VERSION_SOURCES, checkEnvironmentVersion, satisfiesDeclaredNodeVersion } from "./environment-version-check.js";
+export { tokenizeCommand, validateServicesConfiguration, substitutePortPlaceholders } from "./orchestration.js";
+//# sourceMappingURL=index.js.map