@grinev/opencode-telegram-bot 0.16.0 → 0.17.0

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/settings/manager.js

@@ -103,17 +103,6 @@ export function clearPinnedMessageId() {
     currentSettings.pinnedMessageId = undefined;
     void writeSettingsFile(currentSettings);
 }
-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;
 }
@@ -138,10 +127,18 @@ export function __resetSettingsForTests() {
 }
 export async function loadSettings() {
     const loadedSettings = (await readSettingsFile());
+    let requiresRewrite = false;
     if ("toolMessagesIntervalSec" in loadedSettings) {
         delete loadedSettings.toolMessagesIntervalSec;
-        void writeSettingsFile(loadedSettings);
+        requiresRewrite = true;
+    }
+    if ("serverProcess" in loadedSettings) {
+        delete loadedSettings.serverProcess;
+        requiresRewrite = true;
     }
     currentSettings = loadedSettings;
     currentSettings.scheduledTasks = cloneScheduledTasks(loadedSettings.scheduledTasks) ?? [];
+    if (requiresRewrite) {
+        void writeSettingsFile(currentSettings);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",

package/dist/process/manager.js

@@ -1,273 +0,0 @@
-import { spawn, exec } from "child_process";
-import { promisify } from "util";
-import { getServerProcess, setServerProcess, clearServerProcess } from "../settings/manager.js";
-import { logger } from "../utils/logger.js";
-const execAsync = promisify(exec);
-/**
- * Singleton manager for OpenCode server process
- * Handles starting, stopping, and monitoring the server process
- * Persists PID to settings.json for recovery after bot restart
- */
-class ProcessManager {
-    state = {
-        process: null,
-        pid: null,
-        startTime: null,
-        isRunning: false,
-    };
-    /**
-     * Initialize the manager by restoring state from settings
-     * Checks if the stored process is still alive
-     */
-    async initialize() {
-        const savedProcess = getServerProcess();
-        if (!savedProcess) {
-            logger.debug("[ProcessManager] No saved process found in settings");
-            return;
-        }
-        logger.info(`[ProcessManager] Found saved process: PID=${savedProcess.pid}`);
-        // Check if the process is still alive
-        if (this.isProcessAlive(savedProcess.pid)) {
-            logger.info(`[ProcessManager] Process PID=${savedProcess.pid} is still alive, restoring state`);
-            this.state = {
-                process: null, // Cannot recover ChildProcess reference
-                pid: savedProcess.pid,
-                startTime: new Date(savedProcess.startTime),
-                isRunning: true,
-            };
-        }
-        else {
-            logger.warn(`[ProcessManager] Process PID=${savedProcess.pid} is dead, cleaning up`);
-            clearServerProcess();
-        }
-    }
-    /**
-     * Start the OpenCode server process
-     */
-    async start() {
-        if (this.state.isRunning) {
-            return {
-                success: false,
-                error: "Process already running",
-            };
-        }
-        try {
-            logger.info("[ProcessManager] Starting OpenCode server process...");
-            const isWindows = process.platform === "win32";
-            const command = isWindows ? "cmd.exe" : "opencode";
-            const args = isWindows ? ["/c", "opencode", "serve"] : ["serve"];
-            // Spawn the process
-            // Windows: use cmd.exe to resolve npm-installed global commands
-            // Unix-like: run opencode directly
-            const childProcess = spawn(command, args, {
-                detached: false,
-                stdio: ["ignore", "pipe", "pipe"],
-                windowsHide: isWindows,
-            });
-            if (!childProcess.pid) {
-                throw new Error("Failed to start OpenCode server process. Ensure 'opencode' is installed and available in PATH.");
-            }
-            // Setup event handlers
-            childProcess.on("error", (err) => {
-                logger.error("[ProcessManager] Process error:", err);
-                this.cleanup();
-            });
-            childProcess.on("exit", (code, signal) => {
-                logger.info(`[ProcessManager] Process exited: code=${code}, signal=${signal}`);
-                this.cleanup();
-            });
-            // Log stdout/stderr
-            if (childProcess.stdout) {
-                childProcess.stdout.on("data", (data) => {
-                    logger.debug(`[OpenCode Server] ${data.toString().trim()}`);
-                });
-            }
-            if (childProcess.stderr) {
-                childProcess.stderr.on("data", (data) => {
-                    logger.warn(`[OpenCode Server Error] ${data.toString().trim()}`);
-                });
-            }
-            // Save state in memory
-            const startTime = new Date();
-            this.state = {
-                process: childProcess,
-                pid: childProcess.pid,
-                startTime,
-                isRunning: true,
-            };
-            // Persist to settings.json
-            setServerProcess({
-                pid: childProcess.pid,
-                startTime: startTime.toISOString(),
-            });
-            logger.info(`[ProcessManager] OpenCode server started with PID=${childProcess.pid}`);
-            return { success: true };
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            logger.error("[ProcessManager] Failed to start process:", err);
-            this.cleanup();
-            return { success: false, error: errorMessage };
-        }
-    }
-    /**
-     * Stop the OpenCode server process
-     * Sends SIGINT (Ctrl+C) and waits for graceful shutdown
-     * Falls back to SIGKILL if timeout is exceeded
-     */
-    async stop(timeoutMs = 5000) {
-        if (!this.state.isRunning || !this.state.pid) {
-            return {
-                success: false,
-                error: "Process not running",
-            };
-        }
-        try {
-            const pid = this.state.pid;
-            logger.info(`[ProcessManager] Stopping process PID=${pid}...`);
-            // On Windows, use taskkill to kill the entire process tree
-            // This is necessary because cmd.exe spawns child processes
-            if (process.platform === "win32") {
-                try {
-                    // /F = force terminate, /T = terminate tree, /PID = process id
-                    logger.debug(`[ProcessManager] Using taskkill to terminate process tree for PID=${pid}`);
-                    await execAsync(`taskkill /F /T /PID ${pid}`);
-                    logger.info(`[ProcessManager] Process tree terminated successfully for PID=${pid}`);
-                }
-                catch (err) {
-                    // taskkill returns error if process not found, which is ok
-                    const error = err;
-                    if (error.message?.includes("not found")) {
-                        logger.debug(`[ProcessManager] Process PID=${pid} already terminated`);
-                    }
-                    else {
-                        logger.warn(`[ProcessManager] taskkill error for PID=${pid}:`, err);
-                    }
-                }
-                // Wait a bit for cleanup
-                await new Promise((resolve) => setTimeout(resolve, 1000));
-            }
-            else {
-                // Unix-like systems: use SIGINT/SIGKILL
-                if (this.state.process) {
-                    const childProcess = this.state.process;
-                    // Send SIGINT (Ctrl+C)
-                    logger.debug(`[ProcessManager] Sending SIGINT to PID=${pid}`);
-                    childProcess.kill("SIGINT");
-                    // Wait for graceful shutdown
-                    const gracefulExit = await this.waitForProcessExit(childProcess, timeoutMs);
-                    if (!gracefulExit && this.state.isRunning) {
-                        logger.warn(`[ProcessManager] Graceful shutdown failed, sending SIGKILL to PID=${pid}`);
-                        childProcess.kill("SIGKILL");
-                        await new Promise((resolve) => setTimeout(resolve, 2000));
-                    }
-                }
-                else {
-                    // No ChildProcess reference (recovered from settings)
-                    logger.debug(`[ProcessManager] Sending SIGTERM to PID=${pid}`);
-                    try {
-                        process.kill(pid, "SIGTERM");
-                    }
-                    catch (err) {
-                        logger.debug(`[ProcessManager] Failed to send SIGTERM to PID=${pid}:`, err);
-                    }
-                    // Wait for process to die
-                    await new Promise((resolve) => setTimeout(resolve, timeoutMs));
-                    // Check if still alive
-                    if (this.isProcessAlive(pid)) {
-                        logger.warn(`[ProcessManager] Graceful shutdown failed, sending SIGKILL to PID=${pid}`);
-                        try {
-                            process.kill(pid, "SIGKILL");
-                        }
-                        catch (err) {
-                            logger.error(`[ProcessManager] Failed to send SIGKILL to PID=${pid}:`, err);
-                        }
-                        await new Promise((resolve) => setTimeout(resolve, 2000));
-                    }
-                }
-            }
-            this.cleanup();
-            logger.info(`[ProcessManager] Process PID=${pid} stopped successfully`);
-            return { success: true };
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            logger.error("[ProcessManager] Failed to stop process:", err);
-            return { success: false, error: errorMessage };
-        }
-    }
-    /**
-     * Check if the process is running
-     * Validates that the process with stored PID is actually alive
-     */
-    isRunning() {
-        if (!this.state.isRunning || !this.state.pid) {
-            return false;
-        }
-        // Verify that the process is actually alive
-        if (!this.isProcessAlive(this.state.pid)) {
-            logger.warn(`[ProcessManager] Process PID=${this.state.pid} appears dead, cleaning up`);
-            this.cleanup();
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Get the process ID of the running server
-     */
-    getPID() {
-        return this.state.pid;
-    }
-    /**
-     * Get the uptime of the server in milliseconds
-     */
-    getUptime() {
-        if (!this.state.startTime || !this.state.isRunning) {
-            return null;
-        }
-        return Date.now() - this.state.startTime.getTime();
-    }
-    /**
-     * Check if a process with given PID is alive
-     * Uses process.kill(pid, 0) which checks existence without killing
-     */
-    isProcessAlive(pid) {
-        try {
-            process.kill(pid, 0);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Wait for process to exit
-     */
-    async waitForProcessExit(childProcess, timeoutMs) {
-        return new Promise((resolve) => {
-            const exitHandler = () => {
-                logger.debug("[ProcessManager] Process exited gracefully");
-                resolve(true);
-            };
-            childProcess.once("exit", exitHandler);
-            setTimeout(() => {
-                childProcess.removeListener("exit", exitHandler);
-                resolve(false);
-            }, timeoutMs);
-        });
-    }
-    /**
-     * Clean up state and settings
-     */
-    cleanup() {
-        this.state = {
-            process: null,
-            pid: null,
-            startTime: null,
-            isRunning: false,
-        };
-        clearServerProcess();
-    }
-}
-// Export singleton instance
-export const processManager = new ProcessManager();