opencode-telegram-group-topics-bot 0.11.2

package/dist/process/manager.js

@@ -0,0 +1,273 @@
+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();

package/dist/process/types.js

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

package/dist/project/manager.js

@@ -0,0 +1,88 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { opencodeClient } from "../opencode/client.js";
+import { getCachedSessionProjects } from "../session/cache-manager.js";
+import { logger } from "../utils/logger.js";
+async function isLinkedGitWorktree(worktree) {
+    if (worktree === "/") {
+        return false;
+    }
+    const gitPath = path.join(worktree, ".git");
+    try {
+        const gitStat = await stat(gitPath);
+        if (!gitStat.isFile()) {
+            return false;
+        }
+        const gitPointer = (await readFile(gitPath, "utf-8")).trim();
+        const match = gitPointer.match(/^gitdir:\s*(.+)$/i);
+        if (!match) {
+            return false;
+        }
+        const gitDir = path.resolve(worktree, match[1].trim()).replace(/\\/g, "/").toLowerCase();
+        return gitDir.includes("/.git/worktrees/");
+    }
+    catch {
+        return false;
+    }
+}
+function worktreeKey(worktree) {
+    if (process.platform === "win32") {
+        return worktree.toLowerCase();
+    }
+    return worktree;
+}
+export async function getProjects() {
+    const { data: projects, error } = await opencodeClient.project.list();
+    if (error || !projects) {
+        throw error || new Error("No data received from server");
+    }
+    const apiProjects = projects.map((project) => ({
+        id: project.id,
+        worktree: project.worktree,
+        name: project.name || project.worktree,
+        lastUpdated: project.time?.updated ?? 0,
+    }));
+    const cachedProjects = await getCachedSessionProjects();
+    const mergedByWorktree = new Map();
+    for (const apiProject of apiProjects) {
+        mergedByWorktree.set(worktreeKey(apiProject.worktree), apiProject);
+    }
+    for (const cachedProject of cachedProjects) {
+        const key = worktreeKey(cachedProject.worktree);
+        const existing = mergedByWorktree.get(key);
+        if (existing) {
+            if ((cachedProject.lastUpdated ?? 0) > existing.lastUpdated) {
+                existing.lastUpdated = cachedProject.lastUpdated;
+            }
+            continue;
+        }
+        mergedByWorktree.set(key, {
+            id: cachedProject.id,
+            worktree: cachedProject.worktree,
+            name: cachedProject.name,
+            lastUpdated: cachedProject.lastUpdated ?? 0,
+        });
+    }
+    const projectList = Array.from(mergedByWorktree.values()).sort((left, right) => right.lastUpdated - left.lastUpdated);
+    const linkedWorktreeFlags = await Promise.all(projectList.map((project) => isLinkedGitWorktree(project.worktree)));
+    const visibleProjects = projectList.filter((_, index) => !linkedWorktreeFlags[index]);
+    const hiddenLinkedWorktrees = projectList.length - visibleProjects.length;
+    logger.debug(`[ProjectManager] Projects resolved: api=${projects.length}, cached=${cachedProjects.length}, hiddenLinkedWorktrees=${hiddenLinkedWorktrees}, total=${visibleProjects.length}`);
+    return visibleProjects.map(({ id, worktree, name }) => ({ id, worktree, name }));
+}
+export async function getProjectById(id) {
+    const projects = await getProjects();
+    const project = projects.find((p) => p.id === id);
+    if (!project) {
+        throw new Error(`Project with id ${id} not found`);
+    }
+    return project;
+}
+export async function getProjectByWorktree(worktree) {
+    const projects = await getProjects();
+    const project = projects.find((p) => p.worktree === worktree);
+    if (!project) {
+        throw new Error(`Project with worktree ${worktree} not found`);
+    }
+    return project;
+}

package/dist/question/manager.js

