opencode-telegram-group-topics-bot 0.11.2

package/dist/bot/utils/file-download.js

@@ -0,0 +1,91 @@
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
+const TELEGRAM_FILE_URL_BASE = "https://api.telegram.org/file/bot";
+const MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024; // 20MB Telegram limit
+/**
+ * Download a photo from Telegram servers
+ * @param api Grammy API instance
+ * @param fileId Telegram file_id
+ * @returns Downloaded photo buffer and path
+ */
+export async function downloadTelegramFile(api, fileId) {
+    logger.debug(`[FileDownload] Getting file info for fileId=${fileId}`);
+    const file = await api.getFile(fileId);
+    if (!file.file_path) {
+        throw new Error("File path not available from Telegram");
+    }
+    if (file.file_size && file.file_size > MAX_FILE_SIZE_BYTES) {
+        const sizeMb = (file.file_size / (1024 * 1024)).toFixed(2);
+        throw new Error(`File too large: ${sizeMb}MB (max 20MB)`);
+    }
+    const fileUrl = `${TELEGRAM_FILE_URL_BASE}${config.telegram.token}/${file.file_path}`;
+    logger.debug(`[FileDownload] Downloading from ${fileUrl.replace(config.telegram.token, "***")}`);
+    const fetchOptions = {};
+    // Use proxy if configured
+    if (config.telegram.proxyUrl) {
+        const { HttpsProxyAgent } = await import("https-proxy-agent");
+        fetchOptions.agent = new HttpsProxyAgent(config.telegram.proxyUrl);
+    }
+    const response = await fetch(fileUrl, fetchOptions);
+    if (!response.ok) {
+        throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    logger.debug(`[FileDownload] Downloaded ${buffer.length} bytes`);
+    return {
+        buffer,
+        filePath: file.file_path,
+    };
+}
+/**
+ * Convert buffer to base64 data URI
+ * @param buffer File buffer
+ * @param mimeType MIME type (e.g., "image/jpeg")
+ * @returns Data URI string
+ */
+export function toDataUri(buffer, mimeType) {
+    const base64 = buffer.toString("base64");
+    return `data:${mimeType};base64,${base64}`;
+}
+/**
+ * Check if photo size is within limits
+ * @param fileSize Photo size in bytes
+ * @param maxSizeKb Maximum size in KB (from config)
+ * @returns true if within limit
+ */
+export function isFileSizeAllowed(fileSize, maxSizeKb) {
+    if (!fileSize) {
+        return true; // Unknown size, allow (will be checked on download)
+    }
+    const maxBytes = maxSizeKb * 1024;
+    return fileSize <= maxBytes;
+}
+/**
+ * Get human-readable photo size
+ */
+export function formatFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes}B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    }
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+const APPLICATION_TEXT_MIME_TYPES = new Set([
+    "application/json",
+    "application/xml",
+    "application/javascript",
+    "application/x-yaml",
+    "application/sql",
+]);
+export function isTextMimeType(mimeType) {
+    if (!mimeType) {
+        return false;
+    }
+    if (mimeType.startsWith("text/")) {
+        return true;
+    }
+    return APPLICATION_TEXT_MIME_TYPES.has(mimeType);
+}

package/dist/bot/utils/keyboard.js

@@ -0,0 +1,85 @@
+import { Keyboard } from "grammy";
+import { getAgentDisplayName } from "../../agent/types.js";
+import { formatModelForButton } from "../../model/types.js";
+import { t } from "../../i18n/index.js";
+/**
+ * Format token count for display (e.g., 150000 -> "150K", 1500000 -> "1.5M")
+ */
+function formatTokenCount(count) {
+    if (count >= 1000000) {
+        return `${(count / 1000000).toFixed(1)}M`;
+    }
+    else if (count >= 1000) {
+        return `${Math.round(count / 1000)}K`;
+    }
+    return count.toString();
+}
+/**
+ * Format context information for button
+ */
+function formatContextForButton(contextInfo) {
+    const used = formatTokenCount(contextInfo.tokensUsed);
+    const limit = formatTokenCount(contextInfo.tokensLimit);
+    const percent = Math.round((contextInfo.tokensUsed / contextInfo.tokensLimit) * 100);
+    return t("keyboard.context", { used, limit, percent });
+}
+/**
+ * Create Reply Keyboard with agent, model, variant, and context indicators
+ * @param currentAgent Current agent name (e.g., "build", "plan")
+ * @param currentModel Current model info
+ * @param contextInfo Optional context information (tokens used/limit)
+ * @param variantName Optional variant display name (e.g., "💭 Default")
+ * @returns Reply Keyboard with agent and context in row 1, model and variant in row 2
+ */
+export function createMainKeyboard(currentAgent, currentModel, contextInfo, variantName, options) {
+    const keyboard = new Keyboard();
+    const agentText = getAgentDisplayName(currentAgent);
+    // Format model with compact provider/model text and icon
+    const modelText = formatModelForButton(currentModel.providerID, currentModel.modelID);
+    // Context text - show "0" if no data available
+    const contextText = options?.contextLabel ??
+        (contextInfo ? formatContextForButton(contextInfo) : t("keyboard.context_empty"));
+    // Variant text - default to "💭 Default" if not provided
+    const variantText = variantName || t("keyboard.variant_default");
+    // Row 1: context and agent buttons (for control-plane) or agent/context defaults
+    const contextFirst = options?.contextFirst ?? true;
+    if (contextFirst) {
+        keyboard.text(contextText).text(agentText).row();
+    }
+    else {
+        keyboard.text(agentText).text(contextText).row();
+    }
+    // Row 2: model and variant buttons
+    keyboard.text(modelText).text(variantText).row();
+    return keyboard.resized().persistent();
+}
+export function createDmKeyboard() {
+    return new Keyboard()
+        .text(t("keyboard.dm.status"))
+        .text(t("keyboard.dm.help"))
+        .row()
+        .text(t("keyboard.dm.opencode_start"))
+        .text(t("keyboard.dm.opencode_stop"))
+        .row()
+        .resized()
+        .persistent();
+}
+/**
+ * Create Reply Keyboard with agent mode indicator
+ * @param currentAgent Current agent name (e.g., "build", "plan")
+ * @returns Reply Keyboard with single button showing current mode
+ * @deprecated Use createMainKeyboard instead
+ */
+export function createAgentKeyboard(currentAgent) {
+    const keyboard = new Keyboard();
+    const displayName = getAgentDisplayName(currentAgent);
+    // Single button with current agent mode
+    keyboard.text(displayName).row();
+    return keyboard.resized().persistent();
+}
+/**
+ * Remove Reply Keyboard (for cleanup)
+ */
+export function removeKeyboard() {
+    return { remove_keyboard: true };
+}

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

