@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.921

package/dist/heart/daemon/sanctuary-telegram-authority-entry.js

@@ -0,0 +1,475 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSanctuaryTelegramAuthorityConfig = loadSanctuaryTelegramAuthorityConfig;
+exports.startSanctuaryTelegramAuthority = startSanctuaryTelegramAuthority;
+exports.runSanctuaryTelegramAuthorityCli = runSanctuaryTelegramAuthorityCli;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+const telegram_client_1 = require("../../senses/telegram-client");
+const sanctuary_telegram_authority_gateway_1 = require("./sanctuary-telegram-authority-gateway");
+const sanctuary_host_authority_1 = require("./sanctuary-host-authority");
+const sanctuary_authority_ledger_1 = require("./sanctuary-authority-ledger");
+const sanctuary_authority_codec_1 = require("./sanctuary-authority-codec");
+const sanctuary_host_detached_supervisor_1 = require("./sanctuary-host-detached-supervisor");
+const sanctuary_host_executor_1 = require("./sanctuary-host-executor");
+const sanctuary_authority_installation_1 = require("./sanctuary-authority-installation");
+const sanctuary_authority_epoch_1 = require("./sanctuary-authority-epoch");
+const sanctuary_telegram_authority_service_1 = require("./sanctuary-telegram-authority-service");
+const MAX_PRIVATE_FILE_BYTES = 64 * 1024;
+const MAX_ATTACHMENT_BYTES = 20_000_000;
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function readPrivateFile(filePath, expectedUid) {
+    if (!path.isAbsolute(filePath))
+        throw new Error("Sanctuary Telegram authority private path must be absolute");
+    const handle = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    try {
+        const stat = fs.fstatSync(handle);
+        if (!stat.isFile() || stat.nlink !== 1 || stat.uid !== expectedUid || stat.gid !== (expectedUid === 0 ? 0 : process.getgid())
+            || (stat.mode & 0o7777) !== 0o600 || fs.realpathSync(filePath) !== filePath || stat.size < 1 || stat.size > MAX_PRIVATE_FILE_BYTES)
+            throw new Error("Sanctuary Telegram authority private file is unsafe");
+        return fs.readFileSync(handle, "utf8");
+    }
+    finally {
+        fs.closeSync(handle);
+    }
+}
+function loadSanctuaryTelegramAuthorityConfig(configPath, options = {}) {
+    const expectedUid = options.expectedUid ?? 0;
+    const value = JSON.parse(readPrivateFile(configPath, expectedUid));
+    const keys = [
+        "schemaVersion", "agentRoot", "targetHost", "botId", "ownerUserId", "ownerChatId", "keyId",
+        "publicKeyDigest", "tokenPath", "privateKeyPath", "socketPath", "socketGroupId", "readinessPath", "lockPath",
+        "hostStagingRoot", "hostExecutionStateRoot", "hostSupervisorStateRoot", "hostCgroupRoot", "hostSupervisorProgramPath",
+        "hostSupervisorProgramDigest", "hostLauncherPath", "hostLauncherDigest", "hostPrlimitPath",
+        "hostPrlimitDigest", "hostSetsidPath", "hostSetsidDigest",
+        "hostShellPath", "hostShellDigest",
+        "epochRoot", "packageRoot", "packageManifestPath", "packageManifestDigest",
+    ];
+    if (!isObject(value)
+        || !exactKeys(value, keys)
+        || value.schemaVersion !== 1
+        || ![
+            "agentRoot", "tokenPath", "privateKeyPath", "socketPath", "readinessPath", "lockPath",
+            "hostStagingRoot", "hostExecutionStateRoot", "hostSupervisorStateRoot", "hostCgroupRoot", "hostSupervisorProgramPath",
+            "hostLauncherPath", "hostPrlimitPath", "hostSetsidPath",
+            "hostShellPath",
+            "epochRoot", "packageRoot", "packageManifestPath",
+        ]
+            .every((key) => typeof value[key] === "string" && path.isAbsolute(value[key]))
+        || !["targetHost", "keyId"].every((key) => typeof value[key] === "string" && value[key].length > 0)
+        || !["botId", "ownerUserId", "ownerChatId"].every((key) => typeof value[key] === "string" && /^[1-9][0-9]*$/u.test(value[key]))
+        || typeof value.publicKeyDigest !== "string"
+        || !/^sha256:[a-f0-9]{64}$/u.test(value.publicKeyDigest)
+        || !["hostSupervisorProgramDigest", "hostLauncherDigest", "hostPrlimitDigest", "hostSetsidDigest", "hostShellDigest", "packageManifestDigest"]
+            .every((key) => typeof value[key] === "string" && /^sha256:[a-f0-9]{64}$/u.test(value[key]))
+        || !Number.isSafeInteger(value.socketGroupId)
+        || value.socketGroupId < 1) {
+        throw new Error("Sanctuary Telegram authority configuration is invalid");
+    }
+    readPrivateFile(value.tokenPath, expectedUid);
+    readPrivateFile(value.privateKeyPath, expectedUid);
+    return value;
+}
+function privateDirectory(directory, mode) {
+    fs.mkdirSync(directory, { recursive: true, mode });
+    const stat = fs.lstatSync(directory);
+    if (!stat.isDirectory() || fs.realpathSync(directory) !== directory || (stat.mode & 0o7777) !== mode)
+        throw new Error("Sanctuary Telegram authority directory is unsafe");
+}
+function writePrivateJson(filePath, value, mode = 0o600) {
+    const directoryMode = mode === 0o600 ? 0o700 : 0o750;
+    privateDirectory(path.dirname(filePath), directoryMode);
+    const temporaryPath = `${filePath}.${process.pid}.tmp`;
+    const handle = fs.openSync(temporaryPath, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY | fs.constants.O_NOFOLLOW, 0o600);
+    try {
+        try {
+            fs.writeFileSync(handle, `${JSON.stringify(value)}\n`, "utf8");
+            fs.fsyncSync(handle);
+        }
+        finally {
+            fs.closeSync(handle);
+        }
+        fs.renameSync(temporaryPath, filePath);
+    }
+    catch (error) {
+        fs.unlinkSync(temporaryPath);
+        throw error;
+    }
+    fs.chmodSync(filePath, mode);
+    const directory = fs.openSync(path.dirname(filePath), fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW);
+    try {
+        fs.fsyncSync(directory);
+    }
+    finally {
+        fs.closeSync(directory);
+    }
+}
+function acquireProcessLock(lockPath, expectedUid, processAlive) {
+    privateDirectory(path.dirname(lockPath), 0o700);
+    try {
+        const existing = readPrivateFile(lockPath, expectedUid).trim();
+        const pid = Number(existing);
+        if (Number.isSafeInteger(pid) && pid > 0 && processAlive(pid)) {
+            throw new Error("Sanctuary Telegram authority is already running");
+        }
+        fs.unlinkSync(lockPath);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            if (error instanceof Error && error.message.includes("already running"))
+                throw error;
+            throw error;
+        }
+    }
+    const handle = fs.openSync(lockPath, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY | fs.constants.O_NOFOLLOW, 0o600);
+    fs.writeFileSync(handle, String(process.pid), "utf8");
+    fs.fsyncSync(handle);
+    fs.closeSync(handle);
+    return () => fs.rmSync(lockPath, { force: true });
+}
+async function readBoundedFileResponse(response) {
+    if (!response.ok)
+        throw new Error(`Sanctuary Telegram file download failed with HTTP ${response.status}`);
+    const advertised = Number(response.headers.get("content-length"));
+    if (Number.isFinite(advertised) && advertised > MAX_ATTACHMENT_BYTES) {
+        throw new Error("Sanctuary Telegram file download exceeds its limit");
+    }
+    if (!response.body)
+        throw new Error("Sanctuary Telegram file download is empty");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > MAX_ATTACHMENT_BYTES)
+                throw new Error("Sanctuary Telegram file download exceeds its limit");
+            chunks.push(Buffer.from(value));
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+    }
+    const contentType = response.headers.get("content-type");
+    return { body: Buffer.concat(chunks, total), ...(contentType ? { contentType } : {}) };
+}
+const GET_ME_BACKOFF_MS = [5_000, 10_000, 20_000, 30_000];
+const NETWORK_FAILURE = /fetch failed|ECONNRESET|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|EPIPE|socket hang up|network|timed out/iu;
+/** A getMe failure worth another try: Telegram 5xx, or no HTTP answer at all (the client reports a
+ * transport failure as a status-less TelegramApiError). Auth and other 4xx answers are never retried. */
+function isTransientTelegramFailure(error) {
+    if (!(error instanceof telegram_client_1.TelegramApiError))
+        return false;
+    if (error.status !== null)
+        return error.status >= 500;
+    return error.errorCode === null && NETWORK_FAILURE.test(error.message);
+}
+async function getMeWithRetry(api, sleep) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await api.request("getMe", {});
+        }
+        catch (error) {
+            if (attempt >= GET_ME_BACKOFF_MS.length || !isTransientTelegramFailure(error))
+                throw error;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.sanctuary_authority_getme_retry",
+                message: "Telegram getMe failed with a transient error; retrying",
+                meta: { attempt: attempt + 1, delayMs: GET_ME_BACKOFF_MS[attempt] },
+            });
+            await sleep(GET_ME_BACKOFF_MS[attempt]);
+        }
+    }
+}
+async function startSanctuaryTelegramAuthority(options) {
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.sanctuary_authority_boot_requested", message: "Sanctuary authority boot requested; prerequisite verification pending" });
+    const expectedUid = options.expectedUid ?? 0;
+    if (process.getuid() !== expectedUid) {
+        throw new Error("Sanctuary Telegram authority must run as the configured root owner");
+    }
+    const config = options.loadConfig
+        ? options.loadConfig(options.configPath, expectedUid)
+        : loadSanctuaryTelegramAuthorityConfig(options.configPath, { expectedUid });
+    const expectedGid = expectedUid === 0 ? 0 : process.getgid();
+    (0, sanctuary_authority_installation_1.verifySanctuaryAuthorityInstallation)({
+        packageRoot: config.packageRoot, manifestPath: config.packageManifestPath, manifestDigest: config.packageManifestDigest,
+        stateRoot: config.epochRoot, stagingRoot: config.hostStagingRoot, socketRoot: path.dirname(config.socketPath),
+        cgroupRoot: config.hostCgroupRoot, expectedUid, expectedGid, socketGroupId: config.socketGroupId,
+    });
+    const epoch = (0, sanctuary_authority_epoch_1.readSanctuaryAuthorityEpoch)(config.epochRoot, { expectedUid, expectedGid });
+    if (epoch.state !== "prepared" || epoch.epochId !== config.keyId || epoch.botId !== config.botId
+        || epoch.ownerUserId !== config.ownerUserId || epoch.ownerChatId !== config.ownerChatId || epoch.publicKeyDigest !== config.publicKeyDigest
+        || epoch.tokenPath !== config.tokenPath || epoch.packageDigest !== config.packageManifestDigest)
+        throw new Error("Sanctuary authority epoch is retired or does not match its installation");
+    if (!options.retireOnly && fs.existsSync(path.join(config.epochRoot, "retiring.json")))
+        throw new Error("Sanctuary authority retirement must finish before restart");
+    const readPrivateText = options.readPrivateText ?? readPrivateFile;
+    const processAlive = options.processAlive ?? ((pid) => {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            return error.code === "EPERM";
+        }
+    });
+    const releaseLock = acquireProcessLock(config.lockPath, expectedUid, processAlive);
+    let api;
+    let server;
+    let service;
+    let closed = false;
+    try {
+        const token = readPrivateText(config.tokenPath, expectedUid).trim();
+        if (!/^[1-9][0-9]*:[A-Za-z0-9_-]{20,}$/u.test(token)) {
+            throw new Error("Sanctuary Telegram authority token is invalid");
+        }
+        const privateKey = (0, node_crypto_1.createPrivateKey)(readPrivateText(config.privateKeyPath, expectedUid));
+        const publicKey = (0, node_crypto_1.createPublicKey)(privateKey);
+        if (!options.retireOnly) {
+            api = (options.createApi ?? ((value) => (0, telegram_client_1.createTelegramBotApi)({ token: value })))(token);
+            const identity = await getMeWithRetry(api, options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))));
+            if (!isObject(identity) || String(identity.id) !== config.botId) {
+                throw new Error("Sanctuary Telegram authority bot identity changed");
+            }
+        }
+        const gateway = new sanctuary_telegram_authority_gateway_1.FileSanctuaryTelegramAuthorityGateway(config.agentRoot, {
+            targetHost: config.targetHost,
+            botId: config.botId,
+            ownerUserId: config.ownerUserId,
+            ownerChatId: config.ownerChatId,
+            keyId: config.keyId,
+            publicKeyDigest: config.publicKeyDigest,
+            privateKey,
+            now: options.now,
+        });
+        if (!fs.existsSync((0, sanctuary_telegram_authority_gateway_1.sanctuaryTelegramAuthorityStatePath)(config.agentRoot)))
+            throw new Error("Sanctuary authority cursor state is absent");
+        if (gateway.cursor() < epoch.predecessorCursor)
+            throw new Error("Sanctuary authority cursor precedes its epoch");
+        const hostAuthority = new sanctuary_host_authority_1.FileSanctuaryHostAuthority(config.agentRoot, {
+            targetHost: config.targetHost,
+            botId: config.botId,
+            ownerUserId: config.ownerUserId,
+            ownerChatId: config.ownerChatId,
+            keyId: config.keyId,
+            publicKeyDigest: config.publicKeyDigest,
+            publicKey,
+            privateKey,
+            now: options.now,
+            resolveOwnerObservation: (input) => gateway.ownerObservation(input),
+        });
+        hostAuthority.reconcilePrepared();
+        const hostExecutor = options.createHostExecutor?.({ config, privateKey, publicKey, expectedUid }) ?? (() => {
+            const hostSupervisor = new sanctuary_host_detached_supervisor_1.DetachedSanctuaryHostSupervisor({
+                stateRoot: config.hostSupervisorStateRoot,
+                cgroupRoot: config.hostCgroupRoot,
+                programPath: config.hostSupervisorProgramPath,
+                programDigest: config.hostSupervisorProgramDigest,
+                launcherPath: config.hostLauncherPath,
+                launcherDigest: config.hostLauncherDigest,
+                prlimitPath: config.hostPrlimitPath,
+                prlimitDigest: config.hostPrlimitDigest,
+                setsidPath: config.hostSetsidPath,
+                setsidDigest: config.hostSetsidDigest,
+                shellPath: config.hostShellPath,
+                shellDigest: config.hostShellDigest,
+                expectedUid,
+                keyId: config.keyId,
+                publicKeyPem: publicKey.export({ type: "spki", format: "pem" }).toString(),
+            });
+            return new sanctuary_host_executor_1.SanctuaryHostPermitExecutor({
+                ledger: new sanctuary_authority_ledger_1.FileSanctuaryAuthorityLedger(config.agentRoot),
+                expectedTargetHost: config.targetHost,
+                expectedOwnerUserId: config.ownerUserId,
+                expectedOwnerChatId: config.ownerChatId,
+                expectedKeyId: config.keyId,
+                expectedPublicKeyDigest: config.publicKeyDigest,
+                publicKey,
+                privateKey,
+                stagingRoot: config.hostStagingRoot,
+                stateRoot: config.hostExecutionStateRoot,
+                supervisor: hostSupervisor,
+                now: options.now,
+            });
+        })();
+        async function reconcileExecutions() {
+            for (const receipt of await hostExecutor.reconcile?.() ?? []) {
+                const registrationId = String(receipt.payload.registrationId);
+                const status = hostAuthority.status(registrationId);
+                if (status?.state === "permitted") {
+                    hostAuthority.completeExecution(registrationId, receipt);
+                }
+                else if (status?.state !== "executed"
+                    || !sameSignedReceipt(status.receipt, receipt)) {
+                    throw new Error("Sanctuary host execution receipt is not incorporated into authority state");
+                }
+                hostExecutor.acknowledge?.(String(receipt.payload.permitId));
+            }
+        }
+        const ledger = new sanctuary_authority_ledger_1.FileSanctuaryAuthorityLedger(config.agentRoot);
+        const control = {
+            close: async () => {
+                if (closed)
+                    return;
+                closed = true;
+                fs.rmSync(config.readinessPath, { force: true });
+                await server?.close();
+                api?.stop();
+                releaseLock();
+            },
+            retire: async () => {
+                writePrivateJson(path.join(config.epochRoot, "retiring.json"), { schemaVersion: 1, keyId: config.keyId });
+                fs.rmSync(config.readinessPath, { force: true });
+                await server?.close();
+                server = undefined;
+                await service?.drainHostExecutions();
+                api?.stop();
+                api = undefined;
+                hostAuthority.retireRegistrations(ledger);
+                await reconcileExecutions();
+                if (hostAuthority.retireRegistrations(ledger).length !== 0
+                    || (0, sanctuary_authority_installation_1.sanctuaryCgroupChildren)(config.hostCgroupRoot).length !== 0)
+                    throw new Error("Sanctuary authority retirement cleanup is unproven");
+                writePrivateJson(path.join(config.epochRoot, "retirement.json"), {
+                    schemaVersion: 1, keyId: config.keyId, publicKeyDigest: config.publicKeyDigest,
+                    cursor: gateway.cursor(), quiescent: true,
+                });
+                await control.close();
+            },
+        };
+        if (options.retireOnly) {
+            await control.retire();
+            return control;
+        }
+        await reconcileExecutions();
+        function sameSignedReceipt(left, right) {
+            return isObject(left)
+                && typeof left.domain === "string"
+                && typeof left.keyId === "string"
+                && typeof left.signature === "string"
+                && isObject(left.payload)
+                && left.domain === right.domain
+                && left.keyId === right.keyId
+                && left.signature === right.signature
+                && (0, sanctuary_authority_codec_1.authorityArtifactDigest)(left.domain, left.payload) === (0, sanctuary_authority_codec_1.authorityArtifactDigest)(right.domain, right.payload);
+        }
+        const fetchImpl = options.fetch ?? globalThis.fetch;
+        service = new sanctuary_telegram_authority_service_1.SanctuaryTelegramAuthorityService({
+            api: api,
+            gateway,
+            hostAuthority,
+            hostExecutor,
+            downloadFile: async (filePath) => readBoundedFileResponse(await fetchImpl(`https://api.telegram.org/file/bot${token}/${filePath}`, { signal: AbortSignal.timeout(30_000) })),
+        });
+        server = (options.createServer ?? ((value) => (0, sanctuary_telegram_authority_service_1.createSanctuaryTelegramAuthorityServer)({
+            socketPath: value.socketPath,
+            dispatch: (method, params) => value.service.dispatch(method, params),
+        })))({ socketPath: config.socketPath, service, gateway });
+        await server.listen();
+        const residentPinsPath = path.join(path.dirname(config.socketPath), "resident.json");
+        writePrivateJson(residentPinsPath, {
+            schemaVersion: 1, ...gateway.identity(), publicKeyPem: publicKey.export({ type: "spki", format: "pem" }).toString(),
+        }, 0o640);
+        if (options.setSocketOwnership) {
+            options.setSocketOwnership(config);
+        }
+        else if (expectedUid === 0) {
+            ;
+            (options.chown ?? fs.chownSync)(path.dirname(config.socketPath), 0, config.socketGroupId);
+            (options.chmod ?? fs.chmodSync)(path.dirname(config.socketPath), 0o750);
+            (options.chown ?? fs.chownSync)(config.socketPath, 0, config.socketGroupId);
+            (options.chmod ?? fs.chmodSync)(config.socketPath, 0o660);
+            (options.chown ?? fs.chownSync)(residentPinsPath, 0, config.socketGroupId);
+        }
+        const startedAt = options.now?.() ?? new Date().toISOString();
+        writePrivateJson(config.readinessPath, {
+            schemaVersion: 1,
+            status: "ready",
+            botId: config.botId,
+            socketPath: config.socketPath,
+            publicKeyDigest: config.publicKeyDigest,
+            startedAt,
+        });
+        return control;
+    }
+    catch (error) {
+        await server?.close().catch(() => undefined);
+        api?.stop();
+        fs.rmSync(config.readinessPath, { force: true });
+        releaseLock();
+        throw error;
+    }
+}
+async function runSanctuaryTelegramAuthorityCli(options = {}) {
+    const argv = options.argv ?? process.argv;
+    const configIndex = argv.indexOf("--config");
+    const configPath = configIndex >= 0 ? argv[configIndex + 1] : undefined;
+    if (!configPath)
+        throw new Error("Sanctuary Telegram authority requires --config");
+    const authority = await (options.start ?? startSanctuaryTelegramAuthority)({ configPath, ...(argv.includes("--retire-only") ? { retireOnly: true } : {}) });
+    const close = async () => {
+        await authority.close();
+        const exit = options.exit ?? process.exit;
+        exit(0);
+    };
+    const once = options.once ?? ((event, listener) => { process.once(event, listener); });
+    once("SIGINT", () => { void close(); });
+    once("SIGTERM", () => { void close(); });
+    once("SIGUSR2", () => {
+        void authority.retire().then(() => (options.exit ?? process.exit)(0)).catch(() => (options.exit ?? process.exit)(1));
+    });
+}
+if (process.argv[1] && fs.existsSync(process.argv[1]) && fs.realpathSync(process.argv[1]) === __filename) {
+    void runSanctuaryTelegramAuthorityCli().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : "Sanctuary Telegram authority failed"}\n`);
+        process.exitCode = 1;
+    });
+}