mattermost-claude-code 0.10.2 → 0.10.3

package/CHANGELOG.md

@@ -7,6 +7,23 @@ 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

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;
@@ -59,6 +60,8 @@ interface Session {
     isRestarting: boolean;
     isResumed: boolean;
     wasInterrupted: boolean;
+    inProgressTaskStart: number | null;
+    activeToolStarts: Map<string, number>;
 }
 export declare class SessionManager {
     private mattermost;
@@ -141,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

@@ -146,6 +146,8 @@ export class SessionManager {
             isRestarting: false,
             isResumed: true,
             wasInterrupted: false,
+            inProgressTaskStart: null,
+            activeToolStarts: new Map(),
         };
         // Register session
         this.sessions.set(state.threadId, session);
@@ -322,6 +324,8 @@ export class SessionManager {
             isRestarting: false,
             isResumed: false,
             wasInterrupted: false,
+            inProgressTaskStart: null,
+            activeToolStarts: new Map(),
         };
         // Register session
         this.sessions.set(actualThreadId, session);
@@ -469,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;
@@ -479,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`;
@@ -770,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': {
@@ -1089,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);

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/package.json

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