@grinev/opencode-telegram-bot 0.4.0 → 0.6.0

package/dist/interaction/guard.js

@@ -0,0 +1,87 @@
+import { interactionManager } from "./manager.js";
+function normalizeIncomingCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/")) {
+        return null;
+    }
+    const token = trimmed.split(/\s+/)[0];
+    const withoutMention = token.split("@")[0].toLowerCase();
+    if (withoutMention.length <= 1) {
+        return null;
+    }
+    return withoutMention;
+}
+function classifyIncomingInput(ctx) {
+    if (ctx.callbackQuery?.data) {
+        return { inputType: "callback" };
+    }
+    const text = ctx.message?.text;
+    if (typeof text === "string") {
+        const command = normalizeIncomingCommand(text);
+        if (command) {
+            return { inputType: "command", command };
+        }
+        return { inputType: "text" };
+    }
+    return { inputType: "other" };
+}
+function getExpectedInputBlockReason(expectedInput) {
+    switch (expectedInput) {
+        case "callback":
+            return "expected_callback";
+        case "command":
+            return "expected_command";
+        case "text":
+        case "mixed":
+            return "expected_text";
+    }
+}
+function createAllowDecision(inputType, state, command) {
+    return {
+        allow: true,
+        inputType,
+        state,
+        command,
+    };
+}
+function createBlockDecision(inputType, state, reason, command) {
+    return {
+        allow: false,
+        inputType,
+        state,
+        reason,
+        command,
+    };
+}
+function isAllowedRenameCancelCallback(ctx, state) {
+    return (state.kind === "rename" &&
+        state.expectedInput === "text" &&
+        ctx.callbackQuery?.data === "rename:cancel");
+}
+export function resolveInteractionGuardDecision(ctx) {
+    const state = interactionManager.getSnapshot();
+    const { inputType, command } = classifyIncomingInput(ctx);
+    if (!state) {
+        return createAllowDecision(inputType, null, command);
+    }
+    if (interactionManager.isExpired()) {
+        interactionManager.clear("expired");
+        return createBlockDecision(inputType, state, "expired", command);
+    }
+    if (inputType === "command") {
+        if (command && state.allowedCommands.includes(command)) {
+            return createAllowDecision(inputType, state, command);
+        }
+        return createBlockDecision(inputType, state, "command_not_allowed", command);
+    }
+    if (state.expectedInput === "mixed") {
+        return createAllowDecision(inputType, state, command);
+    }
+    if (inputType === "callback" && isAllowedRenameCancelCallback(ctx, state)) {
+        return createAllowDecision(inputType, state, command);
+    }
+    if (state.expectedInput === inputType) {
+        return createAllowDecision(inputType, state, command);
+    }
+    return createBlockDecision(inputType, state, getExpectedInputBlockReason(state.expectedInput), command);
+}

package/dist/interaction/manager.js

