zardbot-telegram 1.0.0

package/dist/bot/message-patterns.js

@@ -0,0 +1,4 @@
+export const AGENT_MODE_BUTTON_TEXT_PATTERN = /^(📋|🛠️|💬|🔍|📝|📄|📦|🤖)\s.+\sMode$/;
+export const MODEL_BUTTON_TEXT_PATTERN = /^🤖\s(?!.*\sMode$)[\s\S]+$/;
+// Keep support for both legacy "💭" and current "💡" prefix.
+export const VARIANT_BUTTON_TEXT_PATTERN = /^(💡|💭)\s.+$/;

package/dist/bot/middleware/auth.js

@@ -0,0 +1,30 @@
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
+export async function authMiddleware(ctx, next) {
+    const userId = ctx.from?.id;
+    logger.debug(`[Auth] Checking access: userId=${userId}, allowedUserId=${config.telegram.allowedUserId}, hasCallbackQuery=${!!ctx.callbackQuery}, hasMessage=${!!ctx.message}`);
+    if (userId && userId === config.telegram.allowedUserId) {
+        logger.debug(`[Auth] Access granted for userId=${userId}`);
+        await next();
+    }
+    else {
+        // Silently ignore unauthorized users
+        logger.warn(`Unauthorized access attempt from user ID: ${userId}`);
+        // Actively hide commands for unauthorized users by setting empty command list
+        // Only do this if the chat is NOT the authorized user's chat
+        // (to avoid resetting commands when forwarded messages are received)
+        if (ctx.chat?.id && ctx.chat.id !== config.telegram.allowedUserId) {
+            try {
+                // Set empty commands for this specific chat (more reliable than deleteMyCommands)
+                await ctx.api.setMyCommands([], {
+                    scope: { type: "chat", chat_id: ctx.chat.id },
+                });
+                logger.debug(`[Auth] Set empty commands for unauthorized chat_id=${ctx.chat.id}`);
+            }
+            catch (err) {
+                // Ignore errors
+                logger.debug(`[Auth] Could not set empty commands: ${err}`);
+            }
+        }
+    }
+}

package/dist/bot/middleware/interaction-guard.js

@@ -0,0 +1,95 @@
+import { resolveInteractionGuardDecision } from "../../interaction/guard.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+function getInteractionBlockedMessage(reason, interactionKind) {
+    if (interactionKind === "permission") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("permission.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("permission.blocked.expected_reply");
+        }
+    }
+    if (interactionKind === "inline") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("inline.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("inline.blocked.expected_choice");
+        }
+    }
+    if (interactionKind === "question") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("question.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("question.blocked.expected_answer");
+        }
+    }
+    if (interactionKind === "rename") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("rename.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("rename.blocked.expected_name");
+        }
+    }
+    if (interactionKind === "task") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("task.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("task.blocked.expected_input");
+        }
+    }
+    switch (reason) {
+        case "expired":
+            return t("interaction.blocked.expired");
+        case "expected_callback":
+            return t("interaction.blocked.expected_callback");
+        case "expected_command":
+            return t("interaction.blocked.expected_command");
+        case "command_not_allowed":
+            return t("interaction.blocked.command_not_allowed");
+        case "expected_text":
+        default:
+            return t("interaction.blocked.expected_text");
+    }
+}
+export async function interactionGuardMiddleware(ctx, next) {
+    const decision = resolveInteractionGuardDecision(ctx);
+    if (decision.allow) {
+        await next();
+        return;
+    }
+    const message = decision.busy
+        ? decision.state?.kind === "question" || decision.state?.kind === "permission"
+            ? getInteractionBlockedMessage(decision.reason, decision.state.kind)
+            : t("interaction.blocked.finish_current")
+        : getInteractionBlockedMessage(decision.reason, decision.state?.kind);
+    logger.debug(`[InteractionGuard] Blocked input: interactionKind=${decision.state?.kind || "none"}, inputType=${decision.inputType}, reason=${decision.reason || "unknown"}, command=${decision.command || "-"}, busy=${decision.busy ? "yes" : "no"}`);
+    if (ctx.callbackQuery) {
+        await ctx.answerCallbackQuery({ text: message }).catch(() => { });
+        return;
+    }
+    if (ctx.chat) {
+        await ctx.reply(message).catch((err) => {
+            logger.error("[InteractionGuard] Failed to send blocked input message:", err);
+        });
+    }
+}

package/dist/bot/middleware/unknown-command.js

@@ -0,0 +1,22 @@
+import { extractCommandName, isKnownCommand } from "../utils/commands.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+export async function unknownCommandMiddleware(ctx, next) {
+    const text = ctx.message?.text;
+    if (!text) {
+        await next();
+        return;
+    }
+    const commandName = extractCommandName(text);
+    if (!commandName) {
+        await next();
+        return;
+    }
+    if (isKnownCommand(commandName)) {
+        await next();
+        return;
+    }
+    const commandToken = text.trim().split(/\s+/)[0];
+    logger.debug(`[Bot] Unknown slash command received: ${commandToken}`);
+    await ctx.reply(t("bot.unknown_command", { command: commandToken }));
+}