@@ -0,0 +1,57 @@
+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",
+];
+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, options, parseMode, }) {
+    if (!parseMode) {
+        return await api.sendMessage(chatId, text, options);
+    }
+    const markdownOptions = {
+        ...(options || {}),
+        parse_mode: parseMode,
+    };
+    try {
+        return await api.sendMessage(chatId, text, markdownOptions);
+    }
+    catch (error) {
+        if (!isTelegramMarkdownParseError(error)) {
+            throw error;
+        }
+        logger.warn("[Bot] Markdown parse failed, retrying assistant message in raw mode", error);
+        return await api.sendMessage(chatId, text, options);
+    }
+}

package/dist/bot/utils/session-error-filter.js

@@ -0,0 +1,34 @@
+const OPERATION_ABORTED_MARKERS = [
+    "the operation was aborted",
+    "operation was aborted",
+    "aborterror",
+];
+export function isOperationAbortedSessionError(message) {
+    const normalized = message.trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return OPERATION_ABORTED_MARKERS.some((marker) => normalized.includes(marker));
+}
+export class SessionErrorThrottle {
+    windowMs;
+    lastBySession = new Map();
+    constructor(windowMs = 3000) {
+        this.windowMs = windowMs;
+    }
+    shouldSuppress(sessionId, message, now = Date.now()) {
+        const normalized = message.trim().toLowerCase();
+        if (!normalized) {
+            return false;
+        }
+        const previous = this.lastBySession.get(sessionId);
+        this.lastBySession.set(sessionId, {
+            message: normalized,
+            timestamp: now,
+        });
+        if (!previous) {
+            return false;
+        }
+        return previous.message === normalized && now - previous.timestamp < this.windowMs;
+    }
+}

package/dist/bot/utils/topic-link.js

@@ -0,0 +1,29 @@
+import { CHAT_TYPE, TELEGRAM_CHAT_ID_PREFIX, TELEGRAM_URL, TELEGRAM_CHAT_FIELD, } from "../constants.js";
+function getInternalSupergroupId(chatId) {
+    const absoluteId = Math.abs(chatId).toString();
+    if (absoluteId.startsWith(TELEGRAM_CHAT_ID_PREFIX.PRIVATE_SUPERGROUP)) {
+        return absoluteId.slice(TELEGRAM_CHAT_ID_PREFIX.PRIVATE_SUPERGROUP.length);
+    }
+    return absoluteId;
+}
+export function buildTopicMessageLink(chat, messageId) {
+    if (!chat) {
+        return null;
+    }
+    const username = Reflect.get(chat, TELEGRAM_CHAT_FIELD.USERNAME);
+    if (typeof username === "string" && username.length > 0) {
+        return `${TELEGRAM_URL.BASE}/${username}/${messageId}`;
+    }
+    if (chat.type !== CHAT_TYPE.SUPERGROUP) {
+        return null;
+    }
+    const internalId = getInternalSupergroupId(chat.id);
+    return `${TELEGRAM_URL.BASE}${TELEGRAM_URL.PRIVATE_SUPERGROUP_PATH}/${internalId}/${messageId}`;
+}
+export function buildTopicThreadLink(chat, threadId) {
+    if (!chat || chat.type !== CHAT_TYPE.SUPERGROUP) {
+        return null;
+    }
+    const internalId = getInternalSupergroupId(chat.id);
+    return `${TELEGRAM_URL.BASE}${TELEGRAM_URL.PRIVATE_SUPERGROUP_PATH}/${internalId}/${threadId}`;
+}

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" && command !== "config" && 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(mode) {
+    setRuntimeMode(mode ?? "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(parsedArgs.mode);
+    }
+    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,103 @@
+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 getOptionalNonNegativeIntEnvVarFromKeys(keys, defaultValue) {
+    for (const key of keys) {
+        const value = getEnvVar(key, false);
+        if (!value) {
+            continue;
+        }
+        const parsedValue = Number.parseInt(value, 10);
+        if (Number.isNaN(parsedValue) || parsedValue < 0) {
+            return defaultValue;
+        }
+        return parsedValue;
+    }
+    return defaultValue;
+}
+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),
+        locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
+        serviceMessagesIntervalSec: getOptionalNonNegativeIntEnvVarFromKeys(["SERVICE_MESSAGES_INTERVAL_SEC", "TOOL_MESSAGES_INTERVAL_SEC"], 5),
+        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),
+    },
+};