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

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

@@ -0,0 +1,676 @@
+"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.SocketSanctuaryTelegramAuthorityClient = exports.SanctuaryTelegramAuthorityService = void 0;
+exports.createSanctuaryTelegramAuthorityServer = createSanctuaryTelegramAuthorityServer;
+const fs = __importStar(require("node:fs"));
+const net = __importStar(require("node:net"));
+const path = __importStar(require("node:path"));
+const telegram_client_1 = require("../../senses/telegram-client");
+const telegram_effect_adapter_1 = require("../../senses/telegram-effect-adapter");
+const frontend_socket_client_1 = require("../frontend-socket-client");
+const sanctuary_authority_codec_1 = require("./sanctuary-authority-codec");
+const runtime_1 = require("../../nerves/runtime");
+const PROTOCOL_VERSION = 1;
+const DEFAULT_MAX_REQUEST_BYTES = 256 * 1024;
+const DEFAULT_CONNECTION_TIMEOUT_MS = 65_000;
+const MAX_TELEGRAM_ATTACHMENT_BYTES = 20_000_000;
+const SAFE_TELEGRAM_FILE_PATH = /^(?!\/)(?!.*(?:^|\/)\.\.(?:\/|$))[A-Za-z0-9._/-]{1,512}$/u;
+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 emptyParams(value) {
+    return isObject(value) && Object.keys(value).length === 0;
+}
+function exactBody(value, required, optional = []) {
+    if (!isObject(value))
+        return false;
+    const keys = Object.keys(value);
+    return required.every((key) => keys.includes(key))
+        && keys.every((key) => required.includes(key) || optional.includes(key));
+}
+function boundedText(value, maxLength) {
+    return typeof value === "string" && value.length > 0 && value.length <= maxLength;
+}
+// After a gateway restart, Telegram keeps the previous getUpdates long-poll
+// alive server-side and answers 409 Conflict to the new poller until that
+// session expires (about the previous poll's timeout). Retry through that
+// window so the tokenless resident never sees the reclaim error; a transient
+// 5xx from Telegram is retried the same way.
+const AUTHORITY_POLL_RECLAIM_ATTEMPTS = 20;
+const AUTHORITY_POLL_RECLAIM_DELAY_MS = 4_000;
+class SanctuaryTelegramAuthorityService {
+    #api;
+    #pollReclaimAttempts;
+    #pollReclaimDelayMs;
+    #gateway;
+    #downloadFile;
+    #hostAuthority;
+    #hostExecutor;
+    #allowedFilePaths = new Set();
+    #hostExecutions = new Map();
+    #hostExecutionFailures = new Map();
+    #hostMaintenanceFailures = new Map();
+    constructor(options) {
+        this.#api = {
+            request: (method, body) => options.api.request(method, body, AbortSignal.timeout(method === "getUpdates" ? 60_000 : 15_000)),
+        };
+        this.#gateway = options.gateway;
+        this.#hostAuthority = options.hostAuthority;
+        this.#hostExecutor = options.hostExecutor;
+        this.#downloadFile = options.downloadFile;
+        this.#pollReclaimAttempts = options.pollReclaimAttempts ?? AUTHORITY_POLL_RECLAIM_ATTEMPTS;
+        this.#pollReclaimDelayMs = options.pollReclaimDelayMs ?? AUTHORITY_POLL_RECLAIM_DELAY_MS;
+    }
+    async drainHostExecutions() {
+        await Promise.allSettled(this.#hostExecutions.values());
+    }
+    async #pollUpdates() {
+        for (let attempt = 1;; attempt += 1) {
+            try {
+                return await this.#api.request("getUpdates", {
+                    offset: this.#gateway.cursor(),
+                    timeout: 50,
+                    allowed_updates: ["message", "callback_query"],
+                });
+            }
+            catch (error) {
+                const status = error instanceof telegram_client_1.TelegramApiError ? error.status : null;
+                const reclaimable = status === 409 || (status !== null && status >= 500);
+                if (!reclaimable || attempt >= this.#pollReclaimAttempts)
+                    throw error;
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.sanctuary_authority_poll_reclaim",
+                    message: "getUpdates conflicted while reclaiming the Telegram session; retrying",
+                    meta: { status, attempt },
+                });
+                await new Promise((resolve) => setTimeout(resolve, this.#pollReclaimDelayMs));
+            }
+        }
+    }
+    #hostReady() {
+        return this.#hostExecutor !== undefined && (this.#hostExecutor.isHealthy?.() ?? true);
+    }
+    async dispatch(method, params) {
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.sanctuary_authority_request_received", message: "Sanctuary authority protocol request received; validation pending" });
+        if (this.#hostAuthority) {
+            for (const registrationId of this.#hostAuthority.expireRegistrations()) {
+                await this.#maintainHostCard(registrationId);
+            }
+        }
+        if (method === "telegram.poll") {
+            if (!emptyParams(params))
+                throw new Error("Sanctuary Telegram poll params are invalid");
+            const updates = await this.#pollUpdates();
+            if (!Array.isArray(updates))
+                throw new Error("Sanctuary Telegram poll result must be an array");
+            this.#gateway.capture(updates);
+            const observation = this.#gateway.poll();
+            if (!observation)
+                return null;
+            const record = this.#gateway.record(observation.payload.updateId);
+            if (!record || record.disposition !== "dispatch") {
+                throw new Error("Sanctuary Telegram pending observation state is unavailable");
+            }
+            const callback = record.rawUpdate.callback_query;
+            let hostCallback = null;
+            if (callback && callback.message && this.#hostAuthority) {
+                hostCallback = this.#hostAuthority.claimCallback({
+                    callbackQueryId: callback.id,
+                    callbackData: callback.data ?? "",
+                    telegramMessageId: callback.message.message_id,
+                    userId: String(callback.from.id),
+                    chatId: String(callback.message.chat.id),
+                    callbackObservationDigest: (0, sanctuary_authority_codec_1.authorityArtifactDigest)(observation.domain, observation.payload),
+                    decidedAt: observation.payload.observedAt,
+                });
+                if (hostCallback)
+                    await this.#maintainHostCard(hostCallback.payload.registrationId);
+            }
+            return {
+                observation, update: record.deliveryUpdate ?? record.rawUpdate,
+                ...(hostCallback ? {
+                    hostClaimed: true, hostCallback,
+                    ...(hostCallback.payload.decision ? { hostDecision: hostCallback.payload.decision } : {}),
+                } : {}),
+            };
+        }
+        if (method === "telegram.settle") {
+            this.#gateway.settle(params);
+            return { settled: true, cursor: this.#gateway.cursor() };
+        }
+        if (method === "telegram.cursor") {
+            if (!emptyParams(params))
+                throw new Error("Sanctuary Telegram cursor params are invalid");
+            return { cursor: this.#gateway.cursor() };
+        }
+        if (method === "telegram.cursor.snapshot") {
+            if (!emptyParams(params))
+                throw new Error("Sanctuary Telegram cursor snapshot params are invalid");
+            return this.#gateway.cursorSnapshot();
+        }
+        if (method === "telegram.chat.admit") {
+            this.#gateway.admitChat(params);
+            return { admitted: true };
+        }
+        if (method === "telegram.chat.revoke") {
+            this.#gateway.revokeChat(params);
+            return { revoked: true };
+        }
+        if (method === "telegram.request") {
+            if ((!exactKeys(params, ["method", "body"]) && !exactKeys(params, ["method", "body", "observation"]))
+                || typeof params.method !== "string") {
+                throw new Error("Sanctuary Telegram request params are invalid");
+            }
+            const requestMethod = params.method;
+            const body = params.body;
+            const ownerChatId = this.#gateway.identity().ownerChatId;
+            if (requestMethod === "getMe") {
+                if (!emptyParams(body))
+                    throw new Error("Sanctuary Telegram getMe body is invalid");
+            }
+            else if (requestMethod === "sendMessage") {
+                if (!exactBody(body, ["chat_id", "text"], ["parse_mode", "reply_markup"])) {
+                    throw new Error("Sanctuary Telegram send body is invalid");
+                }
+                if (!boundedText(body.text, 4_096)
+                    || (body.parse_mode !== undefined && body.parse_mode !== "HTML")
+                    || (body.reply_markup !== undefined && !isObject(body.reply_markup))) {
+                    throw new Error("Sanctuary Telegram send body is invalid");
+                }
+                const chatId = String(body.chat_id);
+                if (this.#hostAuthority?.ownsPrompt(body.text)
+                    || (chatId === ownerChatId && body.reply_markup !== undefined && this.#hostAuthority?.ownerMutationFrozen())
+                    || (body.reply_markup !== undefined && this.#replyMarkupContainsHostHandle(body.reply_markup))) {
+                    throw new Error("Sanctuary Telegram host approval content is root-owned");
+                }
+                const observedStrangerAcknowledgement = body.text === telegram_effect_adapter_1.FIXED_ADMISSION_ACKNOWLEDGEMENT
+                    && body.reply_markup === undefined
+                    && isObject(params.observation)
+                    && exactKeys(params.observation, ["updateId", "observationDigest"])
+                    && this.#gateway.ownsCurrentObservation({
+                        updateId: params.observation.updateId,
+                        observationDigest: params.observation.observationDigest,
+                        chatId,
+                    });
+                if (chatId !== ownerChatId
+                    && !observedStrangerAcknowledgement
+                    && !this.#gateway.isAuthorizedChat(chatId)) {
+                    throw new Error("Sanctuary Telegram send target is invalid");
+                }
+            }
+            else if (requestMethod === "editMessageText") {
+                if (!exactBody(body, ["chat_id", "message_id", "text"], ["parse_mode", "reply_markup"])
+                    || String(body.chat_id) !== ownerChatId) {
+                    throw new Error("Sanctuary Telegram edit target is invalid");
+                }
+                if (this.#hostAuthority?.ownsMessage(body.message_id)
+                    || this.#hostAuthority?.ownerMutationFrozen()
+                    || this.#hostAuthority?.ownsPrompt(body.text)
+                    || (body.reply_markup !== undefined && this.#replyMarkupContainsHostHandle(body.reply_markup))) {
+                    throw new Error("Sanctuary Telegram host approval message is root-owned");
+                }
+                if (!Number.isSafeInteger(body.message_id)
+                    || body.message_id <= 0
+                    || !boundedText(body.text, 4_096)
+                    || (body.parse_mode !== undefined && body.parse_mode !== "HTML")
+                    || (body.reply_markup !== undefined && !isObject(body.reply_markup))) {
+                    throw new Error("Sanctuary Telegram edit body is invalid");
+                }
+            }
+            else if (requestMethod === "answerCallbackQuery") {
+                if (!exactBody(body, ["callback_query_id"], ["text", "show_alert"])) {
+                    throw new Error("Sanctuary Telegram callback body is invalid");
+                }
+                if (!boundedText(body.callback_query_id, 256)
+                    || !this.#gateway.ownsCallbackQuery(body.callback_query_id)) {
+                    throw new Error("Sanctuary Telegram callback is not root-observed");
+                }
+                if ((body.text !== undefined && !boundedText(body.text, 200))
+                    || (body.show_alert !== undefined && body.show_alert !== true)) {
+                    throw new Error("Sanctuary Telegram callback body is invalid");
+                }
+            }
+            else if (requestMethod === "sendChatAction") {
+                // A typing indicator is ephemeral and carries no content, so it is admitted
+                // for chats the agent may already message — but only as "typing", and only
+                // with the two fields that action needs, so it cannot become a side channel.
+                if (!exactBody(body, ["chat_id", "action"])) {
+                    throw new Error("Sanctuary Telegram chat action is invalid");
+                }
+                if (body.action !== "typing") {
+                    throw new Error("Sanctuary Telegram chat action is invalid");
+                }
+                const actionChatId = String(body.chat_id);
+                if (actionChatId !== ownerChatId && !this.#gateway.isAuthorizedChat(actionChatId)) {
+                    throw new Error("Sanctuary Telegram chat action target is invalid");
+                }
+            }
+            else if (requestMethod === "getFile") {
+                if (!exactBody(body, ["file_id"]) || !boundedText(body.file_id, 512)) {
+                    throw new Error("Sanctuary Telegram file body is invalid");
+                }
+                if (!this.#gateway.ownsFileId(body.file_id)) {
+                    throw new Error("Sanctuary Telegram file is not root-observed");
+                }
+            }
+            else {
+                throw new Error("Sanctuary Telegram request method is not available");
+            }
+            const result = await this.#api.request(requestMethod, body);
+            if (requestMethod === "getFile") {
+                if (!isObject(result)
+                    || typeof result.file_path !== "string"
+                    || !SAFE_TELEGRAM_FILE_PATH.test(result.file_path)
+                    || (result.file_size !== undefined
+                        && (!Number.isSafeInteger(result.file_size)
+                            || result.file_size < 0
+                            || result.file_size > MAX_TELEGRAM_ATTACHMENT_BYTES))) {
+                    throw new Error("Sanctuary Telegram file metadata is invalid");
+                }
+                this.#allowedFilePaths.add(result.file_path);
+            }
+            return result;
+        }
+        if (method === "host.approval") {
+            if (!this.#hostAuthority || !this.#hostReady())
+                throw new Error("Sanctuary host authority is unavailable");
+            if (!exactKeys(params, ["proposal"]))
+                throw new Error("Sanctuary host approval params are invalid");
+            const prepared = this.#hostAuthority.prepare(params.proposal);
+            try {
+                const sent = await this.#api.request("sendMessage", {
+                    chat_id: this.#gateway.identity().ownerChatId,
+                    text: prepared.prompt,
+                    parse_mode: "HTML",
+                    reply_markup: prepared.replyMarkup,
+                });
+                if (!isObject(sent) || !Number.isSafeInteger(sent.message_id) || sent.message_id <= 0) {
+                    throw new Error("Sanctuary host approval message result is invalid");
+                }
+                const registration = this.#hostAuthority.commit({
+                    registrationId: prepared.registrationId,
+                    telegramMessageId: sent.message_id,
+                });
+                return {
+                    registration,
+                    registrationId: prepared.registrationId,
+                    telegramMessageId: sent.message_id,
+                    expiresAt: prepared.expiresAt,
+                };
+            }
+            catch (error) {
+                this.#hostAuthority.reconcilePrepared();
+                throw error;
+            }
+        }
+        if (method === "host.status") {
+            if (!this.#hostAuthority)
+                throw new Error("Sanctuary host authority is unavailable");
+            if (!exactKeys(params, ["registrationId"]) || (params.registrationId !== null && typeof params.registrationId !== "string")) {
+                throw new Error("Sanctuary host status params are invalid");
+            }
+            if (params.registrationId === null) {
+                this.#gateway.cursorSnapshot();
+                const identity = await this.#api.request("getMe", {});
+                if (!isObject(identity) || String(identity.id) !== this.#gateway.identity().botId)
+                    throw new Error("Sanctuary Telegram authority bot identity is invalid");
+                return { health: this.#hostAuthority.attestStatus(this.#hostReady() && !this.#hostAuthority.ownerMutationFrozen()) };
+            }
+            let status = this.#hostAuthority.status(params.registrationId);
+            if (!status)
+                return null;
+            if (status.state === "executed") {
+                try {
+                    if (!isObject(status.receipt)
+                        || status.receipt.schemaVersion !== 1
+                        || typeof status.receipt.domain !== "string"
+                        || typeof status.receipt.keyId !== "string"
+                        || typeof status.receipt.signature !== "string"
+                        || !isObject(status.receipt.payload)) {
+                        throw new Error("Sanctuary host terminal receipt is invalid");
+                    }
+                    const terminalReceipt = {
+                        schemaVersion: 1,
+                        domain: status.receipt.domain,
+                        keyId: status.receipt.keyId,
+                        signature: status.receipt.signature,
+                        payload: status.receipt.payload,
+                    };
+                    await this.#completeHostMaintenance(params.registrationId, terminalReceipt);
+                    this.#hostMaintenanceFailures.delete(params.registrationId);
+                    status = this.#hostAuthority.status(params.registrationId);
+                }
+                catch {
+                    this.#hostMaintenanceFailures.set(params.registrationId, "Sanctuary host terminal cleanup is pending");
+                }
+            }
+            else {
+                await this.#maintainHostCard(params.registrationId);
+                status = this.#hostAuthority.status(params.registrationId);
+            }
+            const result = {
+                ...status,
+                execution: this.#hostExecutions.has(params.registrationId)
+                    ? "running"
+                    : this.#hostExecutionFailures.has(params.registrationId)
+                        ? "reconciliation_required"
+                        : status.state === "permitted"
+                            ? "reconciliation_required"
+                            : "terminal",
+                ...(this.#hostExecutionFailures.has(params.registrationId)
+                    ? { executionError: this.#hostExecutionFailures.get(params.registrationId) }
+                    : {}),
+                ...(this.#hostMaintenanceFailures.has(params.registrationId)
+                    ? { maintenanceError: this.#hostMaintenanceFailures.get(params.registrationId) }
+                    : {}),
+            };
+            return { ...result, authority: this.#hostAuthority.attestStatus(result) };
+        }
+        if (method === "host.execute") {
+            if (!this.#hostAuthority || !this.#hostReady())
+                throw new Error("Sanctuary host execution is unavailable");
+            if (!exactKeys(params, ["correlation"]) || !isObject(params.correlation)) {
+                throw new Error("Sanctuary host execution params are invalid");
+            }
+            const permit = this.#hostAuthority.issuePermit(params.correlation);
+            const registrationId = params.correlation.registrationId;
+            const execution = this.#completeHostExecution(registrationId, permit);
+            this.#hostExecutions.set(registrationId, execution);
+            void execution.finally(() => this.#hostExecutions.delete(registrationId)).catch(() => undefined);
+            return {
+                registrationId,
+                permitId: permit.payload.permitId,
+                state: "executing",
+            };
+        }
+        if (method === "telegram.file") {
+            if (!exactKeys(params, ["filePath"])
+                || typeof params.filePath !== "string"
+                || !SAFE_TELEGRAM_FILE_PATH.test(params.filePath)
+                || !this.#allowedFilePaths.has(params.filePath)) {
+                throw new Error("Sanctuary Telegram file path is not root-observed");
+            }
+            if (!this.#downloadFile)
+                throw new Error("Sanctuary Telegram file transport is unavailable");
+            const result = await this.#downloadFile(params.filePath);
+            if (!Buffer.isBuffer(result.body)
+                || result.body.length > MAX_TELEGRAM_ATTACHMENT_BYTES
+                || (result.contentType !== undefined && !boundedText(result.contentType, 256))) {
+                throw new Error("Sanctuary Telegram file response is invalid");
+            }
+            return {
+                bodyBase64: result.body.toString("base64"),
+                ...(result.contentType ? { contentType: result.contentType } : {}),
+            };
+        }
+        throw new Error("Sanctuary authority method is not available");
+    }
+    #replyMarkupContainsHostHandle(value) {
+        if (typeof value === "string")
+            return this.#hostAuthority?.ownsHandle(value) ?? false;
+        if (Array.isArray(value))
+            return value.some((entry) => this.#replyMarkupContainsHostHandle(entry));
+        if (!isObject(value))
+            return false;
+        return Object.values(value).some((entry) => this.#replyMarkupContainsHostHandle(entry));
+    }
+    async #flushHostCard(registrationId) {
+        const hostAuthority = this.#hostAuthority;
+        const pending = hostAuthority.pendingCardEdit(registrationId);
+        if (!pending)
+            return;
+        await this.#api.request("editMessageText", {
+            chat_id: this.#gateway.identity().ownerChatId,
+            message_id: pending.telegramMessageId,
+            text: pending.text,
+            parse_mode: "HTML",
+            reply_markup: { inline_keyboard: [] },
+        });
+        hostAuthority.markCardEdited(registrationId, pending.revision);
+    }
+    async #maintainHostCard(registrationId) {
+        try {
+            await this.#flushHostCard(registrationId);
+            this.#hostMaintenanceFailures.delete(registrationId);
+        }
+        catch {
+            this.#hostMaintenanceFailures.set(registrationId, "Sanctuary host terminal cleanup is pending");
+        }
+    }
+    async #completeHostExecution(registrationId, permit) {
+        let receipt;
+        try {
+            receipt = await this.#hostExecutor.execute(permit);
+            this.#hostAuthority.completeExecution(registrationId, receipt);
+            this.#hostExecutionFailures.delete(registrationId);
+        }
+        catch (error) {
+            this.#hostExecutionFailures.set(registrationId, "Sanctuary host execution failed");
+            throw error;
+        }
+        try {
+            await this.#completeHostMaintenance(registrationId, receipt);
+            this.#hostMaintenanceFailures.delete(registrationId);
+        }
+        catch {
+            this.#hostMaintenanceFailures.set(registrationId, "Sanctuary host terminal cleanup is pending");
+        }
+    }
+    async #completeHostMaintenance(registrationId, receipt) {
+        this.#hostExecutor.acknowledge?.(String(receipt.payload.permitId));
+        await this.#flushHostCard(registrationId);
+    }
+}
+exports.SanctuaryTelegramAuthorityService = SanctuaryTelegramAuthorityService;
+function createSanctuaryTelegramAuthorityServer(options) {
+    if (!path.isAbsolute(options.socketPath))
+        throw new Error("Sanctuary authority socket path must be absolute");
+    const maxRequestBytes = options.maxRequestBytes ?? DEFAULT_MAX_REQUEST_BYTES;
+    if (!Number.isSafeInteger(maxRequestBytes) || maxRequestBytes < 128) {
+        throw new Error("Sanctuary authority request limit is invalid");
+    }
+    const connectionTimeoutMs = options.connectionTimeoutMs ?? DEFAULT_CONNECTION_TIMEOUT_MS;
+    if (!Number.isSafeInteger(connectionTimeoutMs) || connectionTimeoutMs < 1) {
+        throw new Error("Sanctuary authority connection timeout is invalid");
+    }
+    const connections = new Set();
+    let dispatchTail = Promise.resolve();
+    const server = net.createServer({ allowHalfOpen: true }, (connection) => {
+        connections.add(connection);
+        connection.setEncoding("utf8");
+        connection.setTimeout(connectionTimeoutMs, () => connection.destroy());
+        connection.once("close", () => connections.delete(connection));
+        // A client that vanishes mid-response (reset, timeout, crash) surfaces as EPIPE/ECONNRESET on this
+        // socket; unhandled, that killed the whole gateway. Log it and let the connection close.
+        connection.on("error", (error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.sanctuary_authority_connection_error",
+                message: "Sanctuary authority client connection failed; dropping it",
+                meta: { code: error.code ?? "unknown" },
+            });
+        });
+        let buffer = "";
+        connection.on("data", (chunk) => {
+            buffer += chunk;
+            if (Buffer.byteLength(buffer) > maxRequestBytes) {
+                connection.end(`${JSON.stringify({
+                    protocolVersion: PROTOCOL_VERSION,
+                    id: null,
+                    ok: false,
+                    error: { message: "Sanctuary authority request is too large" },
+                })}\n`);
+                return;
+            }
+            for (;;) {
+                const newline = buffer.indexOf("\n");
+                if (newline < 0)
+                    break;
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                if (!line.trim())
+                    continue;
+                let request;
+                try {
+                    request = JSON.parse(line);
+                }
+                catch {
+                    connection.end(`${JSON.stringify({
+                        protocolVersion: PROTOCOL_VERSION,
+                        id: null,
+                        ok: false,
+                        error: { message: "Sanctuary authority request failed" },
+                    })}\n`);
+                    return;
+                }
+                const frame = request;
+                if (!isObject(frame)
+                    || !exactKeys(frame, ["protocolVersion", "id", "method", "params"])
+                    || frame.protocolVersion !== PROTOCOL_VERSION
+                    || typeof frame.id !== "string"
+                    || frame.id.length === 0
+                    || typeof frame.method !== "string"
+                    || frame.method.length === 0
+                    || !isObject(frame.params)) {
+                    connection.end(`${JSON.stringify({
+                        protocolVersion: PROTOCOL_VERSION,
+                        id: isObject(frame) && typeof frame.id === "string" ? frame.id : null,
+                        ok: false,
+                        error: { message: "Sanctuary authority request failed" },
+                    })}\n`);
+                    return;
+                }
+                const response = dispatchTail.then(async () => {
+                    try {
+                        const result = await options.dispatch(frame.method, frame.params);
+                        if (!connection.destroyed)
+                            connection.write(`${JSON.stringify({
+                                protocolVersion: PROTOCOL_VERSION,
+                                id: frame.id,
+                                ok: true,
+                                result,
+                            })}\n`);
+                    }
+                    catch {
+                        if (!connection.destroyed)
+                            connection.write(`${JSON.stringify({
+                                protocolVersion: PROTOCOL_VERSION,
+                                id: frame.id,
+                                ok: false,
+                                error: { message: "Sanctuary authority request failed" },
+                            })}\n`);
+                    }
+                });
+                dispatchTail = response;
+            }
+        });
+    });
+    return {
+        listen: () => new Promise((resolve, reject) => {
+            const directory = path.dirname(options.socketPath);
+            if (fs.existsSync(directory)) {
+                const directoryStat = fs.lstatSync(directory);
+                if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink()) {
+                    throw new Error("Sanctuary authority socket directory is unsafe");
+                }
+            }
+            else {
+                fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+            }
+            if (fs.existsSync(options.socketPath)) {
+                const socketStat = fs.lstatSync(options.socketPath);
+                /* v8 ignore next -- the valid stale-socket branch is exercised by the deployment restart fixture @preserve */
+                if (!socketStat.isSocket()) {
+                    throw new Error("Sanctuary authority socket path is unsafe");
+                }
+                /* v8 ignore next -- stale Unix-socket inode cleanup is exercised by the deployment restart fixture @preserve */
+                fs.unlinkSync(options.socketPath);
+            }
+            server.once("error", reject);
+            server.listen(options.socketPath, () => {
+                server.removeListener("error", reject);
+                fs.chmodSync(options.socketPath, 0o660);
+                resolve();
+            });
+        }),
+        close: async () => {
+            for (const connection of connections)
+                connection.destroy();
+            await dispatchTail;
+            await new Promise((resolve, reject) => {
+                server.close((error) => error ? reject(error) : resolve());
+            });
+            /* v8 ignore start -- Node removes the bound Unix socket on ordinary close; changed-path cleanup is a live race defense @preserve */
+            if (fs.existsSync(options.socketPath)) {
+                const socketStat = fs.lstatSync(options.socketPath);
+                if (!socketStat.isSocket()) {
+                    throw new Error("Sanctuary authority socket path changed before cleanup");
+                }
+                fs.unlinkSync(options.socketPath);
+            }
+            /* v8 ignore stop */
+        },
+    };
+}
+class SocketSanctuaryTelegramAuthorityClient {
+    #client;
+    constructor(socketPath) {
+        if (!path.isAbsolute(socketPath))
+            throw new Error("Sanctuary authority socket path must be absolute");
+        this.#client = new frontend_socket_client_1.SocketFrontendClient(socketPath);
+    }
+    request(method, params) {
+        if (typeof method !== "string" || method.length === 0) {
+            return Promise.reject(new Error("Sanctuary authority method is invalid"));
+        }
+        if (!isObject(params)) {
+            return Promise.reject(new Error("Sanctuary authority params are invalid"));
+        }
+        return this.#client.request(method, params);
+    }
+    close() {
+        this.#client.close();
+    }
+}
+exports.SocketSanctuaryTelegramAuthorityClient = SocketSanctuaryTelegramAuthorityClient;