@ouro.bot/cli 0.1.0-alpha.816 → 0.1.0-alpha.817

package/dist/senses/telegram-authority-transport.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSanctuaryTelegramAuthorityTransport = createSanctuaryTelegramAuthorityTransport;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+const sanctuary_authority_codec_1 = require("../heart/daemon/sanctuary-authority-codec");
+const root_host_approval_port_1 = require("./root-host-approval-port");
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validPollBody(body) {
+    return Object.keys(body).sort().join(",") === "allowed_updates,offset,timeout"
+        && Number.isSafeInteger(body.offset)
+        && body.offset >= 0
+        && body.timeout === 50
+        && Array.isArray(body.allowed_updates)
+        && body.allowed_updates.length === 2
+        && body.allowed_updates[0] === "message"
+        && body.allowed_updates[1] === "callback_query";
+}
+function rawUpdateDigest(update) {
+    return `tgu_${(0, node_crypto_1.createHash)("sha256")
+        .update(`ouroboros.telegram.update.v1\0${JSON.stringify(update)}`, "utf8")
+        .digest("base64url")}`;
+}
+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 canonicalTime(value) {
+    if (typeof value !== "string")
+        return false;
+    const instant = new Date(value);
+    return !Number.isNaN(instant.getTime()) && instant.toISOString() === value;
+}
+function verifyObservation(artifact, update, verification) {
+    let payload;
+    try {
+        payload = (0, sanctuary_authority_codec_1.verifyAuthorityPayload)({
+            artifact,
+            expectedDomain: "ouro.sanctuary.telegram-observation.v1",
+            expectedKeyId: verification.expectedKeyId,
+            publicKey: verification.publicKey,
+        });
+    }
+    catch (error) {
+        throw new Error("Sanctuary Telegram authority poll response is invalid", { cause: error });
+    }
+    if (!isObject(payload)
+        || !exactKeys(payload, [
+            "targetHost", "botId", "updateId", "updateClass", "userId", "chatId", "ownerEligible",
+            "messageId", "callbackQueryId", "rawUpdateDigest", "observedAt", "settlement", "nonce", "publicKeyDigest",
+            ...(Object.hasOwn(payload, "deliveryUpdateDigest") ? ["deliveryUpdateDigest"] : []),
+        ])
+        || payload.targetHost !== verification.expectedTargetHost
+        || payload.botId !== verification.expectedBotId
+        || payload.publicKeyDigest !== verification.expectedPublicKeyDigest
+        || payload.updateId !== update.update_id
+        || !["message", "callback"].includes(String(payload.updateClass))
+        || typeof payload.userId !== "string"
+        || typeof payload.chatId !== "string"
+        || typeof payload.ownerEligible !== "boolean"
+        || (payload.messageId !== null && typeof payload.messageId !== "string")
+        || (payload.callbackQueryId !== null && typeof payload.callbackQueryId !== "string")
+        || typeof payload.rawUpdateDigest !== "string"
+        || !/^tgu_[A-Za-z0-9_-]{43}$/u.test(payload.rawUpdateDigest)
+        || (Object.hasOwn(payload, "deliveryUpdateDigest") && typeof payload.deliveryUpdateDigest !== "string")
+        || (payload.deliveryUpdateDigest ?? payload.rawUpdateDigest) !== rawUpdateDigest(update)
+        || !canonicalTime(payload.observedAt)
+        || payload.settlement !== "pending"
+        || typeof payload.nonce !== "string"
+        || !/^[A-Za-z0-9_-]{43}$/u.test(payload.nonce)) {
+        throw new Error("Sanctuary Telegram authority observation payload is invalid");
+    }
+    const callback = update.callback_query;
+    const message = update.message;
+    if ((!callback && !message) || (callback && message) || (callback && (!callback.message || !callback.from)) || (message && !message.from)) {
+        throw new Error("Sanctuary Telegram authority observation update is unsupported");
+    }
+    const updateClass = callback ? "callback" : "message";
+    const userId = String(callback ? callback.from.id : message.from.id);
+    const chatId = String(callback ? callback.message.chat.id : message.chat.id);
+    const messageId = String(callback ? callback.message.message_id : message.message_id);
+    const callbackQueryId = callback ? callback.id : null;
+    if (payload.updateClass !== updateClass
+        || payload.userId !== userId
+        || payload.chatId !== chatId
+        || payload.messageId !== messageId
+        || payload.callbackQueryId !== callbackQueryId
+        || payload.ownerEligible !== (userId === verification.expectedOwnerUserId && chatId === verification.expectedOwnerChatId)) {
+        throw new Error("Sanctuary Telegram authority observation coordinates changed");
+    }
+    return Object.freeze({
+        schemaVersion: 1,
+        observationDigest: (0, sanctuary_authority_codec_1.authorityArtifactDigest)(artifact.domain, payload),
+        targetHost: payload.targetHost,
+        botId: payload.botId,
+        updateId: payload.updateId,
+        updateClass: payload.updateClass,
+        userId: payload.userId,
+        chatId: payload.chatId,
+        ownerEligible: payload.ownerEligible,
+        messageId: payload.messageId,
+        callbackQueryId: payload.callbackQueryId,
+        rawUpdateDigest: payload.rawUpdateDigest,
+        ...(payload.deliveryUpdateDigest ? { deliveryUpdateDigest: payload.deliveryUpdateDigest } : {}),
+        observedAt: payload.observedAt,
+        keyId: artifact.keyId,
+        publicKeyDigest: payload.publicKeyDigest,
+    });
+}
+function createSanctuaryTelegramAuthorityTransport(client, verification) {
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_authority_transport_created", message: "Tokenless Sanctuary Telegram authority transport created" });
+    verification = Object.freeze({ ...verification });
+    const observations = new Map();
+    const metadata = new Map();
+    const callbacks = new Map();
+    let currentObservation = null;
+    let stopped = false;
+    const api = {
+        async request(method, body, signal) {
+            if (signal?.aborted)
+                throw signal.reason;
+            if (stopped)
+                throw new Error("Sanctuary Telegram authority transport is stopped");
+            if (method !== "getUpdates") {
+                return await client.request("telegram.request", {
+                    method,
+                    body,
+                    ...(currentObservation ? {
+                        observation: {
+                            updateId: currentObservation.payload.updateId,
+                            observationDigest: (0, sanctuary_authority_codec_1.authorityArtifactDigest)(currentObservation.domain, currentObservation.payload),
+                        },
+                    } : {}),
+                });
+            }
+            if (!validPollBody(body))
+                throw new Error("Sanctuary Telegram authority poll request is invalid");
+            const result = await client.request("telegram.poll", {});
+            if (result === null)
+                return [];
+            if (!isObject(result)
+                || !isObject(result.observation)
+                || !isObject(result.observation.payload)
+                || !isObject(result.update)
+                || !Number.isSafeInteger(result.update.update_id)
+                || result.observation.payload.updateId !== result.update.update_id) {
+                throw new Error("Sanctuary Telegram authority poll response is invalid");
+            }
+            const update = result.update;
+            const observation = result.observation;
+            const verifiedMetadata = verifyObservation(observation, update, verification);
+            const existing = observations.get(update.update_id);
+            if (existing
+                && (0, sanctuary_authority_codec_1.authorityArtifactDigest)(existing.domain, existing.payload)
+                    !== (0, sanctuary_authority_codec_1.authorityArtifactDigest)(observation.domain, observation.payload)) {
+                throw new Error("Sanctuary Telegram authority observation changed during redelivery");
+            }
+            observations.set(update.update_id, observation);
+            metadata.set(update.update_id, verifiedMetadata);
+            callbacks.set(update.update_id, result.hostCallback);
+            currentObservation = observation;
+            return [update];
+        },
+        stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            client.close();
+        },
+    };
+    const transport = {
+        api,
+        async downloadFile(filePath) {
+            const result = await client.request("telegram.file", { filePath });
+            if (!isObject(result)
+                || typeof result.bodyBase64 !== "string"
+                || (result.contentType !== undefined && typeof result.contentType !== "string")) {
+                throw new Error("Sanctuary Telegram authority file response is invalid");
+            }
+            const body = Buffer.from(result.bodyBase64, "base64");
+            if (body.toString("base64") !== result.bodyBase64 || body.length > 20_000_000) {
+                throw new Error("Sanctuary Telegram authority file response is invalid");
+            }
+            return new Response(body, {
+                headers: result.contentType ? { "content-type": result.contentType } : undefined,
+            });
+        },
+        async admitChat(input) {
+            await client.request("telegram.chat.admit", input);
+        },
+        async revokeChat(input) {
+            await client.request("telegram.chat.revoke", input);
+        },
+        metadataForUpdate(update) {
+            const value = metadata.get(update.update_id);
+            if (!value)
+                return null;
+            if ((value.deliveryUpdateDigest ?? value.rawUpdateDigest) !== rawUpdateDigest(update)) {
+                throw new Error("Sanctuary Telegram authority update changed after verification");
+            }
+            return value;
+        },
+        async settleTransport(update, outcome) {
+            const observation = observations.get(update.update_id);
+            if (!observation)
+                throw new Error("Sanctuary Telegram authority observation is unavailable for settlement");
+            await client.request("telegram.settle", {
+                updateId: update.update_id,
+                observationDigest: (0, sanctuary_authority_codec_1.authorityArtifactDigest)(observation.domain, observation.payload),
+                outcome,
+            });
+            observations.delete(update.update_id);
+            metadata.delete(update.update_id);
+            callbacks.delete(update.update_id);
+            if (currentObservation?.payload.updateId === update.update_id)
+                currentObservation = null;
+        },
+    };
+    transport.hostApproval = (0, root_host_approval_port_1.createRootHostApprovalPort)(client, verification, {
+        current: () => currentObservation ? metadata.get(currentObservation.payload.updateId) : null,
+        lookup: (update) => {
+            const value = transport.metadataForUpdate(update);
+            return value ? { metadata: value, hostCallback: callbacks.get(update.update_id) } : null;
+        },
+        stopped: () => stopped,
+    });
+    return transport;
+}

