@push.rocks/smartdaemon 2.3.1 → 2.4.1

package/.smartconfig.json

@@ -20,7 +20,6 @@
     },
     "release": {
       "preflight": {
-        "requireCleanTree": true,
         "test": true,
         "build": true
       },

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/classes.systemdservicedefinition.d.ts

@@ -0,0 +1,22 @@
+export interface ISystemdServiceDefinitionOptions {
+    unitName: string;
+    description: string;
+    executable: string;
+    args: readonly string[];
+    workingDirectory: string;
+    user: string;
+    group: string;
+    restart: 'no' | 'on-failure' | 'always';
+    killMode: 'mixed' | 'control-group';
+    timeoutStopSeconds: number;
+}
+export declare class SystemdServiceDefinitionError extends Error {
+    constructor();
+}
+/** Literal direct-execution definition; never introduces a shell or environment expansion. */
+export declare class SystemdServiceDefinition {
+    readonly unitName: string;
+    readonly content: string;
+    readonly sha256: string;
+    constructor(options: ISystemdServiceDefinitionOptions);
+}

package/dist_ts/classes.systemdservicedefinition.js

@@ -0,0 +1,93 @@
+import * as plugins from './smartdaemon.plugins.js';
+export class SystemdServiceDefinitionError extends Error {
+    constructor() {
+        super('Invalid direct systemd service definition.');
+        this.name = 'SystemdServiceDefinitionError';
+    }
+}
+/** Literal direct-execution definition; never introduces a shell or environment expansion. */
+export class SystemdServiceDefinition {
+    constructor(options) {
+        const requireValue = (value) => {
+            if (!value)
+                throw new SystemdServiceDefinitionError();
+        };
+        const text = (value, maximum = 4096) => typeof value === 'string' && value.length <= maximum && !/[\x00-\x1f\x7f]/.test(value) &&
+            !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value);
+        const absolute = (value) => text(value) && plugins.path.isAbsolute(value) &&
+            plugins.path.normalize(value) === value;
+        const keys = [
+            'unitName',
+            'description',
+            'executable',
+            'args',
+            'workingDirectory',
+            'user',
+            'group',
+            'restart',
+            'killMode',
+            'timeoutStopSeconds',
+        ];
+        requireValue(options && Object.getPrototypeOf(options) === Object.prototype &&
+            Reflect.ownKeys(options).length === keys.length && keys.every((key) => {
+            const descriptor = Object.getOwnPropertyDescriptor(options, key);
+            return descriptor && 'value' in descriptor;
+        }));
+        requireValue(typeof options.unitName === 'string' &&
+            /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,230}\.service$/.test(options.unitName));
+        requireValue(text(options.description, 1024) && options.description.length > 0 &&
+            options.description.trim() === options.description && !options.description.includes('\\'));
+        requireValue(absolute(options.executable) && options.executable !== '/' &&
+            !/[\\"']/.test(options.executable) && !options.executable.endsWith('/') &&
+            absolute(options.workingDirectory) &&
+            options.workingDirectory.trim() === options.workingDirectory &&
+            !options.workingDirectory.includes('\\'));
+        requireValue(Array.isArray(options.args) && Object.getPrototypeOf(options.args) === Array.prototype &&
+            options.args.length <= 128 &&
+            Reflect.ownKeys(options.args).length === options.args.length + 1 &&
+            Array.from({ length: options.args.length }, (_, index) => Object.getOwnPropertyDescriptor(options.args, String(index)))
+                .every((descriptor) => descriptor && 'value' in descriptor && text(descriptor.value)));
+        requireValue([options.user, options.group].every((value) => typeof value === 'string' && /^[a-zA-Z_][a-zA-Z0-9_-]{0,63}$/.test(value)));
+        requireValue(['no', 'on-failure', 'always'].includes(options.restart) &&
+            ['mixed', 'control-group'].includes(options.killMode) &&
+            Number.isSafeInteger(options.timeoutStopSeconds) &&
+            options.timeoutStopSeconds >= 1 && options.timeoutStopSeconds <= 600);
+        // Quoting and percent/dollar escaping follow systemd.syntax and systemd.service.
+        const quote = (value, command = false) => '"' + value
+            .replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%')
+            .replaceAll('$', () => command ? '$$' : '$') +
+            '"';
+        this.unitName = options.unitName;
+        this.content = [
+            '[Unit]',
+            `Description=${options.description.replaceAll('%', '%%')}`,
+            'After=local-fs.target',
+            '',
+            '[Service]',
+            'Type=exec',
+            `User=${options.user}`,
+            `Group=${options.group}`,
+            `ExecStart=${[quote(options.executable), ...options.args.map((value) => quote(value, true))].join(' ')}`,
+            // WorkingDirectory is a raw path value, not an ExecStart word list.
+            `WorkingDirectory=${options.workingDirectory.replaceAll('%', '%%')}`,
+            `Restart=${options.restart}`,
+            `KillMode=${options.killMode}`,
+            'KillSignal=SIGTERM',
+            'FinalKillSignal=SIGKILL',
+            'SendSIGKILL=yes',
+            'SendSIGHUP=no',
+            `TimeoutStopSec=${options.timeoutStopSeconds}s`,
+            'StandardInput=null',
+            'StandardOutput=journal',
+            'StandardError=journal',
+            '',
+            '[Install]',
+            'WantedBy=multi-user.target',
+            '',
+        ].join('\n');
+        requireValue(Buffer.byteLength(this.content) <= 16384);
+        this.sha256 = plugins.crypto.createHash('sha256').update(this.content).digest('hex');
+        Object.freeze(this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.systemdunit.d.ts

@@ -18,6 +18,13 @@ export interface ISystemdUnitState {
     /** Empty when no systemd job is pending; otherwise systemctl's job description. */
     readonly job: string;
 }
+export interface ISystemdUnitConfigurationState {
+    readonly unitName: string;
+    readonly fragmentPath: string;
+    /** Opaque systemctl path list. An empty value proves no effective drop-ins. */
+    readonly dropInPaths: string;
+    readonly needsReload: boolean;
+}
 export declare class SystemdUnitError extends Error {
     readonly code: 'invalid_options' | 'command_failed' | 'invalid_state';
     constructor(code: 'invalid_options' | 'command_failed' | 'invalid_state');
@@ -34,5 +41,9 @@ export declare class SystemdUnit {
     start(): Promise<ISystemdUnitState>;
     /** Await the systemd job, then inspect. The snapshot alone is not an application data-drain proof. */
     stop(): Promise<ISystemdUnitState>;
+    /** Reports the manager's selected definition without reading or changing its contents. */
+    inspectConfiguration(): Promise<ISystemdUnitConfigurationState>;
+    /** Reloads unit definitions globally; does not enable, unmask, start or stop a unit. */
+    reloadConfiguration(): Promise<ISystemdUnitConfigurationState>;
     private command;
 }

package/dist_ts/classes.systemdunit.js

@@ -75,6 +75,34 @@ export class SystemdUnit {
         await this.command(['stop', this.unitName]);
         return this.inspect();
     }
+    /** Reports the manager's selected definition without reading or changing its contents. */
+    async inspectConfiguration() {
+        const keys = ['Id', 'FragmentPath', 'DropInPaths', 'NeedDaemonReload'];
+        const stdout = await this.command(['show', this.unitName, `--property=${keys.join(',')}`, '--all']);
+        const fields = new Map();
+        for (const line of stdout.trimEnd().split('\n')) {
+            const separator = line.indexOf('='), key = line.slice(0, separator);
+            if (separator < 1 || !keys.includes(key) || fields.has(key)) {
+                throw new SystemdUnitError('invalid_state');
+            }
+            fields.set(key, line.slice(separator + 1));
+        }
+        if (fields.size !== keys.length || fields.get('Id') !== this.unitName ||
+            !['yes', 'no'].includes(fields.get('NeedDaemonReload'))) {
+            throw new SystemdUnitError('invalid_state');
+        }
+        return Object.freeze({
+            unitName: this.unitName,
+            fragmentPath: fields.get('FragmentPath'),
+            dropInPaths: fields.get('DropInPaths'),
+            needsReload: fields.get('NeedDaemonReload') === 'yes',
+        });
+    }
+    /** Reloads unit definitions globally; does not enable, unmask, start or stop a unit. */
+    async reloadConfiguration() {
+        await this.command(['daemon-reload']);
+        return this.inspectConfiguration();
+    }
     command(argsArg) {
         return new Promise((resolve, reject) => {
             plugins.childProcess.execFile(this.executable, ['--system', '--no-ask-password', '--no-pager', ...argsArg], {
@@ -94,4 +122,4 @@ export class SystemdUnit {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.systemdunitfile.d.ts

@@ -0,0 +1,45 @@
+import { SystemdServiceDefinition } from './classes.systemdservicedefinition.js';
+import { type ISystemdUnitOptions } from './classes.systemdunit.js';
+export interface ISystemdUnitFileOptions extends ISystemdUnitOptions {
+    /** Local vendor definitions can be installed without removing an administrator's mask. */
+    unitDirectory?: string;
+    /** Trusted owning-code qualification only. Defaults to root. */
+    expectedUid?: number;
+}
+export interface ISystemdUnitFileRecord {
+    readonly path: string;
+    readonly sha256: string;
+}
+export declare class SystemdUnitFileError extends Error {
+    readonly code: 'invalid_options' | 'unsafe_path' | 'busy' | 'changed' | 'unsafe_unit' | 'write_failed' | 'reload_failed';
+    constructor(code: 'invalid_options' | 'unsafe_path' | 'busy' | 'changed' | 'unsafe_unit' | 'write_failed' | 'reload_failed');
+}
+/**
+ * Protected code/config installation, inside the caller's cross-process installation ownership scope.
+ * Other privileged writers must be serialized by that owner. Never changes enablement or masks.
+ */
+export declare class SystemdUnitFile {
+    readonly path: string;
+    private readonly directory;
+    private readonly uid;
+    private readonly unit;
+    private readonly name;
+    private busy;
+    constructor(options: ISystemdUnitFileOptions);
+    /** Reads only the exact protected definition; no systemd or filesystem mutation. */
+    inspect(): Promise<ISystemdUnitFileRecord | null>;
+    /**
+     * Expected previous digest is mandatory; null admits an absent file. Exact desired bytes are idempotent.
+     * Retains changed definitions beside the unit before replacement. A failed reload never rolls code back.
+     */
+    install(definition: SystemdServiceDefinition, expectedSha256: string | null): Promise<Readonly<{
+        changed: boolean;
+        record: ISystemdUnitFileRecord;
+        masked: boolean;
+    }>>;
+    private admit;
+    private directories;
+    private read;
+    private create;
+    private flushDirectory;
+}

package/dist_ts/classes.systemdunitfile.js

@@ -0,0 +1,249 @@
+import * as plugins from './smartdaemon.plugins.js';
+import { SystemdServiceDefinition } from './classes.systemdservicedefinition.js';
+import { SystemdUnit, } from './classes.systemdunit.js';
+export class SystemdUnitFileError extends Error {
+    constructor(code) {
+        super(`Systemd unit definition installation failed: ${code}.`);
+        this.code = code;
+        this.name = 'SystemdUnitFileError';
+    }
+}
+const requireValue = (value, code) => {
+    if (!value)
+        throw new SystemdUnitFileError(code);
+};
+const digest = (bytes) => plugins.crypto.createHash('sha256').update(bytes).digest('hex');
+const quiet = (state) => state.mainPid === 0 && state.controlPid === 0 &&
+    state.controlGroup === '' && state.job === '' &&
+    (state.activeState === 'inactive' && state.subState === 'dead' ||
+        state.activeState === 'failed' && state.subState === 'failed');
+const masked = (state) => state.loadState === 'masked' &&
+    ['masked', 'masked-runtime'].includes(state.unitFileState);
+const sameFile = (left, right) => left.dev === right.dev && left.ino === right.ino;
+/**
+ * Protected code/config installation, inside the caller's cross-process installation ownership scope.
+ * Other privileged writers must be serialized by that owner. Never changes enablement or masks.
+ */
+export class SystemdUnitFile {
+    constructor(options) {
+        this.busy = false;
+        this.unit = new SystemdUnit(options);
+        this.name = options.unitName;
+        this.directory = options.unitDirectory ?? '/usr/local/lib/systemd/system';
+        this.uid = options.expectedUid ?? 0;
+        requireValue(typeof this.directory === 'string' && this.directory !== '/' &&
+            plugins.path.isAbsolute(this.directory) &&
+            plugins.path.normalize(this.directory) === this.directory &&
+            !this.directory.endsWith('/') && !/[\x00-\x1f\x7f]/.test(this.directory) &&
+            this.directory.length <= 4000 && Number.isSafeInteger(this.uid) && this.uid >= 0, 'invalid_options');
+        this.path = plugins.path.join(this.directory, this.name);
+    }
+    /** Reads only the exact protected definition; no systemd or filesystem mutation. */
+    async inspect() {
+        if (!await this.directories(false))
+            return null;
+        const file = await this.read(this.path);
+        return file ? Object.freeze({ path: this.path, sha256: digest(file.bytes) }) : null;
+    }
+    /**
+     * Expected previous digest is mandatory; null admits an absent file. Exact desired bytes are idempotent.
+     * Retains changed definitions beside the unit before replacement. A failed reload never rolls code back.
+     */
+    async install(definition, expectedSha256) {
+        requireValue(definition instanceof SystemdServiceDefinition && definition.unitName === this.name &&
+            (expectedSha256 === null ||
+                typeof expectedSha256 === 'string' && /^[a-f0-9]{64}$/.test(expectedSha256)), 'invalid_options');
+        requireValue(!this.busy, 'busy');
+        this.busy = true;
+        let temporary;
+        let temporaryInfo;
+        try {
+            const before = await this.unit.inspect();
+            const beforeConfiguration = await this.admit(before);
+            await this.directories(true);
+            const parent = await plugins.fs.lstat(this.directory);
+            const previous = await this.read(this.path);
+            const previousSha = previous ? digest(previous.bytes) : null;
+            const changed = previousSha !== definition.sha256;
+            requireValue(!changed || previousSha === expectedSha256, 'changed');
+            if (changed) {
+                if (previous) {
+                    const backup = `${this.path}.previous-${previousSha}`;
+                    try {
+                        await this.create(backup, previous.bytes);
+                    }
+                    catch (error) {
+                        if (error.code !== 'EEXIST')
+                            throw error;
+                        requireValue(digest((await this.read(backup)).bytes) === previousSha, 'changed');
+                    }
+                    await this.flushDirectory(parent);
+                }
+                temporary = plugins.path.join(this.directory, `.${this.name}.${plugins.crypto.randomUUID()}.tmp`);
+                await this.create(temporary, Buffer.from(definition.content));
+                temporaryInfo = await plugins.fs.lstat(temporary);
+                const current = await this.read(this.path);
+                requireValue((current ? digest(current.bytes) : null) === previousSha &&
+                    (!current || previous && sameFile(current.info, previous.info)), 'changed');
+                requireValue(sameFile(parent, await plugins.fs.lstat(this.directory)), 'unsafe_path');
+                const rechecked = await this.unit.inspect();
+                requireValue(JSON.stringify(rechecked) === JSON.stringify(before), 'changed');
+                const recheckedConfiguration = await this.admit(rechecked);
+                requireValue(recheckedConfiguration.fragmentPath === beforeConfiguration.fragmentPath, 'changed');
+                await plugins.fs.rename(temporary, this.path);
+                temporary = undefined;
+                await this.flushDirectory(parent);
+            }
+            try {
+                const reloadedConfiguration = await this.unit.reloadConfiguration();
+                const after = await this.unit.inspect();
+                requireValue(quiet(after) &&
+                    (before.loadState === 'not-found'
+                        ? after.loadState === 'loaded' && after.unitFileState === 'disabled'
+                        : after.loadState === before.loadState &&
+                            after.unitFileState === before.unitFileState), 'changed');
+                const configuration = await this.unit.inspectConfiguration();
+                requireValue([reloadedConfiguration, configuration].every((snapshot) => !snapshot.needsReload && snapshot.dropInPaths === '' &&
+                    snapshot.fragmentPath ===
+                        (masked(after) ? beforeConfiguration.fragmentPath : this.path)), 'unsafe_unit');
+                const installed = await this.inspect();
+                requireValue(installed?.sha256 === definition.sha256, 'changed');
+                return Object.freeze({ changed, record: installed, masked: masked(after) });
+            }
+            catch {
+                throw new SystemdUnitFileError('reload_failed');
+            }
+        }
+        catch (error) {
+            if (error instanceof SystemdUnitFileError)
+                throw error;
+            throw new SystemdUnitFileError('write_failed');
+        }
+        finally {
+            try {
+                if (temporary && temporaryInfo) {
+                    const named = await plugins.fs.lstat(temporary);
+                    requireValue(sameFile(temporaryInfo, named), 'unsafe_path');
+                    await plugins.fs.unlink(temporary);
+                }
+            }
+            finally {
+                this.busy = false;
+            }
+        }
+    }
+    async admit(state) {
+        requireValue(quiet(state) && (masked(state) ||
+            state.loadState === 'loaded' &&
+                ['enabled', 'enabled-runtime', 'disabled'].includes(state.unitFileState) ||
+            state.loadState === 'not-found' && state.unitFileState === ''), 'unsafe_unit');
+        const configuration = await this.unit.inspectConfiguration();
+        const maskPath = plugins.path.join(state.unitFileState === 'masked-runtime' ? '/run/systemd/system' : '/etc/systemd/system', this.name);
+        requireValue(!configuration.needsReload && configuration.dropInPaths === '' &&
+            (masked(state)
+                ? configuration.fragmentPath !== this.path &&
+                    ['/dev/null', maskPath].includes(configuration.fragmentPath)
+                : configuration.fragmentPath === (state.loadState === 'not-found' ? '' : this.path)), 'unsafe_unit');
+        return configuration;
+    }
+    async directories(create) {
+        requireValue(process.platform === 'linux' && process.getuid?.() === this.uid, 'unsafe_path');
+        let directory = '/';
+        for (const part of this.directory.split('/').filter(Boolean)) {
+            directory = plugins.path.join(directory, part);
+            let info;
+            try {
+                info = await plugins.fs.lstat(directory);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+                if (!create)
+                    return false;
+                await plugins.fs.mkdir(directory, { mode: 0o755 });
+                const parent = await plugins.fs.open(plugins.path.dirname(directory), plugins.fsConstants.O_RDONLY | plugins.fsConstants.O_DIRECTORY |
+                    plugins.fsConstants.O_NOFOLLOW);
+                try {
+                    await parent.sync();
+                }
+                finally {
+                    await parent.close();
+                }
+                info = await plugins.fs.lstat(directory);
+            }
+            requireValue(info.isDirectory() && !info.isSymbolicLink() && [0, this.uid].includes(info.uid) &&
+                ((info.mode & 0o022) === 0 || directory === '/tmp' && info.uid === 0 &&
+                    (info.mode & 0o7777) === 0o1777), 'unsafe_path');
+        }
+        return true;
+    }
+    async read(path) {
+        let file;
+        try {
+            file = await plugins.fs.open(path, plugins.fsConstants.O_RDONLY | plugins.fsConstants.O_NOFOLLOW |
+                plugins.fsConstants.O_NONBLOCK);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw new SystemdUnitFileError('unsafe_path');
+        }
+        try {
+            const info = await file.stat();
+            requireValue(info.isFile() && info.uid === this.uid && info.nlink === 1 &&
+                (info.mode & 0o7777) === 0o644 && info.size <= 16384, 'unsafe_path');
+            const bytes = Buffer.alloc(16385);
+            let size = 0;
+            for (;;) {
+                const result = await file.read(bytes, size, bytes.length - size, size);
+                if (result.bytesRead === 0)
+                    break;
+                size += result.bytesRead;
+                requireValue(size <= 16384, 'unsafe_path');
+            }
+            const after = await file.stat(), named = await plugins.fs.lstat(path);
+            requireValue(sameFile(info, named) && !named.isSymbolicLink() && after.size === size &&
+                info.size === after.size && info.mtimeMs === after.mtimeMs &&
+                info.ctimeMs === after.ctimeMs, 'changed');
+            return { bytes: bytes.subarray(0, size), info };
+        }
+        finally {
+            await file.close();
+        }
+    }
+    async create(path, bytes) {
+        const file = await plugins.fs.open(path, plugins.fsConstants.O_CREAT | plugins.fsConstants.O_EXCL |
+            plugins.fsConstants.O_WRONLY | plugins.fsConstants.O_NOFOLLOW, 0o644);
+        let created;
+        try {
+            try {
+                created = await file.stat();
+                await file.chmod(0o644);
+                await file.writeFile(bytes);
+                await file.sync();
+            }
+            finally {
+                await file.close();
+            }
+        }
+        catch (error) {
+            if (created) {
+                requireValue(sameFile(created, await plugins.fs.lstat(path)), 'unsafe_path');
+                await plugins.fs.unlink(path);
+            }
+            throw error;
+        }
+    }
+    async flushDirectory(expected) {
+        const directory = await plugins.fs.open(this.directory, plugins.fsConstants.O_RDONLY |
+            plugins.fsConstants.O_DIRECTORY | plugins.fsConstants.O_NOFOLLOW);
+        try {
+            requireValue(sameFile(expected, await directory.stat()), 'unsafe_path');
+            await directory.sync();
+        }
+        finally {
+            await directory.close();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.systemdunitfile.js","sourceRoot":"","sources":["../ts/classes.systemdunitfile.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

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

package/dist_ts/index.js

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

package/dist_ts/smartdaemon.plugins.d.ts

@@ -1,6 +1,10 @@
 import * as path from 'path';
 import * as childProcess from 'node:child_process';
-export { path, childProcess };
+import * as fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import * as crypto from 'node:crypto';
+export type { Stats } from 'node:fs';
+export { path, childProcess, fs, fsConstants, crypto };
 import * as lik from '@push.rocks/lik';
 import * as smartfm from '@push.rocks/smartfm';
 import * as smartfs from '@push.rocks/smartfs';

package/dist_ts/smartdaemon.plugins.js

@@ -1,7 +1,10 @@
 // node native scope
 import * as path from 'path';
 import * as childProcess from 'node:child_process';
-export { path, childProcess };
+import * as fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import * as crypto from 'node:crypto';
+export { path, childProcess, fs, fsConstants, crypto };
 // @pushrocks scope
 import * as lik from '@push.rocks/lik';
 import * as smartfm from '@push.rocks/smartfm';
@@ -13,4 +16,4 @@ import * as smartshell from '@push.rocks/smartshell';
 import * as smartsystem from '@push.rocks/smartsystem';
 export { lik, smartfm, smartfs, smartlog, smartlogDestinationLocal, smartpath, smartshell, smartsystem, };
 // third party
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYWVtb24ucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0ZGFlbW9uLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFFbkQsT0FBTyxFQUFFLElBQUksRUFBRSxZQUFZLEVBQUUsQ0FBQztBQUU5QixtQkFBbUI7QUFDbkIsT0FBTyxLQUFLLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQztBQUN2QyxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBQy9DLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssd0JBQXdCLE1BQU0sd0NBQXdDLENBQUM7QUFDbkYsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFFdkQsT0FBTyxFQUNMLEdBQUcsRUFDSCxPQUFPLEVBQ1AsT0FBTyxFQUNQLFFBQVEsRUFDUix3QkFBd0IsRUFDeEIsU0FBUyxFQUNULFVBQVUsRUFDVixXQUFXLEdBQ1osQ0FBQztBQUVGLGNBQWMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYWVtb24ucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0ZGFlbW9uLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEVBQUUsU0FBUyxJQUFJLFdBQVcsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUNuRCxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUd0QyxPQUFPLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBRXZELG1CQUFtQjtBQUNuQixPQUFPLEtBQUssR0FBRyxNQUFNLGlCQUFpQixDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyx3QkFBd0IsTUFBTSx3Q0FBd0MsQ0FBQztBQUNuRixPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUV2RCxPQUFPLEVBQ0wsR0FBRyxFQUNILE9BQU8sRUFDUCxPQUFPLEVBQ1AsUUFBUSxFQUNSLHdCQUF3QixFQUN4QixTQUFTLEVBQ1QsVUFBVSxFQUNWLFdBQVcsR0FDWixDQUFDO0FBRUYsY0FBYyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartdaemon",
-  "version": "2.3.1",
+  "version": "2.4.1",
   "private": false,
   "description": "Start scripts as long running daemons and manage them.",
   "main": "dist_ts/index.js",
@@ -28,7 +28,7 @@
   "devDependencies": {
     "@git.zone/tsbuild": "^4.4.2",
     "@git.zone/tsrun": "^2.0.6",
-    "@git.zone/tstest": "^4.0.0",
+    "@git.zone/tstest": "^6.0.0",
     "@types/node": "^26.4.1"
   },
   "dependencies": {

package/readme.md

@@ -186,6 +186,76 @@ environment, no shell or password prompt, and bounded output. Trusted owning cod
 can choose another absolute executable path and `commandTimeoutMs` (default
 120000, maximum 600000). This timeout bounds the client process only.
 
+`inspectConfiguration()` reports the selected `fragmentPath`, opaque `dropInPaths`
+list and `needsReload` flag. `reloadConfiguration()` explicitly reloads the manager's
+unit definitions globally and returns a fresh configuration snapshot. Neither
+operation changes enablement or masks.
+
+### Installing a direct systemd service definition
+
+`SystemdServiceDefinition` encodes a literal executable and argument list, with
+explicit user, group, restart policy, kill mode and stop timeout. It uses `Type=exec`,
+journal output and null stdin. It introduces no shell; percent specifiers and
+argument environment expansion are escaped. Paths must be absolute and normalized;
+control characters are rejected. Descriptions and working directories cannot have
+backslashes or surrounding whitespace; executable paths also reject quotes and
+backslashes. Arguments may contain spaces, quotes, backslashes and empty strings.
+
+```typescript
+import { SystemdServiceDefinition, SystemdUnitFile } from '@push.rocks/smartdaemon';
+
+const definition = new SystemdServiceDefinition({
+  unitName: 'smartdaemon_my-api-server.service',
+  description: 'My API server',
+  executable: '/opt/my-api/bin/server',
+  args: ['serve'],
+  workingDirectory: '/opt/my-api',
+  user: 'root',
+  group: 'root',
+  restart: 'no',
+  killMode: 'mixed',
+  timeoutStopSeconds: 360,
+});
+const file = new SystemdUnitFile({ unitName: definition.unitName });
+// Inside the privileged installer's existing cross-process ownership scope:
+const previous = await file.inspect();
+const installed = await file.install(definition, previous?.sha256 ?? null);
+console.log(installed.changed, installed.masked, installed.record.sha256);
+```
+
+Installation requires Linux, root and a quiescent exact unit with no process,
+cgroup or job. It rejects effective drop-ins and shadowing fragments. Definitions
+default to `/usr/local/lib/systemd/system`, below administrator configuration in
+the load path, so existing persistent/runtime masks remain intact. Existing
+enablement is preserved; an absent unit becomes disabled. It never enables,
+unmasks, starts or stops a service, or invokes sudo.
+
+Masked units may report `/dev/null` or their exact administrator mask path:
+`/etc/systemd/system/<unit>` for a persistent mask, `/run/systemd/system/<unit>`
+for a runtime mask. Installation preserves that exact manager-selected fragment
+through the write and reload, and never replaces the masking fragment itself.
+Pending manager reloads are rejected before writing; inspect and explicitly
+reload an existing changed configuration before retrying installation.
+
+The caller must already serialize privileged installation across processes;
+`SystemdUnitFile` only excludes simultaneous operations on the same instance.
+The expected previous SHA-256 is mandatory (`null` requires an absent file),
+while already matching bytes are idempotent. Installation checks protected
+directories and regular single-link mode-0644 files, retains changed definitions
+as `<unit>.previous-<sha256>`, flushes them before atomic replacement, reloads
+the manager and checks its selected fragment and final bytes. A reload failure
+leaves the new file and retained previous definition in place; recovery requires
+inspection, never an automatic rollback. Filesystem and definition errors use
+`SystemdUnitFileError` with a local code. Trusted qualification code can set
+`unitDirectory`, `expectedUid` and the inherited `SystemdUnit` command options.
+
+With `killMode: 'mixed'`, the main process owns graceful child shutdown and must
+remain alive until its children have joined. Systemd sends SIGTERM to the main
+process first and can send SIGKILL to the whole cgroup when the main process exits
+or the stop deadline expires. `control-group` sends the initial signal to the
+whole group. A successful systemd start still requires application readiness
+verification, and a completed stop alone does not prove database drain.
+
 ### SmartDaemonService Class
 
 ```typescript

package/ts/00_commitinfo_data.ts

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

package/ts/classes.systemdservicedefinition.ts

@@ -0,0 +1,134 @@
+import * as plugins from './smartdaemon.plugins.js';
+
+export interface ISystemdServiceDefinitionOptions {
+  unitName: string;
+  description: string;
+  executable: string;
+  args: readonly string[];
+  workingDirectory: string;
+  user: string;
+  group: string;
+  restart: 'no' | 'on-failure' | 'always';
+  killMode: 'mixed' | 'control-group';
+  timeoutStopSeconds: number;
+}
+
+export class SystemdServiceDefinitionError extends Error {
+  constructor() {
+    super('Invalid direct systemd service definition.');
+    this.name = 'SystemdServiceDefinitionError';
+  }
+}
+
+/** Literal direct-execution definition; never introduces a shell or environment expansion. */
+export class SystemdServiceDefinition {
+  public readonly unitName: string;
+  public readonly content: string;
+  public readonly sha256: string;
+
+  constructor(options: ISystemdServiceDefinitionOptions) {
+    const requireValue = (value: unknown): void => {
+      if (!value) throw new SystemdServiceDefinitionError();
+    };
+    const text = (value: unknown, maximum = 4096): value is string =>
+      typeof value === 'string' && value.length <= maximum && !/[\x00-\x1f\x7f]/.test(value) &&
+      !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value);
+    const absolute = (value: unknown) =>
+      text(value) && plugins.path.isAbsolute(value) &&
+      plugins.path.normalize(value) === value;
+    const keys = [
+      'unitName',
+      'description',
+      'executable',
+      'args',
+      'workingDirectory',
+      'user',
+      'group',
+      'restart',
+      'killMode',
+      'timeoutStopSeconds',
+    ];
+    requireValue(
+      options && Object.getPrototypeOf(options) === Object.prototype &&
+        Reflect.ownKeys(options).length === keys.length && keys.every((key) => {
+          const descriptor = Object.getOwnPropertyDescriptor(options, key);
+          return descriptor && 'value' in descriptor;
+        }),
+    );
+    requireValue(
+      typeof options.unitName === 'string' &&
+        /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,230}\.service$/.test(options.unitName),
+    );
+    requireValue(
+      text(options.description, 1024) && options.description.length > 0 &&
+        options.description.trim() === options.description && !options.description.includes('\\'),
+    );
+    requireValue(
+      absolute(options.executable) && options.executable !== '/' &&
+        !/[\\"']/.test(options.executable) && !options.executable.endsWith('/') &&
+        absolute(options.workingDirectory) &&
+        options.workingDirectory.trim() === options.workingDirectory &&
+        !options.workingDirectory.includes('\\'),
+    );
+    requireValue(
+      Array.isArray(options.args) && Object.getPrototypeOf(options.args) === Array.prototype &&
+        options.args.length <= 128 &&
+        Reflect.ownKeys(options.args).length === options.args.length + 1 &&
+        Array.from(
+          { length: options.args.length },
+          (_, index) => Object.getOwnPropertyDescriptor(options.args, String(index)),
+        )
+          .every((descriptor) => descriptor && 'value' in descriptor && text(descriptor.value)),
+    );
+    requireValue(
+      [options.user, options.group].every((value) =>
+        typeof value === 'string' && /^[a-zA-Z_][a-zA-Z0-9_-]{0,63}$/.test(value)
+      ),
+    );
+    requireValue(
+      ['no', 'on-failure', 'always'].includes(options.restart) &&
+        ['mixed', 'control-group'].includes(options.killMode) &&
+        Number.isSafeInteger(options.timeoutStopSeconds) &&
+        options.timeoutStopSeconds >= 1 && options.timeoutStopSeconds <= 600,
+    );
+    // Quoting and percent/dollar escaping follow systemd.syntax and systemd.service.
+    const quote = (value: string, command = false) =>
+      '"' + value
+        .replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%')
+        .replaceAll('$', () => command ? '$$' : '$') +
+      '"';
+    this.unitName = options.unitName;
+    this.content = [
+      '[Unit]',
+      `Description=${options.description.replaceAll('%', '%%')}`,
+      'After=local-fs.target',
+      '',
+      '[Service]',
+      'Type=exec',
+      `User=${options.user}`,
+      `Group=${options.group}`,
+      `ExecStart=${
+        [quote(options.executable), ...options.args.map((value) => quote(value, true))].join(' ')
+      }`,
+      // WorkingDirectory is a raw path value, not an ExecStart word list.
+      `WorkingDirectory=${options.workingDirectory.replaceAll('%', '%%')}`,
+      `Restart=${options.restart}`,
+      `KillMode=${options.killMode}`,
+      'KillSignal=SIGTERM',
+      'FinalKillSignal=SIGKILL',
+      'SendSIGKILL=yes',
+      'SendSIGHUP=no',
+      `TimeoutStopSec=${options.timeoutStopSeconds}s`,
+      'StandardInput=null',
+      'StandardOutput=journal',
+      'StandardError=journal',
+      '',
+      '[Install]',
+      'WantedBy=multi-user.target',
+      '',
+    ].join('\n');
+    requireValue(Buffer.byteLength(this.content) <= 16384);
+    this.sha256 = plugins.crypto.createHash('sha256').update(this.content).digest('hex');
+    Object.freeze(this);
+  }
+}

package/ts/classes.systemdunit.ts

@@ -22,6 +22,14 @@ export interface ISystemdUnitState {
   readonly job: string;
 }
 
+export interface ISystemdUnitConfigurationState {
+  readonly unitName: string;
+  readonly fragmentPath: string;
+  /** Opaque systemctl path list. An empty value proves no effective drop-ins. */
+  readonly dropInPaths: string;
+  readonly needsReload: boolean;
+}
+
 export class SystemdUnitError extends Error {
   constructor(public readonly code: 'invalid_options' | 'command_failed' | 'invalid_state') {
     super(`Systemd unit operation failed: ${code}.`);
@@ -111,6 +119,36 @@ export class SystemdUnit {
     return this.inspect();
   }
 
+  /** Reports the manager's selected definition without reading or changing its contents. */
+  public async inspectConfiguration(): Promise<ISystemdUnitConfigurationState> {
+    const keys = ['Id', 'FragmentPath', 'DropInPaths', 'NeedDaemonReload'];
+    const stdout = await this.command(['show', this.unitName, `--property=${keys.join(',')}`, '--all']);
+    const fields = new Map<string, string>();
+    for (const line of stdout.trimEnd().split('\n')) {
+      const separator = line.indexOf('='), key = line.slice(0, separator);
+      if (separator < 1 || !keys.includes(key) || fields.has(key)) {
+        throw new SystemdUnitError('invalid_state');
+      }
+      fields.set(key, line.slice(separator + 1));
+    }
+    if (fields.size !== keys.length || fields.get('Id') !== this.unitName ||
+      !['yes', 'no'].includes(fields.get('NeedDaemonReload')!)) {
+      throw new SystemdUnitError('invalid_state');
+    }
+    return Object.freeze({
+      unitName: this.unitName,
+      fragmentPath: fields.get('FragmentPath')!,
+      dropInPaths: fields.get('DropInPaths')!,
+      needsReload: fields.get('NeedDaemonReload') === 'yes',
+    });
+  }
+
+  /** Reloads unit definitions globally; does not enable, unmask, start or stop a unit. */
+  public async reloadConfiguration(): Promise<ISystemdUnitConfigurationState> {
+    await this.command(['daemon-reload']);
+    return this.inspectConfiguration();
+  }
+
   private command(argsArg: string[]): Promise<string> {
     return new Promise((resolve, reject) => {
       plugins.childProcess.execFile(

package/ts/classes.systemdunitfile.ts

@@ -0,0 +1,327 @@
+import * as plugins from './smartdaemon.plugins.js';
+import { SystemdServiceDefinition } from './classes.systemdservicedefinition.js';
+import {
+  type ISystemdUnitOptions,
+  type ISystemdUnitConfigurationState,
+  type ISystemdUnitState,
+  SystemdUnit,
+} from './classes.systemdunit.js';
+
+export interface ISystemdUnitFileOptions extends ISystemdUnitOptions {
+  /** Local vendor definitions can be installed without removing an administrator's mask. */
+  unitDirectory?: string;
+  /** Trusted owning-code qualification only. Defaults to root. */
+  expectedUid?: number;
+}
+export interface ISystemdUnitFileRecord {
+  readonly path: string;
+  readonly sha256: string;
+}
+export class SystemdUnitFileError extends Error {
+  constructor(
+    public readonly code:
+      | 'invalid_options'
+      | 'unsafe_path'
+      | 'busy'
+      | 'changed'
+      | 'unsafe_unit'
+      | 'write_failed'
+      | 'reload_failed',
+  ) {
+    super(`Systemd unit definition installation failed: ${code}.`);
+    this.name = 'SystemdUnitFileError';
+  }
+}
+const requireValue = (value: unknown, code: SystemdUnitFileError['code']): void => {
+  if (!value) throw new SystemdUnitFileError(code);
+};
+const digest = (bytes: Uint8Array) =>
+  plugins.crypto.createHash('sha256').update(bytes).digest('hex');
+const quiet = (state: ISystemdUnitState) =>
+  state.mainPid === 0 && state.controlPid === 0 &&
+  state.controlGroup === '' && state.job === '' &&
+  (state.activeState === 'inactive' && state.subState === 'dead' ||
+    state.activeState === 'failed' && state.subState === 'failed');
+const masked = (state: ISystemdUnitState) =>
+  state.loadState === 'masked' &&
+  ['masked', 'masked-runtime'].includes(state.unitFileState);
+const sameFile = (left: { dev: number; ino: number }, right: { dev: number; ino: number }) =>
+  left.dev === right.dev && left.ino === right.ino;
+
+/**
+ * Protected code/config installation, inside the caller's cross-process installation ownership scope.
+ * Other privileged writers must be serialized by that owner. Never changes enablement or masks.
+ */
+export class SystemdUnitFile {
+  public readonly path: string;
+  private readonly directory: string;
+  private readonly uid: number;
+  private readonly unit: SystemdUnit;
+  private readonly name: string;
+  private busy = false;
+
+  constructor(options: ISystemdUnitFileOptions) {
+    this.unit = new SystemdUnit(options);
+    this.name = options.unitName;
+    this.directory = options.unitDirectory ?? '/usr/local/lib/systemd/system';
+    this.uid = options.expectedUid ?? 0;
+    requireValue(
+      typeof this.directory === 'string' && this.directory !== '/' &&
+        plugins.path.isAbsolute(this.directory) &&
+        plugins.path.normalize(this.directory) === this.directory &&
+        !this.directory.endsWith('/') && !/[\x00-\x1f\x7f]/.test(this.directory) &&
+        this.directory.length <= 4000 && Number.isSafeInteger(this.uid) && this.uid >= 0,
+      'invalid_options',
+    );
+    this.path = plugins.path.join(this.directory, this.name);
+  }
+
+  /** Reads only the exact protected definition; no systemd or filesystem mutation. */
+  public async inspect(): Promise<ISystemdUnitFileRecord | null> {
+    if (!await this.directories(false)) return null;
+    const file = await this.read(this.path);
+    return file ? Object.freeze({ path: this.path, sha256: digest(file.bytes) }) : null;
+  }
+
+  /**
+   * Expected previous digest is mandatory; null admits an absent file. Exact desired bytes are idempotent.
+   * Retains changed definitions beside the unit before replacement. A failed reload never rolls code back.
+   */
+  public async install(
+    definition: SystemdServiceDefinition,
+    expectedSha256: string | null,
+  ): Promise<Readonly<{ changed: boolean; record: ISystemdUnitFileRecord; masked: boolean }>> {
+    requireValue(
+      definition instanceof SystemdServiceDefinition && definition.unitName === this.name &&
+        (expectedSha256 === null ||
+          typeof expectedSha256 === 'string' && /^[a-f0-9]{64}$/.test(expectedSha256)),
+      'invalid_options',
+    );
+    requireValue(!this.busy, 'busy');
+    this.busy = true;
+    let temporary: string | undefined;
+    let temporaryInfo: plugins.Stats | undefined;
+    try {
+      const before = await this.unit.inspect();
+      const beforeConfiguration = await this.admit(before);
+      await this.directories(true);
+      const parent = await plugins.fs.lstat(this.directory);
+      const previous = await this.read(this.path);
+      const previousSha = previous ? digest(previous.bytes) : null;
+      const changed = previousSha !== definition.sha256;
+      requireValue(!changed || previousSha === expectedSha256, 'changed');
+      if (changed) {
+        if (previous) {
+          const backup = `${this.path}.previous-${previousSha}`;
+          try {
+            await this.create(backup, previous.bytes);
+          } catch (error) {
+            if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+            requireValue(digest((await this.read(backup))!.bytes) === previousSha, 'changed');
+          }
+          await this.flushDirectory(parent);
+        }
+        temporary = plugins.path.join(
+          this.directory,
+          `.${this.name}.${plugins.crypto.randomUUID()}.tmp`,
+        );
+        await this.create(temporary, Buffer.from(definition.content));
+        temporaryInfo = await plugins.fs.lstat(temporary);
+        const current = await this.read(this.path);
+        requireValue(
+          (current ? digest(current.bytes) : null) === previousSha &&
+            (!current || previous && sameFile(current.info, previous.info)),
+          'changed',
+        );
+        requireValue(sameFile(parent, await plugins.fs.lstat(this.directory)), 'unsafe_path');
+        const rechecked = await this.unit.inspect();
+        requireValue(JSON.stringify(rechecked) === JSON.stringify(before), 'changed');
+        const recheckedConfiguration = await this.admit(rechecked);
+        requireValue(
+          recheckedConfiguration.fragmentPath === beforeConfiguration.fragmentPath,
+          'changed',
+        );
+        await plugins.fs.rename(temporary, this.path);
+        temporary = undefined;
+        await this.flushDirectory(parent);
+      }
+      try {
+        const reloadedConfiguration = await this.unit.reloadConfiguration();
+        const after = await this.unit.inspect();
+        requireValue(
+          quiet(after) &&
+            (before.loadState === 'not-found'
+              ? after.loadState === 'loaded' && after.unitFileState === 'disabled'
+              : after.loadState === before.loadState &&
+                after.unitFileState === before.unitFileState),
+          'changed',
+        );
+        const configuration = await this.unit.inspectConfiguration();
+        requireValue(
+          [reloadedConfiguration, configuration].every((snapshot) =>
+            !snapshot.needsReload && snapshot.dropInPaths === '' &&
+            snapshot.fragmentPath ===
+              (masked(after) ? beforeConfiguration.fragmentPath : this.path)
+          ),
+          'unsafe_unit',
+        );
+        const installed = await this.inspect();
+        requireValue(installed?.sha256 === definition.sha256, 'changed');
+        return Object.freeze({ changed, record: installed!, masked: masked(after) });
+      } catch {
+        throw new SystemdUnitFileError('reload_failed');
+      }
+    } catch (error) {
+      if (error instanceof SystemdUnitFileError) throw error;
+      throw new SystemdUnitFileError('write_failed');
+    } finally {
+      try {
+        if (temporary && temporaryInfo) {
+          const named = await plugins.fs.lstat(temporary);
+          requireValue(sameFile(temporaryInfo, named), 'unsafe_path');
+          await plugins.fs.unlink(temporary);
+        }
+      } finally {
+        this.busy = false;
+      }
+    }
+  }
+
+  private async admit(state: ISystemdUnitState): Promise<ISystemdUnitConfigurationState> {
+    requireValue(
+      quiet(state) && (masked(state) ||
+        state.loadState === 'loaded' &&
+          ['enabled', 'enabled-runtime', 'disabled'].includes(state.unitFileState) ||
+        state.loadState === 'not-found' && state.unitFileState === ''),
+      'unsafe_unit',
+    );
+    const configuration = await this.unit.inspectConfiguration();
+    const maskPath = plugins.path.join(
+      state.unitFileState === 'masked-runtime' ? '/run/systemd/system' : '/etc/systemd/system',
+      this.name,
+    );
+    requireValue(
+      !configuration.needsReload && configuration.dropInPaths === '' &&
+        (masked(state)
+          ? configuration.fragmentPath !== this.path &&
+            ['/dev/null', maskPath].includes(configuration.fragmentPath)
+          : configuration.fragmentPath === (state.loadState === 'not-found' ? '' : this.path)),
+      'unsafe_unit',
+    );
+    return configuration;
+  }
+
+  private async directories(create: boolean): Promise<boolean> {
+    requireValue(process.platform === 'linux' && process.getuid?.() === this.uid, 'unsafe_path');
+    let directory = '/';
+    for (const part of this.directory.split('/').filter(Boolean)) {
+      directory = plugins.path.join(directory, part);
+      let info: plugins.Stats;
+      try {
+        info = await plugins.fs.lstat(directory);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+        if (!create) return false;
+        await plugins.fs.mkdir(directory, { mode: 0o755 });
+        const parent = await plugins.fs.open(
+          plugins.path.dirname(directory),
+          plugins.fsConstants.O_RDONLY | plugins.fsConstants.O_DIRECTORY |
+            plugins.fsConstants.O_NOFOLLOW,
+        );
+        try {
+          await parent.sync();
+        } finally {
+          await parent.close();
+        }
+        info = await plugins.fs.lstat(directory);
+      }
+      requireValue(
+        info.isDirectory() && !info.isSymbolicLink() && [0, this.uid].includes(info.uid) &&
+          ((info.mode & 0o022) === 0 || directory === '/tmp' && info.uid === 0 &&
+              (info.mode & 0o7777) === 0o1777),
+        'unsafe_path',
+      );
+    }
+    return true;
+  }
+
+  private async read(path: string): Promise<{ bytes: Buffer; info: plugins.Stats } | null> {
+    let file: Awaited<ReturnType<typeof plugins.fs.open>>;
+    try {
+      file = await plugins.fs.open(
+        path,
+        plugins.fsConstants.O_RDONLY | plugins.fsConstants.O_NOFOLLOW |
+          plugins.fsConstants.O_NONBLOCK,
+      );
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+      throw new SystemdUnitFileError('unsafe_path');
+    }
+    try {
+      const info = await file.stat();
+      requireValue(
+        info.isFile() && info.uid === this.uid && info.nlink === 1 &&
+          (info.mode & 0o7777) === 0o644 && info.size <= 16384,
+        'unsafe_path',
+      );
+      const bytes = Buffer.alloc(16385);
+      let size = 0;
+      for (;;) {
+        const result = await file.read(bytes, size, bytes.length - size, size);
+        if (result.bytesRead === 0) break;
+        size += result.bytesRead;
+        requireValue(size <= 16384, 'unsafe_path');
+      }
+      const after = await file.stat(), named = await plugins.fs.lstat(path);
+      requireValue(
+        sameFile(info, named) && !named.isSymbolicLink() && after.size === size &&
+          info.size === after.size && info.mtimeMs === after.mtimeMs &&
+          info.ctimeMs === after.ctimeMs,
+        'changed',
+      );
+      return { bytes: bytes.subarray(0, size), info };
+    } finally {
+      await file.close();
+    }
+  }
+
+  private async create(path: string, bytes: Uint8Array): Promise<void> {
+    const file = await plugins.fs.open(
+      path,
+      plugins.fsConstants.O_CREAT | plugins.fsConstants.O_EXCL |
+        plugins.fsConstants.O_WRONLY | plugins.fsConstants.O_NOFOLLOW,
+      0o644,
+    );
+    let created: plugins.Stats | undefined;
+    try {
+      try {
+        created = await file.stat();
+        await file.chmod(0o644);
+        await file.writeFile(bytes);
+        await file.sync();
+      } finally {
+        await file.close();
+      }
+    } catch (error) {
+      if (created) {
+        requireValue(sameFile(created, await plugins.fs.lstat(path)), 'unsafe_path');
+        await plugins.fs.unlink(path);
+      }
+      throw error;
+    }
+  }
+
+  private async flushDirectory(expected: plugins.Stats): Promise<void> {
+    const directory = await plugins.fs.open(
+      this.directory,
+      plugins.fsConstants.O_RDONLY |
+        plugins.fsConstants.O_DIRECTORY | plugins.fsConstants.O_NOFOLLOW,
+    );
+    try {
+      requireValue(sameFile(expected, await directory.stat()), 'unsafe_path');
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  }
+}

package/ts/index.ts

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

package/ts/smartdaemon.plugins.ts

@@ -1,8 +1,12 @@
 // node native scope
 import * as path from 'path';
 import * as childProcess from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import * as crypto from 'node:crypto';
+export type { Stats } from 'node:fs';
 
-export { path, childProcess };
+export { path, childProcess, fs, fsConstants, crypto };
 
 // @pushrocks scope
 import * as lik from '@push.rocks/lik';