mattermost-claude-code 0.10.1 → 0.10.3

package/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.10.3] - 2025-12-28
+
+### Changed
+- **Improved task list UX**
+  - Progress indicator: `📋 **Tasks** (2/5 · 40%)`
+  - Elapsed time for in-progress tasks: `🔄 **Running tests...** (45s)`
+  - Better pending icon: `○` instead of `⬜` (no longer overlaps)
+- **Tool output now shows elapsed time**
+  - Long-running tools (≥3s) show completion time: `↳ ✓ (12s)`
+  - Errors also show timing: `↳ ❌ Error (5s)`
+
+### Fixed
+- **Paused sessions now resume on new message** - messages to paused sessions were being ignored
+  - After ⏸️ interrupt, sending a new message in the thread now resumes the session
+  - Previously messages without @mention were ignored because the session was removed from memory
+  - Added `hasPausedSession()`, `resumePausedSession()`, and `getPersistedSession()` methods
+
+## [0.10.2] - 2025-12-28
+
+### Changed
+- Version number now displays directly after "mm-claude" in the logo instead of on a separate line
+
+### Fixed
+- **Interrupt (⏸️) no longer kills session** - sessions now pause and can be resumed
+  - Previously SIGINT caused Claude CLI to exit and the session was lost
+  - Now session is preserved and user can send a new message to continue
+  - Works with both ⏸️ reaction and `!escape`/`!interrupt` commands
+- **Filter `<thinking>` tags from output** - Claude's internal thinking is no longer shown to users
+  - Previously `<thinking>...</thinking>` tags would appear literally in Mattermost messages
+
 ## [0.10.1] - 2025-12-28
 
 ### Fixed

package/dist/claude/session.d.ts

@@ -1,6 +1,7 @@
 import { ClaudeCli } from './cli.js';
 import { MattermostClient } from '../mattermost/client.js';
 import { MattermostFile } from '../mattermost/types.js';
