mattermost-claude-code 0.9.2 → 0.9.3

package/CHANGELOG.md

@@ -5,6 +5,18 @@ 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.3] - 2025-12-28
+
+### Fixed
+- **Major fix for session persistence** - completely rewrote session lifecycle management
+  - Sessions now correctly survive bot restarts (was broken in 0.9.0-0.9.2)
+  - `killAllSessions()` now explicitly preserves persistence instead of relying on exit event timing
+  - `killSession()` now takes an `unpersist` parameter to control persistence behavior
+  - `handleExit()` now only unpersists on graceful exits (code 0), not on errors
+  - Resumed sessions that fail are preserved for retry instead of being removed
+  - Added comprehensive debug logging to trace session lifecycle
+  - Race condition between shutdown and exit events eliminated
+
 ## [0.9.2] - 2025-12-28
 
 ### Fixed

package/dist/claude/session.d.ts

@@ -94,6 +94,8 @@ export declare class SessionManager {
     getSessionCount(): number;
     /** Get all active session thread IDs */
     getActiveThreadIds(): string[];
+    /** Mark that we're shutting down (prevents cleanup of persisted sessions) */
+    setShuttingDown(): void;
     /** Register a post for reaction routing */
     private registerPost;
     /** Find session by post ID (for reaction routing) */
@@ -138,7 +140,7 @@ export declare class SessionManager {
     /** Send a follow-up message to an existing session */
     sendFollowUp(threadId: string, message: string, files?: MattermostFile[]): Promise<void>;
     /** Kill a specific session */
-    killSession(threadId: string): void;
+    killSession(threadId: string, unpersist?: boolean): void;
     /** Cancel a session with user feedback */
     cancelSession(threadId: string, username: string): Promise<void>;
     /** Change working directory for a session (restarts Claude CLI) */

package/dist/claude/session.js

@@ -180,6 +180,8 @@ export class SessionManager {
      * Persist a session to disk
      */
     persistSession(session) {
+        const shortId = session.threadId.substring(0, 8);
+        console.log(`  [persist] Saving session ${shortId}...`);
         const state = {
             threadId: session.threadId,
             claudeSessionId: session.claudeSessionId,
@@ -195,19 +197,14 @@ 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)}...)`);
-        }
+        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}...`);
-        }
+        const shortId = threadId.substring(0, 8);
+        console.log(`  [persist] REMOVING session ${shortId}... (this should NOT happen during shutdown!)`);
         this.sessionStore.remove(threadId);
     }
     // ---------------------------------------------------------------------------
