opencode-telegram-group-topics-bot 0.11.2

package/dist/topic/constants.js

@@ -0,0 +1,10 @@
+import { TOPIC_SESSION_STATUS } from "../settings/manager.js";
+export const TOPIC_CLEANUP_POLICY = {
+    CLOSE_ONLY: "close-only",
+};
+export const TOPIC_STATUS_CLOSEABLE = new Set([
+    TOPIC_SESSION_STATUS.CLOSED,
+    TOPIC_SESSION_STATUS.STALE,
+    TOPIC_SESSION_STATUS.ABANDONED,
+    TOPIC_SESSION_STATUS.ERROR,
+]);

package/dist/topic/manager.js

@@ -0,0 +1,161 @@
+import { TOPIC_SESSION_STATUS, clearTopicSessionBinding, getCurrentProject, getScopedSessions, findTopicSessionBindingByScopeKey, findTopicSessionBindingBySessionId, getTopicSessionBinding, getTopicSessionBindings, getTopicSessionBindingsByChat, setTopicSessionBinding, updateTopicSessionBindingStatus, } from "../settings/manager.js";
+import { getScopeForSession } from "../session/manager.js";
+import { SCOPE_CONTEXT, getScopeFromKey } from "../bot/scope.js";
+import { logger } from "../utils/logger.js";
+const BINDING_KEY_SEPARATOR = ":";
+let hydratedFromScopedSessions = false;
+function nowTimestamp() {
+    return Date.now();
+}
+export function createTopicBindingKey(chatId, threadId) {
+    return `${chatId}${BINDING_KEY_SEPARATOR}${threadId}`;
+}
+function buildBinding(input, existing) {
+    const timestamp = nowTimestamp();
+    return {
+        scopeKey: input.scopeKey,
+        chatId: input.chatId,
+        threadId: input.threadId,
+        sessionId: input.sessionId,
+        projectId: input.projectId,
+        projectWorktree: input.projectWorktree,
+        topicName: input.topicName,
+        status: input.status ?? existing?.status ?? TOPIC_SESSION_STATUS.ACTIVE,
+        createdAt: existing?.createdAt ?? timestamp,
+        updatedAt: timestamp,
+        closedAt: existing?.closedAt,
+    };
+}
+function ensureTopicBindingsHydrated() {
+    if (hydratedFromScopedSessions) {
+        return;
+    }
+    hydratedFromScopedSessions = true;
+    const scopedSessions = getScopedSessions();
+    for (const [scopeKey, sessionInfo] of Object.entries(scopedSessions)) {
+        const scope = getScopeFromKey(scopeKey);
+        if (!scope || scope.context !== SCOPE_CONTEXT.GROUP_TOPIC || scope.threadId === null) {
+            continue;
+        }
+        const bindingKey = createTopicBindingKey(scope.chatId, scope.threadId);
+        const existingByTopic = getTopicSessionBinding(bindingKey);
+        const existingBySession = findTopicSessionBindingBySessionId(sessionInfo.id);
+        if (existingByTopic || existingBySession) {
+            continue;
+        }
+        const project = getCurrentProject(scopeKey);
+        if (!project) {
+            continue;
+        }
+        const timestamp = nowTimestamp();
+        const hydratedBinding = {
+            scopeKey,
+            chatId: scope.chatId,
+            threadId: scope.threadId,
+            sessionId: sessionInfo.id,
+            projectId: project.id,
+            projectWorktree: project.worktree,
+            topicName: undefined,
+            status: TOPIC_SESSION_STATUS.ACTIVE,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        setTopicSessionBinding(bindingKey, hydratedBinding);
+        logger.info(`[TopicManager] Hydrated binding from scoped session: scope=${scopeKey}, session=${sessionInfo.id}`);
+    }
+}
+export function registerTopicSessionBinding(input) {
+    ensureTopicBindingsHydrated();
+    const bindingKey = createTopicBindingKey(input.chatId, input.threadId);
+    const existingByTopic = getTopicSessionBinding(bindingKey);
+    if (existingByTopic && existingByTopic.sessionId !== input.sessionId) {
+        throw new Error(`[TopicManager] Topic ${bindingKey} is already bound to session ${existingByTopic.sessionId}`);
+    }
+    const existingBySession = findTopicSessionBindingBySessionId(input.sessionId);
+    if (existingBySession) {
+        const existingBySessionKey = createTopicBindingKey(existingBySession.chatId, existingBySession.threadId);
+        if (existingBySessionKey !== bindingKey) {
+            clearTopicSessionBinding(existingBySessionKey);
+            logger.warn(`[TopicManager] Rebinding session ${input.sessionId} from topic ${existingBySessionKey} to ${bindingKey}`);
+        }
+    }
+    const nextBinding = buildBinding(input, existingByTopic);
+    setTopicSessionBinding(bindingKey, nextBinding);
+    logger.info(`[TopicManager] Registered topic binding: scope=${nextBinding.scopeKey}, session=${nextBinding.sessionId}, status=${nextBinding.status}`);
+    return nextBinding;
+}
+export function getTopicBinding(chatId, threadId) {
+    ensureTopicBindingsHydrated();
+    return getTopicSessionBinding(createTopicBindingKey(chatId, threadId));
+}
+export function getTopicBindingByScopeKey(scopeKey) {
+    ensureTopicBindingsHydrated();
+    return findTopicSessionBindingByScopeKey(scopeKey);
+}
+export function getTopicBindingBySessionId(sessionId) {
+    ensureTopicBindingsHydrated();
+    return findTopicSessionBindingBySessionId(sessionId);
+}
+export function getTopicBindingsByChat(chatId) {
+    ensureTopicBindingsHydrated();
+    return getTopicSessionBindingsByChat(chatId);
+}
+export function listAllTopicBindings() {
+    ensureTopicBindingsHydrated();
+    return Object.values(getTopicSessionBindings());
+}
+export function updateTopicBindingStatus(chatId, threadId, status) {
+    ensureTopicBindingsHydrated();
+    const bindingKey = createTopicBindingKey(chatId, threadId);
+    updateTopicSessionBindingStatus(bindingKey, status);
+}
+export function updateTopicBindingStatusBySessionId(sessionId, status) {
+    ensureTopicBindingsHydrated();
+    const binding = findTopicSessionBindingBySessionId(sessionId);
+    if (!binding) {
+        return;
+    }
+    updateTopicSessionBindingStatus(createTopicBindingKey(binding.chatId, binding.threadId), status);
+}
+export function updateTopicBindingNameBySessionId(sessionId, topicName) {
+    ensureTopicBindingsHydrated();
+    const binding = findTopicSessionBindingBySessionId(sessionId);
+    if (!binding) {
+        return;
+    }
+    const bindingKey = createTopicBindingKey(binding.chatId, binding.threadId);
+    const nextBinding = {
+        ...binding,
+        topicName,
+        updatedAt: nowTimestamp(),
+    };
+    setTopicSessionBinding(bindingKey, nextBinding);
+}
+export function removeTopicBinding(chatId, threadId) {
+    ensureTopicBindingsHydrated();
+    clearTopicSessionBinding(createTopicBindingKey(chatId, threadId));
+}
+export function getSessionRouteTarget(sessionId) {
+    ensureTopicBindingsHydrated();
+    const binding = findTopicSessionBindingBySessionId(sessionId);
+    if (binding) {
+        return {
+            scopeKey: binding.scopeKey,
+            chatId: binding.chatId,
+            threadId: binding.threadId,
+        };
+    }
+    const scopeKey = getScopeForSession(sessionId);
+    if (!scopeKey) {
+        return null;
+    }
+    const scope = getScopeFromKey(scopeKey);
+    if (!scope) {
+        return null;
+    }
+    return {
+        scopeKey,
+        chatId: scope.chatId,
+        threadId: scope.threadId,
+    };
+}

package/dist/topic/title-constants.js

@@ -0,0 +1,2 @@
+export const TOPIC_NAME_MAX_LENGTH = 128;
+export const TOPIC_NAME_TRUNCATION_SUFFIX = "...";

package/dist/topic/title-format.js

@@ -0,0 +1,10 @@
+import { TOPIC_NAME_MAX_LENGTH, TOPIC_NAME_TRUNCATION_SUFFIX } from "./title-constants.js";
+const TOPIC_TITLE_FALLBACK = "Session";
+export function formatTopicTitle(rawTitle, fallbackTitle) {
+    const baseTitle = rawTitle.trim() || fallbackTitle?.trim() || TOPIC_TITLE_FALLBACK;
+    if (baseTitle.length <= TOPIC_NAME_MAX_LENGTH) {
+        return baseTitle;
+    }
+    const allowedLength = TOPIC_NAME_MAX_LENGTH - TOPIC_NAME_TRUNCATION_SUFFIX.length;
+    return `${baseTitle.slice(0, allowedLength).trimEnd()}${TOPIC_NAME_TRUNCATION_SUFFIX}`;
+}

package/dist/topic/title-sync.js

@@ -0,0 +1,17 @@
+import { logger } from "../utils/logger.js";
+import { getTopicBindingBySessionId, updateTopicBindingNameBySessionId } from "./manager.js";
+import { formatTopicTitle } from "./title-format.js";
+export async function syncTopicTitleForSession(api, sessionId, sessionTitle) {
+    const binding = getTopicBindingBySessionId(sessionId);
+    if (!binding) {
+        return false;
+    }
+    const topicName = formatTopicTitle(sessionTitle);
+    if (!topicName || binding.topicName === topicName) {
+        return false;
+    }
+    await api.editForumTopic(binding.chatId, binding.threadId, { name: topicName });
+    updateTopicBindingNameBySessionId(sessionId, topicName);
+    logger.info(`[TopicTitle] Synced topic title for session ${sessionId}: thread=${binding.threadId}, title=${topicName}`);
+    return true;
+}

package/dist/utils/error-format.js

@@ -0,0 +1,29 @@
+const DEFAULT_MAX_ERROR_DETAILS_LENGTH = 1500;
+function clipText(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+export function formatErrorDetails(error, maxLength = DEFAULT_MAX_ERROR_DETAILS_LENGTH) {
+    let details = "";
+    if (error instanceof Error) {
+        details = error.stack ?? `${error.name}: ${error.message}`;
+    }
+    else if (typeof error === "string") {
+        details = error;
+    }
+    else {
+        try {
+            details = JSON.stringify(error, null, 2);
+        }
+        catch {
+            details = String(error);
+        }
+    }
+    const normalized = details.trim();
+    if (!normalized || normalized === "{}" || normalized === "[object Object]") {
+        return "unknown error";
+    }
+    return clipText(normalized, maxLength);
+}

package/dist/utils/logger.js

@@ -0,0 +1,175 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { config } from "../config.js";
+import { getRuntimePaths } from "../runtime/paths.js";
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+const FILE_LOG_NAME = "opencode-telegram-group-topics-bot.log";
+const FILE_LOG_MAX_BYTES = 5 * 1024 * 1024;
+const FILE_LOG_MAX_ROTATIONS = 5;
+const LOG_LINE_SEPARATOR = "\n";
+const LOG_FILE_SUFFIX_SEPARATOR = ".";
+let fileLoggerInitialized = false;
+let currentLogFileSizeBytes = 0;
+let fileWriteQueue = Promise.resolve();
+function normalizeLogLevel(value) {
+    if (value in LOG_LEVELS) {
+        return value;
+    }
+    return "info";
+}
+function formatPrefix(level) {
+    return `[${new Date().toISOString()}] [${level.toUpperCase()}]`;
+}
+function formatArg(arg) {
+    if (arg instanceof Error) {
+        return arg.stack ?? `${arg.name}: ${arg.message}`;
+    }
+    return arg;
+}
+function withPrefix(level, args) {
+    const formattedArgs = args.map((arg) => formatArg(arg));
+    const prefix = formatPrefix(level);
+    if (formattedArgs.length === 0) {
+        return [prefix];
+    }
+    if (typeof formattedArgs[0] === "string") {
+        return [`${prefix} ${formattedArgs[0]}`, ...formattedArgs.slice(1)];
+    }
+    return [prefix, ...formattedArgs];
+}
+function shouldLog(level) {
+    const configLevel = normalizeLogLevel(config.server.logLevel);
+    return LOG_LEVELS[level] >= LOG_LEVELS[configLevel];
+}
+function getLogFilePath() {
+    return path.join(getRuntimePaths().logsDirPath, FILE_LOG_NAME);
+}
+function getRotatedLogPath(logFilePath, index) {
+    return `${logFilePath}${LOG_FILE_SUFFIX_SEPARATOR}${index}`;
+}
+async function pathExists(filePath) {
+    try {
+        await fs.stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureFileLoggerInitialized(logFilePath) {
+    if (fileLoggerInitialized) {
+        return;
+    }
+    await fs.mkdir(path.dirname(logFilePath), { recursive: true });
+    try {
+        const stat = await fs.stat(logFilePath);
+        currentLogFileSizeBytes = stat.size;
+    }
+    catch {
+        currentLogFileSizeBytes = 0;
+    }
+    fileLoggerInitialized = true;
+}
+async function rotateLogFile(logFilePath) {
+    const oldestPath = getRotatedLogPath(logFilePath, FILE_LOG_MAX_ROTATIONS);
+    if (await pathExists(oldestPath)) {
+        await fs.rm(oldestPath, { force: true });
+    }
+    for (let index = FILE_LOG_MAX_ROTATIONS - 1; index >= 1; index--) {
+        const currentPath = getRotatedLogPath(logFilePath, index);
+        if (!(await pathExists(currentPath))) {
+            continue;
+        }
+        const nextPath = getRotatedLogPath(logFilePath, index + 1);
+        await fs.rename(currentPath, nextPath);
+    }
+    if (await pathExists(logFilePath)) {
+        await fs.rename(logFilePath, getRotatedLogPath(logFilePath, 1));
+    }
+    currentLogFileSizeBytes = 0;
+}
+function stringifyLogArg(arg) {
+    if (arg instanceof Error) {
+        return arg.stack ?? `${arg.name}: ${arg.message}`;
+    }
+    if (typeof arg === "string") {
+        return arg;
+    }
+    if (typeof arg === "number" || typeof arg === "boolean" || arg === null || arg === undefined) {
+        return String(arg);
+    }
+    try {
+        return JSON.stringify(arg);
+    }
+    catch {
+        return String(arg);
+    }
+}
+function toFileLogLine(level, args) {
+    const prefix = formatPrefix(level);
+    if (args.length === 0) {
+        return prefix;
+    }
+    const serializedArgs = args.map((arg) => stringifyLogArg(arg));
+    return `${prefix} ${serializedArgs.join(" ")}`;
+}
+function writeToConsole(level, args) {
+    const output = withPrefix(level, args);
+    if (level === "warn") {
+        console.warn(...output);
+        return;
+    }
+    if (level === "error") {
+        console.error(...output);
+        return;
+    }
+    console.log(...output);
+}
+function writeToFile(level, args) {
+    const logFilePath = getLogFilePath();
+    const logLine = `${toFileLogLine(level, args)}${LOG_LINE_SEPARATOR}`;
+    fileWriteQueue = fileWriteQueue
+        .catch(() => {
+        // Keep queue alive after previous write error.
+    })
+        .then(async () => {
+        try {
+            await ensureFileLoggerInitialized(logFilePath);
+            const lineSizeBytes = Buffer.byteLength(logLine);
+            if (currentLogFileSizeBytes + lineSizeBytes > FILE_LOG_MAX_BYTES) {
+                await rotateLogFile(logFilePath);
+            }
+            await fs.appendFile(logFilePath, logLine, "utf-8");
+            currentLogFileSizeBytes += lineSizeBytes;
+        }
+        catch (error) {
+            console.error("[Logger] Failed to write log file:", error);
+        }
+    });
+}
+function log(level, ...args) {
+    if (!shouldLog(level)) {
+        return;
+    }
+    writeToConsole(level, args);
+    writeToFile(level, args);
+}
+export const logger = {
+    debug: (...args) => {
+        log("debug", ...args);
+    },
+    info: (...args) => {
+        log("info", ...args);
+    },
+    warn: (...args) => {
+        log("warn", ...args);
+    },
+    error: (...args) => {
+        log("error", ...args);
+    },
+};

package/dist/utils/safe-background-task.js

@@ -0,0 +1,33 @@
+import { logger } from "./logger.js";
+function runHookSafely(taskName, hookName, hook, value) {
+    if (!hook) {
+        return;
+    }
+    try {
+        void Promise.resolve(hook(value)).catch((hookError) => {
+            logger.error(`[safeBackgroundTask] ${taskName}: ${hookName} failed:`, hookError);
+        });
+    }
+    catch (hookError) {
+        logger.error(`[safeBackgroundTask] ${taskName}: ${hookName} failed:`, hookError);
+    }
+}
+export function safeBackgroundTask({ taskName, task, onSuccess, onError, }) {
+    const handleError = (error) => {
+        logger.error(`[safeBackgroundTask] ${taskName} failed:`, error);
+        runHookSafely(taskName, "onError", onError, error);
+    };
+    try {
+        const taskPromise = task();
+        void taskPromise
+            .then((result) => {
+            runHookSafely(taskName, "onSuccess", onSuccess, result);
+        })
+            .catch((error) => {
+            handleError(error);
+        });
+    }
+    catch (error) {
+        handleError(error);
+    }
+}

package/dist/variant/manager.js

@@ -0,0 +1,103 @@
+/**
+ * Variant Manager - manages model variants (reasoning modes)
+ */
+import { opencodeClient } from "../opencode/client.js";
+import { getCurrentModel, setCurrentModel } from "../settings/manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Get available variants for a model from OpenCode API
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns Array of available variants
+ */
+export async function getAvailableVariants(providerID, modelID) {
+    try {
+        const { data, error } = await opencodeClient.config.providers();
+        if (error || !data) {
+            logger.warn("[VariantManager] Failed to fetch providers:", error);
+            return [{ id: "default" }];
+        }
+        const provider = data.providers.find((p) => p.id === providerID);
+        if (!provider) {
+            logger.warn(`[VariantManager] Provider ${providerID} not found`);
+            return [{ id: "default" }];
+        }
+        const model = provider.models[modelID];
+        if (!model) {
+            logger.warn(`[VariantManager] Model ${modelID} not found in provider ${providerID}`);
+            return [{ id: "default" }];
+        }
+        // Start with default variant (always present)
+        const variants = [{ id: "default" }];
+        if (model.variants) {
+            // Add other variants from API (excluding default if it's already there)
+            const apiVariants = Object.entries(model.variants)
+                .filter(([id]) => id !== "default")
+                .map(([id, info]) => ({
+                id,
+                disabled: info.disabled,
+            }));
+            variants.push(...apiVariants);
+            logger.debug(`[VariantManager] Found ${variants.length} variants for ${providerID}/${modelID} (including default)`);
+        }
+        else {
+            logger.debug(`[VariantManager] No variants found for ${providerID}/${modelID}, using default only`);
+        }
+        return variants;
+    }
+    catch (err) {
+        logger.error("[VariantManager] Error fetching variants:", err);
+        return [{ id: "default" }];
+    }
+}
+/**
+ * Get current variant from settings
+ * @returns Current variant ID (defaults to "default")
+ */
+export function getCurrentVariant(scopeKey = "global") {
+    const currentModel = getCurrentModel(scopeKey);
+    return currentModel?.variant || "default";
+}
+/**
+ * Set current variant in settings
+ * @param variantId Variant ID to set
+ */
+export function setCurrentVariant(variantId, scopeKey = "global") {
+    const currentModel = getCurrentModel(scopeKey);
+    if (!currentModel) {
+        logger.warn("[VariantManager] Cannot set variant: no current model");
+        return;
+    }
+    currentModel.variant = variantId;
+    setCurrentModel(currentModel, scopeKey);
+    logger.info(`[VariantManager] Variant set to: ${variantId}`);
+}
+/**
+ * Format variant for button display
+ * @param variantId Variant ID (e.g., "default", "low", "high")
+ * @returns Formatted string "💭 Default", "💭 Low", etc.
+ */
+export function formatVariantForButton(variantId) {
+    const capitalized = variantId.charAt(0).toUpperCase() + variantId.slice(1);
+    return `💡 ${capitalized}`;
+}
+/**
+ * Format variant for display in messages
+ * @param variantId Variant ID
+ * @returns Formatted string with capitalized first letter
+ */
+export function formatVariantForDisplay(variantId) {
+    return variantId.charAt(0).toUpperCase() + variantId.slice(1);
+}
+/**
+ * Validate if a model supports a specific variant
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @param variantId Variant ID to validate
+ * @returns true if variant is supported, false otherwise
+ */
+export async function validateVariantForModel(providerID, modelID, variantId) {
+    const variants = await getAvailableVariants(providerID, modelID);
+    const found = variants.find((v) => v.id === variantId && !v.disabled);
+    return found !== undefined;
+}

package/dist/variant/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "opencode-telegram-group-topics-bot",
+  "version": "0.11.2",
+  "description": "Telegram bot client for OpenCode with Telegram forum-topic session lanes.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "opencode-telegram-group-topics-bot": "dist/cli.js"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./cli": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "npm run build && npm start",
+    "release:prepare": "node scripts/release-prepare.mjs",
+    "release:rc": "node scripts/release-prepare.mjs rc",
+    "release:notes:preview": "node scripts/release-notes-preview.mjs",
+    "lint": "eslint src --ext .ts --max-warnings=0",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shanekunz/opencode-telegram-group-topics-bot.git"
+  },
+  "keywords": [
+    "opencode",
+    "telegram",
+    "telegram-bot",
+    "grammy",
+    "developer-tools",
+    "cli"
+  ],
+  "author": "Shane Kunz and contributors",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/shanekunz/opencode-telegram-group-topics-bot/issues"
+  },
+  "homepage": "https://github.com/shanekunz/opencode-telegram-group-topics-bot#readme",
+  "dependencies": {
+    "@grammyjs/menu": "^1.3.1",
+    "@opencode-ai/sdk": "^1.1.21",
+    "better-sqlite3": "^12.6.2",
+    "dotenv": "^17.2.3",
+    "grammy": "^1.39.2",
+    "https-proxy-agent": "^7.0.6",
+    "socks-proxy-agent": "^8.0.5",
+    "telegram-markdown-v2": "^0.0.4"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.0.8",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^10.1.8",
+    "prettier": "^3.8.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}