@push.rocks/smartdaemon 2.11.0 → 2.12.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartdaemon',
-    version: '2.11.0',
+    version: '2.12.0',
     description: 'Start scripts as long running daemons and manage them.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHdEQUF3RDtDQUN0RSxDQUFBIn0=

package/dist_ts/classes.systemdtransientscope.d.ts

@@ -0,0 +1,78 @@
+export interface ISystemdTransientScopeOptions {
+    /** The calling user's manager; the only manager a transient scope is started in. */
+    scope: 'user';
+    /** Absolute, normalized program path, executed directly: no shell, no PATH search. */
+    executable: string;
+    /** Literal arguments, at most 128 of at most 32768 characters each, without NUL. */
+    args: readonly string[];
+    /** Absolute, normalized directory the program starts in. */
+    workingDirectory: string;
+    /**
+     * The program's complete environment. Nothing of the calling process is inherited: the program
+     * receives exactly these variables, the manager's `XDG_RUNTIME_DIR` and systemd's
+     * `INVOCATION_ID`. Names match `[A-Za-z_][A-Za-z0-9_]*` (at most 128 characters); values are
+     * strings of at most 32768 characters without NUL; at most 256 variables. `XDG_RUNTIME_DIR`,
+     * `INVOCATION_ID` and names starting with `SYSTEMD_` or `DBUS_`, which configure systemd-run
+     * itself, are refused.
+     */
+    environment: Readonly<Record<string, string>>;
+    /** Literal unit description: clean text of 1 to 1024 characters, trimmed, without `\`. */
+    description: string;
+    /** A `.scope` unit name; defaults to a unique `smartdaemon-<32 hex digits>.scope`. */
+    unitName?: string;
+    /** User-manager socket directory. Defaults to a non-empty XDG_RUNTIME_DIR. */
+    runtimeDirectory?: string;
+    /** Absolute executable path supplied by trusted owning code. Defaults to `/usr/bin/systemd-run`. */
+    systemdRunPath?: string;
+    /** Absolute executable path supplied by trusted owning code. Defaults to `/usr/bin/systemctl`. */
+    systemctlPath?: string;
+    /** Bounds the manager probe and the program's direct process, each. Defaults to 120 seconds. */
+    commandTimeoutMs?: number;
+}
+export interface ISystemdTransientScopeResult {
+    /** The scope unit. It stays active while any process the program started runs in it. */
+    readonly unitName: string;
+    /** Exit status of the program's direct process; null when a signal ended it. */
+    readonly exitCode: number | null;
+    readonly signal: NodeJS.Signals | null;
+    /** UTF-8 decoded output of the program and every process that shared its stdout. */
+    readonly stdout: string;
+    /** As `stdout`, without the line systemd-run prints on starting the scope. */
+    readonly stderr: string;
+}
+export type TSystemdTransientScopeErrorCode = 
+/** The options are malformed, or the runtime directory is not a private directory of the caller. */
+'invalid_options'
+/** The process is not running on Linux. */
+ | 'unsupported_platform'
+/** No runtime directory is set or it does not exist, or the manager does not answer systemctl. */
+ | 'user_manager_unavailable'
+/** systemd-run exited without reporting the scope running; the program has not run. */
+ | 'scope_start_failed'
+/** The manager probe or the program did not finish, and close its output, in time. */
+ | 'timed_out'
+/** The program's stdout or stderr exceeded 1 MiB. */
+ | 'output_limit';
+export declare class SystemdTransientScopeError extends Error {
+    readonly code: TSystemdTransientScopeErrorCode;
+    /** The scope the call used; null when the options were refused. */
+    readonly unitName: string | null;
+    /** The probe's or systemd-run's stderr as far as it was read; empty when none ran. */
+    readonly stderr: string;
+    constructor(code: TSystemdTransientScopeErrorCode, 
+    /** The scope the call used; null when the options were refused. */
+    unitName: string | null, 
+    /** The probe's or systemd-run's stderr as far as it was read; empty when none ran. */
+    stderr: string, options?: ErrorOptions);
+}
+/**
+ * Starts a program in a new transient scope unit of the calling user's systemd manager, so it and
+ * every process it starts run outside the caller's own unit and survive that unit's stop, and
+ * waits for the program's direct process. A program that daemonizes and exits returns its result
+ * while its daemon keeps the scope active; the scope ends when its last process exits. The daemon
+ * must not keep the program's stdout or stderr open, or the call runs into its timeout.
+ *
+ * On `timed_out` and `output_limit` the direct process is killed; processes it started stay in
+ * the scope. A program that exits with a failure status is a result, not an error.
+ */
+export declare const runInTransientScope: (options: ISystemdTransientScopeOptions) => Promise<ISystemdTransientScopeResult>;

package/dist_ts/classes.systemdtransientscope.js

