opencode-telegram-group-topics-bot 0.11.2

package/dist/settings/manager.js

@@ -0,0 +1,283 @@
+import path from "node:path";
+import { getRuntimePaths } from "../runtime/paths.js";
+import { logger } from "../utils/logger.js";
+export const TOPIC_SESSION_STATUS = {
+    ACTIVE: "active",
+    CLOSED: "closed",
+    STALE: "stale",
+    ABANDONED: "abandoned",
+    ERROR: "error",
+};
+const GLOBAL_SCOPE_KEY = "global";
+function getSettingsFilePath() {
+    return getRuntimePaths().settingsFilePath;
+}
+async function readSettingsFile() {
+    try {
+        const fs = await import("fs/promises");
+        const content = await fs.readFile(getSettingsFilePath(), "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            logger.error("[SettingsManager] Error reading settings file:", error);
+        }
+        return {};
+    }
+}
+let settingsWriteQueue = Promise.resolve();
+function writeSettingsFile(settings) {
+    settingsWriteQueue = settingsWriteQueue
+        .catch(() => {
+        // Keep write queue alive after failed writes.
+    })
+        .then(async () => {
+        try {
+            const fs = await import("fs/promises");
+            const settingsFilePath = getSettingsFilePath();
+            await fs.mkdir(path.dirname(settingsFilePath), { recursive: true });
+            await fs.writeFile(settingsFilePath, JSON.stringify(settings, null, 2));
+        }
+        catch (err) {
+            logger.error("[SettingsManager] Error writing settings file:", err);
+        }
+    });
+    return settingsWriteQueue;
+}
+let currentSettings = {};
+function getScopedMap(map, scopeKey) {
+    return map?.[scopeKey];
+}
+function setScopedMapValue(map, scopeKey, value) {
+    return {
+        ...(map ?? {}),
+        [scopeKey]: value,
+    };
+}
+function clearScopedMapValue(map, scopeKey) {
+    if (!map || !(scopeKey in map)) {
+        return map;
+    }
+    const rest = Object.fromEntries(Object.entries(map).filter(([key]) => key !== scopeKey));
+    return Object.keys(rest).length > 0 ? rest : undefined;
+}
+function isTopicSessionStatus(value) {
+    return Object.values(TOPIC_SESSION_STATUS).includes(value);
+}
+function sanitizeTopicSessionBindings(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const sanitizedEntries = Object.entries(value)
+        .map(([bindingKey, rawBinding]) => {
+        if (!rawBinding || typeof rawBinding !== "object") {
+            return null;
+        }
+        const binding = rawBinding;
+        const now = Date.now();
+        const chatId = typeof binding.chatId === "number" ? binding.chatId : null;
+        const threadId = typeof binding.threadId === "number" ? binding.threadId : null;
+        const sessionId = typeof binding.sessionId === "string" ? binding.sessionId : "";
+        const projectId = typeof binding.projectId === "string" ? binding.projectId : "";
+        const scopeKey = typeof binding.scopeKey === "string" ? binding.scopeKey : "";
+        if (chatId === null || threadId === null || !sessionId || !projectId || !scopeKey) {
+            return null;
+        }
+        const createdAt = typeof binding.createdAt === "number" ? binding.createdAt : now;
+        const updatedAt = typeof binding.updatedAt === "number" ? binding.updatedAt : createdAt;
+        const sanitizedBinding = {
+            scopeKey,
+            chatId,
+            threadId,
+            sessionId,
+            projectId,
+            projectWorktree: typeof binding.projectWorktree === "string" ? binding.projectWorktree : undefined,
+            topicName: typeof binding.topicName === "string" ? binding.topicName : undefined,
+            status: isTopicSessionStatus(binding.status) ? binding.status : TOPIC_SESSION_STATUS.ACTIVE,
+            createdAt,
+            updatedAt,
+            closedAt: typeof binding.closedAt === "number" ? binding.closedAt : undefined,
+        };
+        return [bindingKey, sanitizedBinding];
+    })
+        .filter((entry) => entry !== null);
+    if (sanitizedEntries.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(sanitizedEntries);
+}
+export function getCurrentProject(scopeKey = GLOBAL_SCOPE_KEY) {
+    return getScopedMap(currentSettings.scopedProjects, scopeKey);
+}
+export function setCurrentProject(projectInfo, scopeKey = GLOBAL_SCOPE_KEY) {
+    currentSettings.scopedProjects = setScopedMapValue(currentSettings.scopedProjects, scopeKey, projectInfo);
+    void writeSettingsFile(currentSettings);
+}
+export function clearProject(scopeKey = GLOBAL_SCOPE_KEY) {
+    currentSettings.scopedProjects = clearScopedMapValue(currentSettings.scopedProjects, scopeKey);
+    void writeSettingsFile(currentSettings);
+}
+export function getCurrentSession(scopeKey = GLOBAL_SCOPE_KEY) {
+    return getScopedMap(currentSettings.scopedSessions, scopeKey);
+}
+export function setCurrentSession(sessionInfo, scopeKey = GLOBAL_SCOPE_KEY) {
+    currentSettings.scopedSessions = setScopedMapValue(currentSettings.scopedSessions, scopeKey, sessionInfo);
+    void writeSettingsFile(currentSettings);
+}
+export function clearSession(scopeKey = GLOBAL_SCOPE_KEY) {
+    currentSettings.scopedSessions = clearScopedMapValue(currentSettings.scopedSessions, scopeKey);
+    void writeSettingsFile(currentSettings);
+}
+export function getScopedSessions() {
+    return { ...(currentSettings.scopedSessions ?? {}) };
+}
+export function setScopedSession(scopeKey, sessionInfo) {
+    setCurrentSession(sessionInfo, scopeKey);
+}
+export function clearScopedSession(scopeKey) {
+    clearSession(scopeKey);
+}
+export function getCurrentAgent(scopeKey = GLOBAL_SCOPE_KEY) {
+    return getScopedMap(currentSettings.scopedAgents, scopeKey);
+}
+export function setCurrentAgent(agentName, scopeKey = GLOBAL_SCOPE_KEY) {
+    currentSettings.scopedAgents = setScopedMapValue(currentSettings.scopedAgents, scopeKey, agentName);
+    void writeSettingsFile(currentSettings);
+}
+export function clearCurrentAgent(scopeKey = GLOBAL_SCOPE_KEY) {
+    currentSettings.scopedAgents = clearScopedMapValue(currentSettings.scopedAgents, scopeKey);
+    void writeSettingsFile(currentSettings);
+}
+export function getCurrentModel(scopeKey = GLOBAL_SCOPE_KEY) {
+    return getScopedMap(currentSettings.scopedModels, scopeKey);
+}
+export function getScopedModels() {
+    return { ...(currentSettings.scopedModels ?? {}) };
+}
+export function setCurrentModel(modelInfo, scopeKey = GLOBAL_SCOPE_KEY) {
+    currentSettings.scopedModels = setScopedMapValue(currentSettings.scopedModels, scopeKey, modelInfo);
+    void writeSettingsFile(currentSettings);
+}
+export function clearCurrentModel(scopeKey = GLOBAL_SCOPE_KEY) {
+    currentSettings.scopedModels = clearScopedMapValue(currentSettings.scopedModels, scopeKey);
+    void writeSettingsFile(currentSettings);
+}
+export function getScopedPinnedMessageId(scopeKey) {
+    return getScopedMap(currentSettings.scopedPinnedMessageIds, scopeKey);
+}
+export function setScopedPinnedMessageId(scopeKey, messageId) {
+    currentSettings.scopedPinnedMessageIds = setScopedMapValue(currentSettings.scopedPinnedMessageIds, scopeKey, messageId);
+    void writeSettingsFile(currentSettings);
+}
+export function clearScopedPinnedMessageId(scopeKey) {
+    currentSettings.scopedPinnedMessageIds = clearScopedMapValue(currentSettings.scopedPinnedMessageIds, scopeKey);
+    void writeSettingsFile(currentSettings);
+}
+export function getTopicSessionBindings() {
+    return { ...(currentSettings.topicSessionBindings ?? {}) };
+}
+export function getTopicSessionBinding(bindingKey) {
+    return getScopedMap(currentSettings.topicSessionBindings, bindingKey);
+}
+export function setTopicSessionBinding(bindingKey, binding) {
+    currentSettings.topicSessionBindings = setScopedMapValue(currentSettings.topicSessionBindings, bindingKey, binding);
+    void writeSettingsFile(currentSettings);
+}
+export function clearTopicSessionBinding(bindingKey) {
+    currentSettings.topicSessionBindings = clearScopedMapValue(currentSettings.topicSessionBindings, bindingKey);
+    void writeSettingsFile(currentSettings);
+}
+export function findTopicSessionBindingBySessionId(sessionId) {
+    return Object.values(currentSettings.topicSessionBindings ?? {}).find((binding) => binding.sessionId === sessionId);
+}
+export function findTopicSessionBindingByScopeKey(scopeKey) {
+    return Object.values(currentSettings.topicSessionBindings ?? {}).find((binding) => binding.scopeKey === scopeKey);
+}
+export function getTopicSessionBindingsByChat(chatId) {
+    return Object.values(currentSettings.topicSessionBindings ?? {}).filter((binding) => binding.chatId === chatId);
+}
+export function updateTopicSessionBindingStatus(bindingKey, status) {
+    const binding = getTopicSessionBinding(bindingKey);
+    if (!binding) {
+        return;
+    }
+    const updatedBinding = {
+        ...binding,
+        status,
+        updatedAt: Date.now(),
+        closedAt: status === TOPIC_SESSION_STATUS.CLOSED || status === TOPIC_SESSION_STATUS.STALE
+            ? Date.now()
+            : binding.closedAt,
+    };
+    setTopicSessionBinding(bindingKey, updatedBinding);
+}
+export function getServerProcess() {
+    return currentSettings.serverProcess;
+}
+export function setServerProcess(processInfo) {
+    currentSettings.serverProcess = processInfo;
+    void writeSettingsFile(currentSettings);
+}
+export function clearServerProcess() {
+    currentSettings.serverProcess = undefined;
+    void writeSettingsFile(currentSettings);
+}
+export function getSessionDirectoryCache() {
+    return currentSettings.sessionDirectoryCache;
+}
+export function setSessionDirectoryCache(cache) {
+    currentSettings.sessionDirectoryCache = cache;
+    return writeSettingsFile(currentSettings);
+}
+export function clearSessionDirectoryCache() {
+    currentSettings.sessionDirectoryCache = undefined;
+    void writeSettingsFile(currentSettings);
+}
+export function __resetSettingsForTests() {
+    currentSettings = {};
+    settingsWriteQueue = Promise.resolve();
+}
+export async function loadSettings() {
+    const loadedSettings = (await readSettingsFile());
+    let dirty = false;
+    if ("toolMessagesIntervalSec" in loadedSettings) {
+        delete loadedSettings.toolMessagesIntervalSec;
+        dirty = true;
+    }
+    if ("currentProject" in loadedSettings) {
+        delete loadedSettings.currentProject;
+        dirty = true;
+    }
+    if ("currentSession" in loadedSettings) {
+        delete loadedSettings.currentSession;
+        dirty = true;
+    }
+    if ("currentAgent" in loadedSettings) {
+        delete loadedSettings.currentAgent;
+        dirty = true;
+    }
+    if ("currentModel" in loadedSettings) {
+        delete loadedSettings.currentModel;
+        dirty = true;
+    }
+    if ("pinnedMessageId" in loadedSettings) {
+        delete loadedSettings.pinnedMessageId;
+        dirty = true;
+    }
+    const sanitizedTopicSessionBindings = sanitizeTopicSessionBindings(loadedSettings.topicSessionBindings);
+    if (loadedSettings.topicSessionBindings !== undefined) {
+        const loadedCount = loadedSettings.topicSessionBindings && typeof loadedSettings.topicSessionBindings === "object"
+            ? Object.keys(loadedSettings.topicSessionBindings).length
+            : 0;
+        const sanitizedCount = Object.keys(sanitizedTopicSessionBindings ?? {}).length;
+        if (loadedCount !== sanitizedCount) {
+            dirty = true;
+            logger.warn(`[SettingsManager] Removed ${loadedCount - sanitizedCount} invalid topic-session bindings during load`);
+        }
+    }
+    loadedSettings.topicSessionBindings = sanitizedTopicSessionBindings;
+    currentSettings = loadedSettings;
+    if (dirty) {
+        void writeSettingsFile(currentSettings);
+    }
+}

package/dist/stt/client.js

@@ -0,0 +1,64 @@
+import { config } from "../config.js";
+import { logger } from "../utils/logger.js";
+const STT_REQUEST_TIMEOUT_MS = 60_000;
+/**
+ * Returns true if STT is configured (API URL and API key are set).
+ */
+export function isSttConfigured() {
+    return Boolean(config.stt.apiUrl && config.stt.apiKey);
+}
+/**
+ * Transcribes an audio buffer using a Whisper-compatible API (OpenAI / Groq / etc.).
+ *
+ * Sends a multipart/form-data POST to `{STT_API_URL}/audio/transcriptions`.
+ *
+ * @param audioBuffer - Raw audio file bytes (ogg, mp3, wav, m4a, webm, etc.)
+ * @param filename    - Original filename with extension (used by the API to detect format)
+ * @returns Transcribed text
+ * @throws Error if STT is not configured, the request fails, or the response is invalid
+ */
+export async function transcribeAudio(audioBuffer, filename) {
+    if (!isSttConfigured()) {
+        throw new Error("STT is not configured: STT_API_URL and STT_API_KEY are required");
+    }
+    const url = `${config.stt.apiUrl}/audio/transcriptions`;
+    const formData = new FormData();
+    formData.append("file", new Blob([new Uint8Array(audioBuffer)]), filename);
+    formData.append("model", config.stt.model);
+    formData.append("response_format", "json");
+    if (config.stt.language) {
+        formData.append("language", config.stt.language);
+    }
+    logger.debug(`[STT] Sending transcription request: url=${url}, model=${config.stt.model}, filename=${filename}, size=${audioBuffer.length} bytes`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), STT_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.stt.apiKey}`,
+            },
+            body: formData,
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "");
+            throw new Error(`STT API returned HTTP ${response.status}: ${errorBody || response.statusText}`);
+        }
+        const data = (await response.json());
+        if (typeof data.text !== "string") {
+            throw new Error("STT API response does not contain a text field");
+        }
+        logger.debug(`[STT] Transcription result: ${data.text.length} chars`);
+        return { text: data.text };
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+            throw new Error(`STT request timed out after ${STT_REQUEST_TIMEOUT_MS}ms`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}