@@ -0,0 +1,106 @@
+import { logger } from "../utils/logger.js";
+export const DEFAULT_ALLOWED_INTERACTION_COMMANDS = ["/help", "/status", "/stop"];
+function normalizeCommand(command) {
+    const trimmed = command.trim().toLowerCase();
+    if (!trimmed) {
+        return null;
+    }
+    const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    const withoutMention = withSlash.split("@")[0];
+    if (withoutMention.length <= 1) {
+        return null;
+    }
+    return withoutMention;
+}
+function normalizeAllowedCommands(commands) {
+    if (commands === undefined) {
+        return [...DEFAULT_ALLOWED_INTERACTION_COMMANDS];
+    }
+    const normalized = new Set();
+    for (const command of commands) {
+        const value = normalizeCommand(command);
+        if (value) {
+            normalized.add(value);
+        }
+    }
+    return Array.from(normalized);
+}
+function cloneState(state) {
+    return {
+        ...state,
+        allowedCommands: [...state.allowedCommands],
+        metadata: { ...state.metadata },
+    };
+}
+class InteractionManager {
+    state = null;
+    start(options) {
+        const now = Date.now();
+        let expiresAt = null;
+        if (this.state) {
+            this.clear("state_replaced");
+        }
+        if (typeof options.expiresInMs === "number") {
+            expiresAt = now + options.expiresInMs;
+        }
+        const nextState = {
+            kind: options.kind,
+            expectedInput: options.expectedInput,
+            allowedCommands: normalizeAllowedCommands(options.allowedCommands),
+            metadata: options.metadata ? { ...options.metadata } : {},
+            createdAt: now,
+            expiresAt,
+        };
+        this.state = nextState;
+        logger.info(`[InteractionManager] Started interaction: kind=${nextState.kind}, expectedInput=${nextState.expectedInput}, allowedCommands=${nextState.allowedCommands.join(",") || "none"}`);
+        return cloneState(nextState);
+    }
+    get() {
+        if (!this.state) {
+            return null;
+        }
+        return cloneState(this.state);
+    }
+    getSnapshot() {
+        return this.get();
+    }
+    isActive() {
+        return this.state !== null;
+    }
+    isExpired(referenceTimeMs = Date.now()) {
+        if (!this.state || this.state.expiresAt === null) {
+            return false;
+        }
+        return referenceTimeMs >= this.state.expiresAt;
+    }
+    transition(options) {
+        if (!this.state) {
+            return null;
+        }
+        const now = Date.now();
+        this.state = {
+            ...this.state,
+            kind: options.kind ?? this.state.kind,
+            expectedInput: options.expectedInput ?? this.state.expectedInput,
+            allowedCommands: options.allowedCommands !== undefined
+                ? normalizeAllowedCommands(options.allowedCommands)
+                : [...this.state.allowedCommands],
+            metadata: options.metadata ? { ...options.metadata } : { ...this.state.metadata },
+            expiresAt: options.expiresInMs === undefined
+                ? this.state.expiresAt
+                : options.expiresInMs === null
+                    ? null
+                    : now + options.expiresInMs,
+        };
+        logger.debug(`[InteractionManager] Transitioned interaction: kind=${this.state.kind}, expectedInput=${this.state.expectedInput}, allowedCommands=${this.state.allowedCommands.join(",") || "none"}`);
+        return cloneState(this.state);
+    }
+    clear(reason = "manual") {
+        if (!this.state) {
+            return;
+        }
+        logger.info(`[InteractionManager] Cleared interaction: reason=${reason}, kind=${this.state.kind}, expectedInput=${this.state.expectedInput}`);
+        this.state = null;
+    }
+}
+export const interactionManager = new InteractionManager();

package/dist/interaction/types.js

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

package/dist/permission/manager.js