@@ -0,0 +1,186 @@
+import { logger } from "../utils/logger.js";
+class QuestionManager {
+    stateByScope = new Map();
+    createDefaultState() {
+        return {
+            questions: [],
+            currentIndex: 0,
+            selectedOptions: new Map(),
+            customAnswers: new Map(),
+            customInputQuestionIndex: null,
+            activeMessageId: null,
+            messageIds: [],
+            isActive: false,
+            requestID: null,
+        };
+    }
+    getState(scopeKey) {
+        const state = this.stateByScope.get(scopeKey);
+        if (state) {
+            return state;
+        }
+        const next = this.createDefaultState();
+        this.stateByScope.set(scopeKey, next);
+        return next;
+    }
+    startQuestions(questions, requestID, scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        logger.debug(`[QuestionManager] startQuestions called: isActive=${state.isActive}, currentQuestions=${state.questions.length}, newQuestions=${questions.length}, requestID=${requestID}`);
+        if (state.isActive) {
+            logger.info(`[QuestionManager] Poll already active! Forcing reset before starting new poll.`);
+            this.clear(scopeKey);
+        }
+        logger.info(`[QuestionManager] Starting new poll with ${questions.length} questions, requestID=${requestID}`);
+        this.stateByScope.set(scopeKey, {
+            questions,
+            currentIndex: 0,
+            selectedOptions: new Map(),
+            customAnswers: new Map(),
+            customInputQuestionIndex: null,
+            activeMessageId: null,
+            messageIds: [],
+            isActive: true,
+            requestID,
+        });
+    }
+    getRequestID(scopeKey = "global") {
+        return this.getState(scopeKey).requestID;
+    }
+    getCurrentQuestion(scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        if (state.currentIndex >= state.questions.length) {
+            return null;
+        }
+        return state.questions[state.currentIndex];
+    }
+    selectOption(questionIndex, optionIndex, scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        if (!state.isActive) {
+            return;
+        }
+        const question = state.questions[questionIndex];
+        if (!question) {
+            return;
+        }
+        const selected = state.selectedOptions.get(questionIndex) || new Set();
+        if (question.multiple) {
+            if (selected.has(optionIndex)) {
+                selected.delete(optionIndex);
+            }
+            else {
+                selected.add(optionIndex);
+            }
+        }
+        else {
+            selected.clear();
+            selected.add(optionIndex);
+        }
+        state.selectedOptions.set(questionIndex, selected);
+        logger.debug(`[QuestionManager] Selected options for question ${questionIndex}: ${Array.from(selected).join(", ")}`);
+    }
+    getSelectedOptions(questionIndex, scopeKey = "global") {
+        return this.getState(scopeKey).selectedOptions.get(questionIndex) || new Set();
+    }
+    getSelectedAnswer(questionIndex, scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        const question = state.questions[questionIndex];
+        if (!question) {
+            return "";
+        }
+        const selected = state.selectedOptions.get(questionIndex) || new Set();
+        const options = Array.from(selected)
+            .map((idx) => question.options[idx])
+            .filter((opt) => opt)
+            .map((opt) => `* ${opt.label}: ${opt.description}`);
+        return options.join("\n");
+    }
+    setCustomAnswer(questionIndex, answer, scopeKey = "global") {
+        logger.debug(`[QuestionManager] Custom answer received for question ${questionIndex}: ${answer}`);
+        this.getState(scopeKey).customAnswers.set(questionIndex, answer);
+    }
+    getCustomAnswer(questionIndex, scopeKey = "global") {
+        return this.getState(scopeKey).customAnswers.get(questionIndex);
+    }
+    hasCustomAnswer(questionIndex, scopeKey = "global") {
+        return this.getState(scopeKey).customAnswers.has(questionIndex);
+    }
+    nextQuestion(scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        state.currentIndex++;
+        state.customInputQuestionIndex = null;
+        state.activeMessageId = null;
+        logger.debug(`[QuestionManager] Moving to next question: ${state.currentIndex}/${state.questions.length}`);
+    }
+    hasNextQuestion(scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        return state.currentIndex < state.questions.length;
+    }
+    getCurrentIndex(scopeKey = "global") {
+        return this.getState(scopeKey).currentIndex;
+    }
+    getTotalQuestions(scopeKey = "global") {
+        return this.getState(scopeKey).questions.length;
+    }
+    addMessageId(messageId, scopeKey = "global") {
+        this.getState(scopeKey).messageIds.push(messageId);
+    }
+    setActiveMessageId(messageId, scopeKey = "global") {
+        this.getState(scopeKey).activeMessageId = messageId;
+    }
+    getActiveMessageId(scopeKey = "global") {
+        return this.getState(scopeKey).activeMessageId;
+    }
+    isActiveMessage(messageId, scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        return state.isActive && state.activeMessageId !== null && messageId === state.activeMessageId;
+    }
+    startCustomInput(questionIndex, scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        if (!state.isActive || !state.questions[questionIndex]) {
+            return;
+        }
+        state.customInputQuestionIndex = questionIndex;
+    }
+    clearCustomInput(scopeKey = "global") {
+        this.getState(scopeKey).customInputQuestionIndex = null;
+    }
+    isWaitingForCustomInput(questionIndex, scopeKey = "global") {
+        return this.getState(scopeKey).customInputQuestionIndex === questionIndex;
+    }
+    getMessageIds(scopeKey = "global") {
+        return [...this.getState(scopeKey).messageIds];
+    }
+    isActive(scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        logger.debug(`[QuestionManager] isActive check: ${state.isActive}, questions=${state.questions.length}, currentIndex=${state.currentIndex}`);
+        return state.isActive;
+    }
+    cancel(scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        logger.info("[QuestionManager] Poll cancelled");
+        state.isActive = false;
+        state.customInputQuestionIndex = null;
+        state.activeMessageId = null;
+    }
+    clear(scopeKey = "global") {
+        this.stateByScope.set(scopeKey, this.createDefaultState());
+    }
+    getAllAnswers(scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        const answers = [];
+        for (let i = 0; i < state.questions.length; i++) {
+            const question = state.questions[i];
+            const selectedAnswer = this.getSelectedAnswer(i, scopeKey);
+            const customAnswer = this.getCustomAnswer(i, scopeKey);
+            const finalAnswer = customAnswer || selectedAnswer;
+            if (finalAnswer) {
+                answers.push({
+                    question: question.question,
+                    answer: finalAnswer,
+                });
+            }
+        }
+        return answers;
+    }
+}
+export const questionManager = new QuestionManager();