@@ -229,6 +226,11 @@ export class SessionManager {
     getActiveThreadIds() {
         return [...this.sessions.keys()];
     }
+    /** Mark that we're shutting down (prevents cleanup of persisted sessions) */
+    setShuttingDown() {
+        console.log('  [shutdown] Setting isShuttingDown = true');
+        this.isShuttingDown = true;
+    }
     /** Register a post for reaction routing */
     registerPost(postId, threadId) {
         this.postIndex.set(postId, threadId);
@@ -947,26 +949,52 @@ export class SessionManager {
     async handleExit(threadId, code) {
         const session = this.sessions.get(threadId);
         const shortId = threadId.substring(0, 8);
+        // Always log exit events to trace the flow
+        console.log(`  [exit] handleExit called for ${shortId}... code=${code} isShuttingDown=${this.isShuttingDown}`);
         if (!session) {
-            if (this.debug)
-                console.log(`  [exit] Session ${shortId}... not found (already cleaned up)`);
+            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`);
+            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)
+        // IMPORTANT: Check this flag FIRST before any cleanup. The session should remain
+        // persisted so it can be resumed after restart.
         if (this.isShuttingDown) {
-            if (this.debug)
-                console.log(`  [exit] Session ${shortId}... bot shutting down, preserving persistence`);
+            console.log(`  [exit] Session ${shortId}... bot shutting down, preserving persistence`);
+            // Still clean up from in-memory maps since we're shutting down anyway
+            this.stopTyping(session);
+            if (session.updateTimer) {
+                clearTimeout(session.updateTimer);
+                session.updateTimer = null;
+            }
+            this.sessions.delete(threadId);
             return;
         }
-        if (this.debug)
-            console.log(`  [exit] Session ${shortId}... exited with code ${code}, cleaning up`);
+        // For resumed sessions that exit quickly (e.g., Claude --resume fails),
+        // don't unpersist immediately - give it a chance to be retried
+        if (session.isResumed && code !== 0) {
+            console.log(`  [exit] Resumed session ${shortId}... failed with code ${code}, preserving for retry`);
+            this.stopTyping(session);
+            if (session.updateTimer) {
+                clearTimeout(session.updateTimer);
+                session.updateTimer = null;
+            }
+            this.sessions.delete(threadId);
+            // Post error message but keep persistence
+            try {
+                await this.mattermost.createPost(`⚠️ **Session resume failed** (exit code ${code}). The session data is preserved - try restarting the bot.`, session.threadId);
+            }
+            catch {
+                // Ignore if we can't post
+            }
+            return;
+        }
+        console.log(`  [exit] Session ${shortId}... normal exit, cleaning up`);
         this.stopTyping(session);
         if (session.updateTimer) {
             clearTimeout(session.updateTimer);
@@ -984,8 +1012,14 @@ export class SessionManager {
                 this.postIndex.delete(postId);
             }
         }
-        // Remove from persistence when session ends normally
-        this.unpersistSession(threadId);
+        // Only unpersist for normal exits (code 0 or null means graceful completion)
+        // Non-zero exits might be recoverable, so we keep the session persisted
+        if (code === 0 || code === null) {
+            this.unpersistSession(threadId);
+        }
+        else {
+            console.log(`  [exit] Session ${shortId}... non-zero exit, preserving for potential retry`);
+        }
         console.log(`  ■ Session ended (${shortId}…) — ${this.sessions.size} active`);
     }
     // ---------------------------------------------------------------------------
@@ -1011,10 +1045,16 @@ export class SessionManager {
         this.startTyping(session);
     }
     /** Kill a specific session */
-    killSession(threadId) {
+    killSession(threadId, unpersist = true) {
         const session = this.sessions.get(threadId);
         if (!session)
             return;
+        const shortId = threadId.substring(0, 8);
+        // Set restarting flag to prevent handleExit from also unpersisting
+        // (we'll do it explicitly here if requested)
+        if (!unpersist) {
+            session.isRestarting = true; // Reuse this flag to skip cleanup in handleExit
+        }
         this.stopTyping(session);
         session.claude.kill();
         // Clean up session from maps
@@ -1024,7 +1064,10 @@ export class SessionManager {
                 this.postIndex.delete(postId);
             }
         }
-        const shortId = threadId.substring(0, 8);
+        // Explicitly unpersist if requested (e.g., for timeout, cancel, etc.)
+        if (unpersist) {
+            this.unpersistSession(threadId);
+        }
         console.log(`  ✖ Session killed (${shortId}…) — ${this.sessions.size} active`);
     }
     /** Cancel a session with user feedback */
@@ -1274,13 +1317,16 @@ export class SessionManager {
     }
     /** Kill all active sessions (for graceful shutdown) */
     killAllSessions() {
-        // Set shutdown flag to suppress exit messages
+        console.log(`  [shutdown] killAllSessions called, isShuttingDown already=${this.isShuttingDown}`);
+        // Set shutdown flag to suppress exit messages (should already be true from setShuttingDown)
         this.isShuttingDown = true;
         const count = this.sessions.size;
-        for (const [, session] of this.sessions.entries()) {
-            this.stopTyping(session);
-            session.claude.kill();
+        console.log(`  [shutdown] About to kill ${count} session(s) (preserving persistence for resume)`);
+        // Kill each session WITHOUT unpersisting - we want them to resume after restart
+        for (const [threadId] of this.sessions.entries()) {
+            this.killSession(threadId, false); // false = don't unpersist
         }
+        // Maps should already be cleared by killSession, but clear again to be safe
         this.sessions.clear();
         this.postIndex.clear();
         if (this.cleanupTimer) {
@@ -1288,7 +1334,7 @@ export class SessionManager {
             this.cleanupTimer = null;
         }
         if (count > 0) {
-            console.log(`  ✖ Killed ${count} session${count === 1 ? '' : 's'}`);
+            console.log(`  ✖ Killed ${count} session${count === 1 ? '' : 's'} (sessions preserved for resume)`);
         }
     }
     /** Cleanup idle sessions that have exceeded timeout */

package/dist/index.js

@@ -211,6 +211,8 @@ async function main() {
         isShuttingDown = true;
         console.log('');
         console.log(`  👋 ${dim('Shutting down...')}`);
+        // Set shutdown flag FIRST to prevent race conditions with exit events
+        session.setShuttingDown();
         // Post shutdown message to active sessions
         const activeThreads = session.getActiveThreadIds();
         if (activeThreads.length > 0) {

package/package.json

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