@grinev/opencode-telegram-bot 0.14.1 → 0.16.0

package/dist/tts/client.js

@@ -0,0 +1,59 @@
+import { config } from "../config.js";
+import { logger } from "../utils/logger.js";
+const TTS_REQUEST_TIMEOUT_MS = 60_000;
+export function isTtsConfigured() {
+    return Boolean(config.tts.apiUrl && config.tts.apiKey);
+}
+export async function synthesizeSpeech(text) {
+    if (!isTtsConfigured()) {
+        throw new Error("TTS is not configured: set TTS API credentials");
+    }
+    const input = text.trim();
+    if (!input) {
+        throw new Error("TTS input text is empty");
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), TTS_REQUEST_TIMEOUT_MS);
+    try {
+        const url = `${config.tts.apiUrl}/audio/speech`;
+        logger.debug(`[TTS] Sending speech synthesis request: url=${url}, model=${config.tts.model}, voice=${config.tts.voice}, chars=${input.length}`);
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.tts.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: config.tts.model,
+                voice: config.tts.voice,
+                input,
+                response_format: "mp3",
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "");
+            throw new Error(`TTS API returned HTTP ${response.status}: ${errorBody || response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        if (buffer.length === 0) {
+            throw new Error("TTS API returned an empty audio response");
+        }
+        logger.debug(`[TTS] Generated speech audio: ${buffer.length} bytes`);
+        return {
+            buffer,
+            filename: "assistant-reply.mp3",
+            mimeType: "audio/mpeg",
+        };
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+            throw new Error(`TTS request timed out after ${TTS_REQUEST_TIMEOUT_MS}ms`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/utils/logger.js

@@ -1,57 +1,65 @@
-import { config } from "../config.js";
-/**
- * Mapping of log levels to numeric values for comparison
- * Used to determine if a message should be logged based on configured level
- */
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+import { inspect } from "node:util";
+import { getRuntimeMode } from "../runtime/mode.js";
+import { getRuntimePaths } from "../runtime/paths.js";
+const DEFAULT_LOG_LEVEL = "info";
+const DEFAULT_LOG_RETENTION = 10;
+const LOGGER_ERROR_PREFIX = "[LOGGER]";
 const LOG_LEVELS = {
     debug: 0,
     info: 1,
     warn: 2,
     error: 3,
 };
-/**
- * Normalizes a string value to a valid LogLevel
- * Falls back to 'info' if the value is invalid
- *
- * @param value - The log level string to normalize
- * @returns A valid LogLevel
- */
+let logStream = null;
+let logFilePath = null;
+let initializePromise = null;
+let streamErrorReported = false;
 function normalizeLogLevel(value) {
     if (value in LOG_LEVELS) {
         return value;
     }
-    return "info";
+    return DEFAULT_LOG_LEVEL;
+}
+function parsePositiveInteger(value, defaultValue) {
+    if (!value) {
+        return defaultValue;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed) || parsed <= 0) {
+        return defaultValue;
+    }
+    return parsed;
+}
+function getConfiguredLogLevel() {
+    return normalizeLogLevel(process.env.LOG_LEVEL ?? DEFAULT_LOG_LEVEL);
+}
+function getConfiguredLogRetention() {
+    return parsePositiveInteger(process.env.LOG_RETENTION, DEFAULT_LOG_RETENTION);
 }
-/**
- * Formats the log message prefix with timestamp and level
- *
- * @param level - The log level for the message
- * @returns Formatted prefix string
- */
 function formatPrefix(level) {
     return `[${new Date().toISOString()}] [${level.toUpperCase()}]`;
 }
-/**
- * Formats individual arguments for logging
- * Special handling for Error objects to extract stack trace
- *
- * @param arg - The argument to format
- * @returns Formatted argument
- */
 function formatArg(arg) {
     if (arg instanceof Error) {
         return arg.stack ?? `${arg.name}: ${arg.message}`;
     }
     return arg;
 }
-/**
- * Prepends formatted prefix to log arguments
- * Handles different argument formats (string vs non-string first argument)
- *
- * @param level - The log level for prefix formatting
- * @param args - The arguments to log
- * @returns Array with prefix prepended
- */
+function formatArgForFile(arg) {
+    const formatted = formatArg(arg);
+    if (typeof formatted === "string") {
+        return formatted;
+    }
+    return inspect(formatted, {
+        colors: false,
+        compact: true,
+        depth: 8,
+        breakLength: Infinity,
+    });
+}
 function withPrefix(level, args) {
     const formattedArgs = args.map((arg) => formatArg(arg));
     const prefix = formatPrefix(level);
@@ -63,65 +71,184 @@ function withPrefix(level, args) {
     }
     return [prefix, ...formattedArgs];
 }
-/**
- * Determines if a message should be logged based on configured log level
- * Messages with level >= configured level will be logged
- *
- * @param level - The level of the message to check
- * @returns True if the message should be logged
- */
+function formatLine(level, args) {
+    const prefix = formatPrefix(level);
+    const formattedArgs = args.map((arg) => formatArgForFile(arg));
+    if (formattedArgs.length === 0) {
+        return prefix;
+    }
+    return `${prefix} ${formattedArgs.join(" ")}`;
+}
 function shouldLog(level) {
-    const configLevel = normalizeLogLevel(config.server.logLevel);
-    return LOG_LEVELS[level] >= LOG_LEVELS[configLevel];
-}
-/**
- * Logger interface with methods for different log levels
- * Each method checks if the message should be logged based on configured level
- * and formats the output with timestamp and level prefix
- */
+    const configuredLevel = getConfiguredLogLevel();
+    return LOG_LEVELS[level] >= LOG_LEVELS[configuredLevel];
+}
+function sanitizeTimestampForFile(timestamp) {
+    return timestamp.replace(/:/g, "-").replace("T", "_");
+}
+function getSourcesLogFileName() {
+    const timestamp = sanitizeTimestampForFile(new Date().toISOString().slice(0, 19));
+    return `bot-${timestamp}_${process.pid}.log`;
+}
+function getInstalledLogFileName() {
+    return `bot-${new Date().toISOString().slice(0, 10)}.log`;
+}
+function getLogFileName(mode) {
+    return mode === "installed" ? getInstalledLogFileName() : getSourcesLogFileName();
+}
+function getLogFilePattern(mode) {
+    if (mode === "installed") {
+        return /^bot-\d{4}-\d{2}-\d{2}\.log$/;
+    }
+    return /^bot-\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}_\d+\.log$/;
+}
+function reportLoggerInternalError(message, error) {
+    const details = error instanceof Error
+        ? (error.stack ?? `${error.name}: ${error.message}`)
+        : String(error ?? "");
+    const suffix = details && details !== "undefined" ? ` ${details}` : "";
+    process.stderr.write(`${formatPrefix("error")} ${LOGGER_ERROR_PREFIX} ${message}${suffix}\n`);
+}
+function handleLogStreamError(error) {
+    if (!streamErrorReported) {
+        streamErrorReported = true;
+        reportLoggerInternalError("Failed to write to log file.", error);
+    }
+    if (logStream) {
+        logStream.destroy();
+        logStream = null;
+    }
+}
+function closeLogStream() {
+    if (!logStream) {
+        return;
+    }
+    logStream.removeAllListeners("error");
+    logStream.end();
+    logStream = null;
+}
+function ensureLogStream(filePath) {
+    if (logStream && logFilePath === filePath) {
+        return;
+    }
+    closeLogStream();
+    streamErrorReported = false;
+    const stream = fs.createWriteStream(filePath, { flags: "a" });
+    stream.on("error", handleLogStreamError);
+    logStream = stream;
+    logFilePath = filePath;
+}
+async function cleanupOldLogs(logsDirPath, mode) {
+    const retention = getConfiguredLogRetention();
+    const filePattern = getLogFilePattern(mode);
+    let fileNames;
+    try {
+        fileNames = await fsPromises.readdir(logsDirPath);
+    }
+    catch (error) {
+        reportLoggerInternalError(`Failed to read log directory ${logsDirPath}.`, error);
+        return;
+    }
+    const matchingFiles = fileNames.filter((fileName) => filePattern.test(fileName)).sort();
+    const filesToDelete = matchingFiles.slice(0, Math.max(0, matchingFiles.length - retention));
+    await Promise.all(filesToDelete.map(async (fileName) => {
+        try {
+            await fsPromises.unlink(path.join(logsDirPath, fileName));
+        }
+        catch (error) {
+            reportLoggerInternalError(`Failed to delete old log file ${fileName}.`, error);
+        }
+    }));
+}
+function writeToFile(line) {
+    if (!logStream) {
+        return;
+    }
+    try {
+        logStream.write(`${line}\n`);
+    }
+    catch (error) {
+        handleLogStreamError(error);
+    }
+}
+async function initializeLoggerInternal() {
+    if (logStream && logFilePath) {
+        return;
+    }
+    const runtimePaths = getRuntimePaths();
+    const mode = getRuntimeMode();
+    try {
+        await fsPromises.mkdir(runtimePaths.logsDirPath, { recursive: true });
+        const nextLogFilePath = path.join(runtimePaths.logsDirPath, getLogFileName(mode));
+        await fsPromises.appendFile(nextLogFilePath, "");
+        ensureLogStream(nextLogFilePath);
+        await cleanupOldLogs(runtimePaths.logsDirPath, mode);
+    }
+    catch (error) {
+        reportLoggerInternalError(`Failed to initialize file logging in ${runtimePaths.logsDirPath}.`, error);
+        closeLogStream();
+        logFilePath = null;
+    }
+}
+export async function initializeLogger() {
+    if (initializePromise) {
+        await initializePromise;
+        return;
+    }
+    initializePromise = initializeLoggerInternal();
+    try {
+        await initializePromise;
+    }
+    finally {
+        initializePromise = null;
+    }
+}
+export function getLogFilePath() {
+    return logFilePath;
+}
+export async function __flushLoggerForTests() {
+    if (!logStream) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        logStream?.write("", (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+export function __resetLoggerForTests() {
+    initializePromise = null;
+    logFilePath = null;
+    streamErrorReported = false;
+    closeLogStream();
+}
 export const logger = {
-    /**
-     * Logs debug-level messages (most verbose)
-     * Used for detailed diagnostics and internal operations
-     *
-     * @param args - Arguments to log
-     */
     debug: (...args) => {
         if (shouldLog("debug")) {
             console.log(...withPrefix("debug", args));
+            writeToFile(formatLine("debug", args));
         }
     },
-    /**
-     * Logs info-level messages
-     * Used for important events and general information
-     *
-     * @param args - Arguments to log
-     */
     info: (...args) => {
         if (shouldLog("info")) {
             console.log(...withPrefix("info", args));
+            writeToFile(formatLine("info", args));
         }
     },
-    /**
-     * Logs warning-level messages
-     * Used for recoverable errors and potential issues
-     *
-     * @param args - Arguments to log
-     */
     warn: (...args) => {
         if (shouldLog("warn")) {
             console.warn(...withPrefix("warn", args));
+            writeToFile(formatLine("warn", args));
         }
     },
-    /**
-     * Logs error-level messages
-     * Used for critical failures and exceptions
-     *
-     * @param args - Arguments to log
-     */
     error: (...args) => {
         if (shouldLog("error")) {
             console.error(...withPrefix("error", args));
+            writeToFile(formatLine("error", args));
         }
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.14.1",
+  "version": "0.16.0",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",
@@ -57,8 +57,12 @@
     "dotenv": "^17.2.3",
     "grammy": "^1.39.2",
     "https-proxy-agent": "^7.0.6",
+    "mdast-util-to-string": "^4.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
     "socks-proxy-agent": "^8.0.5",
-    "telegram-markdown-v2": "^0.0.4"
+    "telegram-markdown-v2": "^0.0.4",
+    "unified": "^11.0.5"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",