opencode-telegram-group-topics-bot 0.11.2

package/dist/opencode/prompt-submit-error.js

@@ -0,0 +1,101 @@
+function asObject(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    return value;
+}
+function readString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function readStatusCode(error) {
+    const root = asObject(error);
+    if (!root) {
+        return null;
+    }
+    const direct = root.statusCode ?? root.status;
+    if (typeof direct === "number") {
+        return direct;
+    }
+    const data = asObject(root.data);
+    if (data) {
+        const fromData = data.statusCode ?? data.status;
+        if (typeof fromData === "number") {
+            return fromData;
+        }
+    }
+    const response = asObject(root.response);
+    if (response && typeof response.status === "number") {
+        return response.status;
+    }
+    return null;
+}
+function collectErrorTexts(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    const root = asObject(error);
+    if (!root) {
+        return "";
+    }
+    const parts = [];
+    const directMessage = readString(root.message);
+    const directError = readString(root.error);
+    if (directMessage) {
+        parts.push(directMessage);
+    }
+    if (directError) {
+        parts.push(directError);
+    }
+    const data = asObject(root.data);
+    if (data) {
+        const dataMessage = readString(data.message);
+        const responseBody = readString(data.responseBody);
+        if (dataMessage) {
+            parts.push(dataMessage);
+        }
+        if (responseBody) {
+            parts.push(responseBody);
+        }
+    }
+    if (Array.isArray(root.errors)) {
+        for (const item of root.errors) {
+            const itemObject = asObject(item);
+            if (!itemObject) {
+                continue;
+            }
+            const itemMessage = readString(itemObject.message) ?? readString(itemObject.error);
+            if (itemMessage) {
+                parts.push(itemMessage);
+            }
+        }
+    }
+    if (parts.length > 0) {
+        return parts.join(" ");
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function looksBusyText(text) {
+    return /(\bbusy\b|already running|currently running|still running|in progress|another run|another task|please wait)/i.test(text);
+}
+function looksMissingSessionText(text) {
+    return /(session.*not found|not found.*session|unknown session)/i.test(text);
+}
+export function classifyPromptSubmitError(error) {
+    const statusCode = readStatusCode(error);
+    const text = collectErrorTexts(error);
+    if (statusCode === 409 || looksBusyText(text)) {
+        return "busy";
+    }
+    if (statusCode === 404 || looksMissingSessionText(text)) {
+        return "session_not_found";
+    }
+    return "other";
+}

package/dist/permission/manager.js

@@ -0,0 +1,92 @@
+import { logger } from "../utils/logger.js";
+class PermissionManager {
+    stateByScope = new Map();
+    getState(scopeKey) {
+        const state = this.stateByScope.get(scopeKey);
+        if (state) {
+            return state;
+        }
+        const next = {
+            requestsByMessageId: new Map(),
+        };
+        this.stateByScope.set(scopeKey, next);
+        return next;
+    }
+    startPermission(request, messageId, scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        logger.debug(`[PermissionManager] startPermission: id=${request.id}, permission=${request.permission}, messageId=${messageId}`);
+        if (state.requestsByMessageId.has(messageId)) {
+            logger.warn(`[PermissionManager] Message ID already tracked, replacing: ${messageId}`);
+        }
+        state.requestsByMessageId.set(messageId, request);
+        logger.info(`[PermissionManager] New permission request: type=${request.permission}, patterns=${request.patterns.join(", ")}, pending=${state.requestsByMessageId.size}`);
+    }
+    getRequest(messageId, scopeKey = "global") {
+        if (messageId === null) {
+            return null;
+        }
+        return this.getState(scopeKey).requestsByMessageId.get(messageId) ?? null;
+    }
+    getRequestByID(requestID, scopeKey = "global") {
+        const entries = Array.from(this.getState(scopeKey).requestsByMessageId.entries());
+        for (const [messageId, request] of entries) {
+            if (request.id === requestID) {
+                return { messageId, request };
+            }
+        }
+        return null;
+    }
+    getRequestID(messageId, scopeKey = "global") {
+        return this.getRequest(messageId, scopeKey)?.id ?? null;
+    }
+    getPermissionType(messageId, scopeKey = "global") {
+        return this.getRequest(messageId, scopeKey)?.permission ?? null;
+    }
+    getPatterns(messageId, scopeKey = "global") {
+        return this.getRequest(messageId, scopeKey)?.patterns ?? [];
+    }
+    isActiveMessage(messageId, scopeKey = "global") {
+        return messageId !== null && this.getState(scopeKey).requestsByMessageId.has(messageId);
+    }
+    getMessageId(scopeKey = "global") {
+        const messageIds = this.getMessageIds(scopeKey);
+        if (messageIds.length === 0) {
+            return null;
+        }
+        return messageIds[messageIds.length - 1];
+    }
+    getMessageIds(scopeKey = "global") {
+        return Array.from(this.getState(scopeKey).requestsByMessageId.keys());
+    }
+    removeByMessageId(messageId, scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        const request = this.getRequest(messageId, scopeKey);
+        if (!request || messageId === null) {
+            return null;
+        }
+        state.requestsByMessageId.delete(messageId);
+        logger.debug(`[PermissionManager] Removed permission request: id=${request.id}, messageId=${messageId}, pending=${state.requestsByMessageId.size}`);
+        return request;
+    }
+    removeByRequestID(requestID, scopeKey = "global") {
+        const match = this.getRequestByID(requestID, scopeKey);
+        if (!match) {
+            return null;
+        }
+        return this.removeByMessageId(match.messageId, scopeKey);
+    }
+    getPendingCount(scopeKey = "global") {
+        return this.getState(scopeKey).requestsByMessageId.size;
+    }
+    isActive(scopeKey = "global") {
+        return this.getState(scopeKey).requestsByMessageId.size > 0;
+    }
+    clear(scopeKey = "global") {
+        const state = this.getState(scopeKey);
+        logger.debug(`[PermissionManager] Clearing permission state: pending=${state.requestsByMessageId.size}`);
+        this.stateByScope.set(scopeKey, {
+            requestsByMessageId: new Map(),
+        });
+    }
+}
+export const permissionManager = new PermissionManager();

package/dist/permission/types.js

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

package/dist/pinned/manager.js

@@ -0,0 +1,405 @@
+import { logger } from "../utils/logger.js";
+import { opencodeClient } from "../opencode/client.js";
+import { getScopedPinnedMessageId, setScopedPinnedMessageId, clearScopedPinnedMessageId, getCurrentProject, } from "../settings/manager.js";
+import { getStoredModel } from "../model/manager.js";
+import { t } from "../i18n/index.js";
+import { getThreadIdFromScopeKey, getThreadSendOptions } from "../bot/scope.js";
+class PinnedMessageManager {
+    contexts = new Map();
+    onKeyboardUpdateCallback;
+    createDefaultState(scopeKey) {
+        return {
+            scopeKey,
+            messageId: null,
+            chatId: null,
+            threadId: null,
+            sessionId: null,
+            sessionTitle: t("pinned.default_session_title"),
+            projectName: "",
+            tokensUsed: 0,
+            tokensLimit: 0,
+            lastUpdated: 0,
+            changedFiles: [],
+        };
+    }
+    getContext(scopeKey) {
+        const existing = this.contexts.get(scopeKey);
+        if (existing) {
+            return existing;
+        }
+        const savedId = getScopedPinnedMessageId(scopeKey);
+        const context = {
+            api: null,
+            chatId: null,
+            state: {
+                ...this.createDefaultState(scopeKey),
+                messageId: savedId ?? null,
+            },
+            contextLimit: null,
+            debounceTimer: null,
+        };
+        this.contexts.set(scopeKey, context);
+        return context;
+    }
+    initialize(api, chatId, scopeKey = "global", threadId = null) {
+        const context = this.getContext(scopeKey);
+        const scopeThreadId = getThreadIdFromScopeKey(scopeKey);
+        const resolvedThreadId = threadId ?? scopeThreadId ?? context.state.threadId;
+        context.api = api;
+        context.chatId = chatId;
+        context.state.chatId = chatId;
+        context.state.threadId = resolvedThreadId;
+    }
+    persistPinnedId(scopeKey, messageId) {
+        setScopedPinnedMessageId(scopeKey, messageId);
+    }
+    clearPersistedPinnedId(scopeKey) {
+        clearScopedPinnedMessageId(scopeKey);
+    }
+    async onSessionChange(sessionId, sessionTitle, scopeKey = "global") {
+        const context = this.getContext(scopeKey);
+        const state = context.state;
+        state.tokensUsed = 0;
+        state.sessionId = sessionId;
+        state.sessionTitle = sessionTitle || t("pinned.default_session_title");
+        const project = getCurrentProject(scopeKey);
+        state.projectName =
+            project?.name || this.extractProjectName(project?.worktree) || t("pinned.unknown");
+        await this.fetchContextLimit(scopeKey);
+        if (this.onKeyboardUpdateCallback && state.tokensLimit > 0) {
+            this.onKeyboardUpdateCallback(state.tokensUsed, state.tokensLimit, scopeKey);
+        }
+        state.changedFiles = [];
+        await this.unpinOldMessage(scopeKey);
+        await this.createPinnedMessage(scopeKey);
+        await this.loadDiffsFromApi(sessionId, scopeKey);
+    }
+    async onSessionTitleUpdate(newTitle, scopeKey = "global") {
+        const state = this.getContext(scopeKey).state;
+        if (state.sessionTitle !== newTitle && newTitle) {
+            state.sessionTitle = newTitle;
+            await this.updatePinnedMessage(scopeKey);
+        }
+    }
+    async loadContextFromHistory(sessionId, directory, scopeKey = "global") {
+        const context = this.getContext(scopeKey);
+        try {
+            const { data: messagesData, error } = await opencodeClient.session.messages({
+                sessionID: sessionId,
+                directory,
+            });
+            if (error || !messagesData) {
+                return;
+            }
+            let maxContextSize = 0;
+            messagesData.forEach(({ info }) => {
+                if (info.role !== "assistant") {
+                    return;
+                }
+                const assistantInfo = info;
+                if (assistantInfo.summary) {
+                    return;
+                }
+                const contextSize = (assistantInfo.tokens?.input || 0) + (assistantInfo.tokens?.cache?.read || 0);
+                if (contextSize > maxContextSize) {
+                    maxContextSize = contextSize;
+                }
+            });
+            context.state.tokensUsed = maxContextSize;
+            context.state.sessionId = sessionId;
+            await this.updatePinnedMessage(scopeKey);
+        }
+        catch (err) {
+            logger.error("[PinnedManager] Error loading context from history:", err);
+        }
+    }
+    async onSessionCompacted(sessionId, directory, scopeKey = "global") {
+        await this.loadContextFromHistory(sessionId, directory, scopeKey);
+    }
+    async onMessageComplete(tokens, scopeKey = "global") {
+        if (this.getContextLimit(scopeKey) === 0) {
+            await this.fetchContextLimit(scopeKey);
+        }
+        const context = this.getContext(scopeKey);
+        context.state.tokensUsed = tokens.input + tokens.cacheRead;
+        await this.refreshSessionTitle(scopeKey);
+        this.scheduleDebouncedUpdate(scopeKey, 1200);
+    }
+    setOnKeyboardUpdate(callback) {
+        this.onKeyboardUpdateCallback = callback;
+    }
+    getContextInfo(scopeKey = "global") {
+        const context = this.getContext(scopeKey);
+        const limit = context.state.tokensLimit > 0 ? context.state.tokensLimit : context.contextLimit || 0;
+        if (limit === 0) {
+            return null;
+        }
+        return { tokensUsed: context.state.tokensUsed, tokensLimit: limit };
+    }
+    getContextLimit(scopeKey = "global") {
+        const context = this.getContext(scopeKey);
+        return context.contextLimit || context.state.tokensLimit || 0;
+    }
+    async refreshContextLimit(scopeKey = "global") {
+        await this.fetchContextLimit(scopeKey);
+    }
+    async onSessionDiff(diffs, scopeKey = "global") {
+        const context = this.getContext(scopeKey);
+        if (diffs.length === 0 && context.state.changedFiles.length > 0) {
+            return;
+        }
+        context.state.changedFiles = diffs;
+        this.scheduleDebouncedUpdate(scopeKey, 1200);
+    }
+    addFileChange(change, scopeKey = "global") {
+        const context = this.getContext(scopeKey);
+        const existing = context.state.changedFiles.find((f) => f.file === change.file);
+        if (existing) {
+            existing.additions += change.additions;
+            existing.deletions += change.deletions;
+        }
+        else {
+            context.state.changedFiles.push(change);
+        }
+        this.scheduleDebouncedUpdate(scopeKey);
+    }
+    scheduleDebouncedUpdate(scopeKey, delayMs = 1500) {
+        const context = this.getContext(scopeKey);
+        if (context.debounceTimer) {
+            clearTimeout(context.debounceTimer);
+        }
+        context.debounceTimer = setTimeout(() => {
+            context.debounceTimer = null;
+            void this.updatePinnedMessage(scopeKey);
+        }, delayMs);
+    }
+    async loadDiffsFromApi(sessionId, scopeKey) {
+        try {
+            const project = getCurrentProject(scopeKey);
+            if (!project) {
+                return;
+            }
+            const { data, error } = await opencodeClient.session.diff({
+                sessionID: sessionId,
+                directory: project.worktree,
+            });
+            const context = this.getContext(scopeKey);
+            if (!error && data && data.length > 0) {
+                context.state.changedFiles = data.map((d) => ({
+                    file: d.file,
+                    additions: d.additions,
+                    deletions: d.deletions,
+                }));
+                await this.updatePinnedMessage(scopeKey);
+            }
+        }
+        catch (err) {
+            logger.debug("[PinnedManager] Could not load diffs from API:", err);
+        }
+    }
+    async refreshSessionTitle(scopeKey) {
+        const context = this.getContext(scopeKey);
+        const sessionId = context.state.sessionId;
+        const project = getCurrentProject(scopeKey);
+        if (!sessionId || !project) {
+            return;
+        }
+        try {
+            const { data: sessionData } = await opencodeClient.session.get({
+                sessionID: sessionId,
+                directory: project.worktree,
+            });
+            if (sessionData && sessionData.title !== context.state.sessionTitle) {
+                context.state.sessionTitle = sessionData.title;
+            }
+        }
+        catch {
+            // Ignore refresh failures.
+        }
+    }
+    extractProjectName(worktree) {
+        if (!worktree) {
+            return "";
+        }
+        const parts = worktree.replace(/\\/g, "/").split("/");
+        return parts[parts.length - 1] || "";
+    }
+    makeRelativePath(filePath, scopeKey) {
+        const normalized = filePath.replace(/\\/g, "/");
+        const project = getCurrentProject(scopeKey);
+        if (!project?.worktree) {
+            return normalized;
+        }
+        const worktree = project.worktree.replace(/\\/g, "/");
+        if (normalized.startsWith(worktree)) {
+            let relative = normalized.slice(worktree.length);
+            if (relative.startsWith("/")) {
+                relative = relative.slice(1);
+            }
+            return relative || normalized;
+        }
+        const segments = normalized.split("/");
+        if (segments.length <= 3) {
+            return normalized;
+        }
+        return ".../" + segments.slice(-3).join("/");
+    }
+    async fetchContextLimit(scopeKey) {
+        const context = this.getContext(scopeKey);
+        try {
+            const model = getStoredModel(scopeKey);
+            if (!model.providerID || !model.modelID) {
+                context.contextLimit = 200000;
+                context.state.tokensLimit = context.contextLimit;
+                return;
+            }
+            const { data: providersData, error } = await opencodeClient.config.providers();
+            if (error || !providersData) {
+                context.contextLimit = 200000;
+                context.state.tokensLimit = context.contextLimit;
+                return;
+            }
+            for (const provider of providersData.providers) {
+                if (provider.id !== model.providerID) {
+                    continue;
+                }
+                const modelInfo = provider.models[model.modelID];
+                if (modelInfo?.limit?.context) {
+                    context.contextLimit = modelInfo.limit.context;
+                    context.state.tokensLimit = context.contextLimit;
+                    return;
+                }
+            }
+            context.contextLimit = 200000;
+            context.state.tokensLimit = context.contextLimit;
+        }
+        catch {
+            context.contextLimit = 200000;
+            context.state.tokensLimit = context.contextLimit;
+        }
+    }
+    formatTokenCount(count) {
+        if (count >= 1000000) {
+            return `${(count / 1000000).toFixed(1)}M`;
+        }
+        if (count >= 1000) {
+            return `${Math.round(count / 1000)}K`;
+        }
+        return count.toString();
+    }
+    formatMessage(scopeKey) {
+        const context = this.getContext(scopeKey);
+        const state = context.state;
+        const percentage = state.tokensLimit > 0 ? Math.round((state.tokensUsed / state.tokensLimit) * 100) : 0;
+        const currentModel = getStoredModel(scopeKey);
+        const modelName = currentModel.providerID && currentModel.modelID
+            ? `${currentModel.providerID}/${currentModel.modelID}`
+            : t("pinned.unknown");
+        const lines = [
+            `${state.sessionTitle}`,
+            t("pinned.line.project", { project: state.projectName }),
+            t("pinned.line.model", { model: modelName }),
+            t("pinned.line.context", {
+                used: this.formatTokenCount(state.tokensUsed),
+                limit: this.formatTokenCount(state.tokensLimit),
+                percent: percentage,
+            }),
+        ];
+        if (state.changedFiles.length > 0) {
+            const maxFiles = 10;
+            const filesToShow = state.changedFiles.slice(0, maxFiles);
+            lines.push("");
+            lines.push(t("pinned.files.title", { count: state.changedFiles.length }));
+            for (const fileChange of filesToShow) {
+                const parts = [];
+                if (fileChange.additions > 0)
+                    parts.push(`+${fileChange.additions}`);
+                if (fileChange.deletions > 0)
+                    parts.push(`-${fileChange.deletions}`);
+                const diff = parts.length > 0 ? ` (${parts.join(" ")})` : "";
+                lines.push(t("pinned.files.item", { path: this.makeRelativePath(fileChange.file, scopeKey), diff }));
+            }
+            if (state.changedFiles.length > maxFiles) {
+                lines.push(t("pinned.files.more", { count: state.changedFiles.length - maxFiles }));
+            }
+        }
+        return lines.join("\n");
+    }
+    async createPinnedMessage(scopeKey) {
+        const context = this.getContext(scopeKey);
+        if (!context.api || !context.chatId) {
+            return;
+        }
+        const threadId = context.state.threadId ?? getThreadIdFromScopeKey(scopeKey);
+        const sent = await context.api.sendMessage(context.chatId, this.formatMessage(scopeKey), {
+            ...getThreadSendOptions(threadId),
+        });
+        context.state.messageId = sent.message_id;
+        context.state.lastUpdated = Date.now();
+        this.persistPinnedId(scopeKey, sent.message_id);
+        await context.api.pinChatMessage(context.chatId, sent.message_id, {
+            disable_notification: true,
+        });
+    }
+    async updatePinnedMessage(scopeKey) {
+        const context = this.getContext(scopeKey);
+        if (!context.api || !context.chatId || !context.state.messageId) {
+            return;
+        }
+        try {
+            await context.api.editMessageText(context.chatId, context.state.messageId, this.formatMessage(scopeKey));
+            context.state.lastUpdated = Date.now();
+            if (this.onKeyboardUpdateCallback && context.state.tokensLimit > 0) {
+                this.onKeyboardUpdateCallback(context.state.tokensUsed, context.state.tokensLimit, scopeKey);
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("message is not modified")) {
+                return;
+            }
+            if (err instanceof Error && err.message.includes("message to edit not found")) {
+                context.state.messageId = null;
+                this.clearPersistedPinnedId(scopeKey);
+                await this.createPinnedMessage(scopeKey);
+                return;
+            }
+            logger.error("[PinnedManager] Error updating pinned message:", err);
+        }
+    }
+    async unpinOldMessage(scopeKey) {
+        const context = this.getContext(scopeKey);
+        if (!context.api || !context.chatId) {
+            return;
+        }
+        try {
+            if (context.state.messageId) {
+                await context.api.unpinChatMessage(context.chatId, context.state.messageId).catch(() => { });
+            }
+        }
+        finally {
+            context.state.messageId = null;
+            this.clearPersistedPinnedId(scopeKey);
+        }
+    }
+    getState(scopeKey = "global") {
+        return { ...this.getContext(scopeKey).state };
+    }
+    isInitialized(scopeKey = "global") {
+        const context = this.contexts.get(scopeKey);
+        return Boolean(context?.api && context?.chatId);
+    }
+    async clear(scopeKey = "global") {
+        const context = this.getContext(scopeKey);
+        if (context.api && context.chatId && context.state.messageId) {
+            await context.api.unpinChatMessage(context.chatId, context.state.messageId).catch(() => { });
+            await context.api.deleteMessage(context.chatId, context.state.messageId).catch(() => { });
+        }
+        if (context.debounceTimer) {
+            clearTimeout(context.debounceTimer);
+            context.debounceTimer = null;
+        }
+        context.state = this.createDefaultState(scopeKey);
+        this.clearPersistedPinnedId(scopeKey);
+    }
+}
+export const pinnedMessageManager = new PinnedMessageManager();

package/dist/pinned/types.js

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