@grinev/opencode-telegram-bot 0.15.0 → 0.16.1

package/dist/i18n/zh.js

@@ -324,16 +324,6 @@ export const zh = {
     "commands.page_empty_callback": "这一页没有命令",
     "commands.page_load_error_callback": "无法加载此页面。请重试。",
     "cmd.description.rename": "重命名当前会话",
-    "cli.usage": "用法:\n  opencode-telegram [start] [--mode sources|installed]\n  opencode-telegram status\n  opencode-telegram stop\n  opencode-telegram config\n\n注意:\n  - 无命令时默认为 `start`\n  - `--mode` 当前仅支持 `start`",
-    "cli.placeholder.status": "`status` 命令当前为占位符。实际状态检查将在服务层中添加（第5阶段）。",
-    "cli.placeholder.stop": "`stop` 命令当前为占位符。实际后台进程停止功能将在服务层中添加（第5阶段）。",
-    "cli.placeholder.unavailable": "命令不可用。",
-    "cli.error.prefix": "CLI 错误：{message}",
-    "cli.args.unknown_command": "未知命令：{value}",
-    "cli.args.mode_requires_value": "选项 --mode 需要一个值：sources|installed",
-    "cli.args.invalid_mode": "无效的 --mode 值：{value}。期望 sources|installed",
-    "cli.args.unknown_option": "未知选项：{value}",
-    "cli.args.mode_only_start": "选项 --mode 仅支持 start 命令",
     "legacy.models.fetch_error": "🔴 获取模型列表失败。请使用 /status 检查服务器状态。",
     "legacy.models.empty": "📋 没有可用模型。请在 OpenCode 中配置 providers。",
     "legacy.models.header": "📋 可用模型：\n\n",
@@ -345,4 +335,19 @@ export const zh = {
     "stt.not_configured": "🎤 语音识别尚未配置。\n\n在 .env 中设置 STT_API_URL 和 STT_API_KEY 以启用。",
     "stt.error": "🔴 识别音频失败：{error}",
     "stt.empty_result": "🎤 音频消息中未检测到语音。",
+    "cmd.description.open": "通过浏览目录添加项目",
+    "open.back": "⬆️ 上级",
+    "open.roots": "📋 返回根目录",
+    "open.prev_page": "⬅️ 上一页",
+    "open.next_page": "下一页 ➡️",
+    "open.select_current": "✅ 选择此文件夹",
+    "open.select_root": "📂 选择要浏览的根目录：",
+    "open.access_denied": "⛔ 访问被拒绝：路径超出允许的目录范围",
+    "open.scan_error": "🔴 无法浏览目录：{error}",
+    "open.open_error": "🔴 无法打开目录浏览器。",
+    "open.selected": "✅ 项目已添加：{project}\n\n📋 使用 /sessions 或 /new 开始工作。",
+    "open.select_error": "🔴 添加项目失败。",
+    "open.no_subfolders": "📭 无子文件夹",
+    "open.subfolder_count": "{count} 个子文件夹",
+    "open.subfolders_count": "{count} 个子文件夹",
 };

package/dist/index.js

@@ -12,6 +12,8 @@ async function main() {
         return;
     }
     setRuntimeMode(modeResult.mode);
+    const { initializeLogger } = await import("./utils/logger.js");
+    await initializeLogger();
     const { startBotApp } = await import("./app/start-bot-app.js");
     await startBotApp();
 }

package/dist/project/manager.js

@@ -80,7 +80,8 @@ export async function getProjectById(id) {
 }
 export async function getProjectByWorktree(worktree) {
     const projects = await getProjects();
-    const project = projects.find((p) => p.worktree === worktree);
+    const key = worktreeKey(worktree);
+    const project = projects.find((p) => worktreeKey(p.worktree) === key);
     if (!project) {
         throw new Error(`Project with worktree ${worktree} not found`);
     }

package/dist/scheduled-task/runtime.js

@@ -122,6 +122,14 @@ export class ScheduledTaskRuntime {
             this.flushInProgress = false;
         }
     }