@@ -1,77 +1,99 @@
 import { logger } from "../utils/logger.js";
 class PermissionManager {
     state = {
-        request: null,
-        messageId: null,
-        isActive: false,
+        requestsByMessageId: new Map(),
     };
     /**
-     * Start a new permission request
+     * Register a new permission request message
      */
-    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();
+    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}`);
         }
-        logger.info(`[PermissionManager] New permission request: type=${request.permission}, patterns=${request.patterns.join(", ")}`);
-        this.state = {
-            request,
-            messageId: null,
-            isActive: true,
-        };
+        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 current permission request
+     * Get permission request by Telegram message ID
      */
-    getRequest() {
-        return this.state.request;
+    getRequest(messageId) {
+        if (messageId === null) {
+            return null;
+        }
+        return this.state.requestsByMessageId.get(messageId) ?? null;
     }
     /**
-     * Get request ID for API reply
+     * Get request ID for API reply by Telegram message ID
      */
-    getRequestID() {
-        return this.state.request?.id ?? null;
+    getRequestID(messageId) {
+        return this.getRequest(messageId)?.id ?? null;
     }
     /**
-     * Get permission type (bash, edit, etc.)
+     * Get permission type (bash, edit, etc.) by message ID
      */
-    getPermissionType() {
-        return this.state.request?.permission ?? null;
+    getPermissionType(messageId) {
+        return this.getRequest(messageId)?.permission ?? null;
     }
     /**
-     * Get patterns (commands/files)
+     * Get patterns (commands/files) by message ID
      */
-    getPatterns() {
-        return this.state.request?.patterns ?? [];
+    getPatterns(messageId) {
+        return this.getRequest(messageId)?.patterns ?? [];
     }
     /**
-     * Set Telegram message ID for later deletion
+     * Check if callback message ID belongs to active permission request
      */
-    setMessageId(messageId) {
-        this.state.messageId = messageId;
+    isActiveMessage(messageId) {
+        return messageId !== null && this.state.requestsByMessageId.has(messageId);
     }
     /**
-     * Get Telegram message ID
+     * Get latest Telegram message ID
      */
     getMessageId() {
-        return this.state.messageId;
+        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 permission request is active
+     * Check if there are active permission requests
      */
     isActive() {
-        return this.state.isActive;
+        return this.state.requestsByMessageId.size > 0;
     }
     /**
      * Clear state after reply
      */
     clear() {
-        logger.debug("[PermissionManager] Clearing permission state");
+        logger.debug(`[PermissionManager] Clearing permission state: pending=${this.state.requestsByMessageId.size}`);
         this.state = {
-            request: null,
-            messageId: null,
-            isActive: false,
+            requestsByMessageId: new Map(),
         };
     }
 }

package/dist/pinned/manager.js

@@ -266,7 +266,7 @@ class PinnedMessageManager {
             logger.debug(`[PinnedManager] loadDiffsFromMessages: ${messagesData.length} messages`);
             const filesMap = new Map();
             let toolCount = 0;
-            let editWriteCount = 0;
+            let fileToolCount = 0;
             for (const { parts } of messagesData) {
                 for (const part of parts) {
                     if (part.type !== "tool")
@@ -275,10 +275,12 @@ class PinnedMessageManager {
                     const toolPart = part;
                     if (toolPart.state.status !== "completed")
                         continue;
-                    if (toolPart.tool === "edit" || toolPart.tool === "write") {
-                        editWriteCount++;
+                    if (toolPart.tool === "edit" ||
+                        toolPart.tool === "write" ||
+                        toolPart.tool === "apply_patch") {
+                        fileToolCount++;
                     }
-                    if (toolPart.tool === "edit" &&
+                    if ((toolPart.tool === "edit" || toolPart.tool === "apply_patch") &&
                         toolPart.state.metadata &&
                         "filediff" in toolPart.state.metadata) {
                         const filediff = toolPart.state.metadata.filediff;
@@ -318,7 +320,7 @@ class PinnedMessageManager {
                     }
                 }
             }
-            logger.debug(`[PinnedManager] loadDiffsFromMessages: found ${toolCount} tool parts, ${editWriteCount} edit/write`);
+            logger.debug(`[PinnedManager] loadDiffsFromMessages: found ${toolCount} tool parts, ${fileToolCount} file tools`);
             if (filesMap.size > 0) {
                 this.state.changedFiles = Array.from(filesMap.values());
                 logger.info(`[PinnedManager] Loaded ${this.state.changedFiles.length} file diffs from messages`);

package/dist/question/manager.js

@@ -5,6 +5,8 @@ class QuestionManager {
         currentIndex: 0,
         selectedOptions: new Map(),
         customAnswers: new Map(),
+        customInputQuestionIndex: null,
+        activeMessageId: null,
         messageIds: [],
         isActive: false,
         requestID: null,
@@ -22,6 +24,8 @@ class QuestionManager {
             currentIndex: 0,
             selectedOptions: new Map(),
             customAnswers: new Map(),
+            customInputQuestionIndex: null,
+            activeMessageId: null,
             messageIds: [],
             isActive: true,
             requestID,
@@ -87,6 +91,8 @@ class QuestionManager {
     }
     nextQuestion() {
         this.state.currentIndex++;
+        this.state.customInputQuestionIndex = null;
+        this.state.activeMessageId = null;
         logger.debug(`[QuestionManager] Moving to next question: ${this.state.currentIndex}/${this.state.questions.length}`);
     }
     hasNextQuestion() {
@@ -101,6 +107,29 @@ class QuestionManager {
     addMessageId(messageId) {
         this.state.messageIds.push(messageId);
     }
+    setActiveMessageId(messageId) {
+        this.state.activeMessageId = messageId;
+    }
+    getActiveMessageId() {
+        return this.state.activeMessageId;
+    }
+    isActiveMessage(messageId) {
+        return (this.state.isActive &&
+            this.state.activeMessageId !== null &&
+            messageId === this.state.activeMessageId);
+    }
+    startCustomInput(questionIndex) {
+        if (!this.state.isActive || !this.state.questions[questionIndex]) {
+            return;
+        }
+        this.state.customInputQuestionIndex = questionIndex;
+    }
+    clearCustomInput() {
+        this.state.customInputQuestionIndex = null;
+    }
+    isWaitingForCustomInput(questionIndex) {
+        return this.state.customInputQuestionIndex === questionIndex;
+    }
     getMessageIds() {
         return [...this.state.messageIds];
     }
@@ -111,6 +140,8 @@ class QuestionManager {
     cancel() {
         logger.info("[QuestionManager] Poll cancelled");
         this.state.isActive = false;
+        this.state.customInputQuestionIndex = null;
+        this.state.activeMessageId = null;
     }
     clear() {
         this.state = {
@@ -118,6 +149,8 @@ class QuestionManager {
             currentIndex: 0,
             selectedOptions: new Map(),
             customAnswers: new Map(),
+            customInputQuestionIndex: null,
+            activeMessageId: null,
             messageIds: [],
             isActive: false,
             requestID: null,

package/dist/rename/manager.js

@@ -23,6 +23,9 @@ class RenameManager {
     getMessageId() {
         return this.state.messageId;
     }
+    isActiveMessage(messageId) {
+        return (this.state.isWaiting && this.state.messageId !== null && this.state.messageId === messageId);
+    }
     isWaitingForName() {
         return this.state.isWaiting;
     }

package/dist/settings/manager.js

@@ -119,5 +119,10 @@ export function __resetSettingsForTests() {
     settingsWriteQueue = Promise.resolve();
 }
 export async function loadSettings() {
-    currentSettings = await readSettingsFile();
+    const loadedSettings = (await readSettingsFile());
+    if ("toolMessagesIntervalSec" in loadedSettings) {
+        delete loadedSettings.toolMessagesIntervalSec;
+        void writeSettingsFile(loadedSettings);
+    }
+    currentSettings = loadedSettings;
 }

package/dist/summary/aggregator.js

@@ -1,6 +1,29 @@
-import { prepareCodeFile } from "./formatter.js";
+import { normalizePathForDisplay, prepareCodeFile } from "./formatter.js";
 import { logger } from "../utils/logger.js";
 import { getCurrentProject } from "../settings/manager.js";
+function extractFirstUpdatedFileFromTitle(title) {
+    for (const rawLine of title.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length >= 3 && line[1] === " " && /[AMDURC]/.test(line[0])) {
+            return line.slice(2).trim();
+        }
+    }
+    return "";
+}
+function countDiffChangesFromText(text) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of text.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            additions++;
+            continue;
+        }
+        if (line.startsWith("-") && !line.startsWith("---")) {
+            deletions++;
+        }
+    }
+    return { additions, deletions };
+}
 class SummaryAggregator {
     currentSessionId = null;
     currentMessageParts = new Map();
@@ -19,6 +42,7 @@ class SummaryAggregator {
     onPermissionCallback = null;
     onSessionDiffCallback = null;
     onFileChangeCallback = null;
+    onClearedCallback = null;
     processedToolStates = new Set();
     bot = null;
     chatId = null;
@@ -61,6 +85,9 @@ class SummaryAggregator {
     setOnFileChange(callback) {
         this.onFileChangeCallback = callback;
     }
+    setOnCleared(callback) {
+        this.onClearedCallback = callback;
+    }
     startTypingIndicator() {
         if (this.typingTimer) {
             return;
@@ -145,6 +172,14 @@ class SummaryAggregator {
         this.processedToolStates.clear();
         this.messageCount = 0;
         this.lastUpdated = 0;
+        if (this.onClearedCallback) {
+            try {
+                this.onClearedCallback();
+            }
+            catch (err) {
+                logger.error("[Aggregator] Error in clear callback:", err);
+            }
+        }
     }
     handleMessageUpdated(event) {
         const { info } = event.properties;
@@ -160,8 +195,11 @@ class SummaryAggregator {
                 this.startTypingIndicator();
                 // Notify that agent started thinking
                 if (this.onThinkingCallback) {
+                    const callback = this.onThinkingCallback;
                     setImmediate(() => {
-                        this.onThinkingCallback();
+                        if (typeof callback === "function") {
+                            callback(info.sessionID);
+                        }
                     });
                 }
             }
@@ -264,6 +302,7 @@ class SummaryAggregator {
                 if (!this.processedToolStates.has(notifiedKey)) {
                     this.processedToolStates.add(notifiedKey);
                     const toolData = {
+                        sessionId: part.sessionID,
                         messageId: messageID,
                         callId: part.callID,
                         tool: part.tool,
@@ -283,7 +322,8 @@ class SummaryAggregator {
                 if (!this.processedToolStates.has(fileKey)) {
                     this.processedToolStates.add(fileKey);
                     if (part.tool === "write" && input && "content" in input && "filePath" in input) {
-                        const fileData = prepareCodeFile(input.content, input.filePath, "write");
+                        const filePath = normalizePathForDisplay(input.filePath);
+                        const fileData = prepareCodeFile(input.content, filePath, "write");
                         if (fileData && this.onToolFileCallback) {
                             logger.debug(`[Aggregator] Sending write file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
                             this.onToolFileCallback(fileData);
