zardbot-telegram 1.0.0

package/dist/opencode/client.js

@@ -0,0 +1,13 @@
+import { createOpencodeClient } from "@opencode-ai/sdk/v2";
+import { config } from "../config.js";
+const getAuth = () => {
+    if (!config.opencode.password) {
+        return undefined;
+    }
+    const credentials = `${config.opencode.username}:${config.opencode.password}`;
+    return `Basic ${Buffer.from(credentials).toString("base64")}`;
+};
+export const opencodeClient = createOpencodeClient({
+    baseUrl: config.opencode.apiUrl,
+    headers: config.opencode.password ? { Authorization: getAuth() } : undefined,
+});

package/dist/opencode/events.js

@@ -0,0 +1,140 @@
+import { opencodeClient } from "./client.js";
+import { logger } from "../utils/logger.js";
+const RECONNECT_BASE_DELAY_MS = 1000;
+const RECONNECT_MAX_DELAY_MS = 15000;
+const FATAL_NO_STREAM_ERROR = "No stream returned from event subscription";
+let eventStream = null;
+let eventCallback = null;
+let isListening = false;
+let activeDirectory = null;
+let streamAbortController = null;
+function getReconnectDelayMs(attempt) {
+    const exponentialDelay = RECONNECT_BASE_DELAY_MS * Math.pow(2, Math.max(0, attempt - 1));
+    return Math.min(exponentialDelay, RECONNECT_MAX_DELAY_MS);
+}
+function waitWithAbort(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve(false);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timeout);
+            signal.removeEventListener("abort", onAbort);
+            resolve(false);
+        };
+        const timeout = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(true);
+        }, ms);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+export async function subscribeToEvents(directory, callback) {
+    if (isListening && activeDirectory === directory) {
+        eventCallback = callback;
+        logger.debug(`Event listener already running for ${directory}`);
+        return;
+    }
+    if (isListening && activeDirectory !== directory) {
+        logger.info(`Stopping event listener for ${activeDirectory}, starting for ${directory}`);
+        streamAbortController?.abort();
+        streamAbortController = null;
+        isListening = false;
+        activeDirectory = null;
+    }
+    const controller = new AbortController();
+    activeDirectory = directory;
+    eventCallback = callback;
+    isListening = true;
+    streamAbortController = controller;
+    try {
+        let reconnectAttempt = 0;
+        while (isListening && activeDirectory === directory && !controller.signal.aborted) {
+            try {
+                const result = await opencodeClient.event.subscribe({ directory }, { signal: controller.signal });
+                if (!result.stream) {
+                    throw new Error(FATAL_NO_STREAM_ERROR);
+                }
+                reconnectAttempt = 0;
+                eventStream = result.stream;
+                for await (const event of eventStream) {
+                    if (!isListening || activeDirectory !== directory || controller.signal.aborted) {
+                        logger.debug(`Event listener stopped or changed directory, breaking loop`);
+                        break;
+                    }
+                    // CRITICAL: Explicitly yield to the event loop BEFORE processing the event
+                    // This allows grammY to handle getUpdates between SSE events
+                    await new Promise((resolve) => setImmediate(resolve));
+                    if (eventCallback) {
+                        // Use setImmediate to avoid blocking the event loop
+                        // and let grammY process incoming Telegram updates
+                        const callbackSnapshot = eventCallback;
+                        setImmediate(() => callbackSnapshot(event));
+                    }
+                }
+                eventStream = null;
+                if (!isListening || activeDirectory !== directory || controller.signal.aborted) {
+                    break;
+                }
+                reconnectAttempt++;
+                const reconnectDelay = getReconnectDelayMs(reconnectAttempt);
+                logger.warn(`Event stream ended for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`);
+                const shouldContinue = await waitWithAbort(reconnectDelay, controller.signal);
+                if (!shouldContinue) {
+                    break;
+                }
+            }
+            catch (error) {
+                eventStream = null;
+                if (controller.signal.aborted || !isListening || activeDirectory !== directory) {
+                    logger.info("Event listener aborted");
+                    return;
+                }
+                if (error instanceof Error && error.message === FATAL_NO_STREAM_ERROR) {
+                    logger.error("Event stream fatal error:", error);
+                    throw error;
+                }
+                reconnectAttempt++;
+                const reconnectDelay = getReconnectDelayMs(reconnectAttempt);
+                logger.error(`Event stream error for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`, error);
+                const shouldContinue = await waitWithAbort(reconnectDelay, controller.signal);
+                if (!shouldContinue) {
+                    break;
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            logger.info("Event listener aborted");
+            return;
+        }
+        logger.error("Event stream error:", error);
+        isListening = false;
+        activeDirectory = null;
+        streamAbortController = null;
+        throw error;
+    }
+    finally {
+        if (streamAbortController === controller) {
+            if (isListening && activeDirectory === directory && !controller.signal.aborted) {
+                logger.warn(`Event stream ended for ${directory}, listener marked as disconnected`);
+            }
+            streamAbortController = null;
+            eventStream = null;
+            eventCallback = null;
+            isListening = false;
+            activeDirectory = null;
+        }
+    }
+}
+export function stopEventListening() {
+    streamAbortController?.abort();
+    streamAbortController = null;
+    isListening = false;
+    eventCallback = null;
+    eventStream = null;
+    activeDirectory = null;
+    logger.info("Event listener stopped");
+}

package/dist/permission/manager.js

@@ -0,0 +1,100 @@
+import { logger } from "../utils/logger.js";
+class PermissionManager {
+    state = {
+        requestsByMessageId: new Map(),
+    };
+    /**
+     * Register a new permission request message
+     */
+    startPermission(request, messageId) {
+        logger.debug(`[PermissionManager] startPermission: id=${request.id}, permission=${request.permission}, messageId=${messageId}`);
+        if (this.state.requestsByMessageId.has(messageId)) {
+            logger.warn(`[PermissionManager] Message ID already tracked, replacing: ${messageId}`);
+        }
+        this.state.requestsByMessageId.set(messageId, request);
+        logger.info(`[PermissionManager] New permission request: type=${request.permission}, patterns=${request.patterns.join(", ")}, pending=${this.state.requestsByMessageId.size}`);
+    }
+    /**
+     * Get permission request by Telegram message ID
+     */
+    getRequest(messageId) {
+        if (messageId === null) {
+            return null;
+        }
+        return this.state.requestsByMessageId.get(messageId) ?? null;
+    }
+    /**
+     * Get request ID for API reply by Telegram message ID
+     */
+    getRequestID(messageId) {
+        return this.getRequest(messageId)?.id ?? null;
+    }
+    /**
+     * Get permission type (bash, edit, etc.) by message ID
+     */
+    getPermissionType(messageId) {
+        return this.getRequest(messageId)?.permission ?? null;
+    }
+    /**
+     * Get patterns (commands/files) by message ID
+     */
+    getPatterns(messageId) {
+        return this.getRequest(messageId)?.patterns ?? [];
+    }
+    /**
+     * Check if callback message ID belongs to active permission request
+     */
+    isActiveMessage(messageId) {
+        return messageId !== null && this.state.requestsByMessageId.has(messageId);
+    }
+    /**
+     * Get latest Telegram message ID
+     */
+    getMessageId() {
+        const messageIds = this.getMessageIds();
+        if (messageIds.length === 0) {
+            return null;
+        }
+        return messageIds[messageIds.length - 1];
+    }
+    /**
+     * Get Telegram message IDs for all active requests
+     */
+    getMessageIds() {
+        return Array.from(this.state.requestsByMessageId.keys());
+    }
+    /**
+     * Remove permission request by Telegram message ID
+     */
+    removeByMessageId(messageId) {
+        const request = this.getRequest(messageId);
+        if (!request || messageId === null) {
+            return null;
+        }
+        this.state.requestsByMessageId.delete(messageId);
+        logger.debug(`[PermissionManager] Removed permission request: id=${request.id}, messageId=${messageId}, pending=${this.state.requestsByMessageId.size}`);
+        return request;
+    }
+    /**
+     * Get number of active permission requests
+     */
+    getPendingCount() {
+        return this.state.requestsByMessageId.size;
+    }
+    /**
+     * Check if there are active permission requests
+     */
+    isActive() {
+        return this.state.requestsByMessageId.size > 0;
+    }
+    /**
+     * Clear state after reply
+     */
+    clear() {
+        logger.debug(`[PermissionManager] Clearing permission state: pending=${this.state.requestsByMessageId.size}`);
+        this.state = {
+            requestsByMessageId: new Map(),
+        };
+    }
+}
+export const permissionManager = new PermissionManager();

package/dist/permission/types.js

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

package/dist/pinned/format.js

@@ -0,0 +1,29 @@
+import { t } from "../i18n/index.js";
+export const DEFAULT_CONTEXT_LIMIT = 200000;
+export function formatTokenCount(count) {
+    if (count >= 1000000) {
+        return `${(count / 1000000).toFixed(1)}M`;
+    }
+    if (count >= 1000) {
+        return `${Math.round(count / 1000)}K`;
+    }
+    return count.toString();
+}
+export function formatModelDisplayName(providerID, modelID) {
+    if (providerID && modelID) {
+        return `${providerID}/${modelID}`;
+    }
+    return t("pinned.unknown");
+}
+export function formatContextLine(tokensUsed, tokensLimit) {
+    const safeLimit = typeof tokensLimit === "number" && tokensLimit > 0 ? tokensLimit : null;
+    const percentage = safeLimit ? Math.round((tokensUsed / safeLimit) * 100) : 0;
+    return t("pinned.line.context", {
+        used: formatTokenCount(tokensUsed),
+        limit: safeLimit ? formatTokenCount(safeLimit) : t("pinned.unknown"),
+        percent: percentage,
+    });
+}
+export function formatCostLine(cost) {
+    return t("pinned.line.cost", { cost: `$${cost.toFixed(2)}` });
+}