package/dist/question/types.js

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

package/dist/rename/manager.js

@@ -0,0 +1,64 @@
+import { logger } from "../utils/logger.js";
+class RenameManager {
+    stateByScope = new Map();
+    getState(scopeKey) {
+        const state = this.stateByScope.get(scopeKey);
+        if (state) {
+            return state;
+        }
+        const nextState = {
+            isWaiting: false,
+            sessionId: null,
+            sessionDirectory: null,
+            currentTitle: null,
+            messageId: null,
+        };
+        this.stateByScope.set(scopeKey, nextState);
+        return nextState;
+    }
+    startWaiting(sessionId, directory, currentTitle, scopeKey = "global") {
+        logger.info(`[RenameManager] Starting rename flow for session: ${sessionId}`);
+        this.stateByScope.set(scopeKey, {
+            isWaiting: true,
+            sessionId,
+            sessionDirectory: directory,
+            currentTitle,
+            messageId: null,
+        });
+    }
+    setMessageId(messageId, scopeKey = "global") {
+        this.getState(scopeKey).messageId = messageId;
+    }
+    getMessageId(scopeKey = "global") {
+        return this.getState(scopeKey).messageId;
+    }
+    isActiveMessage(messageId, scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        return state.isWaiting && state.messageId !== null && state.messageId === messageId;
+    }
+    isWaitingForName(scopeKey = "global") {
+        return this.getState(scopeKey).isWaiting;
+    }
+    getSessionInfo(scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        if (!state.isWaiting || !state.sessionId) {
+            return null;
+        }
+        return {
+            sessionId: state.sessionId,
+            directory: state.sessionDirectory,
+            currentTitle: state.currentTitle,
+        };
+    }
+    clear(scopeKey = "global") {
+        logger.debug("[RenameManager] Clearing rename state");
+        this.stateByScope.set(scopeKey, {
+            isWaiting: false,
+            sessionId: null,
+            sessionDirectory: null,
+            currentTitle: null,
+            messageId: null,
+        });
+    }
+}
+export const renameManager = new RenameManager();