@@ -292,7 +332,7 @@ class SummaryAggregator {
                         if (this.onFileChangeCallback) {
                             const lines = input.content.split("\n").length;
                             this.onFileChangeCallback({
-                                file: input.filePath,
+                                file: filePath,
                                 additions: lines,
                                 deletions: 0,
                             });
@@ -303,12 +343,12 @@ class SummaryAggregator {
                         "diff" in state.metadata &&
                         "filediff" in state.metadata) {
                         const filediff = state.metadata.filediff;
-                        const filePath = filediff.file;
+                        const filePath = filediff.file ? normalizePathForDisplay(filediff.file) : undefined;
                         const diff = state.metadata.diff;
                         if (filePath && diff) {
                             const fileData = prepareCodeFile(diff, filePath, "edit");
                             if (fileData && this.onToolFileCallback) {
-                                logger.debug(`[Aggregator] Sending edit file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
+                                logger.debug(`[Aggregator] Sending ${part.tool} file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
                                 this.onToolFileCallback(fileData);
                             }
                             // Notify about file change for pinned message
@@ -321,6 +361,47 @@ class SummaryAggregator {
                             }
                         }
                     }
+                    else if (part.tool === "apply_patch") {
+                        const metadata = state.metadata;
+                        const filePathFromInput = input && typeof input.filePath === "string"
+                            ? normalizePathForDisplay(input.filePath)
+                            : input && typeof input.path === "string"
+                                ? normalizePathForDisplay(input.path)
+                                : "";
+                        const filePathFromTitle = title ? extractFirstUpdatedFileFromTitle(title) : "";
+                        const filePath = (metadata?.filediff?.file && normalizePathForDisplay(metadata.filediff.file)) ||
+                            filePathFromInput ||
+                            normalizePathForDisplay(filePathFromTitle);
+                        const diffText = typeof metadata?.diff === "string"
+                            ? metadata.diff
+                            : input && typeof input.patchText === "string"
+                                ? input.patchText
+                                : "";
+                        if (filePath && diffText) {
+                            const fileData = prepareCodeFile(diffText, filePath, "edit");
+                            if (fileData && this.onToolFileCallback) {
+                                logger.debug(`[Aggregator] Sending apply_patch file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
+                                this.onToolFileCallback(fileData);
+                            }
+                        }
+                        if (filePath && this.onFileChangeCallback) {
+                            if (metadata?.filediff) {
+                                this.onFileChangeCallback({
+                                    file: filePath,
+                                    additions: metadata.filediff.additions || 0,
+                                    deletions: metadata.filediff.deletions || 0,
+                                });
+                            }
+                            else if (diffText) {
+                                const changes = countDiffChangesFromText(diffText);
+                                this.onFileChangeCallback({
+                                    file: filePath,
+                                    additions: changes.additions,
+                                    deletions: changes.deletions,
+                                });
+                            }
+                        }
+                    }
                 }
             }
         }