+import { PersistedSession } from '../persistence/session-store.js';
 interface QuestionOption {
     label: string;
     description: string;
@@ -58,6 +59,9 @@ interface Session {
     timeoutWarningPosted: boolean;
     isRestarting: boolean;
     isResumed: boolean;
+    wasInterrupted: boolean;
+    inProgressTaskStart: number | null;
+    activeToolStarts: Map<string, number>;
 }
 export declare class SessionManager {
     private mattermost;
@@ -140,6 +144,20 @@ export declare class SessionManager {
     isInSessionThread(threadRoot: string): boolean;
     /** Send a follow-up message to an existing session */
     sendFollowUp(threadId: string, message: string, files?: MattermostFile[]): Promise<void>;
+    /**
+     * Check if there's a paused (persisted but not active) session for this thread.
+     * This is used to detect when we should resume a session instead of ignoring the message.
+     */
+    hasPausedSession(threadId: string): boolean;
+    /**
+     * Resume a paused session and send a message to it.
+     * Called when a user sends a message to a thread with a paused session.
+     */
+    resumePausedSession(threadId: string, message: string, files?: MattermostFile[]): Promise<void>;
+    /**
+     * Get persisted session info for access control checks
+     */
+    getPersistedSession(threadId: string): PersistedSession | undefined;
     /** Kill a specific session */
     killSession(threadId: string, unpersist?: boolean): void;
     /** Cancel a session with user feedback */

package/dist/claude/session.js

@@ -2,7 +2,7 @@ import { ClaudeCli } from './cli.js';
 import { getUpdateInfo } from '../update-notifier.js';
 import { getReleaseNotes, getWhatsNewSummary } from '../changelog.js';
 import { SessionStore } from '../persistence/session-store.js';
-import { MATTERMOST_LOGO } from '../logo.js';
+import { getMattermostLogo } from '../logo.js';
 import { randomUUID } from 'crypto';
 import { readFileSync } from 'fs';
 import { dirname, resolve } from 'path';
@@ -145,6 +145,9 @@ export class SessionManager {
             timeoutWarningPosted: false,
             isRestarting: false,
             isResumed: true,
+            wasInterrupted: false,
+            inProgressTaskStart: null,
+            activeToolStarts: new Map(),
         };
         // Register session
         this.sessions.set(state.threadId, session);
@@ -275,7 +278,7 @@ export class SessionManager {
         // Post initial session message (will be updated by updateSessionHeader)
         let post;
         try {
-            post = await this.mattermost.createPost(`${MATTERMOST_LOGO}\n**v${pkg.version}**\n\n*Starting session...*`, replyToPostId);
+            post = await this.mattermost.createPost(`${getMattermostLogo(pkg.version)}\n\n*Starting session...*`, replyToPostId);
         }
         catch (err) {
             console.error(`  ❌ Failed to create session post:`, err);
@@ -320,6 +323,9 @@ export class SessionManager {
             timeoutWarningPosted: false,
             isRestarting: false,
             isResumed: false,
+            wasInterrupted: false,
+            inProgressTaskStart: null,
+            activeToolStarts: new Map(),
         };
         // Register session
         this.sessions.set(actualThreadId, session);
@@ -467,8 +473,20 @@ export class SessionManager {
             }
             return;
         }
-        // Format tasks nicely
-        let message = '📋 **Tasks**\n\n';
+        // Count progress
+        const completed = todos.filter(t => t.status === 'completed').length;
+        const total = todos.length;
+        const pct = Math.round((completed / total) * 100);
+        // Check if there's an in_progress task and track timing
+        const hasInProgress = todos.some(t => t.status === 'in_progress');
+        if (hasInProgress && !session.inProgressTaskStart) {
+            session.inProgressTaskStart = Date.now();
+        }
+        else if (!hasInProgress) {
+            session.inProgressTaskStart = null;
+        }
+        // Format tasks nicely with progress header
+        let message = `📋 **Tasks** (${completed}/${total} · ${pct}%)\n\n`;
         for (const todo of todos) {
             let icon;
             let text;
@@ -477,12 +495,21 @@ export class SessionManager {
                     icon = '✅';
                     text = `~~${todo.content}~~`;
                     break;
-                case 'in_progress':
+                case 'in_progress': {
                     icon = '🔄';
-                    text = `**${todo.activeForm}**`;
+                    // Add elapsed time if we have a start time
+                    let elapsed = '';
+                    if (session.inProgressTaskStart) {
+                        const secs = Math.round((Date.now() - session.inProgressTaskStart) / 1000);
+                        if (secs >= 5) { // Only show if >= 5 seconds
+                            elapsed = ` (${secs}s)`;
+                        }
+                    }
+                    text = `**${todo.activeForm}**${elapsed}`;
                     break;
+                }
                 default: // pending
-                    icon = '⬜';
+                    icon = '○';
                     text = todo.content;
             }
             message += `${icon} ${text}\n`;
@@ -743,7 +770,10 @@ export class SessionManager {
                 const parts = [];
                 for (const block of msg?.content || []) {
                     if (block.type === 'text' && block.text) {
-                        parts.push(block.text);
+                        // Filter out <thinking> tags that may appear in text content
+                        const text = block.text.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
+                        if (text)
+                            parts.push(text);
                     }
                     else if (block.type === 'tool_use' && block.name) {
                         const formatted = this.formatToolUse(block.name, block.input || {});
@@ -765,12 +795,30 @@ export class SessionManager {
             }
             case 'tool_use': {
                 const tool = e.tool_use;
+                // Track tool start time for elapsed display
+                if (tool.id) {
+                    session.activeToolStarts.set(tool.id, Date.now());
+                }
                 return this.formatToolUse(tool.name, tool.input || {}) || null;
             }
             case 'tool_result': {
                 const result = e.tool_result;
+                // Calculate elapsed time
+                let elapsed = '';
+                if (result.tool_use_id) {
+                    const startTime = session.activeToolStarts.get(result.tool_use_id);
+                    if (startTime) {
+                        const secs = Math.round((Date.now() - startTime) / 1000);
+                        if (secs >= 3) { // Only show if >= 3 seconds
+                            elapsed = ` (${secs}s)`;
+                        }
+                        session.activeToolStarts.delete(result.tool_use_id);
+                    }
+                }
                 if (result.is_error)
-                    return `  ↳ ❌ Error`;
+                    return `  ↳ ❌ Error${elapsed}`;
+                if (elapsed)
+                    return `  ↳ ✓${elapsed}`;
                 return null;
             }
             case 'result': {
@@ -987,6 +1035,34 @@ export class SessionManager {
             this.sessions.delete(threadId);
             return;
         }
+        // If session was interrupted (SIGINT sent), preserve for resume
+        // Claude CLI exits on SIGINT, but we want to allow resuming the session
+        if (session.wasInterrupted) {
+            console.log(`  [exit] Session ${shortId}... exited after interrupt, preserving for resume`);
+            this.stopTyping(session);
+            if (session.updateTimer) {
+                clearTimeout(session.updateTimer);
+                session.updateTimer = null;
+            }
+            // Update persistence with current state before cleanup
+            this.persistSession(session);
+            this.sessions.delete(threadId);
+            // Clean up post index
+            for (const [postId, tid] of this.postIndex.entries()) {
+                if (tid === threadId) {
+                    this.postIndex.delete(postId);
+                }
+            }
+            // Notify user they can send a new message to resume
+            try {
+                await this.mattermost.createPost(`ℹ️ Session paused. Send a new message to continue.`, session.threadId);
+            }
+            catch {
+                // Ignore if we can't post
+            }
+            console.log(`  ⏸️ Session paused (${shortId}…) — ${this.sessions.size} active`);
+            return;
+        }
         // 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) {
@@ -1056,6 +1132,52 @@ export class SessionManager {
         session.lastActivityAt = new Date();
         this.startTyping(session);
     }
+    /**
+     * Check if there's a paused (persisted but not active) session for this thread.
+     * This is used to detect when we should resume a session instead of ignoring the message.
+     */
+    hasPausedSession(threadId) {
+        // If there's an active session, it's not paused
+        if (this.sessions.has(threadId))
+            return false;
+        // Check persistence
+        const persisted = this.sessionStore.load();
+        return persisted.has(threadId);
+    }
+    /**
+     * Resume a paused session and send a message to it.
+     * Called when a user sends a message to a thread with a paused session.
+     */
+    async resumePausedSession(threadId, message, files) {
+        const persisted = this.sessionStore.load();
+        const state = persisted.get(threadId);
+        if (!state) {
+            console.log(`  [resume] No persisted session found for ${threadId.substring(0, 8)}...`);
+            return;
+        }
+        const shortId = threadId.substring(0, 8);
+        console.log(`  🔄 Resuming paused session ${shortId}... for new message`);
+        // Resume the session (similar to initialize() but for a single session)
+        await this.resumeSession(state);
+        // Wait a moment for the session to be ready, then send the message
+        const session = this.sessions.get(threadId);
+        if (session && session.claude.isRunning()) {
+            const content = await this.buildMessageContent(message, files);
+            session.claude.sendMessage(content);
+            session.lastActivityAt = new Date();
+            this.startTyping(session);
+        }
+        else {
+            console.log(`  ⚠️ Failed to resume session ${shortId}..., could not send message`);
+        }
+    }
+    /**
+     * Get persisted session info for access control checks
+     */
+    getPersistedSession(threadId) {
+        const persisted = this.sessionStore.load();
+        return persisted.get(threadId);
+    }
     /** Kill a specific session */
     killSession(threadId, unpersist = true) {
         const session = this.sessions.get(threadId);
@@ -1102,10 +1224,12 @@ export class SessionManager {
             return;
         }
         const shortId = threadId.substring(0, 8);
+        // Set flag BEFORE interrupt - if Claude exits due to SIGINT, we won't unpersist
+        session.wasInterrupted = true;
         const interrupted = session.claude.interrupt();
         if (interrupted) {
             console.log(`  ⏸️ Session (${shortId}…) interrupted by @${username}`);
-            await this.mattermost.createPost(`⏸️ **Interrupted** by @${username} — session still active, you can continue`, threadId);
+            await this.mattermost.createPost(`⏸️ **Interrupted** by @${username}`, threadId);
         }
     }
     /** Change working directory for a session (restarts Claude CLI) */
@@ -1301,8 +1425,7 @@ export class SessionManager {
         const whatsNew = releaseNotes ? getWhatsNewSummary(releaseNotes) : '';
         const whatsNewLine = whatsNew ? `\n> ✨ **What's new:** ${whatsNew}\n` : '';
         const msg = [
-            MATTERMOST_LOGO,
-            `**v${pkg.version}**`,
+            getMattermostLogo(pkg.version),
             updateNotice,
             whatsNewLine,
             `| | |`,

package/dist/index.js

@@ -201,6 +201,33 @@ async function main() {
                     await session.sendFollowUp(threadRoot, content, files);
                 return;
             }
+            // Check for paused session that can be resumed
+            if (session.hasPausedSession(threadRoot)) {
+                // If message starts with @mention to someone else, ignore it (side conversation)
+                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();
+                // Check if user is allowed in the paused session
+                const persistedSession = session.getPersistedSession(threadRoot);
+                if (persistedSession) {
+                    const allowedUsers = new Set(persistedSession.sessionAllowedUsers);
+                    if (!allowedUsers.has(username) && !mattermost.isUserAllowed(username)) {
+                        // Not allowed - could request approval but that would require the session to be active
+                        await mattermost.createPost(`⚠️ @${username} is not authorized to resume this session`, threadRoot);
+                        return;
+                    }
+                }
+                // Get any attached files (images)
+                const files = post.metadata?.files;
+                if (content || files?.length) {
+                    await session.resumePausedSession(threadRoot, content, files);
+                }
+                return;
+            }
             // New session requires @mention
             if (!mattermost.isBotMentioned(message))
                 return;

package/dist/logo.d.ts

@@ -10,8 +10,13 @@
 export declare const CLI_LOGO: string;
 /**
  * ASCII logo for Mattermost (plain text, no ANSI codes)
+ * Use getMattermostLogo(version) instead to include version
  */
 export declare const MATTERMOST_LOGO = "```\n \u2734 \u2590\u2588\u2599 \u259F\u2588\u258C \u2734   mm-claude\n\u2734  \u2590\u2588\u2590\u2588\u258C\u2588\u258C  \u2734  Mattermost \u00D7 Claude Code\n \u2734 \u2590\u2588\u258C \u2590\u2588\u258C \u2734\n```";
+/**
+ * Get ASCII logo for Mattermost with version included
+ */
+export declare function getMattermostLogo(version: string): string;
 /**
  * Compact inline logo for Mattermost headers
  */

package/dist/logo.js

@@ -24,12 +24,23 @@ ${colors.orange}✴${colors.reset}  ${colors.blue}▐█▐█▌█▌${colors.
 `;
 /**
  * ASCII logo for Mattermost (plain text, no ANSI codes)
+ * Use getMattermostLogo(version) instead to include version
  */
 export const MATTERMOST_LOGO = `\`\`\`
  ✴ ▐█▙ ▟█▌ ✴   mm-claude
 ✴  ▐█▐█▌█▌  ✴  Mattermost × Claude Code
  ✴ ▐█▌ ▐█▌ ✴
 \`\`\``;
+/**
+ * Get ASCII logo for Mattermost with version included
+ */
+export function getMattermostLogo(version) {
+    return `\`\`\`
+ ✴ ▐█▙ ▟█▌ ✴   mm-claude v${version}
+✴  ▐█▐█▌█▌  ✴  Mattermost × Claude Code
+ ✴ ▐█▌ ▐█▌ ✴
+\`\`\``;
+}
 /**
  * Compact inline logo for Mattermost headers
  */

package/package.json

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