package/dist/bot/streaming/response-streamer.js

@@ -0,0 +1,286 @@
+import { logger } from "../../utils/logger.js";
+function buildStateKey(sessionId, messageId) {
+    return `${sessionId}:${messageId}`;
+}
+function normalizePayload(payload) {
+    const normalizedParts = payload.parts
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+    if (normalizedParts.length === 0) {
+        return null;
+    }
+    return {
+        parts: normalizedParts,
+        format: payload.format,
+        sendOptions: payload.sendOptions,
+        editOptions: payload.editOptions,
+    };
+}
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function getRetryAfterMs(error) {
+    const message = getErrorMessage(error);
+    if (!/\b429\b/.test(message)) {
+        return null;
+    }
+    const retryMatch = message.match(/retry after\s+(\d+)/i);
+    if (!retryMatch) {
+        return null;
+    }
+    const seconds = Number.parseInt(retryMatch[1], 10);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return null;
+    }
+    return seconds * 1000;
+}
+function createSignature(text, format) {
+    return `${format}\n${text}`;
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export class ResponseStreamer {
+    throttleMs;
+    sendText;
+    editText;
+    deleteText;
+    states = new Map();
+    constructor(options) {
+        this.throttleMs = Math.max(0, Math.floor(options.throttleMs));
+        this.sendText = options.sendText;
+        this.editText = options.editText;
+        this.deleteText = options.deleteText;
+    }
+    enqueue(sessionId, messageId, payload) {
+        const normalizedPayload = normalizePayload(payload);
+        if (!normalizedPayload) {
+            return;
+        }
+        const state = this.getOrCreateState(sessionId, messageId);
+        state.latestPayload = normalizedPayload;
+        if (state.isBroken) {
+            return;
+        }
+        this.ensureTimer(state);
+    }
+    async complete(sessionId, messageId, payload, options) {
+        const notStreamed = { streamed: false, telegramMessageIds: [] };
+        const state = this.states.get(buildStateKey(sessionId, messageId));
+        if (!state) {
+            return notStreamed;
+        }
+        if (payload) {
+            const normalizedPayload = normalizePayload(payload);
+            if (normalizedPayload) {
+                state.latestPayload = normalizedPayload;
+            }
+        }
+        this.clearTimer(state);
+        await state.task.catch(() => false);
+        if (state.isBroken) {
+            await this.cleanupBrokenStream(state, "complete_broken_stream");
+            this.cancelState(state);
+            this.states.delete(state.key);
+            return notStreamed;
+        }
+        if (state.telegramMessageIds.length === 0) {
+            this.cancelState(state);
+            this.states.delete(state.key);
+            return notStreamed;
+        }
+        let synced = true;
+        if (options?.flushFinal !== false) {
+            synced = await this.enqueueTask(state, () => this.flushState(state, "complete"));
+            if (!synced && state.isBroken) {
+                await this.cleanupBrokenStream(state, "final_sync_failed_cleanup");
+            }
+        }
+        const messageIds = [...state.telegramMessageIds];
+        this.cancelState(state);
+        this.states.delete(state.key);
+        return { streamed: synced, telegramMessageIds: messageIds };
+    }
+    clearMessage(sessionId, messageId, reason) {
+        const key = buildStateKey(sessionId, messageId);
+        const state = this.states.get(key);
+        if (!state) {
+            return;
+        }
+        this.cancelState(state);
+        this.states.delete(key);
+        logger.debug(`[ResponseStreamer] Cleared message stream: session=${sessionId}, message=${messageId}, reason=${reason}`);
+    }
+    clearSession(sessionId, reason) {
+        for (const state of Array.from(this.states.values())) {
+            if (state.sessionId !== sessionId) {
+                continue;
+            }
+            this.cancelState(state);
+            this.states.delete(state.key);
+        }
+        logger.debug(`[ResponseStreamer] Cleared session streams: session=${sessionId}, reason=${reason}`);
+    }
+    clearAll(reason) {
+        for (const state of this.states.values()) {
+            this.cancelState(state);
+        }
+        const count = this.states.size;
+        this.states.clear();
+        if (count > 0) {
+            logger.debug(`[ResponseStreamer] Cleared all streams: count=${count}, reason=${reason}`);
+        }
+    }
+    getOrCreateState(sessionId, messageId) {
+        const key = buildStateKey(sessionId, messageId);
+        const existing = this.states.get(key);
+        if (existing) {
+            return existing;
+        }
+        const state = {
+            key,
+            sessionId,
+            messageId,
+            latestPayload: null,
+            lastSentSignatures: [],
+            telegramMessageIds: [],
+            timer: null,
+            task: Promise.resolve(true),
+            cancelled: false,
+            isBroken: false,
+            fatalErrorMessage: null,
+            fatalErrorLogged: false,
+        };
+        this.states.set(key, state);
+        return state;
+    }
+    ensureTimer(state) {
+        if (state.timer || state.cancelled) {
+            return;
+        }
+        if (this.throttleMs === 0) {
+            void this.enqueueTask(state, () => this.flushState(state, "immediate")).catch((error) => {
+                logger.error(`[ResponseStreamer] Immediate stream sync failed: session=${state.sessionId}, message=${state.messageId}`, error);
+            });
+            return;
+        }
+        state.timer = setTimeout(() => {
+            state.timer = null;
+            void this.enqueueTask(state, () => this.flushState(state, "throttle_elapsed")).catch((error) => {
+                logger.error(`[ResponseStreamer] Throttled stream sync failed: session=${state.sessionId}, message=${state.messageId}`, error);
+            });
+        }, this.throttleMs);
+    }
+    clearTimer(state) {
+        if (!state.timer) {
+            return;
+        }
+        clearTimeout(state.timer);
+        state.timer = null;
+    }
+    cancelState(state) {
+        state.cancelled = true;
+        this.clearTimer(state);
+    }
+    enqueueTask(state, task) {
+        const nextTask = state.task.catch(() => false).then(task);
+        state.task = nextTask;
+        return nextTask;
+    }
+    async flushState(state, reason) {
+        if (state.cancelled) {
+            return false;
+        }
+        if (state.isBroken) {
+            return false;
+        }
+        while (!state.cancelled) {
+            const payload = state.latestPayload;
+            if (!payload) {
+                return state.telegramMessageIds.length > 0;
+            }
+            const targetSignatures = payload.parts.map((part) => createSignature(part, payload.format));
+            const unchanged = targetSignatures.length === state.lastSentSignatures.length &&
+                targetSignatures.every((signature, index) => signature === state.lastSentSignatures[index]);
+            if (unchanged) {
+                return state.telegramMessageIds.length > 0;
+            }
+            try {
+                await this.syncMessages(state, payload, targetSignatures);
+                logger.debug(`[ResponseStreamer] Stream synced: session=${state.sessionId}, message=${state.messageId}, reason=${reason}, parts=${payload.parts.length}`);
+                return true;
+            }
+            catch (error) {
+                const retryAfterMs = getRetryAfterMs(error);
+                if (retryAfterMs === null) {
+                    this.markStreamBroken(state, error, reason);
+                    return false;
+                }
+                const delayMs = Math.max(this.throttleMs, retryAfterMs);
+                logger.warn(`[ResponseStreamer] Stream sync rate-limited, retrying in ${delayMs}ms: session=${state.sessionId}, message=${state.messageId}, reason=${reason}`, error);
+                await delay(delayMs);
+            }
+        }
+        return false;
+    }
+    markStreamBroken(state, error, reason) {
+        state.isBroken = true;
+        state.fatalErrorMessage = getErrorMessage(error);
+        if (state.fatalErrorLogged) {
+            return;
+        }
+        state.fatalErrorLogged = true;
+        logger.error(`[ResponseStreamer] Stream marked as broken: session=${state.sessionId}, message=${state.messageId}, reason=${reason}, error=${state.fatalErrorMessage}`, error);
+    }
+    async cleanupBrokenStream(state, reason) {
+        if (state.telegramMessageIds.length === 0) {
+            return;
+        }
+        for (let index = state.telegramMessageIds.length - 1; index >= 0; index--) {
+            const messageId = state.telegramMessageIds[index];
+            if (!messageId) {
+                continue;
+            }
+            try {
+                await this.deleteText(messageId);
+            }
+            catch (error) {
+                logger.warn(`[ResponseStreamer] Failed to delete broken stream message: session=${state.sessionId}, message=${state.messageId}, telegramMessageId=${messageId}, reason=${reason}`, error);
+            }
+        }
+        state.telegramMessageIds = [];
+        state.lastSentSignatures = [];
+        logger.debug(`[ResponseStreamer] Cleaned up broken stream messages: session=${state.sessionId}, message=${state.messageId}, reason=${reason}`);
+    }
+    async syncMessages(state, payload, targetSignatures) {
+        for (let index = 0; index < payload.parts.length; index++) {
+            const text = payload.parts[index];
+            const nextSignature = targetSignatures[index];
+            const currentMessageId = state.telegramMessageIds[index];
+            if (currentMessageId) {
+                if (state.lastSentSignatures[index] === nextSignature) {
+                    continue;
+                }
+                await this.editText(currentMessageId, text, payload.format, payload.editOptions);
+                state.lastSentSignatures[index] = nextSignature;
+                continue;
+            }
+            const messageId = await this.sendText(text, payload.format, payload.sendOptions);
+            state.telegramMessageIds[index] = messageId;
+            state.lastSentSignatures[index] = nextSignature;
+        }
+        for (let index = state.telegramMessageIds.length - 1; index >= payload.parts.length; index--) {
+            const messageId = state.telegramMessageIds[index];
+            if (messageId) {
+                await this.deleteText(messageId);
+            }
+            state.telegramMessageIds.pop();
+            state.lastSentSignatures.pop();
+        }
+    }
+}