mattermost-claude-code 0.9.0 → 0.9.2

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.2] - 2025-12-28
+
+### Fixed
+- **Fix session persistence** - sessions were being incorrectly cleaned as "stale" on startup
+  - The `cleanStale()` call was removing sessions older than 30 minutes before attempting to resume
+  - Now sessions survive bot restarts regardless of how long the bot was down
+  - Added debug logging (`DEBUG=1`) to trace persistence operations
+- **Fix crash on Mattermost API errors** - bot no longer crashes when posts fail
+  - Added try-catch around message handler to prevent unhandled exceptions
+  - Added try-catch around reaction handler
+  - Graceful error handling when session start post fails (e.g., deleted thread)
+
+## [0.9.1] - 2025-12-28
+
+### Changed
+- Resume message now shows version: "Session resumed after bot restart (v0.9.1)"
+- Session header is updated with new version after resume
+
+### Fixed
+- Fix duplicate "Bot shutting down" messages when stopping bot
+- Fix "[Exited: null]" message appearing during graceful shutdown
+
 ## [0.9.0] - 2025-12-28
 
 ### Added

package/dist/claude/session.d.ts

@@ -67,6 +67,7 @@ export declare class SessionManager {
     private postIndex;
     private sessionStore;
     private cleanupTimer;
+    private isShuttingDown;
     constructor(mattermost: MattermostClient, workingDir: string, skipPermissions?: boolean);
     /**
      * Initialize session manager by resuming any persisted sessions.

package/dist/claude/session.js

@@ -37,13 +37,20 @@ export class SessionManager {
     sessionStore = new SessionStore();
     // Cleanup timer
     cleanupTimer = null;
+    // Shutdown flag to suppress exit messages during graceful shutdown
+    isShuttingDown = false;
     constructor(mattermost, workingDir, skipPermissions = false) {
         this.mattermost = mattermost;
         this.workingDir = workingDir;
         this.skipPermissions = skipPermissions;
         // Listen for reactions to answer questions
-        this.mattermost.on('reaction', (reaction, user) => {
-            this.handleReaction(reaction.post_id, reaction.emoji_name, user?.username || 'unknown');
+        this.mattermost.on('reaction', async (reaction, user) => {
+            try {
+                await this.handleReaction(reaction.post_id, reaction.emoji_name, user?.username || 'unknown');
+            }
+            catch (err) {
+                console.error('  ❌ Error handling reaction:', err);
+            }
         });
         // Start periodic cleanup of idle sessions
         this.cleanupTimer = setInterval(() => this.cleanupIdleSessions(), 60000);
@@ -56,13 +63,22 @@ export class SessionManager {
      * Should be called before starting to listen for new messages.
      */
     async initialize() {
-        // Clean up stale sessions first
-        const staleIds = this.sessionStore.cleanStale(SESSION_TIMEOUT_MS);
-        if (staleIds.length > 0) {
-            console.log(`  🧹 Cleaned ${staleIds.length} stale session(s)`);
-        }
-        // Load persisted sessions
+        // Load persisted sessions FIRST (before cleaning stale ones)
+        // This way we can resume sessions that were active when the bot stopped,
+        // even if the bot was down for longer than SESSION_TIMEOUT_MS
         const persisted = this.sessionStore.load();
+        if (this.debug) {
+            console.log(`  [persist] Found ${persisted.size} persisted session(s)`);
+            for (const [threadId, state] of persisted) {
+                const age = Date.now() - new Date(state.lastActivityAt).getTime();
+                const ageMins = Math.round(age / 60000);
+                console.log(`  [persist] - ${threadId.substring(0, 8)}... by @${state.startedBy}, age: ${ageMins}m`);
+            }
+        }
+        // Note: We intentionally do NOT clean stale sessions on startup anymore.
+        // Sessions are cleaned during normal operation by cleanupIdleSessions().
+        // This allows sessions to survive bot restarts even if the bot was down
+        // for longer than SESSION_TIMEOUT_MS.
         if (persisted.size === 0) {
             if (this.debug)
                 console.log('  [resume] No sessions to resume');
@@ -141,7 +157,7 @@ export class SessionManager {
             claude.start();
             console.log(`  🔄 Resumed session ${shortId}... (@${state.startedBy})`);
             // Post resume message
-            await this.mattermost.createPost(`🔄 **Session resumed** after bot restart\n*Reconnected to Claude session. You can continue where you left off.*`, state.threadId);
+            await this.mattermost.createPost(`🔄 **Session resumed** after bot restart (v${pkg.version})\n*Reconnected to Claude session. You can continue where you left off.*`, state.threadId);
             // Update session header
             await this.updateSessionHeader(session);
             // Update persistence with new activity time
@@ -179,11 +195,19 @@ export class SessionManager {
             planApproved: session.planApproved,
         };
         this.sessionStore.save(session.threadId, state);
+        if (this.debug) {
+            const shortId = session.threadId.substring(0, 8);
+            console.log(`  [persist] Saved session ${shortId}... (claudeId: ${session.claudeSessionId.substring(0, 8)}...)`);
+        }
     }
     /**
      * Remove a session from persistence
      */
     unpersistSession(threadId) {
+        if (this.debug) {
+            const shortId = threadId.substring(0, 8);
+            console.log(`  [persist] Removing session ${shortId}...`);
+        }
         this.sessionStore.remove(threadId);
     }
     // ---------------------------------------------------------------------------
@@ -246,7 +270,15 @@ export class SessionManager {
             return;
         }
         // Post initial session message (will be updated by updateSessionHeader)
-        const post = await this.mattermost.createPost(`### 🤖 mm-claude \`v${pkg.version}\`\n\n*Starting session...*`, replyToPostId);
+        let post;
+        try {
+            post = await this.mattermost.createPost(`### 🤖 mm-claude \`v${pkg.version}\`\n\n*Starting session...*`, replyToPostId);
+        }
+        catch (err) {
+            console.error(`  ❌ Failed to create session post:`, err);
+            // If we can't post to the thread, we can't start a session
+            return;
+        }
         const actualThreadId = replyToPostId || post.id;
         // Generate a unique session ID for this Claude session
         const claudeSessionId = randomUUID();
@@ -914,20 +946,34 @@ export class SessionManager {
     }
     async handleExit(threadId, code) {
         const session = this.sessions.get(threadId);
-        if (!session)
+        const shortId = threadId.substring(0, 8);
+        if (!session) {
+            if (this.debug)
+                console.log(`  [exit] Session ${shortId}... not found (already cleaned up)`);
             return;
+        }
         // If we're intentionally restarting (e.g., !cd), don't clean up or post exit message
         if (session.isRestarting) {
+            if (this.debug)
+                console.log(`  [exit] Session ${shortId}... restarting, skipping cleanup`);
             session.isRestarting = false; // Reset flag here, after the exit event fires
             return;
         }
+        // If bot is shutting down, suppress exit messages (shutdown message already sent)
+        if (this.isShuttingDown) {
+            if (this.debug)
+                console.log(`  [exit] Session ${shortId}... bot shutting down, preserving persistence`);
+            return;
+        }
+        if (this.debug)
+            console.log(`  [exit] Session ${shortId}... exited with code ${code}, cleaning up`);
         this.stopTyping(session);
         if (session.updateTimer) {
             clearTimeout(session.updateTimer);
             session.updateTimer = null;
         }
         await this.flush(session);
-        if (code !== 0) {
+        if (code !== 0 && code !== null) {
             await this.mattermost.createPost(`**[Exited: ${code}]**`, session.threadId);
         }
         // Clean up session from maps
@@ -940,7 +986,6 @@ export class SessionManager {
         }
         // Remove from persistence when session ends normally
         this.unpersistSession(threadId);
-        const shortId = threadId.substring(0, 8);
         console.log(`  ■ Session ended (${shortId}…) — ${this.sessions.size} active`);
     }
     // ---------------------------------------------------------------------------
@@ -1229,6 +1274,8 @@ export class SessionManager {
     }
     /** Kill all active sessions (for graceful shutdown) */
     killAllSessions() {
+        // Set shutdown flag to suppress exit messages
+        this.isShuttingDown = true;
         const count = this.sessions.size;
         for (const [, session] of this.sessions.entries()) {
             this.stopTyping(session);

package/dist/index.js

@@ -72,116 +72,129 @@ async function main() {
     const mattermost = new MattermostClient(config);
     const session = new SessionManager(mattermost, workingDir, config.skipPermissions);
     mattermost.on('message', async (post, user) => {
-        const username = user?.username || 'unknown';
-        const message = post.message;
-        const threadRoot = post.root_id || post.id;
-        // Follow-up in active thread
-        if (session.isInSessionThread(threadRoot)) {
-            // If message starts with @mention to someone else, ignore it (side conversation)
-            // Note: Mattermost usernames can contain letters, numbers, hyphens, periods, and underscores
-            const mentionMatch = message.trim().match(/^@([\w.-]+)/);
-            if (mentionMatch && mentionMatch[1].toLowerCase() !== mattermost.getBotName().toLowerCase()) {
-                return; // Side conversation, don't interrupt
-            }
-            const content = mattermost.isBotMentioned(message)
-                ? mattermost.extractPrompt(message)
-                : message.trim();
-            const lowerContent = content.toLowerCase();
-            // Check for stop/cancel commands (only from allowed users)
-            // Note: Using ! prefix instead of / to avoid Mattermost slash command interception
-            if (lowerContent === '!stop' || lowerContent === 'stop' ||
-                lowerContent === '!cancel' || lowerContent === 'cancel') {
-                if (session.isUserAllowedInSession(threadRoot, username)) {
-                    await session.cancelSession(threadRoot, username);
+        try {
+            const username = user?.username || 'unknown';
+            const message = post.message;
+            const threadRoot = post.root_id || post.id;
+            // Follow-up in active thread
+            if (session.isInSessionThread(threadRoot)) {
+                // If message starts with @mention to someone else, ignore it (side conversation)
+                // Note: Mattermost usernames can contain letters, numbers, hyphens, periods, and underscores
+                const mentionMatch = message.trim().match(/^@([\w.-]+)/);
+                if (mentionMatch && mentionMatch[1].toLowerCase() !== mattermost.getBotName().toLowerCase()) {
+                    return; // Side conversation, don't interrupt
                 }
-                return;
-            }
-            // Check for !help command
-            if (lowerContent === '!help' || lowerContent === 'help') {
-                await mattermost.createPost(`**Available commands:**\n\n` +
-                    `| Command | Description |\n` +
-                    `|:--------|:------------|\n` +
-                    `| \`!help\` | Show this help message |\n` +
-                    `| \`!release-notes\` | Show release notes for current version |\n` +
-                    `| \`!cd <path>\` | Change working directory (restarts Claude) |\n` +
-                    `| \`!invite @user\` | Invite a user to this session |\n` +
-                    `| \`!kick @user\` | Remove an invited user |\n` +
-                    `| \`!permissions interactive\` | Enable interactive permissions |\n` +
-                    `| \`!stop\` | Stop this session |\n\n` +
-                    `**Reactions:**\n` +
-                    `- 👍 Approve action · ✅ Approve all · 👎 Deny\n` +
-                    `- ❌ or 🛑 on any message to stop session`, threadRoot);
-                return;
-            }
-            // Check for !release-notes command
-            if (lowerContent === '!release-notes' || lowerContent === '!changelog') {
-                const notes = getReleaseNotes(pkg.version);
-                if (notes) {
-                    await mattermost.createPost(formatReleaseNotes(notes), threadRoot);
+                const content = mattermost.isBotMentioned(message)
+                    ? mattermost.extractPrompt(message)
+                    : message.trim();
+                const lowerContent = content.toLowerCase();
+                // Check for stop/cancel commands (only from allowed users)
+                // Note: Using ! prefix instead of / to avoid Mattermost slash command interception
+                if (lowerContent === '!stop' || lowerContent === 'stop' ||
+                    lowerContent === '!cancel' || lowerContent === 'cancel') {
+                    if (session.isUserAllowedInSession(threadRoot, username)) {
+                        await session.cancelSession(threadRoot, username);
+                    }
+                    return;
                 }
-                else {
-                    await mattermost.createPost(`📋 **mm-claude v${pkg.version}**\n\nRelease notes not available. See [GitHub releases](https://github.com/anneschuth/mattermost-claude-code/releases).`, threadRoot);
+                // Check for !help command
+                if (lowerContent === '!help' || lowerContent === 'help') {
+                    await mattermost.createPost(`**Available commands:**\n\n` +
+                        `| Command | Description |\n` +
+                        `|:--------|:------------|\n` +
+                        `| \`!help\` | Show this help message |\n` +
+                        `| \`!release-notes\` | Show release notes for current version |\n` +
+                        `| \`!cd <path>\` | Change working directory (restarts Claude) |\n` +
+                        `| \`!invite @user\` | Invite a user to this session |\n` +
+                        `| \`!kick @user\` | Remove an invited user |\n` +
+                        `| \`!permissions interactive\` | Enable interactive permissions |\n` +
+                        `| \`!stop\` | Stop this session |\n\n` +
+                        `**Reactions:**\n` +
+                        `- 👍 Approve action · ✅ Approve all · 👎 Deny\n` +
+                        `- ❌ or 🛑 on any message to stop session`, threadRoot);
+                    return;
                 }
-                return;
-            }
-            // Check for !invite command
-            const inviteMatch = content.match(/^!invite\s+@?([\w.-]+)/i);
-            if (inviteMatch) {
-                await session.inviteUser(threadRoot, inviteMatch[1], username);
-                return;
-            }
-            // Check for !kick command
-            const kickMatch = content.match(/^!kick\s+@?([\w.-]+)/i);
-            if (kickMatch) {
-                await session.kickUser(threadRoot, kickMatch[1], username);
-                return;
-            }
-            // Check for !permissions command
-            const permMatch = content.match(/^!permissions?\s+(interactive|auto)/i);
-            if (permMatch) {
-                const mode = permMatch[1].toLowerCase();
-                if (mode === 'interactive') {
-                    await session.enableInteractivePermissions(threadRoot, username);
+                // Check for !release-notes command
+                if (lowerContent === '!release-notes' || lowerContent === '!changelog') {
+                    const notes = getReleaseNotes(pkg.version);
+                    if (notes) {
+                        await mattermost.createPost(formatReleaseNotes(notes), threadRoot);
+                    }
+                    else {
+                        await mattermost.createPost(`📋 **mm-claude v${pkg.version}**\n\nRelease notes not available. See [GitHub releases](https://github.com/anneschuth/mattermost-claude-code/releases).`, threadRoot);
+                    }
+                    return;
+                }
+                // Check for !invite command
+                const inviteMatch = content.match(/^!invite\s+@?([\w.-]+)/i);
+                if (inviteMatch) {
+                    await session.inviteUser(threadRoot, inviteMatch[1], username);
+                    return;
+                }
+                // Check for !kick command
+                const kickMatch = content.match(/^!kick\s+@?([\w.-]+)/i);
+                if (kickMatch) {
+                    await session.kickUser(threadRoot, kickMatch[1], username);
+                    return;
                 }
-                else {
-                    // Can't upgrade to auto - that would be less secure
-                    await mattermost.createPost(`⚠️ Cannot upgrade to auto permissions - can only downgrade to interactive`, threadRoot);
+                // Check for !permissions command
+                const permMatch = content.match(/^!permissions?\s+(interactive|auto)/i);
+                if (permMatch) {
+                    const mode = permMatch[1].toLowerCase();
+                    if (mode === 'interactive') {
+                        await session.enableInteractivePermissions(threadRoot, username);
+                    }
+                    else {
+                        // Can't upgrade to auto - that would be less secure
+                        await mattermost.createPost(`⚠️ Cannot upgrade to auto permissions - can only downgrade to interactive`, threadRoot);
+                    }
+                    return;
                 }
+                // Check for !cd command
+                const cdMatch = content.match(/^!cd\s+(.+)/i);
+                if (cdMatch) {
+                    await session.changeDirectory(threadRoot, cdMatch[1].trim(), username);
+                    return;
+                }
+                // Check if user is allowed in this session
+                if (!session.isUserAllowedInSession(threadRoot, username)) {
+                    // Request approval for their message
+                    if (content)
+                        await session.requestMessageApproval(threadRoot, username, content);
+                    return;
+                }
+                // Get any attached files (images)
+                const files = post.metadata?.files;
+                if (content || files?.length)
+                    await session.sendFollowUp(threadRoot, content, files);
                 return;
             }
-            // Check for !cd command
-            const cdMatch = content.match(/^!cd\s+(.+)/i);
-            if (cdMatch) {
-                await session.changeDirectory(threadRoot, cdMatch[1].trim(), username);
+            // New session requires @mention
+            if (!mattermost.isBotMentioned(message))
                 return;
-            }
-            // Check if user is allowed in this session
-            if (!session.isUserAllowedInSession(threadRoot, username)) {
-                // Request approval for their message
-                if (content)
-                    await session.requestMessageApproval(threadRoot, username, content);
+            if (!mattermost.isUserAllowed(username)) {
+                await mattermost.createPost(`⚠️ @${username} is not authorized`, threadRoot);
                 return;
             }
-            // Get any attached files (images)
+            const prompt = mattermost.extractPrompt(message);
             const files = post.metadata?.files;
-            if (content || files?.length)
-                await session.sendFollowUp(threadRoot, content, files);
-            return;
-        }
-        // New session requires @mention
-        if (!mattermost.isBotMentioned(message))
-            return;
-        if (!mattermost.isUserAllowed(username)) {
-            await mattermost.createPost(`⚠️ @${username} is not authorized`, threadRoot);
-            return;
+            if (!prompt && !files?.length) {
+                await mattermost.createPost(`Mention me with your request`, threadRoot);
+                return;
+            }
+            await session.startSession({ prompt, files }, username, threadRoot);
         }
-        const prompt = mattermost.extractPrompt(message);
-        const files = post.metadata?.files;
-        if (!prompt && !files?.length) {
-            await mattermost.createPost(`Mention me with your request`, threadRoot);
-            return;
+        catch (err) {
+            console.error('  ❌ Error handling message:', err);
+            // Try to notify user if possible
+            try {
+                const threadRoot = post.root_id || post.id;
+                await mattermost.createPost(`⚠️ An error occurred. Please try again.`, threadRoot);
+            }
+            catch {
+                // Ignore if we can't post the error message
+            }
         }
-        await session.startSession({ prompt, files }, username, threadRoot);
     });
     mattermost.on('connected', () => { });
     mattermost.on('error', (e) => console.error('  ❌ Error:', e));
@@ -190,7 +203,12 @@ async function main() {
     await session.initialize();
     console.log(`  ✅ ${bold('Ready!')} Waiting for @${config.mattermost.botName} mentions...`);
     console.log('');
+    let isShuttingDown = false;
     const shutdown = async () => {
+        // Guard against multiple shutdown calls (SIGINT + SIGTERM)
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
         console.log('');
         console.log(`  👋 ${dim('Shutting down...')}`);
         // Post shutdown message to active sessions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mattermost-claude-code",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",