@grinev/opencode-telegram-bot 0.1.0-rc.1

package/dist/opencode/server.js

@@ -0,0 +1,104 @@
+import { spawn } from "child_process";
+import * as fs from "fs/promises";
+import * as path from "path";
+const PID_FILE = path.join(process.cwd(), ".opencode-server.pid");
+let serverProcess = null;
+export async function getServerPID() {
+    try {
+        const content = await fs.readFile(PID_FILE, "utf-8");
+        const pid = parseInt(content.trim(), 10);
+        if (isNaN(pid)) {
+            return null;
+        }
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveServerPID(pid) {
+    await fs.writeFile(PID_FILE, pid.toString());
+}
+export async function removeServerPID() {
+    try {
+        await fs.unlink(PID_FILE);
+    }
+    catch {
+        // Ignore if file doesn't exist
+    }
+}
+export function isServerRunning() {
+    return serverProcess !== null && serverProcess.process.pid !== undefined;
+}
+export async function startServer() {
+    if (serverProcess !== null) {
+        return { success: false, message: "Server is already running" };
+    }
+    return new Promise((resolve) => {
+        const child = spawn("opencode", ["serve"], {
+            stdio: "pipe",
+            shell: true,
+        });
+        serverProcess = {
+            process: child,
+            startTime: new Date(),
+        };
+        child.stdout?.on("data", (data) => {
+            console.log(`[OpenCode Server] ${data.toString().trim()}`);
+        });
+        child.stderr?.on("data", (data) => {
+            console.error(`[OpenCode Server Error] ${data.toString().trim()}`);
+        });
+        child.on("error", (err) => {
+            console.error("Failed to start OpenCode server:", err);
+            serverProcess = null;
+            resolve({
+                success: false,
+                message: `Failed to start server: ${err.message}`,
+            });
+        });
+        child.on("exit", (code, signal) => {
+            console.log(`[OpenCode Server] Exited with code ${code}, signal ${signal}`);
+            serverProcess = null;
+            removeServerPID().catch((err) => console.error("Failed to remove PID file:", err));
+        });
+        // Wait a bit to check if process started successfully
+        setTimeout(() => {
+            if (child.pid) {
+                saveServerPID(child.pid).catch((err) => console.error("Failed to save PID file:", err));
+                resolve({
+                    success: true,
+                    message: `Server started successfully (PID: ${child.pid})`,
+                });
+            }
+            else {
+                serverProcess = null;
+                resolve({ success: false, message: "Failed to start server: no PID" });
+            }
+        }, 2000);
+    });
+}
+export async function stopServer() {
+    if (!serverProcess) {
+        return { success: false, message: "Server is not running" };
+    }
+    const pid = serverProcess.process.pid;
+    const process = serverProcess.process;
+    process.kill("SIGTERM");
+    serverProcess = null;
+    return new Promise((resolve) => {
+        // Wait for process to exit
+        setTimeout(() => {
+            removeServerPID().catch((err) => console.error("Failed to remove PID file:", err));
+            resolve({ success: true, message: `Server stopped (was PID ${pid})` });
+        }, 1000);
+    });
+}
+export async function restartServer() {
+    const stopResult = await stopServer();
+    if (!stopResult.success && !stopResult.message.includes("not running")) {
+        return stopResult;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    return startServer();
+}

package/dist/permission/manager.js

@@ -0,0 +1,78 @@
+import { logger } from "../utils/logger.js";
+class PermissionManager {
+    state = {
+        request: null,
+        messageId: null,
+        isActive: false,
+    };
+    /**
+     * Start a new permission request
+     */
+    startPermission(request) {
+        logger.debug(`[PermissionManager] startPermission: id=${request.id}, permission=${request.permission}`);
+        if (this.state.isActive) {
+            logger.warn("[PermissionManager] Permission already active, replacing");
+            this.clear();
+        }
+        logger.info(`[PermissionManager] New permission request: type=${request.permission}, patterns=${request.patterns.join(", ")}`);
+        this.state = {
+            request,
+            messageId: null,
+            isActive: true,
+        };
+    }
+    /**
+     * Get current permission request
+     */
+    getRequest() {
+        return this.state.request;
+    }
+    /**
+     * Get request ID for API reply
+     */
+    getRequestID() {
+        return this.state.request?.id ?? null;
+    }
+    /**
+     * Get permission type (bash, edit, etc.)
+     */
+    getPermissionType() {
+        return this.state.request?.permission ?? null;
+    }
+    /**
+     * Get patterns (commands/files)
+     */
+    getPatterns() {
+        return this.state.request?.patterns ?? [];
+    }
+    /**
+     * Set Telegram message ID for later deletion
+     */
+    setMessageId(messageId) {
+        this.state.messageId = messageId;
+    }
+    /**
+     * Get Telegram message ID
+     */
+    getMessageId() {
+        return this.state.messageId;
+    }
+    /**
+     * Check if permission request is active
+     */
+    isActive() {
+        return this.state.isActive;
+    }
+    /**
+     * Clear state after reply
+     */
+    clear() {
+        logger.debug("[PermissionManager] Clearing permission state");
+        this.state = {
+            request: null,
+            messageId: null,
+            isActive: false,
+        };
+    }
+}
+export const permissionManager = new PermissionManager();

package/dist/permission/types.js

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