mattermost-claude-code 0.2.3 → 0.3.0

package/dist/claude/session.d.ts

@@ -1,19 +1,63 @@
+import { ClaudeCli } from './cli.js';
 import { MattermostClient } from '../mattermost/client.js';
+interface QuestionOption {
+    label: string;
+    description: string;
+}
+interface PendingQuestionSet {
+    toolUseId: string;
+    currentIndex: number;
+    currentPostId: string | null;
+    questions: Array<{
+        header: string;
+        question: string;
+        options: QuestionOption[];
+        answer: string | null;
+    }>;
+}
+interface PendingApproval {
+    postId: string;
+    type: 'plan' | 'action';
+}
+/**
+ * Represents a single Claude Code session tied to a Mattermost thread.
+ * Each session has its own Claude CLI process and state.
+ */
+interface Session {
+    threadId: string;
+    startedBy: string;
+    startedAt: Date;
+    lastActivityAt: Date;
+    claude: ClaudeCli;
+    currentPostId: string | null;
+    pendingContent: string;
+    pendingApproval: PendingApproval | null;
+    pendingQuestionSet: PendingQuestionSet | null;
+    planApproved: boolean;
+    tasksPostId: string | null;
+    activeSubagents: Map<string, string>;
+    updateTimer: ReturnType<typeof setTimeout> | null;
+    typingTimer: ReturnType<typeof setInterval> | null;
+}
 export declare class SessionManager {
-    private claude;
     private mattermost;
     private workingDir;
     private skipPermissions;
-    private session;
-    private updateTimer;
-    private typingTimer;
-    private pendingQuestionSet;
-    private pendingApproval;
-    private planApproved;
-    private tasksPostId;
-    private activeSubagents;
     private debug;
+    private sessions;
+    private postIndex;
+    private cleanupTimer;
     constructor(mattermost: MattermostClient, workingDir: string, skipPermissions?: boolean);
+    /** Get a session by thread ID */
+    getSession(threadId: string): Session | undefined;
+    /** Check if a session exists for this thread */
+    hasSession(threadId: string): boolean;
+    /** Get the number of active sessions */
+    getSessionCount(): number;
+    /** Register a post for reaction routing */
+    private registerPost;
+    /** Find session by post ID (for reaction routing) */
+    private getSessionByPost;
     startSession(options: {
         prompt: string;
     }, username: string, replyToPostId?: string): Promise<void>;
@@ -25,6 +69,7 @@ export declare class SessionManager {
     private handleAskUserQuestion;
     private postCurrentQuestion;
     private handleReaction;
+    private handleQuestionReaction;
     private handleApprovalReaction;
     private formatEvent;
     private formatToolUse;
@@ -34,8 +79,17 @@ export declare class SessionManager {
     private stopTyping;
     private flush;
     private handleExit;
+    /** Check if any sessions are active */
     isSessionActive(): boolean;
-    isInCurrentSessionThread(threadRoot: string): boolean;
-    sendFollowUp(message: string): Promise<void>;
-    killSession(): void;
+    /** Check if a session exists for this thread */
+    isInSessionThread(threadRoot: string): boolean;
+    /** Send a follow-up message to an existing session */
+    sendFollowUp(threadId: string, message: string): Promise<void>;
+    /** Kill a specific session */
+    killSession(threadId: string): void;
+    /** Kill all active sessions (for graceful shutdown) */
+    killAllSessions(): void;
+    /** Cleanup idle sessions that have exceeded timeout */
+    private cleanupIdleSessions;
 }
+export {};

package/dist/claude/session.js

@@ -6,20 +6,25 @@ const EMOJI_TO_INDEX = {
     'three': 2, '3️⃣': 2,
     'four': 3, '4️⃣': 3,
 };
+// =============================================================================
+// Configuration
+// =============================================================================
+const MAX_SESSIONS = parseInt(process.env.MAX_SESSIONS || '5', 10);
+const SESSION_TIMEOUT_MS = parseInt(process.env.SESSION_TIMEOUT_MS || '1800000', 10); // 30 min
+// =============================================================================
+// SessionManager - Manages multiple concurrent Claude Code sessions
+// =============================================================================
 export class SessionManager {
-    claude = null;
+    // Shared state
     mattermost;
     workingDir;
     skipPermissions;
-    session = null;
-    updateTimer = null;
-    typingTimer = null;
-    pendingQuestionSet = null;
-    pendingApproval = null;
-    planApproved = false; // Track if we already approved this session
-    tasksPostId = null; // Track the tasks display post
-    activeSubagents = new Map(); // taskId -> postId for subagent status
     debug = process.env.DEBUG === '1' || process.argv.includes('--debug');
+    // Multi-session storage
+    sessions = new Map(); // threadId -> Session
+    postIndex = new Map(); // postId -> threadId (for reaction routing)
+    // Cleanup timer
+    cleanupTimer = null;
     constructor(mattermost, workingDir, skipPermissions = false) {
         this.mattermost = mattermost;
         this.workingDir = workingDir;
@@ -28,41 +33,103 @@ export class SessionManager {
         this.mattermost.on('reaction', (reaction, user) => {
             this.handleReaction(reaction.post_id, reaction.emoji_name, user?.username || 'unknown');
         });
+        // Start periodic cleanup of idle sessions
+        this.cleanupTimer = setInterval(() => this.cleanupIdleSessions(), 60000);
     }
+    // ---------------------------------------------------------------------------
+    // Session Lookup Methods
+    // ---------------------------------------------------------------------------
+    /** Get a session by thread ID */
+    getSession(threadId) {
+        return this.sessions.get(threadId);
+    }
+    /** Check if a session exists for this thread */
+    hasSession(threadId) {
+        return this.sessions.has(threadId);
+    }
+    /** Get the number of active sessions */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+    /** Register a post for reaction routing */
+    registerPost(postId, threadId) {
+        this.postIndex.set(postId, threadId);
+    }
+    /** Find session by post ID (for reaction routing) */
+    getSessionByPost(postId) {
+        const threadId = this.postIndex.get(postId);
+        return threadId ? this.sessions.get(threadId) : undefined;
+    }
+    // ---------------------------------------------------------------------------
+    // Session Lifecycle
+    // ---------------------------------------------------------------------------
     async startSession(options, username, replyToPostId) {
-        // Start Claude if not running
-        if (!this.claude?.isRunning()) {
-            const msg = `🚀 **Session started**\n> Working directory: \`${this.workingDir}\``;
-            const post = await this.mattermost.createPost(msg, replyToPostId);
-            const threadId = replyToPostId || post.id;
-            this.session = { threadId, postId: null, content: '' };
-            this.planApproved = false; // Reset for new session
-            this.tasksPostId = null; // Reset tasks display
-            this.activeSubagents.clear(); // Clear subagent tracking
-            // Create Claude CLI with options (including threadId for permissions)
-            const cliOptions = {
-                workingDir: this.workingDir,
-                threadId: threadId,
-                skipPermissions: this.skipPermissions,
-            };
-            this.claude = new ClaudeCli(cliOptions);
-            this.claude.on('event', (e) => this.handleEvent(e));
-            this.claude.on('exit', (code) => this.handleExit(code));
-            try {
-                this.claude.start();
-            }
-            catch (err) {
-                console.error('[Session] Start error:', err);
-                await this.mattermost.createPost(`❌ ${err}`, threadId);
-                this.session = null;
-                return;
-            }
+        const threadId = replyToPostId || '';
+        // Check if session already exists for this thread
+        const existingSession = this.sessions.get(threadId);
+        if (existingSession && existingSession.claude.isRunning()) {
+            // Send as follow-up instead
+            await this.sendFollowUp(threadId, options.prompt);
+            return;
+        }
+        // Check max sessions limit
+        if (this.sessions.size >= MAX_SESSIONS) {
+            await this.mattermost.createPost(`⚠️ **Too busy** - ${this.sessions.size} sessions active. Please try again later.`, replyToPostId);
+            return;
+        }
+        // Post session start message
+        const msg = `🚀 **Session started**\n> Working directory: \`${this.workingDir}\``;
+        const post = await this.mattermost.createPost(msg, replyToPostId);
+        const actualThreadId = replyToPostId || post.id;
+        // Create Claude CLI with options
+        const cliOptions = {
+            workingDir: this.workingDir,
+            threadId: actualThreadId,
+            skipPermissions: this.skipPermissions,
+        };
+        const claude = new ClaudeCli(cliOptions);
+        // Create the session object
+        const session = {
+            threadId: actualThreadId,
+            startedBy: username,
+            startedAt: new Date(),
+            lastActivityAt: new Date(),
+            claude,
+            currentPostId: null,
+            pendingContent: '',
+            pendingApproval: null,
+            pendingQuestionSet: null,
+            planApproved: false,
+            tasksPostId: null,
+            activeSubagents: new Map(),
+            updateTimer: null,
+            typingTimer: null,
+        };
+        // Register session
+        this.sessions.set(actualThreadId, session);
+        console.log(`[Sessions] Started session for thread ${actualThreadId} by ${username} (active: ${this.sessions.size})`);
+        // Bind event handlers with closure over threadId
+        claude.on('event', (e) => this.handleEvent(actualThreadId, e));
+        claude.on('exit', (code) => this.handleExit(actualThreadId, code));
+        try {
+            claude.start();
+        }
+        catch (err) {
+            console.error('[Session] Start error:', err);
+            await this.mattermost.createPost(`❌ ${err}`, actualThreadId);
+            this.sessions.delete(actualThreadId);
+            return;
         }
         // Send the message and start typing indicator
-        this.claude.sendMessage(options.prompt);
-        this.startTyping();
+        claude.sendMessage(options.prompt);
+        this.startTyping(session);
     }
-    handleEvent(event) {
+    handleEvent(threadId, event) {
+        const session = this.sessions.get(threadId);
+        if (!session)
+            return;
+        // Update last activity
+        session.lastActivityAt = new Date();
         // Check for special tool uses that need custom handling
         if (event.type === 'assistant') {
             const msg = event.message;
@@ -70,24 +137,21 @@ export class SessionManager {
             for (const block of msg?.content || []) {
                 if (block.type === 'tool_use') {
                     if (block.name === 'ExitPlanMode') {
-                        this.handleExitPlanMode();
+                        this.handleExitPlanMode(session);
                         hasSpecialTool = true;
                     }
                     else if (block.name === 'TodoWrite') {
-                        this.handleTodoWrite(block.input);
-                        // Don't set hasSpecialTool - let other content through
+                        this.handleTodoWrite(session, block.input);
                     }
                     else if (block.name === 'Task') {
-                        this.handleTaskStart(block.id, block.input);
-                        // Don't set hasSpecialTool - let other content through
+                        this.handleTaskStart(session, block.id, block.input);
                     }
                     else if (block.name === 'AskUserQuestion') {
-                        this.handleAskUserQuestion(block.id, block.input);
+                        this.handleAskUserQuestion(session, block.id, block.input);
                         hasSpecialTool = true;
                     }
                 }
             }
-            // Skip normal output if we handled a special tool (we post it ourselves)
             if (hasSpecialTool)
                 return;
         }
@@ -96,58 +160,58 @@ export class SessionManager {
             const msg = event.message;
             for (const block of msg?.content || []) {
                 if (block.type === 'tool_result' && block.tool_use_id) {
-                    const postId = this.activeSubagents.get(block.tool_use_id);
+                    const postId = session.activeSubagents.get(block.tool_use_id);
                     if (postId) {
-                        this.handleTaskComplete(block.tool_use_id, postId);
+                        this.handleTaskComplete(session, block.tool_use_id, postId);
                     }
                 }
             }
         }
-        const formatted = this.formatEvent(event);
+        const formatted = this.formatEvent(session, event);
         if (this.debug) {
-            console.log(`[DEBUG] handleEvent: ${event.type} -> ${formatted ? formatted.substring(0, 100) : '(null)'}`);
+            console.log(`[DEBUG] handleEvent(${threadId}): ${event.type} -> ${formatted ? formatted.substring(0, 100) : '(null)'}`);
         }
         if (formatted)
-            this.appendContent(formatted);
+            this.appendContent(session, formatted);
     }
-    async handleTaskComplete(toolUseId, postId) {
+    async handleTaskComplete(session, toolUseId, postId) {
         try {
-            await this.mattermost.updatePost(postId, this.activeSubagents.has(toolUseId)
+            await this.mattermost.updatePost(postId, session.activeSubagents.has(toolUseId)
                 ? `🤖 **Subagent** ✅ *completed*`
                 : `🤖 **Subagent** ✅`);
-            this.activeSubagents.delete(toolUseId);
+            session.activeSubagents.delete(toolUseId);
         }
         catch (err) {
             console.error('[Session] Failed to update subagent completion:', err);
         }
     }
-    async handleExitPlanMode() {
-        if (!this.session)
-            return;
+    async handleExitPlanMode(session) {
         // If already approved in this session, auto-continue
-        if (this.planApproved) {
+        if (session.planApproved) {
             console.log('[Session] Plan already approved, auto-continuing...');
-            if (this.claude?.isRunning()) {
-                this.claude.sendMessage('Continue with the implementation.');
-                this.startTyping();
+            if (session.claude.isRunning()) {
+                session.claude.sendMessage('Continue with the implementation.');
+                this.startTyping(session);
             }
             return;
         }
         // If we already have a pending approval, don't post another one
-        if (this.pendingApproval && this.pendingApproval.type === 'plan') {
+        if (session.pendingApproval && session.pendingApproval.type === 'plan') {
             console.log('[Session] Plan approval already pending, waiting...');
             return;
         }
         // Flush any pending content first
-        await this.flush();
-        this.session.postId = null;
-        this.session.content = '';
+        await this.flush(session);
+        session.currentPostId = null;
+        session.pendingContent = '';
         // Post approval message with reactions
         const message = `✅ **Plan ready for approval**\n\n` +
             `👍 Approve and start building\n` +
             `👎 Request changes\n\n` +
             `*React to respond*`;
-        const post = await this.mattermost.createPost(message, this.session.threadId);
+        const post = await this.mattermost.createPost(message, session.threadId);
+        // Register post for reaction routing
+        this.registerPost(post.id, session.threadId);
         // Add approval reactions
         try {
             await this.mattermost.addReaction(post.id, '+1');
@@ -157,19 +221,17 @@ export class SessionManager {
             console.error('[Session] Failed to add approval reactions:', err);
         }
         // Track this for reaction handling
-        this.pendingApproval = { postId: post.id, type: 'plan' };
+        session.pendingApproval = { postId: post.id, type: 'plan' };
         // Stop typing while waiting
-        this.stopTyping();
+        this.stopTyping(session);
     }
-    async handleTodoWrite(input) {
-        if (!this.session)
-            return;
+    async handleTodoWrite(session, input) {
         const todos = input.todos;
         if (!todos || todos.length === 0) {
             // Clear tasks display if empty
-            if (this.tasksPostId) {
+            if (session.tasksPostId) {
                 try {
-                    await this.mattermost.updatePost(this.tasksPostId, '📋 ~~Tasks~~ *(completed)*');
+                    await this.mattermost.updatePost(session.tasksPostId, '📋 ~~Tasks~~ *(completed)*');
                 }
                 catch (err) {
                     console.error('[Session] Failed to update tasks:', err);
@@ -199,21 +261,19 @@ export class SessionManager {
         }
         // Update or create tasks post
         try {
-            if (this.tasksPostId) {
-                await this.mattermost.updatePost(this.tasksPostId, message);
+            if (session.tasksPostId) {
+                await this.mattermost.updatePost(session.tasksPostId, message);
             }
             else {
-                const post = await this.mattermost.createPost(message, this.session.threadId);
-                this.tasksPostId = post.id;
+                const post = await this.mattermost.createPost(message, session.threadId);
+                session.tasksPostId = post.id;
             }
         }
         catch (err) {
             console.error('[Session] Failed to update tasks:', err);
         }
     }
-    async handleTaskStart(toolUseId, input) {
-        if (!this.session)
-            return;
+    async handleTaskStart(session, toolUseId, input) {
         const description = input.description || 'Working...';
         const subagentType = input.subagent_type || 'general';
         // Post subagent status
@@ -221,30 +281,28 @@ export class SessionManager {
             `> ${description}\n` +
             `⏳ Running...`;
         try {
-            const post = await this.mattermost.createPost(message, this.session.threadId);
-            this.activeSubagents.set(toolUseId, post.id);
+            const post = await this.mattermost.createPost(message, session.threadId);
+            session.activeSubagents.set(toolUseId, post.id);
         }
         catch (err) {
             console.error('[Session] Failed to post subagent status:', err);
         }
     }
-    async handleAskUserQuestion(toolUseId, input) {
-        if (!this.session)
-            return;
+    async handleAskUserQuestion(session, toolUseId, input) {
         // If we already have pending questions, don't start another set
-        if (this.pendingQuestionSet) {
+        if (session.pendingQuestionSet) {
             console.log('[Session] Questions already pending, waiting...');
             return;
         }
         // Flush any pending content first
-        await this.flush();
-        this.session.postId = null;
-        this.session.content = '';
+        await this.flush(session);
+        session.currentPostId = null;
+        session.pendingContent = '';
         const questions = input.questions;
         if (!questions || questions.length === 0)
             return;
         // Create a new question set - we'll ask one at a time
-        this.pendingQuestionSet = {
+        session.pendingQuestionSet = {
             toolUseId,
             currentIndex: 0,
             currentPostId: null,
@@ -256,19 +314,19 @@ export class SessionManager {
             })),
         };
         // Post the first question
-        await this.postCurrentQuestion();
+        await this.postCurrentQuestion(session);
         // Stop typing while waiting for answer
-        this.stopTyping();
+        this.stopTyping(session);
     }
-    async postCurrentQuestion() {
-        if (!this.session || !this.pendingQuestionSet)
+    async postCurrentQuestion(session) {
+        if (!session.pendingQuestionSet)
             return;
-        const { currentIndex, questions } = this.pendingQuestionSet;
+        const { currentIndex, questions } = session.pendingQuestionSet;
         if (currentIndex >= questions.length)
             return;
         const q = questions[currentIndex];
         const total = questions.length;
-        // Format the question message - show "Question (1/3)" not the header
+        // Format the question message
         let message = `❓ **Question** *(${currentIndex + 1}/${total})*\n`;
         message += `**${q.header}:** ${q.question}\n\n`;
         for (let i = 0; i < q.options.length && i < 4; i++) {
@@ -280,8 +338,10 @@ export class SessionManager {
             message += '\n';
         }
         // Post the question
-        const post = await this.mattermost.createPost(message, this.session.threadId);
-        this.pendingQuestionSet.currentPostId = post.id;
+        const post = await this.mattermost.createPost(message, session.threadId);
+        session.pendingQuestionSet.currentPostId = post.id;
+        // Register post for reaction routing
+        this.registerPost(post.id, session.threadId);
         // Add reaction emojis
         for (let i = 0; i < q.options.length && i < 4; i++) {
             try {
@@ -292,19 +352,32 @@ export class SessionManager {
             }
         }
     }
+    // ---------------------------------------------------------------------------
+    // Reaction Handling
+    // ---------------------------------------------------------------------------
     async handleReaction(postId, emojiName, username) {
         // Check if user is allowed
         if (!this.mattermost.isUserAllowed(username))
             return;
+        // Find the session this post belongs to
+        const session = this.getSessionByPost(postId);
+        if (!session)
+            return;
         // Handle approval reactions
-        if (this.pendingApproval && this.pendingApproval.postId === postId) {
-            await this.handleApprovalReaction(emojiName, username);
+        if (session.pendingApproval && session.pendingApproval.postId === postId) {
+            await this.handleApprovalReaction(session, emojiName, username);
             return;
         }
-        // Handle question reactions - must be for current question
-        if (!this.pendingQuestionSet || this.pendingQuestionSet.currentPostId !== postId)
+        // Handle question reactions
+        if (session.pendingQuestionSet && session.pendingQuestionSet.currentPostId === postId) {
+            await this.handleQuestionReaction(session, postId, emojiName, username);
             return;
-        const { currentIndex, questions } = this.pendingQuestionSet;
+        }
+    }
+    async handleQuestionReaction(session, postId, emojiName, username) {
+        if (!session.pendingQuestionSet)
+            return;
+        const { currentIndex, questions } = session.pendingQuestionSet;
         const question = questions[currentIndex];
         if (!question)
             return;
@@ -322,35 +395,34 @@ export class SessionManager {
             console.error('[Session] Failed to update answered question:', err);
         }
         // Move to next question or finish
-        this.pendingQuestionSet.currentIndex++;
-        if (this.pendingQuestionSet.currentIndex < questions.length) {
+        session.pendingQuestionSet.currentIndex++;
+        if (session.pendingQuestionSet.currentIndex < questions.length) {
             // Post next question
-            await this.postCurrentQuestion();
+            await this.postCurrentQuestion(session);
         }
         else {
             // All questions answered - send as follow-up message
-            // (CLI auto-responds with error to AskUserQuestion, so tool_result won't work)
             let answersText = 'Here are my answers:\n';
             for (const q of questions) {
                 answersText += `- **${q.header}**: ${q.answer}\n`;
             }
             console.log(`[Session] All questions answered, sending as message:`, answersText);
             // Clear and send as regular message
-            this.pendingQuestionSet = null;
-            if (this.claude?.isRunning()) {
-                this.claude.sendMessage(answersText);
-                this.startTyping();
+            session.pendingQuestionSet = null;
+            if (session.claude.isRunning()) {
+                session.claude.sendMessage(answersText);
+                this.startTyping(session);
             }
         }
     }
-    async handleApprovalReaction(emojiName, username) {
-        if (!this.pendingApproval)
+    async handleApprovalReaction(session, emojiName, username) {
+        if (!session.pendingApproval)
             return;
         const isApprove = emojiName === '+1' || emojiName === 'thumbsup';
         const isReject = emojiName === '-1' || emojiName === 'thumbsdown';
         if (!isApprove && !isReject)
             return;
-        const postId = this.pendingApproval.postId;
+        const postId = session.pendingApproval.postId;
         console.log(`[Session] User ${username} ${isApprove ? 'approved' : 'rejected'} the plan`);
         // Update the post to show the decision
         try {
@@ -363,20 +435,20 @@ export class SessionManager {
             console.error('[Session] Failed to update approval post:', err);
         }
         // Clear pending approval and mark as approved
-        this.pendingApproval = null;
+        session.pendingApproval = null;
         if (isApprove) {
-            this.planApproved = true;
+            session.planApproved = true;
         }
         // Send response to Claude
-        if (this.claude?.isRunning()) {
+        if (session.claude.isRunning()) {
             const response = isApprove
                 ? 'Approved. Please proceed with the implementation.'
                 : 'Please revise the plan. I would like some changes.';
-            this.claude.sendMessage(response);
-            this.startTyping();
+            session.claude.sendMessage(response);
+            this.startTyping(session);
         }
     }
-    formatEvent(e) {
+    formatEvent(session, e) {
         switch (e.type) {
             case 'assistant': {
                 const msg = e.message;
@@ -415,12 +487,10 @@ export class SessionManager {
             }
             case 'result': {
                 // Response complete - stop typing and start new post for next message
-                this.stopTyping();
-                if (this.session) {
-                    this.flush();
-                    this.session.postId = null;
-                    this.session.content = '';
-                }
+                this.stopTyping(session);
+                this.flush(session);
+                session.currentPostId = null;
+                session.pendingContent = '';
                 return null;
             }
             case 'system':
@@ -508,75 +578,134 @@ export class SessionManager {
             }
         }
     }
-    appendContent(text) {
-        if (!this.session || !text)
+    appendContent(session, text) {
+        if (!text)
             return;
-        this.session.content += text + '\n';
-        this.scheduleUpdate();
+        session.pendingContent += text + '\n';
+        this.scheduleUpdate(session);
     }
-    scheduleUpdate() {
-        if (this.updateTimer)
+    scheduleUpdate(session) {
+        if (session.updateTimer)
             return;
-        this.updateTimer = setTimeout(() => {
-            this.updateTimer = null;
-            this.flush();
+        session.updateTimer = setTimeout(() => {
+            session.updateTimer = null;
+            this.flush(session);
         }, 500);
     }
-    startTyping() {
-        if (this.typingTimer)
+    startTyping(session) {
+        if (session.typingTimer)
             return;
         // Send typing immediately, then every 3 seconds
-        this.mattermost.sendTyping(this.session?.threadId);
-        this.typingTimer = setInterval(() => {
-            this.mattermost.sendTyping(this.session?.threadId);
+        this.mattermost.sendTyping(session.threadId);
+        session.typingTimer = setInterval(() => {
+            this.mattermost.sendTyping(session.threadId);
         }, 3000);
     }
-    stopTyping() {
-        if (this.typingTimer) {
-            clearInterval(this.typingTimer);
-            this.typingTimer = null;
+    stopTyping(session) {
+        if (session.typingTimer) {
+            clearInterval(session.typingTimer);
+            session.typingTimer = null;
         }
     }
-    async flush() {
-        if (!this.session || !this.session.content.trim())
+    async flush(session) {
+        if (!session.pendingContent.trim())
             return;
-        const content = this.session.content.replace(/\n{3,}/g, '\n\n').trim();
-        if (this.session.postId) {
-            await this.mattermost.updatePost(this.session.postId, content);
+        const content = session.pendingContent.replace(/\n{3,}/g, '\n\n').trim();
+        if (session.currentPostId) {
+            await this.mattermost.updatePost(session.currentPostId, content);
         }
         else {
-            const post = await this.mattermost.createPost(content, this.session.threadId);
-            this.session.postId = post.id;
+            const post = await this.mattermost.createPost(content, session.threadId);
+            session.currentPostId = post.id;
+            // Register post for reaction routing
+            this.registerPost(post.id, session.threadId);
         }
     }
-    async handleExit(code) {
-        this.stopTyping();
-        if (this.updateTimer) {
-            clearTimeout(this.updateTimer);
-            this.updateTimer = null;
-        }
-        await this.flush();
-        if (code !== 0 && this.session) {
-            await this.mattermost.createPost(`**[Exited: ${code}]**`, this.session.threadId);
+    async handleExit(threadId, code) {
+        const session = this.sessions.get(threadId);
+        if (!session)
+            return;
+        this.stopTyping(session);
+        if (session.updateTimer) {
+            clearTimeout(session.updateTimer);
+            session.updateTimer = null;
+        }
+        await this.flush(session);
+        if (code !== 0) {
+            await this.mattermost.createPost(`**[Exited: ${code}]**`, session.threadId);
+        }
+        // Clean up session from maps
+        this.sessions.delete(threadId);
+        // Clean up post index entries for this session
+        for (const [postId, tid] of this.postIndex.entries()) {
+            if (tid === threadId) {
+                this.postIndex.delete(postId);
+            }
         }
-        this.session = null;
+        console.log(`[Sessions] Session ended for thread ${threadId} (remaining: ${this.sessions.size})`);
     }
+    // ---------------------------------------------------------------------------
+    // Public Session API
+    // ---------------------------------------------------------------------------
+    /** Check if any sessions are active */
     isSessionActive() {
-        return this.session !== null;
+        return this.sessions.size > 0;
     }
-    isInCurrentSessionThread(threadRoot) {
-        return this.session?.threadId === threadRoot;
+    /** Check if a session exists for this thread */
+    isInSessionThread(threadRoot) {
+        const session = this.sessions.get(threadRoot);
+        return session !== undefined && session.claude.isRunning();
+    }
+    /** Send a follow-up message to an existing session */
+    async sendFollowUp(threadId, message) {
+        const session = this.sessions.get(threadId);
+        if (!session || !session.claude.isRunning())
+            return;
+        session.claude.sendMessage(message);
+        session.lastActivityAt = new Date();
+        this.startTyping(session);
     }
-    async sendFollowUp(message) {
-        if (!this.claude?.isRunning() || !this.session)
+    /** Kill a specific session */
+    killSession(threadId) {
+        const session = this.sessions.get(threadId);
+        if (!session)
             return;
-        this.claude.sendMessage(message);
-        this.startTyping();
+        this.stopTyping(session);
+        session.claude.kill();
+        // Clean up session from maps
+        this.sessions.delete(threadId);
+        for (const [postId, tid] of this.postIndex.entries()) {
+            if (tid === threadId) {
+                this.postIndex.delete(postId);
+            }
+        }
+        console.log(`[Sessions] Session killed for thread ${threadId} (remaining: ${this.sessions.size})`);
+    }
+    /** Kill all active sessions (for graceful shutdown) */
+    killAllSessions() {
+        for (const [threadId, session] of this.sessions.entries()) {
+            this.stopTyping(session);
+            session.claude.kill();
+            console.log(`[Sessions] Killed session for thread ${threadId}`);
+        }
+        this.sessions.clear();
+        this.postIndex.clear();
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        console.log(`[Sessions] All sessions killed`);
     }
-    killSession() {
-        this.stopTyping();
-        this.claude?.kill();
-        this.claude = null;
-        this.session = null;
+    /** Cleanup idle sessions that have exceeded timeout */
+    cleanupIdleSessions() {
+        const now = Date.now();
+        for (const [threadId, session] of this.sessions.entries()) {
+            const idleTime = now - session.lastActivityAt.getTime();
+            if (idleTime > SESSION_TIMEOUT_MS) {
+                console.log(`[Sessions] Session ${threadId} timed out after ${Math.round(idleTime / 60000)} minutes`);
+                this.mattermost.createPost(`⏰ **Session timed out** - no activity for ${Math.round(idleTime / 60000)} minutes`, session.threadId).catch(err => console.error('[Sessions] Failed to post timeout message:', err));
+                this.killSession(threadId);
+            }
+        }
     }
 }

package/dist/index.js

@@ -36,14 +36,14 @@ Usage: cd /your/project && mm-claude`);
         const message = post.message;
         const threadRoot = post.root_id || post.id;
         // Follow-up in active thread
-        if (session.isInCurrentSessionThread(threadRoot)) {
+        if (session.isInSessionThread(threadRoot)) {
             if (!mattermost.isUserAllowed(username))
                 return;
             const content = mattermost.isBotMentioned(message)
                 ? mattermost.extractPrompt(message)
                 : message.trim();
             if (content)
-                await session.sendFollowUp(content);
+                await session.sendFollowUp(threadRoot, content);
             return;
         }
         // New session requires @mention
@@ -66,7 +66,7 @@ Usage: cd /your/project && mm-claude`);
     console.log(`🎉 Ready! @${config.mattermost.botName}`);
     const shutdown = () => {
         console.log('\n👋 Bye');
-        session.killSession();
+        session.killAllSessions();
         mattermost.disconnect();
         process.exit(0);
     };

package/package.json

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