zardbot-telegram 1.0.0

package/dist/bot/utils/send-with-markdown-fallback.js

@@ -0,0 +1,165 @@
+import { logger } from "../../utils/logger.js";
+const MARKDOWN_PARSE_ERROR_MARKERS = [
+    "can't parse entities",
+    "can't parse entity",
+    "can't find end of the entity",
+    "entity beginning",
+    "bad request: can't parse",
+];
+const MARKDOWN_V2_RESERVED_CHARS = new Set([
+    "_",
+    "*",
+    "[",
+    "]",
+    "(",
+    ")",
+    "~",
+    "`",
+    ">",
+    "#",
+    "+",
+    "-",
+    "=",
+    "|",
+    "{",
+    "}",
+    ".",
+    "!",
+    "\\",
+]);
+const MARKDOWN_V2_ESCAPED_CHAR = /\\([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
+function escapeTelegramMarkdownV2(text) {
+    let result = "";
+    let trailingBackslashes = 0;
+    for (const char of text) {
+        if (char === "\\") {
+            result += char;
+            trailingBackslashes += 1;
+            continue;
+        }
+        const isEscaped = trailingBackslashes % 2 === 1;
+        trailingBackslashes = 0;
+        if (MARKDOWN_V2_RESERVED_CHARS.has(char) && !isEscaped) {
+            result += `\\${char}`;
+            continue;
+        }
+        result += char;
+    }
+    return result;
+}
+function unescapeTelegramMarkdownV2(text) {
+    return text.replace(MARKDOWN_V2_ESCAPED_CHAR, "$1");
+}
+function stripMarkdownFormattingOptions(options) {
+    if (!options) {
+        return options;
+    }
+    const rawOptions = {
+        ...options,
+    };
+    delete rawOptions.parse_mode;
+    delete rawOptions.entities;
+    return rawOptions;
+}
+function getErrorText(error) {
+    const parts = [];
+    if (error instanceof Error) {
+        parts.push(error.message);
+    }
+    if (typeof error === "object" && error !== null) {
+        const description = Reflect.get(error, "description");
+        if (typeof description === "string") {
+            parts.push(description);
+        }
+        const message = Reflect.get(error, "message");
+        if (typeof message === "string") {
+            parts.push(message);
+        }
+    }
+    if (typeof error === "string") {
+        parts.push(error);
+    }
+    if (parts.length === 0) {
+        return "";
+    }
+    return parts.join("\n").toLowerCase();
+}
+export function isTelegramMarkdownParseError(error) {
+    const errorText = getErrorText(error);
+    if (!errorText) {
+        return false;
+    }
+    return MARKDOWN_PARSE_ERROR_MARKERS.some((marker) => errorText.includes(marker));
+}
+export async function sendMessageWithMarkdownFallback({ api, chatId, text, rawFallbackText, options, parseMode, }) {
+    if (!parseMode) {
+        return api.sendMessage(chatId, text, options);
+    }
+    const markdownOptions = {
+        ...(options || {}),
+        parse_mode: parseMode,
+    };
+    const fallbackText = rawFallbackText ?? (parseMode === "MarkdownV2" ? unescapeTelegramMarkdownV2(text) : text);
+    try {
+        return await api.sendMessage(chatId, text, markdownOptions);
+    }
+    catch (error) {
+        if (!isTelegramMarkdownParseError(error)) {
+            throw error;
+        }
+        if (parseMode === "MarkdownV2") {
+            const escapedText = escapeTelegramMarkdownV2(text);
+            if (escapedText !== text) {
+                logger.warn("[Bot] Markdown parse failed, retrying assistant message with escaped MarkdownV2", error);
+                try {
+                    return await api.sendMessage(chatId, escapedText, markdownOptions);
+                }
+                catch (escapedError) {
+                    if (!isTelegramMarkdownParseError(escapedError)) {
+                        throw escapedError;
+                    }
+                    logger.warn("[Bot] Escaped Markdown parse failed, retrying assistant message in raw mode", escapedError);
+                    return api.sendMessage(chatId, fallbackText, stripMarkdownFormattingOptions(options));
+                }
+            }
+        }
+        logger.warn("[Bot] Markdown parse failed, retrying assistant message in raw mode", error);
+        return api.sendMessage(chatId, fallbackText, stripMarkdownFormattingOptions(options));
+    }
+}
+export async function editMessageWithMarkdownFallback({ api, chatId, messageId, text, rawFallbackText, options, parseMode, }) {
+    if (!parseMode) {
+        return api.editMessageText(chatId, messageId, text, options);
+    }
+    const markdownOptions = {
+        ...(options || {}),
+        parse_mode: parseMode,
+    };
+    const fallbackText = rawFallbackText ?? (parseMode === "MarkdownV2" ? unescapeTelegramMarkdownV2(text) : text);
+    try {
+        return await api.editMessageText(chatId, messageId, text, markdownOptions);
+    }
+    catch (error) {
+        if (!isTelegramMarkdownParseError(error)) {
+            throw error;
+        }
+        if (parseMode === "MarkdownV2") {
+            const escapedText = escapeTelegramMarkdownV2(text);
+            if (escapedText !== text) {
+                logger.warn("[Bot] Markdown parse failed, retrying edited message with escaped MarkdownV2", error);
+                try {
+                    return await api.editMessageText(chatId, messageId, escapedText, markdownOptions);
+                }
+                catch (escapedError) {
+                    if (!isTelegramMarkdownParseError(escapedError)) {
+                        throw escapedError;
+                    }
+                    logger.warn("[Bot] Escaped Markdown parse failed, retrying edited message in raw mode", escapedError);
+                    return api.editMessageText(chatId, messageId, fallbackText, stripMarkdownFormattingOptions(options));
+                }
+            }
+        }
+        logger.warn("[Bot] Markdown parse failed, retrying edited message in raw mode", error);
+        return api.editMessageText(chatId, messageId, fallbackText, stripMarkdownFormattingOptions(options));
+    }
+}

package/dist/bot/utils/telegram-text.js

@@ -0,0 +1,28 @@
+import { editMessageWithMarkdownFallback, sendMessageWithMarkdownFallback, } from "./send-with-markdown-fallback.js";
+function resolveParseMode(format) {
+    if (format === "markdown_v2") {
+        return "MarkdownV2";
+    }
+    return undefined;
+}
+export async function sendBotText({ api, chatId, text, rawFallbackText, options, format = "raw", }) {
+    await sendMessageWithMarkdownFallback({
+        api,
+        chatId,
+        text,
+        rawFallbackText,
+        options,
+        parseMode: resolveParseMode(format),
+    });
+}
+export async function editBotText({ api, chatId, messageId, text, rawFallbackText, options, format = "raw", }) {
+    await editMessageWithMarkdownFallback({
+        api,
+        chatId,
+        messageId,
+        text,
+        rawFallbackText,
+        options,
+        parseMode: resolveParseMode(format),
+    });
+}

package/dist/bot/utils/thinking-message.js

@@ -0,0 +1,8 @@
+import { t } from "../../i18n/index.js";
+export function deliverThinkingMessage(sessionId, batcher, options) {
+    if (options.hideThinkingMessages) {
+        return;
+    }
+    const message = t("bot.thinking");
+    batcher.sendTextNow(sessionId, message, "thinking_started");
+}

package/dist/cli/args.js

@@ -0,0 +1,98 @@
+import { t } from "../i18n/index.js";
+const SUPPORTED_COMMANDS = ["start", "status", "stop", "config"];
+function isCliCommand(value) {
+    return SUPPORTED_COMMANDS.includes(value);
+}
+function normalizeMode(value) {
+    if (value === "installed") {
+        return "installed";
+    }
+    if (value === "sources") {
+        return "sources";
+    }
+    return null;
+}
+export function parseCliArgs(argv) {
+    const args = [...argv];
+    let command = "start";
+    let mode;
+    let showHelp = false;
+    let currentIndex = 0;
+    const firstArg = args[0];
+    if (firstArg && !firstArg.startsWith("-")) {
+        if (!isCliCommand(firstArg)) {
+            return {
+                command,
+                showHelp: true,
+                error: t("cli.args.unknown_command", { value: firstArg }),
+            };
+        }
+        command = firstArg;
+        currentIndex = 1;
+    }
+    while (currentIndex < args.length) {
+        const token = args[currentIndex];
+        if (token === "--help" || token === "-h") {
+            showHelp = true;
+            currentIndex += 1;
+            continue;
+        }
+        if (token === "--mode") {
+            const modeValue = args[currentIndex + 1];
+            if (!modeValue || modeValue.startsWith("-")) {
+                return {
+                    command,
+                    mode,
+                    showHelp: true,
+                    error: t("cli.args.mode_requires_value"),
+                };
+            }
+            const parsedMode = normalizeMode(modeValue);
+            if (!parsedMode) {
+                return {
+                    command,
+                    mode,
+                    showHelp: true,
+                    error: t("cli.args.invalid_mode", { value: modeValue }),
+                };
+            }
+            mode = parsedMode;
+            currentIndex += 2;
+            continue;
+        }
+        if (token.startsWith("--mode=")) {
+            const modeValue = token.slice("--mode=".length);
+            const parsedMode = normalizeMode(modeValue);
+            if (!parsedMode) {
+                return {
+                    command,
+                    mode,
+                    showHelp: true,
+                    error: t("cli.args.invalid_mode", { value: modeValue }),
+                };
+            }
+            mode = parsedMode;
+            currentIndex += 1;
+            continue;
+        }
+        return {
+            command,
+            mode,
+            showHelp: true,
+            error: t("cli.args.unknown_option", { value: token }),
+        };
+    }
+    if (command !== "start" && mode) {
+        return {
+            command,
+            mode,
+            showHelp: true,
+            error: t("cli.args.mode_only_start"),
+        };
+    }
+    return {
+        command,
+        mode,
+        showHelp,
+    };
+}

package/dist/cli.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { parseCliArgs } from "./cli/args.js";
+import { resolveRuntimeMode, setRuntimeMode } from "./runtime/mode.js";
+import { t } from "./i18n/index.js";
+const EXIT_SUCCESS = 0;
+const EXIT_RUNTIME_ERROR = 1;
+const EXIT_INVALID_ARGS = 2;
+function writeStdout(message) {
+    process.stdout.write(`${message}\n`);
+}
+function writeStderr(message) {
+    process.stderr.write(`${message}\n`);
+}
+function printUsage() {
+    writeStdout(t("cli.usage"));
+}
+function getPlaceholderMessage(command) {
+    if (command === "status") {
+        return t("cli.placeholder.status");
+    }
+    if (command === "stop") {
+        return t("cli.placeholder.stop");
+    }
+    return t("cli.placeholder.unavailable");
+}
+async function runStartCommand(mode) {
+    const modeResult = resolveRuntimeMode({
+        defaultMode: "installed",
+        explicitMode: mode,
+    });
+    if (modeResult.error) {
+        throw new Error(modeResult.error);
+    }
+    setRuntimeMode(modeResult.mode);
+    const { ensureRuntimeConfigForStart } = await import("./runtime/bootstrap.js");
+    await ensureRuntimeConfigForStart();
+    const { startBotApp } = await import("./app/start-bot-app.js");
+    await startBotApp();
+    return EXIT_SUCCESS;
+}
+async function runConfigCommand() {
+    setRuntimeMode("installed");
+    const { runConfigWizardCommand } = await import("./runtime/bootstrap.js");
+    await runConfigWizardCommand();
+    return EXIT_SUCCESS;
+}
+async function runPlaceholderCommand(command) {
+    writeStdout(getPlaceholderMessage(command));
+    return EXIT_SUCCESS;
+}
+async function runCli(argv) {
+    const parsedArgs = parseCliArgs(argv);
+    if (parsedArgs.error) {
+        writeStderr(parsedArgs.error);
+    }
+    if (parsedArgs.showHelp) {
+        printUsage();
+        return parsedArgs.error ? EXIT_INVALID_ARGS : EXIT_SUCCESS;
+    }
+    if (parsedArgs.command === "start") {
+        return runStartCommand(parsedArgs.mode);
+    }
+    if (parsedArgs.command === "config") {
+        return runConfigCommand();
+    }
+    return runPlaceholderCommand(parsedArgs.command);
+}
+void runCli(process.argv.slice(2))
+    .then((exitCode) => {
+    process.exitCode = exitCode;
+})
+    .catch((error) => {
+    if (error instanceof Error) {
+        writeStderr(t("cli.error.prefix", { message: error.message }));
+    }
+    else {
+        writeStderr(t("cli.error.prefix", { message: String(error) }));
+    }
+    process.exitCode = EXIT_RUNTIME_ERROR;
+});

package/dist/config.js

@@ -0,0 +1,97 @@
+import dotenv from "dotenv";
+import { getRuntimePaths } from "./runtime/paths.js";
+import { normalizeLocale } from "./i18n/index.js";
+const runtimePaths = getRuntimePaths();
+dotenv.config({ path: runtimePaths.envFilePath, quiet: true });
+function getEnvVar(key, required = true) {
+    const value = process.env[key];
+    if (required && !value) {
+        throw new Error(`Missing required environment variable: ${key} (expected in ${runtimePaths.envFilePath})`);
+    }
+    return value || "";
+}
+function getOptionalPositiveIntEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    if (!value) {
+        return defaultValue;
+    }
+    const parsedValue = Number.parseInt(value, 10);
+    if (Number.isNaN(parsedValue) || parsedValue <= 0) {
+        return defaultValue;
+    }
+    return parsedValue;
+}
+function getOptionalLocaleEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    return normalizeLocale(value, defaultValue);
+}
+function getOptionalBooleanEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    if (!value) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return defaultValue;
+}
+function getOptionalMessageFormatModeEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    if (!value) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "raw" || normalized === "markdown") {
+        return normalized;
+    }
+    return defaultValue;
+}
+export const config = {
+    telegram: {
+        token: getEnvVar("TELEGRAM_BOT_TOKEN"),
+        allowedUserId: parseInt(getEnvVar("TELEGRAM_ALLOWED_USER_ID"), 10),
+        proxyUrl: getEnvVar("TELEGRAM_PROXY_URL", false),
+    },
+    opencode: {
+        apiUrl: getEnvVar("OPENCODE_API_URL", false) || "http://localhost:4096",
+        username: getEnvVar("OPENCODE_SERVER_USERNAME", false) || "opencode",
+        password: getEnvVar("OPENCODE_SERVER_PASSWORD", false),
+        model: {
+            provider: getEnvVar("OPENCODE_MODEL_PROVIDER", true), // Required
+            modelId: getEnvVar("OPENCODE_MODEL_ID", true), // Required
+        },
+    },
+    server: {
+        logLevel: getEnvVar("LOG_LEVEL", false) || "info",
+    },
+    bot: {
+        sessionsListLimit: getOptionalPositiveIntEnvVar("SESSIONS_LIST_LIMIT", 10),
+        projectsListLimit: getOptionalPositiveIntEnvVar("PROJECTS_LIST_LIMIT", 10),
+        commandsListLimit: getOptionalPositiveIntEnvVar("COMMANDS_LIST_LIMIT", 10),
+        taskLimit: getOptionalPositiveIntEnvVar("TASK_LIMIT", 10),
+        responseStreamThrottleMs: getOptionalPositiveIntEnvVar("RESPONSE_STREAM_THROTTLE_MS", 500),
+        locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
+        hideThinkingMessages: getOptionalBooleanEnvVar("HIDE_THINKING_MESSAGES", false),
+        hideToolCallMessages: getOptionalBooleanEnvVar("HIDE_TOOL_CALL_MESSAGES", false),
+        messageFormatMode: getOptionalMessageFormatModeEnvVar("MESSAGE_FORMAT_MODE", "markdown"),
+    },
+    files: {
+        maxFileSizeKb: parseInt(getEnvVar("CODE_FILE_MAX_SIZE_KB", false) || "100", 10),
+    },
+    stt: {
+        apiUrl: getEnvVar("STT_API_URL", false),
+        apiKey: getEnvVar("STT_API_KEY", false),
+        model: getEnvVar("STT_MODEL", false) || "whisper-large-v3-turbo",
+        language: getEnvVar("STT_LANGUAGE", false),
+    },
+    tts: {
+        apiUrl: getEnvVar("TTS_API_URL", false),
+        voice: getEnvVar("TTS_DEFAULT_VOICE", false) || "david-attenborough-original",
+        model: getEnvVar("TTS_MODEL", false) || "tts-1",
+        speed: parseFloat(getEnvVar("TTS_SPEED", false) || "1.0"),
+    },
+};