@push.rocks/smartdaemon 2.21.0 → 2.22.0

package/dist_ts_systemdruntime/classes.systemdnotifier.js

@@ -0,0 +1,217 @@
+import { SystemdRuntimeError } from './classes.systemdruntimeerror.js';
+import { controlSpace, descriptorsPerMessageMaximum, libcConstants, socketAddressLength, systemdLibc, writeSocketAddress, } from './systemdruntime.libc.js';
+import { assertSystemdDescriptor, assertSystemdNotifySocketAddress, isSystemdDescriptorName, } from './systemdruntime.validation.js';
+/** `NOTIFY_BUFFER_MAX` (`PIPE_BUF`): systemd ignores a longer notification message. */
+export const notifyMessageMaximumBytes = 4096;
+/**
+ * Takes `NOTIFY_SOCKET` out of the environment: the validated address, or null when it is unset or
+ * empty. An address that is set but invalid is removed as well and then refused
+ * (`notify_socket_invalid`).
+ */
+export const takeSystemdNotifySocket = (optionsArg = {}) => {
+    const env = optionsArg.env ?? process.env;
+    const address = env.NOTIFY_SOCKET;
+    delete env.NOTIFY_SOCKET;
+    if (address === undefined || address === '')
+        return null;
+    assertSystemdNotifySocketAddress(address);
+    return address;
+};
+const fieldNamePattern = /^[A-Z][A-Z0-9_]*$/;
+/**
+ * Sends `sd_notify(3)` messages to a service manager's notification socket: one `AF_UNIX`
+ * `SOCK_DGRAM` datagram per message, descriptors attached as `SCM_RIGHTS`. Every call is synchronous
+ * and either delivers the whole message to the socket or throws a `SystemdRuntimeError`; whether
+ * the manager acts on it depends on the unit's `NotifyAccess=`. Fields and descriptor names are
+ * validated before sending, because systemd ignores a message it cannot parse without telling the
+ * sender.
+ */
+export class SystemdNotifier {
+    /**
+     * The notifier for the unit that started this process, or null when `NOTIFY_SOCKET` is unset or
+     * empty — the process was not started by a service manager that listens. The caller decides what
+     * that means; nothing is sent silently nowhere. An invalid `NOTIFY_SOCKET` throws
+     * `notify_socket_invalid`.
+     */
+    static fromEnvironment(optionsArg = {}) {
+        const env = optionsArg.env ?? process.env;
+        const address = optionsArg.take === true ? takeSystemdNotifySocket({ env }) : env.NOTIFY_SOCKET;
+        if (address === undefined || address === null || address === '')
+            return null;
+        return new SystemdNotifier(address);
+    }
+    constructor(socketAddressArg) {
+        assertSystemdNotifySocketAddress(socketAddressArg);
+        this.socketAddress = socketAddressArg;
+    }
+    /** `READY=1`, with an optional `STATUS=`. */
+    ready(statusArg) {
+        this.send({ READY: '1', ...(statusArg === undefined ? {} : { STATUS: statusArg }) });
+    }
+    /** `STATUS=`: free-form text the manager shows as the unit's status. */
+    status(textArg) {
+        this.send({ STATUS: textArg });
+    }
+    /** `STOPPING=1`, with an optional `STATUS=`. */
+    stopping(statusArg) {
+        this.send({ STOPPING: '1', ...(statusArg === undefined ? {} : { STATUS: statusArg }) });
+    }
+    /**
+     * `RELOADING=1` with `MONOTONIC_USEC=` (`CLOCK_MONOTONIC` now), with an optional `STATUS=`. The
+     * service sends `ready()` once the reload finished.
+     */
+    reloading(statusArg) {
+        this.send({
+            RELOADING: '1',
+            MONOTONIC_USEC: String(monotonicMicroseconds()),
+            ...(statusArg === undefined ? {} : { STATUS: statusArg }),
+        });
+    }
+    /** `WATCHDOG=1`: keeps a `WatchdogSec=` unit alive. */
+    watchdog() {
+        this.send({ WATCHDOG: '1' });
+    }
+    /**
+     * `EXTEND_TIMEOUT_USEC=`: asks the manager to wait `microsecondsArg` longer for the current start,
+     * runtime-start, stop or watchdog deadline, with an optional `STATUS=`.
+     */
+    extendTimeout(microsecondsArg, statusArg) {
+        if (!Number.isSafeInteger(microsecondsArg) || microsecondsArg <= 0) {
+            throw new SystemdRuntimeError('notify_field_invalid', 'EXTEND_TIMEOUT_USEC must be a positive integer.');
+        }
+        this.send({
+            EXTEND_TIMEOUT_USEC: String(microsecondsArg),
+            ...(statusArg === undefined ? {} : { STATUS: statusArg }),
+        });
+    }
+    /**
+     * `FDSTORE=1` with `FDNAME=`: the manager keeps duplicates of `descriptorsArg` (1–253) under
+     * `nameArg` in the unit's descriptor store (`FileDescriptorStoreMax=`) and passes them to the
+     * next main process through `LISTEN_FDS`. Storing does not replace descriptors already stored
+     * under the name; `replaceDescriptors()` does.
+     */
+    storeDescriptors(nameArg, descriptorsArg, optionsArg = {}) {
+        assertDescriptorName(nameArg);
+        assertStoredDescriptors(descriptorsArg);
+        this.send({ FDSTORE: '1', FDNAME: nameArg, ...(optionsArg.poll === false ? { FDPOLL: '0' } : {}) }, descriptorsArg);
+    }
+    /** `FDSTOREREMOVE=1` with `FDNAME=`: the manager closes every descriptor stored under `nameArg`. */
+    removeDescriptors(nameArg) {
+        assertDescriptorName(nameArg);
+        this.send({ FDSTOREREMOVE: '1', FDNAME: nameArg });
+    }
+    /**
+     * Removes the descriptors stored under `nameArg`, then stores `descriptorsArg` under it: two
+     * messages, handled by the manager in order. Between them the store holds nothing under the name.
+     */
+    replaceDescriptors(nameArg, descriptorsArg, optionsArg = {}) {
+        assertDescriptorName(nameArg);
+        assertStoredDescriptors(descriptorsArg);
+        this.removeDescriptors(nameArg);
+        this.storeDescriptors(nameArg, descriptorsArg, optionsArg);
+    }
+    /**
+     * Sends one message: `NAME=value` fields in insertion order, joined by newlines, and up to 253
+     * descriptors. Names are upper-case (`A–Z`, digits, `_`); values carry no newline or NUL; the
+     * message is at most 4096 bytes.
+     */
+    send(fieldsArg, descriptorsArg = []) {
+        const entries = Object.entries(fieldsArg);
+        if (entries.length === 0) {
+            throw new SystemdRuntimeError('notify_field_invalid', 'A notification needs at least one field.');
+        }
+        for (const [name, value] of entries) {
+            if (!fieldNamePattern.test(name)) {
+                throw new SystemdRuntimeError('notify_field_invalid', `${JSON.stringify(name)} is not a notification field name.`);
+            }
+            if (typeof value !== 'string' || /[\n\0]/.test(value)) {
+                throw new SystemdRuntimeError('notify_field_invalid', `The ${name} value must be a string without newline or NUL.`);
+            }
+        }
+        assertDescriptorList(descriptorsArg);
+        const payload = Buffer.from(entries.map(([name, value]) => `${name}=${value}`).join('\n'), 'utf8');
+        if (payload.length > notifyMessageMaximumBytes) {
+            throw new SystemdRuntimeError('notify_field_invalid', `The message is ${payload.length} bytes; systemd reads at most ${notifyMessageMaximumBytes}.`);
+        }
+        sendDatagram(this.socketAddress, payload, descriptorsArg);
+    }
+}
+const assertDescriptorName = (nameArg) => {
+    if (!isSystemdDescriptorName(nameArg, true)) {
+        throw new SystemdRuntimeError('descriptor_name_invalid', 'A descriptor name is 1–255 printable ASCII characters without ":".');
+    }
+};
+/** At most 253 valid descriptor numbers. */
+const assertDescriptorList = (descriptorsArg) => {
+    if (descriptorsArg.length > descriptorsPerMessageMaximum) {
+        throw new SystemdRuntimeError('descriptor_invalid', `One message carries at most ${descriptorsPerMessageMaximum} descriptors.`);
+    }
+    descriptorsArg.forEach(assertSystemdDescriptor);
+};
+/** 1–253 valid descriptor numbers, as `FDSTORE=1` needs. */
+const assertStoredDescriptors = (descriptorsArg) => {
+    if (descriptorsArg.length === 0) {
+        throw new SystemdRuntimeError('descriptor_invalid', 'FDSTORE=1 needs at least one descriptor.');
+    }
+    assertDescriptorList(descriptorsArg);
+};
+/** `CLOCK_MONOTONIC` in microseconds, as `MONOTONIC_USEC=` expects. */
+const monotonicMicroseconds = () => {
+    const libc = systemdLibc();
+    const timespec = Buffer.alloc(16);
+    if (libc.functions.clock_gettime(libcConstants.CLOCK_MONOTONIC, timespec) !== 0) {
+        throw new SystemdRuntimeError('notify_failed', 'clock_gettime(CLOCK_MONOTONIC) failed.', { errno: libc.errno() });
+    }
+    return timespec.readBigInt64LE(0) * 1000000n + timespec.readBigInt64LE(8) / 1000n;
+};
+// One block holds the whole message, so every pointer inside it stays valid while the block is
+// borrowed by the call: msghdr, iovec, sockaddr_un, control data, payload.
+const iovecOffset = 56;
+const addressOffset = 72;
+const controlOffset = 184;
+const sendDatagram = (addressArg, payloadArg, descriptorsArg) => {
+    const libc = systemdLibc();
+    const space = descriptorsArg.length === 0 ? 0 : controlSpace(descriptorsArg.length);
+    const payloadOffset = controlOffset + space;
+    const block = Buffer.alloc(payloadOffset + payloadArg.length);
+    const base = libc.ffi.getRawPointer(block);
+    writeSocketAddress(block, addressOffset, addressArg);
+    payloadArg.copy(block, payloadOffset);
+    block.writeBigUInt64LE(base + BigInt(addressOffset), 0);
+    block.writeUInt32LE(socketAddressLength(addressArg), 8);
+    block.writeBigUInt64LE(base + BigInt(iovecOffset), 16);
+    block.writeBigUInt64LE(1n, 24);
+    block.writeBigUInt64LE(base + BigInt(payloadOffset), iovecOffset);
+    block.writeBigUInt64LE(BigInt(payloadArg.length), iovecOffset + 8);
+    if (space > 0) {
+        block.writeBigUInt64LE(base + BigInt(controlOffset), 32);
+        block.writeBigUInt64LE(BigInt(space), 40);
+        block.writeBigUInt64LE(BigInt(16 + 4 * descriptorsArg.length), controlOffset);
+        block.writeInt32LE(libcConstants.SOL_SOCKET, controlOffset + 8);
+        block.writeInt32LE(libcConstants.SCM_RIGHTS, controlOffset + 12);
+        descriptorsArg.forEach((descriptor, index) => block.writeInt32LE(descriptor, controlOffset + 16 + 4 * index));
+    }
+    const socket = libc.functions.socket(libcConstants.AF_UNIX, libcConstants.SOCK_DGRAM | libcConstants.SOCK_CLOEXEC, 0);
+    if (socket < 0) {
+        throw new SystemdRuntimeError('notify_failed', 'socket(AF_UNIX, SOCK_DGRAM) failed.', { errno: libc.errno() });
+    }
+    try {
+        let sent = libc.functions.sendmsg(socket, block, libcConstants.MSG_NOSIGNAL);
+        let errno = sent < 0n ? libc.errno() : 0;
+        while (sent < 0n && errno === libcConstants.EINTR) {
+            sent = libc.functions.sendmsg(socket, block, libcConstants.MSG_NOSIGNAL);
+            errno = sent < 0n ? libc.errno() : 0;
+        }
+        if (sent < 0n) {
+            throw new SystemdRuntimeError('notify_failed', `sendmsg to ${addressArg} failed.`, { errno });
+        }
+        if (sent !== BigInt(payloadArg.length)) {
+            throw new SystemdRuntimeError('notify_failed', `sendmsg to ${addressArg} sent ${sent} of ${payloadArg.length} bytes.`);
+        }
+    }
+    finally {
+        // Linux releases the descriptor whatever close(2) reports; the socket is this call's alone.
+        libc.functions.close(socket);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.systemdnotifier.js","sourceRoot":"","sources":["../ts_systemdruntime/classes.systemdnotifier.ts"],"names":[],"mappings":"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"}

package/dist_ts_systemdruntime/classes.systemdruntimeerror.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Why a systemd runtime operation refused or failed:
+ *
+ * - `runtime_unsupported`: the runtime cannot make the call: Node.js older than 26, a platform
+ *   other than Linux on x64 or arm64, a C library other than glibc (`libc.so.6`), `node:ffi`
+ *   disabled (`--no-experimental-ffi`) or denied by the permission model (no `--allow-ffi`).
+ * - `notify_socket_invalid`: `NOTIFY_SOCKET` is not an `AF_UNIX` path or abstract name this
+ *   module can address (`vsock:` addresses included).
+ * - `notify_field_invalid`: a notification field name or value systemd would not parse, or a
+ *   message larger than systemd reads (4096 bytes).
+ * - `notify_failed`: the message could not be sent (`errno` names why).
+ * - `descriptor_name_invalid`: an `FDNAME=` systemd would refuse.
+ * - `descriptor_invalid`: a descriptor number that cannot exist, or a count outside 1–253.
+ * - `listen_environment_invalid`: `LISTEN_PID`, `LISTEN_FDS` or `LISTEN_FDNAMES` is malformed,
+ *   `LISTEN_FDS` names a descriptor at or above the process's hard `RLIMIT_NOFILE`, or
+ *   `getrlimit(RLIMIT_NOFILE)` failed, so the count cannot be bounded (`errno` names why).
+ * - `watchdog_environment_invalid`: `WATCHDOG_USEC` or `WATCHDOG_PID` is malformed.
+ * - `close_on_exec_failed`: a descriptor could not be marked close-on-exec (`errno` names why).
+ */
+export type TSystemdRuntimeErrorCode = 'runtime_unsupported' | 'notify_socket_invalid' | 'notify_field_invalid' | 'notify_failed' | 'descriptor_name_invalid' | 'descriptor_invalid' | 'listen_environment_invalid' | 'watchdog_environment_invalid' | 'close_on_exec_failed';
+export interface ISystemdRuntimeErrorOptions {
+    /** The C library's `errno` after the failed call, when a call failed. */
+    readonly errno?: number;
+    readonly cause?: unknown;
+}
+export declare class SystemdRuntimeError extends Error {
+    readonly code: TSystemdRuntimeErrorCode;
+    /** The C library's `errno` after the failed call, or null when no call failed. */
+    readonly errno: number | null;
+    constructor(code: TSystemdRuntimeErrorCode, messageArg: string, optionsArg?: ISystemdRuntimeErrorOptions);
+}

package/dist_ts_systemdruntime/classes.systemdruntimeerror.js

@@ -0,0 +1,9 @@
+export class SystemdRuntimeError extends Error {
+    constructor(code, messageArg, optionsArg = {}) {
+        super(`${messageArg}${optionsArg.errno === undefined ? '' : ` (errno ${optionsArg.errno})`}`, optionsArg.cause === undefined ? undefined : { cause: optionsArg.cause });
+        this.code = code;
+        this.name = 'SystemdRuntimeError';
+        this.errno = optionsArg.errno ?? null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zeXN0ZW1kcnVudGltZWVycm9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfc3lzdGVtZHJ1bnRpbWUvY2xhc3Nlcy5zeXN0ZW1kcnVudGltZWVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQW9DQSxNQUFNLE9BQU8sbUJBQW9CLFNBQVEsS0FBSztJQUk1QyxZQUNrQixJQUE4QixFQUM5QyxVQUFrQixFQUNsQixVQUFVLEdBQWdDLEVBQUU7UUFFNUMsS0FBSyxDQUNILEdBQUcsVUFBVSxHQUFHLFVBQVUsQ0FBQyxLQUFLLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFdBQVcsVUFBVSxDQUFDLEtBQUssR0FBRyxFQUFFLEVBQ3RGLFVBQVUsQ0FBQyxLQUFLLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLFVBQVUsQ0FBQyxLQUFLLEVBQUUsQ0FDekUsQ0FBQztvQkFQYyxJQUFJO1FBUXBCLElBQUksQ0FBQyxJQUFJLEdBQUcscUJBQXFCLENBQUM7UUFDbEMsSUFBSSxDQUFDLEtBQUssR0FBRyxVQUFVLENBQUMsS0FBSyxJQUFJLElBQUksQ0FBQztJQUN4QyxDQUFDO0NBQ0YifQ==

package/dist_ts_systemdruntime/index.d.ts

@@ -0,0 +1,5 @@
+export * from './classes.systemdruntimeerror.js';
+export * from './classes.systemdnotifier.js';
+export { type ISystemdListenDescriptor, type ISystemdProcessEnvironmentOptions, setCloseOnExec, systemdListenDescriptorsStart, takeSystemdListenDescriptors, watchdogIntervalUsec, } from './systemdruntime.listen.js';
+export { systemdRuntimeNodeMajor } from './systemdruntime.libc.js';
+export { isSystemdDescriptorName, isSystemdNotifySocketAddress } from './systemdruntime.validation.js';

package/dist_ts_systemdruntime/index.js

@@ -0,0 +1,14 @@
+/**
+ * `@push.rocks/smartdaemon/systemd-runtime`: the service side of systemd for a Node.js main
+ * process — `sd_notify(3)` messages with descriptors, `LISTEN_FDS` adoption with close-on-exec, and
+ * the watchdog interval — through glibc calls made with `node:ffi`. Requires Node.js 26 or later:
+ * importing it on an older Node.js throws `SystemdRuntimeError` `runtime_unsupported`.
+ */
+import { assertSystemdRuntimeNode } from './systemdruntime.libc.js';
+export * from './classes.systemdruntimeerror.js';
+export * from './classes.systemdnotifier.js';
+export { setCloseOnExec, systemdListenDescriptorsStart, takeSystemdListenDescriptors, watchdogIntervalUsec, } from './systemdruntime.listen.js';
+export { systemdRuntimeNodeMajor } from './systemdruntime.libc.js';
+export { isSystemdDescriptorName, isSystemdNotifySocketAddress } from './systemdruntime.validation.js';
+assertSystemdRuntimeNode();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19zeXN0ZW1kcnVudGltZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUNILE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRXBFLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxPQUFPLEVBR0wsY0FBYyxFQUNkLDZCQUE2QixFQUM3Qiw0QkFBNEIsRUFDNUIsb0JBQW9CLEdBQ3JCLE1BQU0sNEJBQTRCLENBQUM7QUFDcEMsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDbkUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLDRCQUE0QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFdkcsd0JBQXdCLEVBQUUsQ0FBQyJ9

package/dist_ts_systemdruntime/systemdruntime.libc.d.ts

@@ -0,0 +1,87 @@
+import type * as ffi from 'node:ffi';
+/** The first Node.js major with `node:ffi`, which this module calls libc through. */
+export declare const systemdRuntimeNodeMajor = 26;
+/** Internal: refuses a Node.js older than `systemdRuntimeNodeMajor`; the subpath runs it on import. */
+export declare const assertSystemdRuntimeNode: (versionArg?: string) => void;
+/**
+ * The generic Linux values both qualified targets (x86_64 and aarch64, glibc) use. The structure
+ * layouts below are the LP64 glibc ones, identical on both:
+ *
+ * - `sockaddr_un`: `sa_family_t` (u16) at 0, `sun_path[108]` at 2.
+ * - `iovec` (16 bytes): `iov_base` at 0, `iov_len` at 8.
+ * - `msghdr` (56 bytes): `msg_name` at 0, `msg_namelen` (u32) at 8, `msg_iov` at 16, `msg_iovlen`
+ *   at 24, `msg_control` at 32, `msg_controllen` at 40, `msg_flags` at 48.
+ * - `cmsghdr`: `cmsg_len` (size_t) at 0, `cmsg_level` at 8, `cmsg_type` at 12, data at 16;
+ *   `CMSG_LEN(n)` is 16 + n and `CMSG_SPACE(n)` 16 + n rounded up to 8.
+ * - `timespec` (16 bytes): `tv_sec` at 0, `tv_nsec` at 8.
+ * - `rlimit` (16 bytes): `rlim_cur` (u64) at 0, `rlim_max` (u64) at 8; `RLIM_INFINITY` is all ones.
+ */
+export declare const libcConstants: {
+    readonly AF_UNIX: 1;
+    readonly SOCK_DGRAM: 2;
+    readonly SOCK_CLOEXEC: 524288;
+    readonly SOL_SOCKET: 1;
+    readonly SCM_RIGHTS: 1;
+    readonly MSG_NOSIGNAL: 16384;
+    readonly F_GETFD: 1;
+    readonly F_SETFD: 2;
+    readonly FD_CLOEXEC: 1;
+    readonly CLOCK_MONOTONIC: 1;
+    readonly EINTR: 4;
+    readonly RLIMIT_NOFILE: 7;
+};
+/** `sun_path` is 108 bytes; an address of up to 107 bytes keeps a path's terminating NUL. */
+export declare const socketAddressMaximumBytes = 107;
+/** The kernel's `SCM_MAX_FD`: the most descriptors one `SCM_RIGHTS` message carries. */
+export declare const descriptorsPerMessageMaximum = 253;
+declare const libcFunctions: {
+    readonly socket: {
+        readonly arguments: readonly ["int32", "int32", "int32"];
+        readonly return: 'int32';
+    };
+    readonly sendmsg: {
+        readonly arguments: readonly ["int32", "pointer", "int32"];
+        readonly return: 'int64';
+    };
+    readonly close: {
+        readonly arguments: readonly ["int32"];
+        readonly return: 'int32';
+    };
+    readonly fcntl: {
+        readonly arguments: readonly ["int32", "int32", "int32"];
+        readonly return: 'int32';
+    };
+    readonly clock_gettime: {
+        readonly arguments: readonly ["int32", "pointer"];
+        readonly return: 'int32';
+    };
+    readonly getrlimit: {
+        readonly arguments: readonly ["int32", "pointer"];
+        readonly return: 'int32';
+    };
+    readonly __errno_location: {
+        readonly arguments: readonly [];
+        readonly return: 'pointer';
+    };
+};
+export interface ISystemdLibc {
+    readonly functions: ffi.WrappedFunctionsFromDefinitions<typeof libcFunctions>;
+    readonly ffi: typeof ffi;
+    /**
+     * The calling thread's `errno`, read through glibc's `__errno_location()`. `node:ffi` has no errno
+     * API; read it immediately after the failed call, before anything else runs on the thread.
+     */
+    errno(): number;
+}
+/**
+ * glibc, opened through `node:ffi` on first use and kept for the process lifetime. Loading
+ * `node:ffi` emits Node's ExperimentalWarning once.
+ */
+export declare const systemdLibc: () => ISystemdLibc;
+/** The `msg_namelen` of an `AF_UNIX` address: a path keeps its NUL; an abstract name has none. */
+export declare const socketAddressLength: (addressArg: string) => number;
+/** Writes a `sockaddr_un` at `offsetArg`; an abstract name's leading `@` becomes its NUL. */
+export declare const writeSocketAddress: (bufferArg: Buffer, offsetArg: number, addressArg: string) => void;
+/** `CMSG_SPACE` for `countArg` descriptors. */
+export declare const controlSpace: (countArg: number) => number;
+export {};

package/dist_ts_systemdruntime/systemdruntime.libc.js

@@ -0,0 +1,92 @@
+import { SystemdRuntimeError } from './classes.systemdruntimeerror.js';
+/** The first Node.js major with `node:ffi`, which this module calls libc through. */
+export const systemdRuntimeNodeMajor = 26;
+/** Internal: refuses a Node.js older than `systemdRuntimeNodeMajor`; the subpath runs it on import. */
+export const assertSystemdRuntimeNode = (versionArg = process.versions.node) => {
+    const major = Number(/^(\d+)\./.exec(versionArg)?.[1]);
+    if (!(major >= systemdRuntimeNodeMajor)) {
+        throw new SystemdRuntimeError('runtime_unsupported', `@push.rocks/smartdaemon/systemd-runtime requires Node.js ${systemdRuntimeNodeMajor} or later; this is Node.js ${versionArg}.`);
+    }
+};
+/**
+ * The generic Linux values both qualified targets (x86_64 and aarch64, glibc) use. The structure
+ * layouts below are the LP64 glibc ones, identical on both:
+ *
+ * - `sockaddr_un`: `sa_family_t` (u16) at 0, `sun_path[108]` at 2.
+ * - `iovec` (16 bytes): `iov_base` at 0, `iov_len` at 8.
+ * - `msghdr` (56 bytes): `msg_name` at 0, `msg_namelen` (u32) at 8, `msg_iov` at 16, `msg_iovlen`
+ *   at 24, `msg_control` at 32, `msg_controllen` at 40, `msg_flags` at 48.
+ * - `cmsghdr`: `cmsg_len` (size_t) at 0, `cmsg_level` at 8, `cmsg_type` at 12, data at 16;
+ *   `CMSG_LEN(n)` is 16 + n and `CMSG_SPACE(n)` 16 + n rounded up to 8.
+ * - `timespec` (16 bytes): `tv_sec` at 0, `tv_nsec` at 8.
+ * - `rlimit` (16 bytes): `rlim_cur` (u64) at 0, `rlim_max` (u64) at 8; `RLIM_INFINITY` is all ones.
+ */
+export const libcConstants = {
+    AF_UNIX: 1,
+    SOCK_DGRAM: 2,
+    SOCK_CLOEXEC: 0o2000000,
+    SOL_SOCKET: 1,
+    SCM_RIGHTS: 1,
+    MSG_NOSIGNAL: 0x4000,
+    F_GETFD: 1,
+    F_SETFD: 2,
+    FD_CLOEXEC: 1,
+    CLOCK_MONOTONIC: 1,
+    EINTR: 4,
+    RLIMIT_NOFILE: 7,
+};
+/** `sun_path` is 108 bytes; an address of up to 107 bytes keeps a path's terminating NUL. */
+export const socketAddressMaximumBytes = 107;
+/** The kernel's `SCM_MAX_FD`: the most descriptors one `SCM_RIGHTS` message carries. */
+export const descriptorsPerMessageMaximum = 253;
+const libcFunctions = {
+    socket: { arguments: ['int32', 'int32', 'int32'], return: 'int32' },
+    sendmsg: { arguments: ['int32', 'pointer', 'int32'], return: 'int64' },
+    close: { arguments: ['int32'], return: 'int32' },
+    // fcntl(2) is variadic; its third argument is an int for F_GETFD and F_SETFD.
+    fcntl: { arguments: ['int32', 'int32', 'int32'], return: 'int32' },
+    clock_gettime: { arguments: ['int32', 'pointer'], return: 'int32' },
+    getrlimit: { arguments: ['int32', 'pointer'], return: 'int32' },
+    __errno_location: { arguments: [], return: 'pointer' },
+};
+let loaded = null;
+/**
+ * glibc, opened through `node:ffi` on first use and kept for the process lifetime. Loading
+ * `node:ffi` emits Node's ExperimentalWarning once.
+ */
+export const systemdLibc = () => {
+    if (loaded !== null)
+        return loaded;
+    if (process.platform !== 'linux' || (process.arch !== 'x64' && process.arch !== 'arm64')) {
+        throw new SystemdRuntimeError('runtime_unsupported', `The systemd runtime supports Linux on x64 and arm64; this is ${process.platform} on ${process.arch}.`);
+    }
+    const ffiModule = process.getBuiltinModule('node:ffi');
+    if (ffiModule === undefined) {
+        throw new SystemdRuntimeError('runtime_unsupported', 'node:ffi is not available (disabled by --no-experimental-ffi?).');
+    }
+    let functions;
+    try {
+        functions = ffiModule.dlopen('libc.so.6', libcFunctions).functions;
+    }
+    catch (error) {
+        throw new SystemdRuntimeError('runtime_unsupported', 'glibc (libc.so.6) could not be opened through node:ffi; under the permission model pass --allow-ffi.', { cause: error });
+    }
+    loaded = Object.freeze({
+        functions,
+        ffi: ffiModule,
+        errno: () => ffiModule.getInt32(functions.__errno_location(), 0),
+    });
+    return loaded;
+};
+/** The `msg_namelen` of an `AF_UNIX` address: a path keeps its NUL; an abstract name has none. */
+export const socketAddressLength = (addressArg) => 2 + Buffer.byteLength(addressArg, 'utf8') + (addressArg.startsWith('/') ? 1 : 0);
+/** Writes a `sockaddr_un` at `offsetArg`; an abstract name's leading `@` becomes its NUL. */
+export const writeSocketAddress = (bufferArg, offsetArg, addressArg) => {
+    bufferArg.writeUInt16LE(libcConstants.AF_UNIX, offsetArg);
+    bufferArg.write(addressArg, offsetArg + 2, 'utf8');
+    if (addressArg.startsWith('@'))
+        bufferArg[offsetArg + 2] = 0;
+};
+/** `CMSG_SPACE` for `countArg` descriptors. */
+export const controlSpace = (countArg) => 16 + ((4 * countArg + 7) & ~7);
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_systemdruntime/systemdruntime.listen.d.ts

@@ -0,0 +1,46 @@
+/** sd_listen_fds(3): `SD_LISTEN_FDS_START`, the first passed descriptor. */
+export declare const systemdListenDescriptorsStart = 3;
+export interface ISystemdProcessEnvironmentOptions {
+    /** The environment to read; `process.env` by default. */
+    readonly env?: NodeJS.ProcessEnv;
+    /** The process the variables must name; `process.pid` by default. */
+    readonly pid?: number;
+}
+/** One descriptor the service manager passed: its number and its `LISTEN_FDNAMES` entry. */
+export interface ISystemdListenDescriptor {
+    readonly descriptor: number;
+    /** The `FDNAME=` it was stored under, the socket unit's `FileDescriptorName=`, or `unknown`. */
+    readonly name: string;
+}
+/**
+ * Marks one open descriptor close-on-exec (`fcntl(F_SETFD, FD_CLOEXEC)`) and verifies the flag,
+ * so no child process inherits it. Throws `close_on_exec_failed` with `errno` when the descriptor
+ * is not open or the flag does not hold.
+ */
+export declare const setCloseOnExec: (descriptorArg: number) => void;
+/**
+ * Takes the descriptors the service manager passed this process (sd_listen_fds_with_names(3)):
+ * socket-activation sockets and descriptor-store entries, numbered from 3.
+ *
+ * `LISTEN_PID`, `LISTEN_FDS` and `LISTEN_FDNAMES` always leave the environment, so no child sees
+ * them. Without them, or with `LISTEN_PID` naming another process (variables inherited from a
+ * parent), it returns an empty list and touches no descriptor. For this process every passed
+ * descriptor is marked close-on-exec before the list returns. Without `LISTEN_FDNAMES` each name is
+ * `unknown`, as in systemd.
+ *
+ * Throws `listen_environment_invalid` before touching any descriptor for a partial or malformed set
+ * (a count that is not a positive integer, a count whose last descriptor, `2 + count`, is at or
+ * above the process's hard `RLIMIT_NOFILE`, a names list whose length differs from the count, an
+ * invalid name), and with `errno` when `getrlimit(2)` fails. Descriptors are then marked one by one
+ * from 3, and memory grows only with descriptors proven open: the first passed descriptor that is
+ * not open throws `close_on_exec_failed`, as `sd_listen_fds(3)` fails on it; descriptors before it
+ * keep the flag.
+ */
+export declare const takeSystemdListenDescriptors: (optionsArg?: ISystemdProcessEnvironmentOptions) => readonly ISystemdListenDescriptor[];
+/**
+ * The watchdog interval the manager expects `WATCHDOG=1` within (`WATCHDOG_USEC`, sd_watchdog_enabled(3)),
+ * in microseconds; null when the unit has no watchdog or `WATCHDOG_PID` names another process.
+ * Reads the environment without changing it. Throws `watchdog_environment_invalid` for a malformed
+ * value.
+ */
+export declare const watchdogIntervalUsec: (optionsArg?: ISystemdProcessEnvironmentOptions) => number | null;