zardbot-telegram 1.0.0

package/dist/pinned/manager.js

@@ -0,0 +1,682 @@
+import { logger } from "../utils/logger.js";
+import { opencodeClient } from "../opencode/client.js";
+import { getCurrentSession } from "../session/manager.js";
+import { getCurrentProject, getPinnedMessageId, setPinnedMessageId, clearPinnedMessageId, } from "../settings/manager.js";
+import { getStoredModel } from "../model/manager.js";
+import { getModelContextLimit } from "../model/context-limit.js";
+import { t } from "../i18n/index.js";
+import { DEFAULT_CONTEXT_LIMIT, formatContextLine, formatCostLine, formatModelDisplayName, } from "./format.js";
+class PinnedMessageManager {
+    api = null;
+    chatId = null;
+    state = {
+        messageId: null,
+        chatId: null,
+        sessionId: null,
+        sessionTitle: t("pinned.default_session_title"),
+        projectName: "",
+        tokensUsed: 0,
+        tokensLimit: 0,
+        lastUpdated: 0,
+        changedFiles: [],
+        cost: 0,
+    };
+    contextLimit = null;
+    onKeyboardUpdateCallback;
+    updateDebounceTimer = null;
+    updateTask = null;
+    pendingUpdate = false;
+    pendingForceUpdate = false;
+    lastRenderedMessageText = null;
+    /**
+     * Initialize manager with bot API and chat ID
+     */
+    initialize(api, chatId) {
+        this.api = api;
+        this.chatId = chatId;
+        // Restore pinned message ID from settings
+        const savedMessageId = getPinnedMessageId();
+        if (savedMessageId) {
+            this.state.messageId = savedMessageId;
+            this.state.chatId = chatId;
+        }
+    }
+    /**
+     * Called when session changes - create new pinned message
+     */
+    async onSessionChange(sessionId, sessionTitle) {
+        logger.info(`[PinnedManager] Session changed: ${sessionId}, title: ${sessionTitle}`);
+        // Reset tokens for new session
+        this.state.tokensUsed = 0;
+        this.state.cost = 0;
+        // Update state
+        this.state.sessionId = sessionId;
+        this.state.sessionTitle = sessionTitle || t("pinned.default_session_title");
+        const project = getCurrentProject();
+        this.state.projectName =
+            project?.name || this.extractProjectName(project?.worktree) || t("pinned.unknown");
+        // Fetch context limit for current model
+        await this.fetchContextLimit();
+        // Trigger keyboard update callback with reset context (0 tokens)
+        if (this.onKeyboardUpdateCallback && this.state.tokensLimit > 0) {
+            this.onKeyboardUpdateCallback(this.state.tokensUsed, this.state.tokensLimit);
+        }
+        // Reset changed files for new session
+        this.state.changedFiles = [];
+        this.lastRenderedMessageText = null;
+        this.pendingUpdate = false;
+        this.pendingForceUpdate = false;
+        // Unpin old message and create new one
+        await this.unpinOldMessage();
+        await this.createPinnedMessage();
+        // Load existing diffs from API (for session restoration)
+        await this.loadDiffsFromApi(sessionId);
+    }
+    /**
+     * Called when session title is updated (after first message)
+     */
+    async onSessionTitleUpdate(newTitle) {
+        if (this.state.sessionTitle !== newTitle && newTitle) {
+            logger.debug(`[PinnedManager] Session title updated: ${newTitle}`);
+            this.state.sessionTitle = newTitle;
+            await this.updatePinnedMessage();
+        }
+    }
+    /**
+     * Load context token usage from session history
+     */
+    async loadContextFromHistory(sessionId, directory) {
+        try {
+            logger.debug(`[PinnedManager] Loading context from history for session: ${sessionId}`);
+            const { data: messagesData, error } = await opencodeClient.session.messages({
+                sessionID: sessionId,
+                directory,
+            });
+            if (error || !messagesData) {
+                logger.warn("[PinnedManager] Failed to load session history:", error);
+                return;
+            }
+            // Get the maximum context size and total cost from session history
+            // Context = input + cache.read (cache.read contains previously cached context)
+            let maxContextSize = 0;
+            let totalCost = 0;
+            logger.debug(`[PinnedManager] Processing ${messagesData.length} messages from history`);
+            messagesData.forEach(({ info }) => {
+                if (info.role === "assistant") {
+                    const assistantInfo = info;
+                    // Skip summary messages (technical, not real agent responses)
+                    if (assistantInfo.summary) {
+                        logger.debug(`[PinnedManager] Skipping summary message`);
+                        return;
+                    }
+                    const input = assistantInfo.tokens?.input || 0;
+                    const cacheRead = assistantInfo.tokens?.cache?.read || 0;
+                    const contextSize = input + cacheRead;
+                    const cost = assistantInfo.cost || 0;
+                    logger.debug(`[PinnedManager] Assistant message: input=${input}, cache.read=${cacheRead}, total=${contextSize}, cost=$${cost.toFixed(2)}`);
+                    // Keep track of maximum context size (peak usage in session)
+                    if (contextSize > maxContextSize) {
+                        maxContextSize = contextSize;
+                    }
+                    // Accumulate total session cost
+                    totalCost += cost;
+                }
+            });
+            this.state.tokensUsed = maxContextSize;
+            this.state.cost = totalCost;
+            this.state.sessionId = sessionId;
+            logger.info(`[PinnedManager] Loaded context from history: ${this.state.tokensUsed} tokens, cost: $${this.state.cost.toFixed(2)}`);
+            await this.updatePinnedMessage();
+        }
+        catch (err) {
+            logger.error("[PinnedManager] Error loading context from history:", err);
+        }
+    }
+    /**
+     * Called when session is compacted - reload context from history
+     */
+    async onSessionCompacted(sessionId, directory) {
+        logger.info(`[PinnedManager] Session compacted, reloading context: ${sessionId}`);
+        // Reload context from updated history (after compaction)
+        await this.loadContextFromHistory(sessionId, directory);
+    }
+    /**
+     * Called when assistant message completes with token info
+     */
+    async onMessageComplete(tokens) {
+        // Ensure context limit is available even if session was restored
+        // without a fresh onSessionChange call (for example after /abort + continue).
+        if (this.getContextLimit() === 0) {
+            await this.fetchContextLimit();
+        }
+        // Context = input + cache.read (cache.read contains previously cached context)
+        // This represents the actual context window usage
+        this.state.tokensUsed = tokens.input + tokens.cacheRead;
+        logger.debug(`[PinnedManager] Tokens updated: ${this.state.tokensUsed}/${this.state.tokensLimit}`);
+        // Also fetch latest session title (it may have changed after first message)
+        await this.refreshSessionTitle();
+        await this.updatePinnedMessage();
+    }
+    /**
+     * Update tokens in memory without triggering an API call.
+     * Used for intermediate (non-completed) message.updated events
+     * to keep pinned state in sync with keyboardManager.
+     */
+    updateTokensSilent(tokens) {
+        this.state.tokensUsed = tokens.input + tokens.cacheRead;
+        logger.debug(`[PinnedManager] Tokens updated (silent): ${this.state.tokensUsed}/${this.state.tokensLimit}`);
+    }
+    /**
+     * Refresh the pinned message with current in-memory state.
+     * Used at thinking time to push accumulated silent updates to Telegram.
+     */
+    async refresh() {
+        await this.updatePinnedMessage(true);
+    }
+    /**
+     * Called when cost info is received from SSE events
+     */
+    async onCostUpdate(cost) {
+        if (!Number.isFinite(cost) || cost === 0) {
+            logger.debug("[PinnedManager] Ignoring non-impacting cost update");
+            return;
+        }
+        const currentCost = this.state.cost || 0;
+        this.state.cost = currentCost + cost;
+        logger.debug(`[PinnedManager] Cost added: $${cost.toFixed(2)}, total session: $${(this.state.cost || 0).toFixed(2)}`);
+        await this.updatePinnedMessage();
+    }
+    /**
+     * Set callback for keyboard updates when context changes
+     */
+    setOnKeyboardUpdate(callback) {
+        this.onKeyboardUpdateCallback = callback;
+        logger.debug("[PinnedManager] Keyboard update callback registered");
+        // Fire immediately with current state to fix race condition:
+        // onSessionChange may have already run before this callback was registered.
+        const limit = this.state.tokensLimit > 0 ? this.state.tokensLimit : this.contextLimit || 0;
+        if (limit > 0) {
+            callback(this.state.tokensUsed, limit);
+        }
+    }
+    /**
+     * Get current context information
+     */
+    getContextInfo() {
+        // Use cached contextLimit if tokensLimit is not set yet
+        const limit = this.state.tokensLimit > 0 ? this.state.tokensLimit : this.contextLimit || 0;
+        if (limit === 0) {
+            return null;
+        }
+        return {
+            tokensUsed: this.state.tokensUsed,
+            tokensLimit: limit,
+        };
+    }
+    /**
+     * Get context limit (for keyboard display when no session)
+     * Returns cached limit or 0 if not available
+     */
+    getContextLimit() {
+        return this.contextLimit || this.state.tokensLimit || 0;
+    }
+    /**
+     * Refresh context limit for current model (call after model change)
+     */
+    async refreshContextLimit() {
+        await this.fetchContextLimit();
+    }
+    /**
+     * Called when session.diff SSE event is received.
+     * Only overwrites if non-empty (API may return empty while tool events collected data).
+     */
+    async onSessionDiff(diffs) {
+        if (diffs.length === 0 && this.state.changedFiles.length > 0) {
+            logger.debug("[PinnedManager] Ignoring empty session.diff, keeping tool-collected data");
+            return;
+        }
+        if (this.areFileDiffsEqual(this.state.changedFiles, diffs)) {
+            logger.debug("[PinnedManager] Ignoring unchanged session.diff");
+            return;
+        }
+        this.state.changedFiles = diffs;
+        logger.debug(`[PinnedManager] Session diff updated: ${diffs.length} files`);
+        await this.updatePinnedMessage();
+    }
+    /**
+     * Called when a single file is changed (from tool events: edit/write)
+     */
+    addFileChange(change) {
+        const existing = this.state.changedFiles.find((f) => f.file === change.file);
+        if (existing) {
+            existing.additions += change.additions;
+            existing.deletions += change.deletions;
+        }
+        else {
+            this.state.changedFiles.push(change);
+        }
+        logger.debug(`[PinnedManager] File change added: ${change.file} (+${change.additions} -${change.deletions}), total: ${this.state.changedFiles.length}`);
+        // Schedule debounced update (avoid spamming Telegram API on rapid tool events)
+        this.scheduleDebouncedUpdate();
+    }
+    scheduleDebouncedUpdate() {
+        if (this.updateDebounceTimer) {
+            clearTimeout(this.updateDebounceTimer);
+        }
+        this.updateDebounceTimer = setTimeout(() => {
+            this.updateDebounceTimer = null;
+            void this.updatePinnedMessage();
+        }, 1000);
+    }
+    /**
+     * Load file diffs from API for current session.
+     * Tries session.diff() first, falls back to parsing session.messages() tool parts.
+     */
+    async loadDiffsFromApi(sessionId) {
+        try {
+            const project = getCurrentProject();
+            if (!project) {
+                logger.debug("[PinnedManager] loadDiffsFromApi: no project");
+                return;
+            }
+            logger.debug(`[PinnedManager] loadDiffsFromApi: trying session.diff() for ${sessionId}`);
+            // Try session.diff() API first
+            const { data, error } = await opencodeClient.session.diff({
+                sessionID: sessionId,
+                directory: project.worktree,
+            });
+            logger.debug(`[PinnedManager] session.diff() result: error=${!!error}, data.length=${data?.length ?? 0}`);
+            if (!error && data && data.length > 0) {
+                this.state.changedFiles = data.map((d) => ({
+                    file: d.file,
+                    additions: d.additions,
+                    deletions: d.deletions,
+                }));
+                logger.info(`[PinnedManager] Loaded ${this.state.changedFiles.length} file diffs from session.diff()`);
+                await this.updatePinnedMessage();
+                return;
+            }
+            // Fallback: parse tool parts from session messages
+            logger.debug("[PinnedManager] session.diff() empty, trying loadDiffsFromMessages()");
+            await this.loadDiffsFromMessages(sessionId, project.worktree);
+        }
+        catch (err) {
+            logger.debug("[PinnedManager] Could not load diffs from API:", err);
+        }
+    }
+    /**
+     * Fallback: extract file changes from session message tool parts
+     */
+    async loadDiffsFromMessages(sessionId, directory) {
+        try {
+            logger.debug(`[PinnedManager] loadDiffsFromMessages: fetching messages for ${sessionId}`);
+            const { data: messagesData, error } = await opencodeClient.session.messages({
+                sessionID: sessionId,
+                directory,
+            });
+            if (error || !messagesData) {
+                logger.debug(`[PinnedManager] loadDiffsFromMessages: error or no data`);
+                return;
+            }
+            logger.debug(`[PinnedManager] loadDiffsFromMessages: ${messagesData.length} messages`);
+            const filesMap = new Map();
+            let toolCount = 0;
+            let fileToolCount = 0;
+            for (const { parts } of messagesData) {
+                for (const part of parts) {
+                    if (part.type !== "tool")
+                        continue;
+                    toolCount++;
+                    const toolPart = part;
+                    if (toolPart.state.status !== "completed")
+                        continue;
+                    if (toolPart.tool === "edit" ||
+                        toolPart.tool === "write" ||
+                        toolPart.tool === "apply_patch") {
+                        fileToolCount++;
+                    }
+                    if ((toolPart.tool === "edit" || toolPart.tool === "apply_patch") &&
+                        toolPart.state.metadata &&
+                        "filediff" in toolPart.state.metadata) {
+                        const filediff = toolPart.state.metadata.filediff;
+                        if (filediff.file) {
+                            const existing = filesMap.get(filediff.file);
+                            if (existing) {
+                                existing.additions += filediff.additions || 0;
+                                existing.deletions += filediff.deletions || 0;
+                            }
+                            else {
+                                filesMap.set(filediff.file, {
+                                    file: filediff.file,
+                                    additions: filediff.additions || 0,
+                                    deletions: filediff.deletions || 0,
+                                });
+                            }
+                        }
+                    }
+                    else if (toolPart.tool === "write" &&
+                        toolPart.state.input &&
+                        "filePath" in toolPart.state.input &&
+                        "content" in toolPart.state.input) {
+                        const filePath = toolPart.state.input.filePath;
+                        const content = toolPart.state.input.content;
+                        const lines = content.split("\n").length;
+                        const existing = filesMap.get(filePath);
+                        if (existing) {
+                            existing.additions += lines;
+                        }
+                        else {
+                            filesMap.set(filePath, {
+                                file: filePath,
+                                additions: lines,
+                                deletions: 0,
+                            });
+                        }
+                    }
+                }
+            }
+            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`);
+                await this.updatePinnedMessage();
+            }
+            else {
+                logger.debug("[PinnedManager] loadDiffsFromMessages: no file changes found");
+            }
+        }
+        catch (err) {
+            logger.debug("[PinnedManager] Could not load diffs from messages:", err);
+        }
+    }
+    /**
+     * Refresh session title from API
+     */
+    async refreshSessionTitle() {
+        const session = getCurrentSession();
+        const project = getCurrentProject();
+        if (!session || !project) {
+            return;
+        }
+        try {
+            const { data: sessionData } = await opencodeClient.session.get({
+                sessionID: session.id,
+                directory: project.worktree,
+            });
+            if (sessionData && sessionData.title !== this.state.sessionTitle) {
+                this.state.sessionTitle = sessionData.title;
+                logger.debug(`[PinnedManager] Session title refreshed: ${sessionData.title}`);
+            }
+        }
+        catch (err) {
+            logger.debug("[PinnedManager] Could not refresh session title:", err);
+        }
+    }
+    /**
+     * Extract project name from worktree path
+     */
+    extractProjectName(worktree) {
+        if (!worktree)
+            return "";
+        // Get last part of path
+        const parts = worktree.replace(/\\/g, "/").split("/");
+        return parts[parts.length - 1] || "";
+    }
+    /**
+     * Make file path relative to project worktree
+     */
+    makeRelativePath(filePath) {
+        const normalized = filePath.replace(/\\/g, "/");
+        const project = getCurrentProject();
+        if (project?.worktree) {
+            const worktree = project.worktree.replace(/\\/g, "/");
+            if (normalized.startsWith(worktree)) {
+                // Remove worktree prefix and leading slash
+                let relative = normalized.slice(worktree.length);
+                if (relative.startsWith("/")) {
+                    relative = relative.slice(1);
+                }
+                return relative || normalized;
+            }
+        }
+        // Fallback: just show last 3 segments if path is still absolute
+        const segments = normalized.split("/");
+        if (segments.length <= 3)
+            return normalized;
+        return ".../" + segments.slice(-3).join("/");
+    }
+    areFileDiffsEqual(current, next) {
+        if (current.length !== next.length) {
+            return false;
+        }
+        for (let index = 0; index < current.length; index++) {
+            const left = current[index];
+            const right = next[index];
+            if (left.file !== right.file ||
+                left.additions !== right.additions ||
+                left.deletions !== right.deletions) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Fetch context limit from current model configuration
+     */
+    async fetchContextLimit() {
+        try {
+            const model = getStoredModel();
+            this.contextLimit = await getModelContextLimit(model.providerID, model.modelID);
+            this.state.tokensLimit = this.contextLimit;
+            logger.debug(`[PinnedManager] Context limit: ${this.contextLimit}`);
+        }
+        catch (err) {
+            logger.error("[PinnedManager] Error fetching context limit:", err);
+            this.contextLimit = DEFAULT_CONTEXT_LIMIT;
+            this.state.tokensLimit = this.contextLimit;
+        }
+    }
+    /**
+     * Format the pinned message text
+     */
+    formatMessage() {
+        const currentModel = getStoredModel();
+        const modelName = formatModelDisplayName(currentModel.providerID, currentModel.modelID);
+        const lines = [
+            `${this.state.sessionTitle}`,
+            t("pinned.line.project", { project: this.state.projectName }),
+            t("pinned.line.model", { model: modelName }),
+            formatContextLine(this.state.tokensUsed, this.state.tokensLimit),
+        ];
+        if (this.state.cost !== undefined && this.state.cost !== null) {
+            lines.push(formatCostLine(this.state.cost));
+        }
+        if (this.state.changedFiles.length > 0) {
+            const maxFiles = 10;
+            const total = this.state.changedFiles.length;
+            const filesToShow = this.state.changedFiles.slice(0, maxFiles);
+            lines.push("");
+            lines.push(t("pinned.files.title", { count: total }));
+            for (const f of filesToShow) {
+                const relativePath = this.makeRelativePath(f.file);
+                const parts = [];
+                if (f.additions > 0)
+                    parts.push(`+${f.additions}`);
+                if (f.deletions > 0)
+                    parts.push(`-${f.deletions}`);
+                const diffStr = parts.length > 0 ? ` (${parts.join(" ")})` : "";
+                lines.push(t("pinned.files.item", { path: relativePath, diff: diffStr }));
+            }
+            if (total > maxFiles) {
+                lines.push(t("pinned.files.more", { count: total - maxFiles }));
+            }
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Create and pin a new status message
+     */
+    async createPinnedMessage() {
+        if (!this.api || !this.chatId) {
+            logger.warn("[PinnedManager] API or chatId not initialized");
+            return;
+        }
+        try {
+            const text = this.formatMessage();
+            // Send new message
+            const sentMessage = await this.api.sendMessage(this.chatId, text);
+            this.state.messageId = sentMessage.message_id;
+            this.state.chatId = this.chatId;
+            this.state.lastUpdated = Date.now();
+            this.lastRenderedMessageText = text;
+            // Save to settings for persistence
+            setPinnedMessageId(sentMessage.message_id);
+            // Pin the message (silently)
+            await this.api.pinChatMessage(this.chatId, sentMessage.message_id, {
+                disable_notification: true,
+            });
+            logger.info(`[PinnedManager] Created and pinned message: ${sentMessage.message_id}`);
+        }
+        catch (err) {
+            logger.error("[PinnedManager] Error creating pinned message:", err);
+        }
+    }
+    /**
+     * Update existing pinned message text
+     */
+    async updatePinnedMessage(forceUpdate = false) {
+        if (!this.api || !this.chatId || !this.state.messageId) {
+            return;
+        }
+        this.pendingUpdate = true;
+        if (forceUpdate) {
+            this.pendingForceUpdate = true;
+        }
+        if (this.updateTask) {
+            await this.updateTask;
+            return;
+        }
+        this.updateTask = this.flushPendingPinnedUpdates().finally(() => {
+            this.updateTask = null;
+        });
+        await this.updateTask;
+    }
+    async flushPendingPinnedUpdates() {
+        while (this.pendingUpdate) {
+            this.pendingUpdate = false;
+            const shouldForceUpdate = this.pendingForceUpdate;
+            this.pendingForceUpdate = false;
+            if (!this.api || !this.chatId || !this.state.messageId) {
+                return;
+            }
+            const text = this.formatMessage();
+            if (!shouldForceUpdate && text === this.lastRenderedMessageText) {
+                logger.debug("[PinnedManager] Skipping pinned update: message content unchanged");
+                continue;
+            }
+            try {
+                await this.api.editMessageText(this.chatId, this.state.messageId, text);
+                this.state.lastUpdated = Date.now();
+                this.lastRenderedMessageText = text;
+                logger.debug(`[PinnedManager] Updated pinned message: ${this.state.messageId}`);
+                // Trigger keyboard update callback
+                if (this.onKeyboardUpdateCallback && this.state.tokensLimit > 0) {
+                    setImmediate(() => {
+                        this.onKeyboardUpdateCallback(this.state.tokensUsed, this.state.tokensLimit);
+                    });
+                }
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+                // Handle "message is not modified" error silently
+                if (errorMessage.includes("message is not modified")) {
+                    this.lastRenderedMessageText = text;
+                    continue;
+                }
+                // Handle "message to edit not found" - recreate
+                if (errorMessage.includes("message to edit not found")) {
+                    logger.warn("[PinnedManager] Pinned message was deleted, recreating...");
+                    this.state.messageId = null;
+                    this.lastRenderedMessageText = null;
+                    this.pendingForceUpdate = false;
+                    clearPinnedMessageId();
+                    await this.createPinnedMessage();
+                    continue;
+                }
+                logger.error("[PinnedManager] Error updating pinned message:", err);
+            }
+        }
+    }
+    /**
+     * Unpin old message before creating new one
+     */
+    async unpinOldMessage() {
+        if (!this.api || !this.chatId) {
+            return;
+        }
+        try {
+            // Unpin all messages (ensures clean state)
+            await this.api.unpinAllChatMessages(this.chatId).catch(() => { });
+            this.state.messageId = null;
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
+            clearPinnedMessageId();
+            logger.debug("[PinnedManager] Unpinned old messages");
+        }
+        catch (err) {
+            logger.error("[PinnedManager] Error unpinning messages:", err);
+        }
+    }
+    /**
+     * Get current state (for debugging/status)
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Check if manager is initialized
+     */
+    isInitialized() {
+        return this.api !== null && this.chatId !== null;
+    }
+    /**
+     * Clear pinned message (when switching projects)
+     */
+    async clear() {
+        if (!this.api || !this.chatId) {
+            // Just reset state if not initialized
+            this.state.messageId = null;
+            this.state.sessionId = null;
+            this.state.tokensUsed = 0;
+            this.state.tokensLimit = 0;
+            this.state.changedFiles = [];
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
+            clearPinnedMessageId();
+            return;
+        }
+        try {
+            // Unpin all messages
+            await this.api.unpinAllChatMessages(this.chatId).catch(() => { });
+            // Reset state
+            this.state.messageId = null;
+            this.state.sessionId = null;
+            this.state.sessionTitle = t("pinned.default_session_title");
+            this.state.projectName = "";
+            this.state.tokensUsed = 0;
+            this.state.tokensLimit = 0;
+            this.state.changedFiles = [];
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
+            clearPinnedMessageId();
+            logger.info("[PinnedManager] Cleared pinned message state");
+        }
+        catch (err) {
+            logger.error("[PinnedManager] Error clearing pinned message:", err);
+        }
+    }
+}
+export const pinnedMessageManager = new PinnedMessageManager();

package/dist/pinned/types.js

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