package/dist/senses/telegram-client.js

@@ -507,7 +507,7 @@ function createTelegramLongPoll(options) {
     const rawAttachmentCount = (message) => [
         message.document, message.audio, message.video, message.voice, message.animation, message.sticker,
     ].filter(Boolean).length + (message.photo?.length ? 1 : 0);
-    const authorizedMessage = (update) => {
+    const authorizedMessage = (update, authority) => {
         const message = update.message;
         const userId = message?.from ? String(message.from.id) : "";
         const chatId = message ? String(message.chat.id) : "";
@@ -532,9 +532,10 @@ function createTelegramLongPoll(options) {
             ...(Number.isSafeInteger(message.reply_to_message?.message_id) && message.reply_to_message.message_id > 0
                 ? { replyToMessageId: String(message.reply_to_message.message_id) }
                 : {}),
+            ...(authority ? { authority } : {}),
         };
     };
-    const unknownMessage = (update) => {
+    const unknownMessage = (update, authority) => {
         const message = update.message;
         if (!options.onUnknownMessage || !options.botId || !message?.from || message.chat.type !== "private")
             return null;
@@ -557,6 +558,7 @@ function createTelegramLongPoll(options) {
             hasAttachments: attachmentCount > 0,
             attachments,
             ...(attachmentCount > attachments.length ? { attachmentNotices: ["attachment unavailable: Telegram media metadata was incomplete"] } : {}),
+            ...(authority ? { authority } : {}),
         };
     };
     const authorizedCallback = (update) => {
@@ -566,17 +568,18 @@ function createTelegramLongPoll(options) {
             && String(callback.message.chat.id) === options.expectedChatId);
     };
     const dispatch = async (update) => {
+        const authority = options.transportMetadata?.(update) ?? undefined;
         const handled = !update.callback_query || authorizedCallback(update)
-            ? await options.onUpdate?.(update) ?? false
+            ? await options.onUpdate?.(update, authority) ?? false
             : false;
         if (handled)
             return;
-        const message = authorizedMessage(update);
+        const message = authorizedMessage(update, authority);
         if (message) {
             await options.onMessage(message);
             return;
         }
-        const stranger = unknownMessage(update);
+        const stranger = unknownMessage(update, authority);
         if (stranger) {
             await options.onUnknownMessage(stranger);
             return;
@@ -619,15 +622,18 @@ function createTelegramLongPoll(options) {
         if (!Array.isArray(updates))
             throw new Error("Telegram getUpdates result must be an array");
         for (const update of updates) {
-            if (!update || !Number.isSafeInteger(update.update_id) || update.update_id < nextUpdateId)
+            if (!update || !Number.isSafeInteger(update.update_id) || (update.update_id < nextUpdateId && !options.settleTransport))
                 continue;
             options.onBeforeDispatch?.();
-            const next = update.update_id + 1;
+            const next = Math.max(nextUpdateId, update.update_id + 1);
             const requiresDurableDispatch = Boolean(authorizedCallback(update) || authorizedMessage(update) || unknownMessage(update));
             const newlyCaptured = requiresDurableDispatch ? (options.inboxStore?.capture(update) ?? true) : true;
             if (newlyCaptured) {
                 if (requiresDurableDispatch && options.inboxStore && !options.inboxStore.claim(update)) {
                     options.onDispatchSettled?.();
+                    const indeterminate = options.inboxStore.loadIndeterminate()
+                        .some((receipt) => sameReceipt(receipt, updateReceipt(update)));
+                    await options.settleTransport?.(update, indeterminate ? "indeterminate" : "completed");
                     options.offsetStore.save(next);
                     nextUpdateId = next;
                     options.inboxStore.commit?.(update);
@@ -651,11 +657,28 @@ function createTelegramLongPoll(options) {
                         throw new AggregateError([dispatchError, auditError], "Telegram dispatch and acceptance audit verification failed");
                     throw auditError;
                 }
+                try {
+                    if (options.settleTransport) {
+                        await options.settleTransport?.(update, dispatchError === undefined ? "completed" : "indeterminate");
+                    }
+                }
+                catch (settlementError) {
+                    if (dispatchError !== undefined)
+                        throw new AggregateError([dispatchError, settlementError], "Telegram dispatch and transport settlement failed");
+                    throw settlementError;
+                }
                 if (dispatchError !== undefined)
                     throw dispatchError;
             }
-            else
+            else {
                 options.onDispatchSettled?.();
+                if (options.settleTransport) {
+                    // Only an existing inbox can report that this update was already captured.
+                    const indeterminate = options.inboxStore.loadIndeterminate()
+                        .some((receipt) => sameReceipt(receipt, updateReceipt(update)));
+                    await options.settleTransport(update, indeterminate ? "indeterminate" : "completed");
+                }
+            }
             options.offsetStore.save(next);
             nextUpdateId = next;
             if (requiresDurableDispatch)

package/dist/senses/telegram-entry.js

@@ -61,7 +61,7 @@ Promise.all([
     }
     const machine = loadOrCreateMachineIdentity();
     await refreshMachineRuntimeCredentialConfig(agentName, machine.machineId, { preserveCachedOnFailure: true }).catch(() => undefined);
-    const app = await startTelegramSenseApp(agentName);
+    const app = await startTelegramSenseApp(agentName, true);
     let stopping;
     const stop = () => { stopping ??= app.stop(); };
     process.once("SIGTERM", stop);