+    shutdown() {
+        for (const timer of this.timersByTaskId.values()) {
+            clearTimeout(timer);
+        }
+        this.timersByTaskId.clear();
+        this.runningTaskIds.clear();
+        this.initialized = false;
+    }
     __resetForTests() {
         for (const timer of this.timersByTaskId.values()) {
             clearTimeout(timer);

package/dist/service/manager.js

@@ -0,0 +1,244 @@
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+import { exec, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { getRuntimePaths } from "../runtime/paths.js";
+import { buildServiceChildEnv } from "./runtime.js";
+const execAsync = promisify(exec);
+const SERVICE_STATE_FILE_NAME = "bot-service.json";
+const PROCESS_EXIT_POLL_MS = 100;
+const DEFAULT_STOP_TIMEOUT_MS = 5000;
+function sanitizeTimestampForFile(timestamp) {
+    return timestamp.replace(/:/g, "-").replace("T", "_");
+}
+function createServiceLogFilePath(logsDirPath) {
+    const timestamp = sanitizeTimestampForFile(new Date().toISOString().slice(0, 19));
+    return path.join(logsDirPath, `bot-service-${timestamp}.log`);
+}
+function isValidServiceState(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.pid === "number" &&
+        Number.isInteger(candidate.pid) &&
+        candidate.pid > 0 &&
+        typeof candidate.startedAt === "string" &&
+        candidate.startedAt.length > 0 &&
+        typeof candidate.logFilePath === "string" &&
+        candidate.logFilePath.length > 0 &&
+        candidate.mode === "daemon");
+}
+async function writeFileAtomically(filePath, content) {
+    await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+    const tempFilePath = `${filePath}.${process.pid}.tmp`;
+    await fsPromises.writeFile(tempFilePath, content, "utf-8");
+    await fsPromises.rename(tempFilePath, filePath);
+}
+async function readServiceStateFile(filePath) {
+    try {
+        const content = await fsPromises.readFile(filePath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (!isValidServiceState(parsed)) {
+            await clearServiceStateFile(filePath);
+            return { service: null, cleanupReason: "invalid" };
+        }
+        return { service: parsed, cleanupReason: null };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { service: null, cleanupReason: null };
+        }
+        if (error instanceof SyntaxError) {
+            await clearServiceStateFile(filePath);
+            return { service: null, cleanupReason: "invalid" };
+        }
+        throw error;
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        if (!isProcessAlive(pid)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, PROCESS_EXIT_POLL_MS));
+    }
+    return !isProcessAlive(pid);
+}
+function getServiceEntryScriptPath() {
+    const scriptPath = process.argv[1];
+    if (!scriptPath || scriptPath.trim().length === 0) {
+        throw new Error("Failed to resolve CLI entry script path.");
+    }
+    return path.resolve(scriptPath);
+}
+async function stopWindowsProcess(pid, timeoutMs) {
+    try {
+        await execAsync(`taskkill /PID ${pid} /T`);
+    }
+    catch {
+        // Continue with forced stop if the process is still alive.
+    }
+    if (await waitForProcessExit(pid, timeoutMs)) {
+        return;
+    }
+    await execAsync(`taskkill /F /PID ${pid} /T`);
+    await waitForProcessExit(pid, timeoutMs);
+}
+async function stopUnixProcess(pid, timeoutMs) {
+    process.kill(pid, "SIGTERM");
+    if (await waitForProcessExit(pid, timeoutMs)) {
+        return;
+    }
+    process.kill(pid, "SIGKILL");
+    await waitForProcessExit(pid, timeoutMs);
+}
+export function getServiceStateFilePath() {
+    return path.join(getRuntimePaths().runDirPath, SERVICE_STATE_FILE_NAME);
+}
+export async function clearServiceStateFile(filePath = getServiceStateFilePath()) {
+    try {
+        await fsPromises.unlink(filePath);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+export async function getBotServiceStatus() {
+    const stateFilePath = getServiceStateFilePath();
+    const { service, cleanupReason } = await readServiceStateFile(stateFilePath);
+    if (!service) {
+        return {
+            status: "stopped",
+            service: null,
+            cleanupReason,
+        };
+    }
+    if (!isProcessAlive(service.pid)) {
+        await clearServiceStateFile(stateFilePath);
+        return {
+            status: "stopped",
+            service: null,
+            cleanupReason: "stale",
+        };
+    }
+    return {
+        status: "running",
+        service,
+        cleanupReason,
+    };
+}
+export async function startBotDaemon(mode) {
+    const currentStatus = await getBotServiceStatus();
+    if (currentStatus.status === "running" && currentStatus.service) {
+        return {
+            success: false,
+            service: currentStatus.service,
+            cleanupReason: currentStatus.cleanupReason,
+            alreadyRunning: true,
+        };
+    }
+    const runtimePaths = getRuntimePaths();
+    await Promise.all([
+        fsPromises.mkdir(runtimePaths.runDirPath, { recursive: true }),
+        fsPromises.mkdir(runtimePaths.logsDirPath, { recursive: true }),
+    ]);
+    const stateFilePath = getServiceStateFilePath();
+    const logFilePath = createServiceLogFilePath(runtimePaths.logsDirPath);
+    const logFileDescriptor = fs.openSync(logFilePath, "a");
+    try {
+        const childArgs = [getServiceEntryScriptPath(), "start"];
+        if (mode) {
+            childArgs.push("--mode", mode);
+        }
+        const childProcess = spawn(process.execPath, childArgs, {
+            detached: true,
+            stdio: ["ignore", logFileDescriptor, logFileDescriptor],
+            windowsHide: true,
+            env: buildServiceChildEnv(process.env, stateFilePath),
+        });
+        if (!childProcess.pid) {
+            throw new Error("Failed to start background bot process.");
+        }
+        childProcess.unref();
+        const serviceState = {
+            pid: childProcess.pid,
+            startedAt: new Date().toISOString(),
+            logFilePath,
+            mode: "daemon",
+        };
+        await writeFileAtomically(stateFilePath, `${JSON.stringify(serviceState, null, 2)}\n`);
+        return {
+            success: true,
+            service: serviceState,
+            cleanupReason: currentStatus.cleanupReason,
+        };
+    }
+    catch (error) {
+        await clearServiceStateFile(stateFilePath);
+        return {
+            success: false,
+            service: null,
+            cleanupReason: currentStatus.cleanupReason,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        fs.closeSync(logFileDescriptor);
+    }
+}
+export async function stopBotDaemon(timeoutMs = DEFAULT_STOP_TIMEOUT_MS) {
+    const currentStatus = await getBotServiceStatus();
+    if (currentStatus.status !== "running" || !currentStatus.service) {
+        return {
+            success: true,
+            service: null,
+            cleanupReason: currentStatus.cleanupReason,
+            alreadyStopped: true,
+        };
+    }
+    const { pid } = currentStatus.service;
+    try {
+        if (process.platform === "win32") {
+            await stopWindowsProcess(pid, timeoutMs);
+        }
+        else {
+            await stopUnixProcess(pid, timeoutMs);
+        }
+        if (isProcessAlive(pid)) {
+            return {
+                success: false,
+                service: currentStatus.service,
+                cleanupReason: currentStatus.cleanupReason,
+                error: `Failed to stop background bot process PID=${pid}.`,
+            };
+        }
+        await clearServiceStateFile();
+        return {
+            success: true,
+            service: currentStatus.service,
+            cleanupReason: currentStatus.cleanupReason,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            service: currentStatus.service,
+            cleanupReason: currentStatus.cleanupReason,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/service/runtime.js

@@ -0,0 +1,19 @@
+const SERVICE_CHILD_ENV_KEY = "OPENCODE_TELEGRAM_SERVICE_CHILD";
+const SERVICE_STATE_PATH_ENV_KEY = "OPENCODE_TELEGRAM_SERVICE_STATE_PATH";
+export function buildServiceChildEnv(baseEnv, stateFilePath) {
+    return {
+        ...baseEnv,
+        [SERVICE_CHILD_ENV_KEY]: "1",
+        [SERVICE_STATE_PATH_ENV_KEY]: stateFilePath,
+    };
+}
+export function isServiceChildProcess() {
+    return process.env[SERVICE_CHILD_ENV_KEY] === "1";
+}
+export function getServiceStateFilePathFromEnv() {
+    const value = process.env[SERVICE_STATE_PATH_ENV_KEY];
+    if (!value || value.trim().length === 0) {
+        return null;
+    }
+    return value;
+}

package/dist/service/types.js

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

package/dist/summary/aggregator.js

@@ -43,6 +43,7 @@ class SummaryAggregator {
     onSessionCompactedCallback = null;
     onSessionErrorCallback = null;
     onSessionRetryCallback = null;
+    onSessionIdleCallback = null;
     onPermissionCallback = null;
     onSessionDiffCallback = null;
     onFileChangeCallback = null;
@@ -105,6 +106,9 @@ class SummaryAggregator {
     setOnSessionRetry(callback) {
         this.onSessionRetryCallback = callback;
     }
+    setOnSessionIdle(callback) {
+        this.onSessionIdleCallback = callback;
+    }
     setOnPermission(callback) {
         this.onPermissionCallback = callback;
     }
@@ -643,7 +647,13 @@ class SummaryAggregator {
                     this.onCostCallback(assistantInfo.cost);
                 }
                 if (this.onCompleteCallback && finalText.length > 0) {
-                    this.onCompleteCallback(this.currentSessionId, messageID, finalText);
+                    this.onCompleteCallback(this.currentSessionId, messageID, finalText, {
+                        agent: assistantMessage.agent,
+                        providerID: assistantMessage.providerID,
+                        modelID: assistantMessage.modelID,
+                        createdAt: time?.created,
+                        completedAt: time?.completed,
+                    });
                 }
                 this.textMessageStates.delete(messageID);
                 this.messages.delete(messageID);
@@ -1038,6 +1048,12 @@ class SummaryAggregator {
         logger.info(`[Aggregator] Session became idle: ${sessionID}`);
         // Stop typing indicator when session goes idle
         this.stopTypingIndicator();
+        if (this.onSessionIdleCallback) {
+            const callback = this.onSessionIdleCallback;
+            setImmediate(() => {
+                callback(sessionID);
+            });
+        }
     }
     handleSessionCompacted(event) {
         const properties = event.properties;

package/dist/summary/formatter.js

@@ -4,6 +4,7 @@ import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { t } from "../i18n/index.js";
 import { getCurrentProject } from "../settings/manager.js";
+import { normalizeMarkdownForTelegramRendering } from "../telegram/render/markdown-normalizer.js";
 const TELEGRAM_MESSAGE_LIMIT = 4096;
 const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
 function truncateWithEllipsis(text, maxLength) {
@@ -59,87 +60,6 @@ function splitText(text, maxLength, options) {
     }
     return parts;
 }
-function isCodeFenceLine(line) {
-    return line.trimStart().startsWith("```");
-}
-function isHorizontalRuleLine(line) {
-    const normalized = line.trim();
-    if (!normalized) {
-        return false;
-    }
-    return /^([-*_])(?:\s*\1){2,}$/.test(normalized);
-}
-function isHeadingLine(line) {
-    return /^\s{0,3}#{1,6}\s+\S/.test(line);
-}
-function normalizeHeadingLine(line) {
-    const match = line.match(/^\s{0,3}#{1,6}\s+(.+?)\s*$/);
-    if (!match) {
-        return line;
-    }
-    return `**${match[1]}**`;
-}
-function normalizeChecklistLine(line) {
-    const match = line.match(/^(\s*)(?:[-+*]|\d+\.)\s+\[( |x|X)\]\s+(.*)$/);
-    if (!match) {
-        return null;
-    }
-    const marker = match[2].toLowerCase() === "x" ? "✅" : "🔲";
-    return `${match[1]}${marker} ${match[3]}`;
-}
-function preprocessMarkdownForTelegram(text) {
-    const lines = text.split("\n");
-    const output = [];
-    let inCodeFence = false;
-    let inQuote = false;
-    for (let index = 0; index < lines.length; index++) {
-        const line = lines[index];
-        if (isCodeFenceLine(line)) {
-            inCodeFence = !inCodeFence;
-            inQuote = false;
-            output.push(line);
-            continue;
-        }
-        if (inCodeFence) {
-            output.push(line);
-            continue;
-        }
-        if (!line.trim()) {
-            inQuote = false;
-            output.push(line);
-            continue;
-        }
-        if (isHeadingLine(line)) {
-            output.push(normalizeHeadingLine(line));
-            inQuote = false;
-            continue;
-        }
-        if (isHorizontalRuleLine(line)) {
-            output.push("──────────");
-            inQuote = false;
-            continue;
-        }
-        const trimmedLeft = line.trimStart();
-        if (trimmedLeft.startsWith(">")) {
-            inQuote = true;
-            const quoteContent = trimmedLeft.replace(/^>\s?/, "");
-            const normalizedChecklistInQuote = normalizeChecklistLine(quoteContent);
-            output.push(normalizedChecklistInQuote ? `> ${normalizedChecklistInQuote.trimStart()}` : trimmedLeft);
-            continue;
-        }
-        const normalizedChecklist = normalizeChecklistLine(line);
-        if (normalizedChecklist) {
-            output.push(inQuote ? `> ${normalizedChecklist.trimStart()}` : normalizedChecklist);
-            continue;
-        }
-        if (inQuote) {
-            output.push(`> ${trimmedLeft}`);
-            continue;
-        }
-        output.push(line);
-    }
-    return output.join("\n");
-}
 export function normalizePathForDisplay(filePath) {
     const normalizedPath = filePath.replace(/\\/g, "/");
     const project = getCurrentProject();
@@ -164,18 +84,12 @@ export function normalizePathForDisplay(filePath) {
 export function formatSummary(text) {
     return formatSummaryWithMode(text, config.bot.messageFormatMode);
 }
-export function getAssistantParseMode() {
-    if (config.bot.messageFormatMode === "markdown") {
-        return "MarkdownV2";
-    }
-    return undefined;
-}
 export function escapePlainTextForTelegramMarkdownV2(text) {
     return text.replace(MARKDOWN_V2_RESERVED_CHARS, "\\$1");
 }
 function formatMarkdownForTelegram(text) {
     try {
-        const preprocessed = preprocessMarkdownForTelegram(text);
+        const preprocessed = normalizeMarkdownForTelegramRendering(text);
         return escapeMarkdownV2PipesOutsideCode(convert(preprocessed, "keep"));
     }
     catch (error) {

package/dist/telegram/render/block-fallback.js

@@ -0,0 +1,28 @@
+import { logger } from "../../utils/logger.js";
+import * as blockRenderer from "./block-renderer.js";
+const BLOCK_RENDER_ORDER = ["full", "simplified", "line-by-line", "plain"];
+export function renderTelegramBlockWithFallback(block) {
+    let lastError;
+    const failures = [];
+    for (const mode of BLOCK_RENDER_ORDER) {
+        try {
+            const renderedBlock = blockRenderer.renderTelegramBlock(block, mode);
+            if (failures.length > 0) {
+                logger.debug("[TelegramRender] Block fallback applied", {
+                    blockType: block.type,
+                    selectedMode: renderedBlock.mode,
+                    failures,
+                });
+            }
+            return renderedBlock;
+        }
+        catch (error) {
+            lastError = error;
+            failures.push({
+                mode,
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Failed to render Telegram block");
+}