@@ -0,0 +1,204 @@
+import * as plugins from './smartdaemon.plugins.js';
+import { isCleanText } from './systemd.definition.js';
+import { captureUserEnvironment, inspectRuntimeDirectory, isSafeDirectory } from './systemd.userenvironment.js';
+export class SystemdTransientScopeError extends Error {
+    constructor(code, 
+    /** The scope the call used; null when the options were refused. */
+    unitName, 
+    /** The probe's or systemd-run's stderr as far as it was read; empty when none ran. */
+    stderr, options) {
+        super(`Systemd transient scope failed: ${code}${unitName === null ? '' : ` (${unitName})`}.`, options);
+        this.code = code;
+        this.unitName = unitName;
+        this.stderr = stderr;
+        this.name = 'SystemdTransientScopeError';
+    }
+}
+const outputLimit = 1048576;
+const reservedName = (name) => name === 'XDG_RUNTIME_DIR' || name === 'INVOCATION_ID' || name.startsWith('SYSTEMD_') || name.startsWith('DBUS_');
+/** Reads every option once through its own data descriptor, so no accessor or proxy trap runs. */
+const validate = (options) => {
+    const plain = (value, prototype) => value !== null &&
+        typeof value === 'object' && !plugins.util.types.isProxy(value) && Object.getPrototypeOf(value) === prototype;
+    if (!plain(options, Object.prototype))
+        return undefined;
+    const required = ['scope', 'executable', 'args', 'workingDirectory', 'environment', 'description'];
+    const optional = ['unitName', 'runtimeDirectory', 'systemdRunPath', 'systemctlPath', 'commandTimeoutMs'];
+    const values = new Map();
+    for (const key of Reflect.ownKeys(options)) {
+        const descriptor = Object.getOwnPropertyDescriptor(options, key);
+        if (typeof key !== 'string' || ![...required, ...optional].includes(key) || !descriptor?.enumerable ||
+            !('value' in descriptor))
+            return undefined;
+        if (descriptor.value !== undefined)
+            values.set(key, descriptor.value);
+    }
+    if (!required.every((key) => values.has(key)) || values.get('scope') !== 'user')
+        return undefined;
+    const path = (value) => isSafeDirectory(value);
+    const bounded = (value) => typeof value === 'string' && value.length <= 32768 && !value.includes('\0');
+    const executable = values.get('executable');
+    const workingDirectory = values.get('workingDirectory');
+    const description = values.get('description');
+    if (!path(executable) || !(workingDirectory === '/' || path(workingDirectory)) ||
+        typeof description !== 'string' || description.length < 1 || description.length > 1024 ||
+        description.trim() !== description || description.includes('\\') || !isCleanText(description))
+        return undefined;
+    const argsValue = values.get('args');
+    if (!plain(argsValue, Array.prototype) || !Array.isArray(argsValue) || argsValue.length > 128 ||
+        Reflect.ownKeys(argsValue).length !== argsValue.length + 1)
+        return undefined;
+    const args = [];
+    for (let index = 0; index < argsValue.length; index++) {
+        const descriptor = Object.getOwnPropertyDescriptor(argsValue, String(index));
+        if (!descriptor || !('value' in descriptor) || !bounded(descriptor.value))
+            return undefined;
+        args.push(descriptor.value);
+    }
+    const variables = values.get('environment');
+    if (!plain(variables, Object.prototype))
+        return undefined;
+    const names = Reflect.ownKeys(variables);
+    if (names.length > 256)
+        return undefined;
+    const environment = new Map();
+    for (const name of names) {
+        const descriptor = Object.getOwnPropertyDescriptor(variables, name);
+        if (typeof name !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(name) || reservedName(name) ||
+            !descriptor?.enumerable || !('value' in descriptor) || !bounded(descriptor.value))
+            return undefined;
+        environment.set(name, descriptor.value);
+    }
+    const unitName = values.get('unitName') ?? `smartdaemon-${plugins.crypto.randomUUID().replaceAll('-', '')}.scope`;
+    const runtimeDirectory = values.get('runtimeDirectory');
+    const systemdRunPath = values.get('systemdRunPath') ?? '/usr/bin/systemd-run';
+    const systemctlPath = values.get('systemctlPath') ?? '/usr/bin/systemctl';
+    const timeoutMs = values.get('commandTimeoutMs') ?? 120000;
+    if (typeof unitName !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,230}\.scope$/.test(unitName) ||
+        (runtimeDirectory !== undefined && !path(runtimeDirectory)) || !path(systemdRunPath) || !path(systemctlPath) ||
+        !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 600000)
+        return undefined;
+    return {
+        executable, args, workingDirectory, environment, description, unitName, runtimeDirectory, systemdRunPath,
+        systemctlPath, timeoutMs: timeoutMs,
+    };
+};
+/**
+ * Runs a program with stdin on /dev/null and bounded output. It settles once the process has exited
+ * and its stdout and stderr have closed; on the deadline or an output overflow it kills the process
+ * if it still runs and releases both pipes, so a descendant holding them keeps no handle open here.
+ */
+const runProcess = (file, args, env, timeoutMs) => new Promise((resolve) => {
+    const child = plugins.childProcess.spawn(file, args, {
+        cwd: '/', env, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true,
+    });
+    const output = { stdout: [], stderr: [] };
+    const sizes = { stdout: 0, stderr: 0 };
+    let settled = false;
+    const text = (chunks) => Buffer.concat(chunks).toString('utf8');
+    const abandon = (kind) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        if (child.exitCode === null && child.signalCode === null)
+            child.kill('SIGKILL');
+        child.stdout.destroy();
+        child.stderr.destroy();
+        resolve({ kind, stderr: text(output.stderr) });
+    };
+    const timer = setTimeout(() => abandon('timed_out'), timeoutMs);
+    for (const stream of ['stdout', 'stderr']) {
+        child[stream].on('data', (chunk) => {
+            sizes[stream] += chunk.length;
+            if (sizes[stream] > outputLimit)
+                abandon('output_limit');
+            else
+                output[stream].push(chunk);
+        });
+    }
+    child.on('error', (error) => {
+        if (settled || child.pid !== undefined)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        resolve({ kind: 'spawn_failed', error });
+    });
+    child.on('close', (code, signal) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        resolve({ kind: 'exited', code, signal, stdout: text(output.stdout), stderr: text(output.stderr) });
+    });
+});
+/**
+ * The first stderr line systemd-run prints once the scope runs, before it executes the program:
+ * systemd 255 and later print `Running as unit: NAME` with an optional `; invocation ID: ID`,
+ * systemd 254 prints `Running scope as unit: NAME`. Returns the rest of stderr, or undefined.
+ */
+const programStderr = (stderr, unitName) => {
+    const newline = stderr.indexOf('\n');
+    if (newline < 0)
+        return undefined;
+    const line = stderr.slice(0, newline);
+    const started = line === `Running as unit: ${unitName}` || line === `Running scope as unit: ${unitName}` ||
+        (line.startsWith(`Running as unit: ${unitName}; invocation ID: `) &&
+            /^[0-9a-f]{32}$/.test(line.slice(`Running as unit: ${unitName}; invocation ID: `.length)));
+    return started ? stderr.slice(newline + 1) : undefined;
+};
+/**
+ * Starts a program in a new transient scope unit of the calling user's systemd manager, so it and
+ * every process it starts run outside the caller's own unit and survive that unit's stop, and
+ * waits for the program's direct process. A program that daemonizes and exits returns its result
+ * while its daemon keeps the scope active; the scope ends when its last process exits. The daemon
+ * must not keep the program's stdout or stderr open, or the call runs into its timeout.
+ *
+ * On `timed_out` and `output_limit` the direct process is killed; processes it started stay in
+ * the scope. A program that exits with a failure status is a result, not an error.
+ */
+export const runInTransientScope = async (options) => {
+    const validated = validate(options);
+    if (validated === undefined)
+        throw new SystemdTransientScopeError('invalid_options', null, '');
+    const { unitName } = validated;
+    const fail = (code, stderr = '', cause) => {
+        throw new SystemdTransientScopeError(code, unitName, stderr, cause === undefined ? undefined : { cause });
+    };
+    if (process.platform !== 'linux')
+        fail('unsupported_platform');
+    const runtimeDirectory = validated.runtimeDirectory ?? captureUserEnvironment(undefined).runtimeDirectory;
+    if (runtimeDirectory === undefined)
+        fail('user_manager_unavailable');
+    if (!isSafeDirectory(runtimeDirectory))
+        fail('invalid_options');
+    const admission = await inspectRuntimeDirectory(runtimeDirectory);
+    if (admission === 'absent')
+        fail('user_manager_unavailable');
+    if (admission !== 'private')
+        fail('invalid_options');
+    const probe = await runProcess(validated.systemctlPath, ['--user', '--no-ask-password', '--no-pager', 'show', '--property=Version'], { PATH: '/usr/bin:/bin', LANG: 'C', LC_ALL: 'C', XDG_RUNTIME_DIR: runtimeDirectory }, validated.timeoutMs);
+    if (probe.kind === 'timed_out')
+        fail('timed_out', probe.stderr);
+    if (probe.kind !== 'exited' || probe.code !== 0 || !probe.stdout.startsWith('Version=')) {
+        fail('user_manager_unavailable', probe.kind === 'spawn_failed' ? '' : probe.stderr, probe.kind === 'spawn_failed' ? probe.error : undefined);
+    }
+    // systemd-run registers its own process as the scope, then executes the program in place with
+    // its environment, so that environment is the program's own plus INVOCATION_ID.
+    const outcome = await runProcess(validated.systemdRunPath, [
+        '--user', '--scope', '--collect', '--no-ask-password', '--expand-environment=no',
+        `--unit=${unitName}`, `--description=${validated.description}`,
+        `--working-directory=${validated.workingDirectory}`, '--', validated.executable, ...validated.args,
+    ], { ...Object.fromEntries(validated.environment), XDG_RUNTIME_DIR: runtimeDirectory }, validated.timeoutMs);
+    if (outcome.kind === 'spawn_failed')
+        return fail('scope_start_failed', '', outcome.error);
+    if (outcome.kind !== 'exited')
+        return fail(outcome.kind, outcome.stderr);
+    const stderr = programStderr(outcome.stderr, unitName);
+    if (stderr === undefined)
+        return fail('scope_start_failed', outcome.stderr);
+    return Object.freeze({
+        unitName, exitCode: outcome.code, signal: outcome.signal, stdout: outcome.stdout, stderr,
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.systemdtransientscope.js","sourceRoot":"","sources":["../ts/classes.systemdtransientscope.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.systemdunit.js

@@ -1,5 +1,5 @@
 import * as plugins from './smartdaemon.plugins.js';
-import { captureUserEnvironment, isSafeDirectory, isUserManagerEnvironment, } from './systemd.userenvironment.js';
+import { captureUserEnvironment, inspectRuntimeDirectory, isSafeDirectory, isUserManagerEnvironment, } from './systemd.userenvironment.js';
 import { environmentByteLimit, environmentVariableLimit, isCleanText } from './systemd.definition.js';
 export class SystemdUnitError extends Error {
     constructor(code) {
@@ -275,19 +275,7 @@ export class SystemdUnit {
             return undefined;
         if (!isUserManagerEnvironment(environment))
             throw new SystemdUnitError('invalid_options');
-        const runtimeDirectory = environment.runtimeDirectory;
-        try {
-            const uid = process.getuid?.();
-            if (process.platform !== 'linux' || uid === undefined || process.geteuid?.() !== uid ||
-                await plugins.fs.realpath(runtimeDirectory) !== runtimeDirectory) {
-                throw new SystemdUnitError('invalid_options');
-            }
-            const info = await plugins.fs.lstat(runtimeDirectory);
-            if (!info.isDirectory() || info.isSymbolicLink() || info.uid !== uid ||
-                (info.mode & 0o077) !== 0)
-                throw new SystemdUnitError('invalid_options');
-        }
-        catch {
+        if (await inspectRuntimeDirectory(environment.runtimeDirectory) !== 'private') {
             throw new SystemdUnitError('invalid_options');
         }
         return environment;
@@ -319,4 +307,4 @@ export class SystemdUnit {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.systemdunit.js","sourceRoot":"","sources":["../ts/classes.systemdunit.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.systemdunit.js","sourceRoot":"","sources":["../ts/classes.systemdunit.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -3,3 +3,4 @@ export * from './smartdaemon.classes.service.js';
 export * from './classes.systemdunit.js';
 export * from './classes.systemdservicedefinition.js';
 export * from './classes.systemdunitfile.js';
+export * from './classes.systemdtransientscope.js';

package/dist_ts/index.js

@@ -3,4 +3,5 @@ export * from './smartdaemon.classes.service.js';
 export * from './classes.systemdunit.js';
 export * from './classes.systemdservicedefinition.js';
 export * from './classes.systemdunitfile.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsOEJBQThCLENBQUMifQ==
+export * from './classes.systemdtransientscope.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxvQ0FBb0MsQ0FBQyJ9

package/dist_ts/systemd.userenvironment.d.ts

@@ -31,3 +31,9 @@ export declare const captureUserEnvironment: (runtimeDirectoryOption: string | u
  * XDG config/data roots to systemctl, so all of them must be well formed before the first call.
  */
 export declare const isUserManagerEnvironment: (environment: ISystemdUserEnvironment) => environment is TSystemdUserManagerEnvironment;
+/**
+ * Admits a user-manager runtime directory: on Linux, for a process whose uid is its effective uid,
+ * the path must be its own real path and a directory owned by that uid without group or other
+ * permissions. `absent` is a directory that does not exist; every other refusal is `unsafe`.
+ */
+export declare const inspectRuntimeDirectory: (runtimeDirectory: string) => Promise<"private" | "absent" | "unsafe">;

package/dist_ts/systemd.userenvironment.js

@@ -30,4 +30,24 @@ export const captureUserEnvironment = (runtimeDirectoryOption) => {
 export const isUserManagerEnvironment = (environment) => isSafeDirectory(environment.runtimeDirectory) && isSafeDirectory(environment.homeDirectory) &&
     (environment.configDirectory === undefined || isSafeDirectory(environment.configDirectory)) &&
     (environment.dataDirectory === undefined || isSafeDirectory(environment.dataDirectory));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3lzdGVtZC51c2VyZW52aXJvbm1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zeXN0ZW1kLnVzZXJlbnZpcm9ubWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLDBCQUEwQixDQUFDO0FBeUJwRCw4RkFBOEY7QUFDOUYsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLENBQUMsS0FBYyxFQUFtQixFQUFFLENBQ2pFLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxLQUFLLEtBQUssR0FBRyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQztJQUM1RSxPQUFPLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsS0FBSyxLQUFLLElBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQztJQUMvRCxLQUFLLENBQUMsTUFBTSxJQUFJLElBQUksSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUV6RDs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxDQUNwQyxzQkFBMEMsRUFDakIsRUFBRTtJQUMzQixJQUFJLGFBQWlDLENBQUM7SUFDdEMsSUFBSSxDQUFDO1FBQ0gsYUFBYSxHQUFHLE9BQU8sQ0FBQyxFQUFFLENBQUMsUUFBUSxFQUFFLENBQUMsT0FBTyxDQUFDO0lBQ2hELENBQUM7SUFBQyxNQUFNLENBQUM7UUFDUCw0RkFBNEY7UUFDNUYsK0VBQStFO0lBQ2pGLENBQUM7SUFDRCxPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUM7UUFDbkIsYUFBYTtRQUNiLGVBQWUsRUFBRSxPQUFPLENBQUMsR0FBRyxDQUFDLGVBQWUsSUFBSSxTQUFTO1FBQ3pELGFBQWEsRUFBRSxPQUFPLENBQUMsR0FBRyxDQUFDLGFBQWEsSUFBSSxTQUFTO1FBQ3JELGdCQUFnQixFQUFFLHNCQUFzQixJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLElBQUksU0FBUyxDQUFDO0tBQ3ZGLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQztBQUVGOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFHLENBQ3RDLFdBQW9DLEVBQ1csRUFBRSxDQUNqRCxlQUFlLENBQUMsV0FBVyxDQUFDLGdCQUFnQixDQUFDLElBQUksZUFBZSxDQUFDLFdBQVcsQ0FBQyxhQUFhLENBQUM7SUFDM0YsQ0FBQyxXQUFXLENBQUMsZUFBZSxLQUFLLFNBQVMsSUFBSSxlQUFlLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBQzNGLENBQUMsV0FBVyxDQUFDLGFBQWEsS0FBSyxTQUFTLElBQUksZUFBZSxDQUFDLFdBQVcsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDIn0=
+/**
+ * Admits a user-manager runtime directory: on Linux, for a process whose uid is its effective uid,
+ * the path must be its own real path and a directory owned by that uid without group or other
+ * permissions. `absent` is a directory that does not exist; every other refusal is `unsafe`.
+ */
+export const inspectRuntimeDirectory = async (runtimeDirectory) => {
+    const uid = process.getuid?.();
+    if (process.platform !== 'linux' || uid === undefined || process.geteuid?.() !== uid)
+        return 'unsafe';
+    try {
+        if (await plugins.fs.realpath(runtimeDirectory) !== runtimeDirectory)
+            return 'unsafe';
+        const info = await plugins.fs.lstat(runtimeDirectory);
+        return info.isDirectory() && !info.isSymbolicLink() && info.uid === uid && (info.mode & 0o077) === 0
+            ? 'private' : 'unsafe';
+    }
+    catch (error) {
+        return error.code === 'ENOENT' ? 'absent' : 'unsafe';
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartdaemon",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "private": false,
   "description": "Start scripts as long running daemons and manage them.",
   "main": "dist_ts/index.js",

package/readme.md

@@ -605,6 +605,77 @@ other process in the unit survives, so the main process must own their shutdown
 deliberate retention (as with `Delegate=yes` workloads). A successful systemd start still requires application readiness
 verification, and a completed stop alone does not prove database drain.
 
+### Starting a program in its own transient scope
+
+A service that launches a long-lived program keeps that program in its own
+control group, so stopping the service ends the program too, even when the
+program detached itself with `setsid`. `runInTransientScope()` starts a program in
+a new transient scope unit of the calling user's systemd manager instead
+(`systemd-run --user --scope`): the program and every process it starts run in
+that scope and outlive the caller's unit. The call waits for the program's direct
+process and returns its result; a program that daemonizes and exits returns while
+its daemon keeps the scope active, and the scope ends when its last process exits.
+
+```typescript
+import { runInTransientScope, SystemdTransientScopeError } from '@push.rocks/smartdaemon';
+
+try {
+  const result = await runInTransientScope({
+    scope: 'user',
+    description: 'Codex app-server daemon',
+    executable: '/home/owner/.local/bin/codex',
+    args: ['app-server', 'daemon', 'start'],
+    workingDirectory: '/home/owner',
+    environment: { HOME: '/home/owner', CODEX_HOME: '/home/owner/.codex', PATH: '/usr/bin:/bin' },
+  });
+  console.log(result.unitName, result.exitCode, result.stdout);
+} catch (error) {
+  if (error instanceof SystemdTransientScopeError && error.code === 'user_manager_unavailable') {
+    // No user manager: the caller decides how to run the program without one.
+  }
+  throw error;
+}
+```
+
+The result holds the scope's `unitName`, the direct process's `exitCode` (or the
+`signal` that ended it), and its `stdout` and `stderr`, UTF-8 decoded. A failure
+status is a result, not an error. The program is executed directly from an
+absolute `executable` with literal `args`, with no shell, PATH search or `$`
+expansion (systemd 258 expands `$` in a scope's command line unless told not to,
+and the call always passes `--expand-environment=no`), in the absolute
+`workingDirectory`, with stdin on `/dev/null`. Its
+environment is exactly `environment` plus the manager's `XDG_RUNTIME_DIR` and
+systemd's `INVOCATION_ID`: nothing of the calling process is inherited, so pass
+every variable the program needs. `XDG_RUNTIME_DIR`, `INVOCATION_ID` and names
+starting with `SYSTEMD_` or `DBUS_`, which would configure systemd-run itself, are
+refused. `unitName` names the scope (a `.scope` name) and defaults to a unique
+`smartdaemon-<32 hex digits>.scope`; a scope of that name that is still active
+refuses a second start. The literal `description` is the unit's description.
+
+Failures throw `SystemdTransientScopeError` with the scope's `unitName` (null for
+refused options), the `stderr` read so far and one of these codes:
+
+| Code | Meaning |
+| --- | --- |
+| `invalid_options` | Malformed options, or a runtime directory that is not a private directory of the caller |
+| `unsupported_platform` | The process is not running on Linux |
+| `user_manager_unavailable` | No `XDG_RUNTIME_DIR` (or `runtimeDirectory`), a runtime directory that does not exist, or a manager that does not answer `systemctl --user` |
+| `scope_start_failed` | systemd-run exited without reporting the scope running; the program has not run |
+| `timed_out` | The manager probe or the program did not finish and close its output within `commandTimeoutMs` |
+| `output_limit` | The program's stdout or stderr exceeded 1 MiB |
+
+The call completes once the direct process has exited and its stdout and stderr
+have closed, so a daemon must not keep them open (Codex, for example, redirects
+its daemon's output); otherwise the call runs into its timeout. On `timed_out` and
+`output_limit` the direct process is killed and the processes it started stay in
+the scope. `commandTimeoutMs` (default 120000, maximum 600000) bounds the probe
+and the program each. Trusted owning code can set `runtimeDirectory` and the
+absolute `systemdRunPath` and `systemctlPath`. systemd-run reports the started
+scope as its first stderr line, which systemd 254 and later print; an older
+systemd-run, which lacks `--expand-environment`, fails with `scope_start_failed`.
+If the program cannot be executed after the scope started, systemd-run reports
+that as the program's exit status 1.
+
 ### SmartDaemonService Class
 
 ```typescript

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartdaemon',
-  version: '2.11.0',
+  version: '2.12.0',
   description: 'Start scripts as long running daemons and manage them.'
 }

package/ts/classes.systemdtransientscope.ts

@@ -0,0 +1,272 @@
+import * as plugins from './smartdaemon.plugins.js';
+import { isCleanText } from './systemd.definition.js';
+import { captureUserEnvironment, inspectRuntimeDirectory, isSafeDirectory } from './systemd.userenvironment.js';
+
+export interface ISystemdTransientScopeOptions {
+  /** The calling user's manager; the only manager a transient scope is started in. */
+  scope: 'user';
+  /** Absolute, normalized program path, executed directly: no shell, no PATH search. */
+  executable: string;
+  /** Literal arguments, at most 128 of at most 32768 characters each, without NUL. */
+  args: readonly string[];
+  /** Absolute, normalized directory the program starts in. */
+  workingDirectory: string;
+  /**
+   * The program's complete environment. Nothing of the calling process is inherited: the program
+   * receives exactly these variables, the manager's `XDG_RUNTIME_DIR` and systemd's
+   * `INVOCATION_ID`. Names match `[A-Za-z_][A-Za-z0-9_]*` (at most 128 characters); values are
+   * strings of at most 32768 characters without NUL; at most 256 variables. `XDG_RUNTIME_DIR`,
+   * `INVOCATION_ID` and names starting with `SYSTEMD_` or `DBUS_`, which configure systemd-run
+   * itself, are refused.
+   */
+  environment: Readonly<Record<string, string>>;
+  /** Literal unit description: clean text of 1 to 1024 characters, trimmed, without `\`. */
+  description: string;
+  /** A `.scope` unit name; defaults to a unique `smartdaemon-<32 hex digits>.scope`. */
+  unitName?: string;
+  /** User-manager socket directory. Defaults to a non-empty XDG_RUNTIME_DIR. */
+  runtimeDirectory?: string;
+  /** Absolute executable path supplied by trusted owning code. Defaults to `/usr/bin/systemd-run`. */
+  systemdRunPath?: string;
+  /** Absolute executable path supplied by trusted owning code. Defaults to `/usr/bin/systemctl`. */
+  systemctlPath?: string;
+  /** Bounds the manager probe and the program's direct process, each. Defaults to 120 seconds. */
+  commandTimeoutMs?: number;
+}
+
+export interface ISystemdTransientScopeResult {
+  /** The scope unit. It stays active while any process the program started runs in it. */
+  readonly unitName: string;
+  /** Exit status of the program's direct process; null when a signal ended it. */
+  readonly exitCode: number | null;
+  readonly signal: NodeJS.Signals | null;
+  /** UTF-8 decoded output of the program and every process that shared its stdout. */
+  readonly stdout: string;
+  /** As `stdout`, without the line systemd-run prints on starting the scope. */
+  readonly stderr: string;
+}
+
+export type TSystemdTransientScopeErrorCode =
+  /** The options are malformed, or the runtime directory is not a private directory of the caller. */
+  | 'invalid_options'
+  /** The process is not running on Linux. */
+  | 'unsupported_platform'
+  /** No runtime directory is set or it does not exist, or the manager does not answer systemctl. */
+  | 'user_manager_unavailable'
+  /** systemd-run exited without reporting the scope running; the program has not run. */
+  | 'scope_start_failed'
+  /** The manager probe or the program did not finish, and close its output, in time. */
+  | 'timed_out'
+  /** The program's stdout or stderr exceeded 1 MiB. */
+  | 'output_limit';
+
+export class SystemdTransientScopeError extends Error {
+  constructor(
+    public readonly code: TSystemdTransientScopeErrorCode,
+    /** The scope the call used; null when the options were refused. */
+    public readonly unitName: string | null,
+    /** The probe's or systemd-run's stderr as far as it was read; empty when none ran. */
+    public readonly stderr: string,
+    options?: ErrorOptions,
+  ) {
+    super(`Systemd transient scope failed: ${code}${unitName === null ? '' : ` (${unitName})`}.`, options);
+    this.name = 'SystemdTransientScopeError';
+  }
+}
+
+const outputLimit = 1048576;
+const reservedName = (name: string) =>
+  name === 'XDG_RUNTIME_DIR' || name === 'INVOCATION_ID' || name.startsWith('SYSTEMD_') || name.startsWith('DBUS_');
+
+interface IValidatedOptions {
+  readonly executable: string;
+  readonly args: readonly string[];
+  readonly workingDirectory: string;
+  readonly environment: ReadonlyMap<string, string>;
+  readonly description: string;
+  readonly unitName: string;
+  readonly runtimeDirectory?: string;
+  readonly systemdRunPath: string;
+  readonly systemctlPath: string;
+  readonly timeoutMs: number;
+}
+
+/** Reads every option once through its own data descriptor, so no accessor or proxy trap runs. */
+const validate = (options: unknown): IValidatedOptions | undefined => {
+  const plain = (value: unknown, prototype: object): value is object => value !== null &&
+    typeof value === 'object' && !plugins.util.types.isProxy(value) && Object.getPrototypeOf(value) === prototype;
+  if (!plain(options, Object.prototype)) return undefined;
+  const required = ['scope', 'executable', 'args', 'workingDirectory', 'environment', 'description'];
+  const optional = ['unitName', 'runtimeDirectory', 'systemdRunPath', 'systemctlPath', 'commandTimeoutMs'];
+  const values = new Map<string, unknown>();
+  for (const key of Reflect.ownKeys(options)) {
+    const descriptor = Object.getOwnPropertyDescriptor(options, key);
+    if (typeof key !== 'string' || ![...required, ...optional].includes(key) || !descriptor?.enumerable ||
+      !('value' in descriptor)) return undefined;
+    if (descriptor.value !== undefined) values.set(key, descriptor.value);
+  }
+  if (!required.every((key) => values.has(key)) || values.get('scope') !== 'user') return undefined;
+  const path = (value: unknown): value is string => isSafeDirectory(value);
+  const bounded = (value: unknown): value is string =>
+    typeof value === 'string' && value.length <= 32768 && !value.includes('\0');
+
+  const executable = values.get('executable');
+  const workingDirectory = values.get('workingDirectory');
+  const description = values.get('description');
+  if (!path(executable) || !(workingDirectory === '/' || path(workingDirectory)) ||
+    typeof description !== 'string' || description.length < 1 || description.length > 1024 ||
+    description.trim() !== description || description.includes('\\') || !isCleanText(description)) return undefined;
+
+  const argsValue = values.get('args');
+  if (!plain(argsValue, Array.prototype) || !Array.isArray(argsValue) || argsValue.length > 128 ||
+    Reflect.ownKeys(argsValue).length !== argsValue.length + 1) return undefined;
+  const args: string[] = [];
+  for (let index = 0; index < argsValue.length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(argsValue, String(index));
+    if (!descriptor || !('value' in descriptor) || !bounded(descriptor.value)) return undefined;
+    args.push(descriptor.value);
+  }
+
+  const variables = values.get('environment');
+  if (!plain(variables, Object.prototype)) return undefined;
+  const names = Reflect.ownKeys(variables);
+  if (names.length > 256) return undefined;
+  const environment = new Map<string, string>();
+  for (const name of names) {
+    const descriptor = Object.getOwnPropertyDescriptor(variables, name);
+    if (typeof name !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(name) || reservedName(name) ||
+      !descriptor?.enumerable || !('value' in descriptor) || !bounded(descriptor.value)) return undefined;
+    environment.set(name, descriptor.value);
+  }
+
+  const unitName = values.get('unitName') ?? `smartdaemon-${plugins.crypto.randomUUID().replaceAll('-', '')}.scope`;
+  const runtimeDirectory = values.get('runtimeDirectory');
+  const systemdRunPath = values.get('systemdRunPath') ?? '/usr/bin/systemd-run';
+  const systemctlPath = values.get('systemctlPath') ?? '/usr/bin/systemctl';
+  const timeoutMs = values.get('commandTimeoutMs') ?? 120000;
+  if (typeof unitName !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,230}\.scope$/.test(unitName) ||
+    (runtimeDirectory !== undefined && !path(runtimeDirectory)) || !path(systemdRunPath) || !path(systemctlPath) ||
+    !Number.isSafeInteger(timeoutMs) || (timeoutMs as number) < 1 || (timeoutMs as number) > 600000) return undefined;
+  return {
+    executable, args, workingDirectory, environment, description, unitName, runtimeDirectory, systemdRunPath,
+    systemctlPath, timeoutMs: timeoutMs as number,
+  };
+};
+
+type TProcessOutcome =
+  | { readonly kind: 'exited'; readonly code: number | null; readonly signal: NodeJS.Signals | null;
+    readonly stdout: string; readonly stderr: string }
+  | { readonly kind: 'spawn_failed'; readonly error: Error }
+  | { readonly kind: 'timed_out' | 'output_limit'; readonly stderr: string };
+
+/**
+ * Runs a program with stdin on /dev/null and bounded output. It settles once the process has exited
+ * and its stdout and stderr have closed; on the deadline or an output overflow it kills the process
+ * if it still runs and releases both pipes, so a descendant holding them keeps no handle open here.
+ */
+const runProcess = (file: string, args: readonly string[], env: Record<string, string>, timeoutMs: number) =>
+  new Promise<TProcessOutcome>((resolve) => {
+    const child = plugins.childProcess.spawn(file, args, {
+      cwd: '/', env, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true,
+    });
+    const output = { stdout: [] as Buffer[], stderr: [] as Buffer[] };
+    const sizes = { stdout: 0, stderr: 0 };
+    let settled = false;
+    const text = (chunks: Buffer[]) => Buffer.concat(chunks).toString('utf8');
+    const abandon = (kind: 'timed_out' | 'output_limit') => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL');
+      child.stdout.destroy();
+      child.stderr.destroy();
+      resolve({ kind, stderr: text(output.stderr) });
+    };
+    const timer = setTimeout(() => abandon('timed_out'), timeoutMs);
+    for (const stream of ['stdout', 'stderr'] as const) {
+      child[stream].on('data', (chunk: Buffer) => {
+        sizes[stream] += chunk.length;
+        if (sizes[stream] > outputLimit) abandon('output_limit');
+        else output[stream].push(chunk);
+      });
+    }
+    child.on('error', (error) => {
+      if (settled || child.pid !== undefined) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ kind: 'spawn_failed', error });
+    });
+    child.on('close', (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ kind: 'exited', code, signal, stdout: text(output.stdout), stderr: text(output.stderr) });
+    });
+  });
+
+/**
+ * The first stderr line systemd-run prints once the scope runs, before it executes the program:
+ * systemd 255 and later print `Running as unit: NAME` with an optional `; invocation ID: ID`,
+ * systemd 254 prints `Running scope as unit: NAME`. Returns the rest of stderr, or undefined.
+ */
+const programStderr = (stderr: string, unitName: string): string | undefined => {
+  const newline = stderr.indexOf('\n');
+  if (newline < 0) return undefined;
+  const line = stderr.slice(0, newline);
+  const started = line === `Running as unit: ${unitName}` || line === `Running scope as unit: ${unitName}` ||
+    (line.startsWith(`Running as unit: ${unitName}; invocation ID: `) &&
+      /^[0-9a-f]{32}$/.test(line.slice(`Running as unit: ${unitName}; invocation ID: `.length)));
+  return started ? stderr.slice(newline + 1) : undefined;
+};
+
+/**
+ * Starts a program in a new transient scope unit of the calling user's systemd manager, so it and
+ * every process it starts run outside the caller's own unit and survive that unit's stop, and
+ * waits for the program's direct process. A program that daemonizes and exits returns its result
+ * while its daemon keeps the scope active; the scope ends when its last process exits. The daemon
+ * must not keep the program's stdout or stderr open, or the call runs into its timeout.
+ *
+ * On `timed_out` and `output_limit` the direct process is killed; processes it started stay in
+ * the scope. A program that exits with a failure status is a result, not an error.
+ */
+export const runInTransientScope = async (
+  options: ISystemdTransientScopeOptions,
+): Promise<ISystemdTransientScopeResult> => {
+  const validated = validate(options);
+  if (validated === undefined) throw new SystemdTransientScopeError('invalid_options', null, '');
+  const { unitName } = validated;
+  const fail = (code: TSystemdTransientScopeErrorCode, stderr = '', cause?: unknown): never => {
+    throw new SystemdTransientScopeError(code, unitName, stderr, cause === undefined ? undefined : { cause });
+  };
+  if (process.platform !== 'linux') fail('unsupported_platform');
+  const runtimeDirectory = validated.runtimeDirectory ?? captureUserEnvironment(undefined).runtimeDirectory;
+  if (runtimeDirectory === undefined) fail('user_manager_unavailable');
+  if (!isSafeDirectory(runtimeDirectory)) fail('invalid_options');
+  const admission = await inspectRuntimeDirectory(runtimeDirectory!);
+  if (admission === 'absent') fail('user_manager_unavailable');
+  if (admission !== 'private') fail('invalid_options');
+
+  const probe = await runProcess(validated.systemctlPath,
+    ['--user', '--no-ask-password', '--no-pager', 'show', '--property=Version'],
+    { PATH: '/usr/bin:/bin', LANG: 'C', LC_ALL: 'C', XDG_RUNTIME_DIR: runtimeDirectory! }, validated.timeoutMs);
+  if (probe.kind === 'timed_out') fail('timed_out', probe.stderr);
+  if (probe.kind !== 'exited' || probe.code !== 0 || !probe.stdout.startsWith('Version=')) {
+    fail('user_manager_unavailable', probe.kind === 'spawn_failed' ? '' : probe.stderr,
+      probe.kind === 'spawn_failed' ? probe.error : undefined);
+  }
+
+  // systemd-run registers its own process as the scope, then executes the program in place with
+  // its environment, so that environment is the program's own plus INVOCATION_ID.
+  const outcome = await runProcess(validated.systemdRunPath, [
+    '--user', '--scope', '--collect', '--no-ask-password', '--expand-environment=no',
+    `--unit=${unitName}`, `--description=${validated.description}`,
+    `--working-directory=${validated.workingDirectory}`, '--', validated.executable, ...validated.args,
+  ], { ...Object.fromEntries(validated.environment), XDG_RUNTIME_DIR: runtimeDirectory! }, validated.timeoutMs);
+  if (outcome.kind === 'spawn_failed') return fail('scope_start_failed', '', outcome.error);
+  if (outcome.kind !== 'exited') return fail(outcome.kind, outcome.stderr);
+  const stderr = programStderr(outcome.stderr, unitName);
+  if (stderr === undefined) return fail('scope_start_failed', outcome.stderr);
+  return Object.freeze({
+    unitName, exitCode: outcome.code, signal: outcome.signal, stdout: outcome.stdout, stderr,
+  });
+};

package/ts/classes.systemdunit.ts

@@ -3,6 +3,7 @@ import {
   type ISystemdUserEnvironment,
   type TSystemdUserManagerEnvironment,
   captureUserEnvironment,
+  inspectRuntimeDirectory,
   isSafeDirectory,
   isUserManagerEnvironment,
 } from './systemd.userenvironment.js';
@@ -371,17 +372,7 @@ export class SystemdUnit {
     const environment = this.userEnvironment;
     if (environment === undefined) return undefined;
     if (!isUserManagerEnvironment(environment)) throw new SystemdUnitError('invalid_options');
-    const runtimeDirectory = environment.runtimeDirectory;
-    try {
-      const uid = process.getuid?.();
-      if (process.platform !== 'linux' || uid === undefined || process.geteuid?.() !== uid ||
-        await plugins.fs.realpath(runtimeDirectory) !== runtimeDirectory) {
-        throw new SystemdUnitError('invalid_options');
-      }
-      const info = await plugins.fs.lstat(runtimeDirectory);
-      if (!info.isDirectory() || info.isSymbolicLink() || info.uid !== uid ||
-        (info.mode & 0o077) !== 0) throw new SystemdUnitError('invalid_options');
-    } catch {
+    if (await inspectRuntimeDirectory(environment.runtimeDirectory) !== 'private') {
       throw new SystemdUnitError('invalid_options');
     }
     return environment;

package/ts/index.ts

@@ -3,3 +3,4 @@ export * from './smartdaemon.classes.service.js';
 export * from './classes.systemdunit.js';
 export * from './classes.systemdservicedefinition.js';
 export * from './classes.systemdunitfile.js';
+export * from './classes.systemdtransientscope.js';

package/ts/systemd.userenvironment.ts

@@ -61,3 +61,23 @@ export const isUserManagerEnvironment = (
   isSafeDirectory(environment.runtimeDirectory) && isSafeDirectory(environment.homeDirectory) &&
   (environment.configDirectory === undefined || isSafeDirectory(environment.configDirectory)) &&
   (environment.dataDirectory === undefined || isSafeDirectory(environment.dataDirectory));
+
+/**
+ * Admits a user-manager runtime directory: on Linux, for a process whose uid is its effective uid,
+ * the path must be its own real path and a directory owned by that uid without group or other
+ * permissions. `absent` is a directory that does not exist; every other refusal is `unsafe`.
+ */
+export const inspectRuntimeDirectory = async (
+  runtimeDirectory: string,
+): Promise<'private' | 'absent' | 'unsafe'> => {
+  const uid = process.getuid?.();
+  if (process.platform !== 'linux' || uid === undefined || process.geteuid?.() !== uid) return 'unsafe';
+  try {
+    if (await plugins.fs.realpath(runtimeDirectory) !== runtimeDirectory) return 'unsafe';
+    const info = await plugins.fs.lstat(runtimeDirectory);
+    return info.isDirectory() && !info.isSymbolicLink() && info.uid === uid && (info.mode & 0o077) === 0
+      ? 'private' : 'unsafe';
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === 'ENOENT' ? 'absent' : 'unsafe';
+  }
+};