mattermost-claude-code 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -0,0 +1,256 @@
+# Changelog
+
+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.0] - 2025-12-28
+
+### Added
+- **Session persistence** - Sessions now survive bot restarts!
+  - Active sessions are saved to `~/.config/mm-claude/sessions.json`
+  - On bot restart, sessions are automatically resumed using Claude's `--resume` flag
+  - Users see "Bot shutting down - session will resume" when bot stops
+  - Users see "Session resumed after bot restart" when session resumes
+  - Session state (participants, working dir, permissions) is preserved
+  - Stale sessions (older than SESSION_TIMEOUT_MS) are cleaned up on startup
+  - Thread existence is verified before resuming (deleted threads are skipped)
+
+### Fixed
+- Truncate messages longer than 16K chars to avoid Mattermost API errors
+
+## [0.8.1] - 2025-12-28
+
+### Added
+- **`!release-notes` command** - Show release notes for the current version
+- **"What's new" in session header** - Shows a brief summary of new features when starting a session
+
+## [0.8.0] - 2025-12-28
+
+### Added
+- **Image attachment support** - Attach images to your messages and Claude Code will analyze them
+- Supports JPEG, PNG, GIF, and WebP formats
+- Images are downloaded from Mattermost and sent to Claude as base64-encoded content blocks
+- Works for both new sessions and follow-up messages
+- Debug logging shows attached image details (name, type, size)
+
+## [0.7.3] - 2025-12-28
+
+### Fixed
+- Actually fix `!cd` showing "[Exited: null]" - reset flag in async exit handler, not synchronously
+
+## [0.7.2] - 2025-12-28
+
+### Fixed
+- Fix `!cd` command showing "[Exited: null]" message - now properly suppresses exit message during intentional restart
+
+## [0.7.1] - 2025-12-28
+
+### Fixed
+- Fix infinite loop when plan is approved - no longer sends "Continue" message on subsequent ExitPlanMode calls
+
+## [0.7.0] - 2025-12-28
+
+### Added
+- **`!cd <path>` command** - Change working directory mid-session
+- Restarts Claude Code in the new directory with fresh context
+- Session header updates to show current working directory
+- Validates directory exists before switching
+
+## [0.6.1] - 2025-12-28
+
+### Changed
+- Cleaner console output: removed verbose `[Session]` prefixes from logs
+- Debug-only logging for internal session state changes (plan approval, question handling)
+- Consistent emoji formatting for all log messages
+
+## [0.6.0] - 2025-12-28
+
+### Added
+- **Auto-update notifications** - shows banner in session header when new version is available
+- Checks npm registry on startup for latest version
+- Update notice includes install command: `npm install -g mattermost-claude-code`
+
+## [0.5.9] - 2025-12-28
+
+### Fixed
+- Security fix: sanitize bot username in regex to prevent injection
+
+## [0.5.8] - 2025-12-28
+
+### Changed
+- Commands now use `!` prefix instead of `/` to avoid Mattermost slash command conflicts
+- `!help`, `!invite`, `!kick`, `!permissions`, `!stop` replace `/` versions
+- Commands without prefix (`help`, `stop`, `cancel`) still work
+
+## [0.5.7] - 2025-12-28
+
+### Fixed
+- Bot now recognizes mentions with hyphens in username (e.g., `@annes-minion`)
+- Side conversation detection regex updated to handle full Mattermost usernames
+
+## [0.5.6] - 2025-12-28
+
+### Added
+- Timeout warning 5 minutes before session expires
+- Warning message tells user to send a message to keep session alive
+- Warning resets if activity resumes
+
+## [0.5.5] - 2025-12-28
+
+### Added
+- `/help` command to show available session commands
+
+### Changed
+- Replace ASCII diagram with Mermaid flowchart in README
+
+## [0.5.4] - 2025-12-28 (not released)
+
+### Added
+- `/help` command to show available session commands
+
+## [0.5.3] - 2025-12-28
+
+### Added
+- `/permissions interactive` command to enable interactive permissions for a session
+- Can only downgrade permissions (auto → interactive), not upgrade
+- Session header updates to show current permission mode
+
+## [0.5.2] - 2025-12-28
+
+### Changed
+- Complete README rewrite with full documentation of all features
+
+## [0.5.1] - 2025-12-28
+
+### Added
+- `--no-skip-permissions` flag to enable interactive permissions even when `SKIP_PERMISSIONS=true` is set in env
+
+## [0.5.0] - 2025-12-28
+
+### Added
+- **Session collaboration** - invite users to specific sessions without global access
+- **`/invite @username`** - Temporarily allow a user to participate in the current session
+- **`/kick @username`** - Remove an invited user from the current session
+- **Message approval flow** - When unauthorized users send messages in a session thread, the session owner/allowed users can approve via reactions:
+  - 👍 Allow this single message
+  - ✅ Invite them to the session
+  - 👎 Deny the message
+- Per-session allowlist tracked via `sessionAllowedUsers` in each session
+- **Side conversation support** - Messages starting with `@someone-else` are ignored, allowing users to chat without triggering the bot
+- **Dynamic session header** - The session start message updates to show current participants when users are invited or kicked
+
+### Changed
+- Session owner is automatically added to session allowlist
+- Authorization checks now use `isUserAllowedInSession()` for follow-ups
+- Globally allowed users can still access all sessions
+
+## [0.4.0] - 2025-12-28
+
+### Added
+- **CLI arguments** to override all config options (`--url`, `--token`, `--channel`, etc.)
+- **Interactive onboarding** when no `.env` file exists - guided setup with help text
+- Full `--help` output with all available options
+- `--debug` flag to enable verbose logging
+
+### Changed
+- Switched from manual arg parsing to `commander` for better CLI experience
+- Config now supports: CLI args > environment variables > defaults
+
+## [0.3.4] - 2025-12-27
+
+### Added
+- Cancel sessions with `/stop`, `/cancel`, `stop`, or `cancel` commands in thread
+- Cancel sessions by reacting with ❌ or 🛑 to any post in the thread
+
+## [0.3.3] - 2025-12-27
+
+### Added
+- WebSocket heartbeat to detect dead connections after laptop sleep/idle
+- Automatic reconnection when connection goes silent for 60+ seconds
+- Ping every 30 seconds to keep connection alive
+
+### Fixed
+- Connections no longer go "zombie" after laptop sleep - mm-claude now detects and reconnects
+
+## [0.3.2] - 2025-12-27
+
+### Fixed
+- Session card now correctly shows "mm-claude" instead of "Claude Code"
+
+## [0.3.1] - 2025-12-27
+
+### Changed
+- Cleaner console output with colors (verbose logs only shown with `DEBUG=1`)
+- Pimped session start card in Mattermost with version, directory, user, session count, permissions mode, and prompt preview
+- Typing indicator starts immediately when session begins
+- Shortened thread IDs in logs for readability
+
+## [0.3.0] - 2025-12-27
+
+### Added
+- **Multiple concurrent sessions** - each Mattermost thread gets its own Claude CLI process
+- Sessions tracked via `sessions: Map<threadId, Session>` and `postIndex: Map<postId, threadId>`
+- Configurable session limits via `MAX_SESSIONS` env var (default: 5)
+- Automatic idle session cleanup via `SESSION_TIMEOUT_MS` env var (default: 30 min)
+- `killAllSessions()` for graceful shutdown of all sessions
+- Session count logging for monitoring
+
+### Changed
+- `SessionManager` now manages multiple sessions instead of single session
+- `sendFollowUp(threadId, message)` takes threadId parameter
+- `isInSessionThread(threadId)` replaces `isInCurrentSessionThread()`
+- `killSession(threadId)` takes threadId parameter
+
+### Fixed
+- Reaction routing now uses post index lookup for correct session targeting
+
+## [0.2.3] - 2025-12-27
+
+### Added
+- GitHub Actions workflow for automated npm publishing on release
+
+## [0.2.2] - 2025-12-27
+
+### Added
+- Comprehensive `CLAUDE.md` with project documentation for AI assistants
+
+## [0.2.1] - 2025-12-27
+
+### Added
+- `--version` / `-v` flag to display version
+- Version number shown in `--help` output
+
+### Changed
+- Lazy config loading (no .env file needed for --version/--help)
+
+## [0.2.0] - 2025-12-27
+
+### Added
+- Interactive permission approval via Mattermost reactions
+- Permission prompts forwarded to Mattermost thread
+- React with 👍 to allow, ✅ to allow all, or 👎 to deny
+- Only authorized users (ALLOWED_USERS) can approve permissions
+- MCP-based permission server using Claude Code's `--permission-prompt-tool`
+- `SKIP_PERMISSIONS` env var to control permission behavior
+
+### Changed
+- Permissions are now interactive by default (previously skipped)
+- Use `SKIP_PERMISSIONS=true` or `--dangerously-skip-permissions` to skip
+
+## [0.1.0] - 2024-12-27
+
+### Added
+- Initial release
+- Connect Claude Code CLI to Mattermost channels
+- Real-time streaming of Claude responses
+- Interactive plan approval with emoji reactions
+- Sequential question flow with emoji answers
+- Task list display with live updates
+- Code diffs for Edit operations
+- Content preview for Write operations
+- Subagent status tracking
+- Typing indicator while Claude is processing
+- User allowlist for access control
+- Bot mention detection for triggering sessions

package/README.md

@@ -116,6 +116,8 @@ Type `!help` in any session thread to see available commands:
 | Command | Description |
 |:--------|:------------|
 | `!help` | Show available commands |
+| `!release-notes` | Show release notes for current version |
+| `!cd <path>` | Change working directory (restarts Claude) |
 | `!invite @user` | Invite a user to this session |
 | `!kick @user` | Remove an invited user |
 | `!permissions interactive` | Enable interactive permissions |

package/dist/changelog.d.ts

@@ -0,0 +1,20 @@
+interface ReleaseNotes {
+    version: string;
+    date: string;
+    sections: {
+        [key: string]: string[];
+    };
+}
+/**
+ * Parse CHANGELOG.md and extract release notes for a specific version.
+ */
+export declare function getReleaseNotes(version?: string): ReleaseNotes | null;
+/**
+ * Format release notes as a Mattermost message.
+ */
+export declare function formatReleaseNotes(notes: ReleaseNotes): string;
+/**
+ * Get a short summary of what's new (for session header).
+ */
+export declare function getWhatsNewSummary(notes: ReleaseNotes): string;
+export {};

package/dist/changelog.js

@@ -0,0 +1,134 @@
+import { readFileSync, existsSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Parse CHANGELOG.md and extract release notes for a specific version.
+ */
+export function getReleaseNotes(version) {
+    // Try to find CHANGELOG.md in various locations
+    const possiblePaths = [
+        resolve(__dirname, '..', 'CHANGELOG.md'), // dist/../CHANGELOG.md (installed)
+        resolve(__dirname, '..', '..', 'CHANGELOG.md'), // src/../CHANGELOG.md (dev)
+    ];
+    let changelogPath = null;
+    for (const p of possiblePaths) {
+        if (existsSync(p)) {
+            changelogPath = p;
+            break;
+        }
+    }
+    if (!changelogPath) {
+        return null;
+    }
+    try {
+        const content = readFileSync(changelogPath, 'utf-8');
+        return parseChangelog(content, version);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse changelog content and extract notes for a version.
+ * If no version specified, returns the latest (first) version.
+ */
+function parseChangelog(content, targetVersion) {
+    const lines = content.split('\n');
+    let currentVersion = null;
+    let currentDate = null;
+    let currentSection = null;
+    let sections = {};
+    let foundTarget = false;
+    for (const line of lines) {
+        // Match version header: ## [0.8.0] - 2025-12-28
+        const versionMatch = line.match(/^## \[(\d+\.\d+\.\d+)\](?: - (\d{4}-\d{2}-\d{2}))?/);
+        if (versionMatch) {
+            // If we already found our target, we're done
+            if (foundTarget) {
+                break;
+            }
+            currentVersion = versionMatch[1];
+            currentDate = versionMatch[2] || '';
+            sections = {};
+            currentSection = null;
+            // Check if this is the version we want
+            if (!targetVersion || currentVersion === targetVersion) {
+                foundTarget = true;
+            }
+            continue;
+        }
+        // Only process if we're in the target version
+        if (!foundTarget)
+            continue;
+        // Match section header: ### Added, ### Fixed, ### Changed
+        const sectionMatch = line.match(/^### (\w+)/);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1];
+            sections[currentSection] = [];
+            continue;
+        }
+        // Match list item: - Item text
+        const itemMatch = line.match(/^- (.+)/);
+        if (itemMatch && currentSection) {
+            sections[currentSection].push(itemMatch[1]);
+        }
+    }
+    if (!foundTarget || !currentVersion) {
+        return null;
+    }
+    return {
+        version: currentVersion,
+        date: currentDate || '',
+        sections,
+    };
+}
+/**
+ * Format release notes as a Mattermost message.
+ */
+export function formatReleaseNotes(notes) {
+    let msg = `### 📋 Release Notes - v${notes.version}`;
+    if (notes.date) {
+        msg += ` (${notes.date})`;
+    }
+    msg += '\n\n';
+    for (const [section, items] of Object.entries(notes.sections)) {
+        if (items.length === 0)
+            continue;
+        const emoji = section === 'Added' ? '✨' :
+            section === 'Fixed' ? '🐛' :
+                section === 'Changed' ? '🔄' :
+                    section === 'Removed' ? '🗑️' : '•';
+        msg += `**${emoji} ${section}**\n`;
+        for (const item of items) {
+            msg += `- ${item}\n`;
+        }
+        msg += '\n';
+    }
+    return msg.trim();
+}
+/**
+ * Get a short summary of what's new (for session header).
+ */
+export function getWhatsNewSummary(notes) {
+    const items = [];
+    // Prioritize: Added > Fixed > Changed
+    for (const section of ['Added', 'Fixed', 'Changed']) {
+        const sectionItems = notes.sections[section] || [];
+        for (const item of sectionItems) {
+            // Extract just the first part (before any dash or detail)
+            const short = item.split(' - ')[0].replace(/\*\*/g, '');
+            if (short.length <= 50) {
+                items.push(short);
+            }
+            else {
+                items.push(short.substring(0, 47) + '...');
+            }
+            if (items.length >= 2)
+                break;
+        }
+        if (items.length >= 2)
+            break;
+    }
+    return items.join(', ');
+}

package/dist/claude/cli.d.ts

@@ -20,6 +20,8 @@ export interface ClaudeCliOptions {
     workingDir: string;
     threadId?: string;
     skipPermissions?: boolean;
+    sessionId?: string;
+    resume?: boolean;
 }
 export declare class ClaudeCli extends EventEmitter {
     private process;

package/dist/claude/cli.js

@@ -20,6 +20,15 @@ export class ClaudeCli extends EventEmitter {
             '--output-format', 'stream-json',
             '--verbose',
         ];
+        // Add session ID for persistence/resume support
+        if (this.options.sessionId) {
+            if (this.options.resume) {
+                args.push('--resume', this.options.sessionId);
+            }
+            else {
+                args.push('--session-id', this.options.sessionId);
+            }
+        }
         // Either use skip permissions or the MCP-based permission system
         if (this.options.skipPermissions) {
             args.push('--dangerously-skip-permissions');

package/dist/claude/session.d.ts

@@ -34,6 +34,7 @@ interface PendingMessageApproval {
  */
 interface Session {
     threadId: string;
+    claudeSessionId: string;
     startedBy: string;
     startedAt: Date;
     lastActivityAt: Date;
@@ -55,6 +56,7 @@ interface Session {
     typingTimer: ReturnType<typeof setInterval> | null;
     timeoutWarningPosted: boolean;
     isRestarting: boolean;
+    isResumed: boolean;
 }
 export declare class SessionManager {
     private mattermost;
@@ -63,14 +65,34 @@ export declare class SessionManager {
     private debug;
     private sessions;
     private postIndex;
+    private sessionStore;
     private cleanupTimer;
     constructor(mattermost: MattermostClient, workingDir: string, skipPermissions?: boolean);
+    /**
+     * Initialize session manager by resuming any persisted sessions.
+     * Should be called before starting to listen for new messages.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Resume a single session from persisted state
+     */
+    private resumeSession;
+    /**
+     * Persist a session to disk
+     */
+    private persistSession;
+    /**
+     * Remove a session from persistence
+     */
+    private unpersistSession;
     /** 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;
+    /** Get all active session thread IDs */
+    getActiveThreadIds(): string[];
     /** Register a post for reaction routing */
     private registerPost;
     /** Find session by post ID (for reaction routing) */

package/dist/claude/session.js

@@ -1,5 +1,8 @@
 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 { randomUUID } from 'crypto';
 import { readFileSync } from 'fs';
 import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
@@ -30,6 +33,8 @@ export class SessionManager {
     // Multi-session storage
     sessions = new Map(); // threadId -> Session
     postIndex = new Map(); // postId -> threadId (for reaction routing)
+    // Persistence
+    sessionStore = new SessionStore();
     // Cleanup timer
     cleanupTimer = null;
     constructor(mattermost, workingDir, skipPermissions = false) {
@@ -44,6 +49,144 @@ export class SessionManager {
         this.cleanupTimer = setInterval(() => this.cleanupIdleSessions(), 60000);
     }
     // ---------------------------------------------------------------------------
+    // Session Initialization (Resume)
+    // ---------------------------------------------------------------------------
+    /**
+     * Initialize session manager by resuming any persisted sessions.
+     * 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
+        const persisted = this.sessionStore.load();
+        if (persisted.size === 0) {
+            if (this.debug)
+                console.log('  [resume] No sessions to resume');
+            return;
+        }
+        console.log(`  📂 Found ${persisted.size} session(s) to resume...`);
+        // Resume each session
+        for (const [threadId, state] of persisted) {
+            await this.resumeSession(state);
+        }
+        console.log(`  ✅ Resumed ${this.sessions.size} session(s)`);
+    }
+    /**
+     * Resume a single session from persisted state
+     */
+    async resumeSession(state) {
+        const shortId = state.threadId.substring(0, 8);
+        // Verify thread still exists
+        const post = await this.mattermost.getPost(state.threadId);
+        if (!post) {
+            console.log(`  ⚠️ Thread ${shortId}... deleted, skipping resume`);
+            this.sessionStore.remove(state.threadId);
+            return;
+        }
+        // Check max sessions limit
+        if (this.sessions.size >= MAX_SESSIONS) {
+            console.log(`  ⚠️ Max sessions reached, skipping resume for ${shortId}...`);
+            return;
+        }
+        // Create Claude CLI with resume flag
+        const skipPerms = this.skipPermissions && !state.forceInteractivePermissions;
+        const cliOptions = {
+            workingDir: state.workingDir,
+            threadId: state.threadId,
+            skipPermissions: skipPerms,
+            sessionId: state.claudeSessionId,
+            resume: true,
+        };
+        const claude = new ClaudeCli(cliOptions);
+        // Rebuild Session object from persisted state
+        const session = {
+            threadId: state.threadId,
+            claudeSessionId: state.claudeSessionId,
+            startedBy: state.startedBy,
+            startedAt: new Date(state.startedAt),
+            lastActivityAt: new Date(),
+            sessionNumber: state.sessionNumber,
+            workingDir: state.workingDir,
+            claude,
+            currentPostId: null,
+            pendingContent: '',
+            pendingApproval: null,
+            pendingQuestionSet: null,
+            pendingMessageApproval: null,
+            planApproved: state.planApproved,
+            sessionAllowedUsers: new Set(state.sessionAllowedUsers),
+            forceInteractivePermissions: state.forceInteractivePermissions,
+            sessionStartPostId: state.sessionStartPostId,
+            tasksPostId: state.tasksPostId,
+            activeSubagents: new Map(),
+            updateTimer: null,
+            typingTimer: null,
+            timeoutWarningPosted: false,
+            isRestarting: false,
+            isResumed: true,
+        };
+        // Register session
+        this.sessions.set(state.threadId, session);
+        if (state.sessionStartPostId) {
+            this.registerPost(state.sessionStartPostId, state.threadId);
+        }
+        // Bind event handlers
+        claude.on('event', (e) => this.handleEvent(state.threadId, e));
+        claude.on('exit', (code) => this.handleExit(state.threadId, code));
+        try {
+            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);
+            // Update session header
+            await this.updateSessionHeader(session);
+            // Update persistence with new activity time
+            this.persistSession(session);
+        }
+        catch (err) {
+            console.error(`  ❌ Failed to resume session ${shortId}...:`, err);
+            this.sessions.delete(state.threadId);
+            this.sessionStore.remove(state.threadId);
+            // Try to notify user
+            try {
+                await this.mattermost.createPost(`⚠️ **Could not resume previous session.** Starting fresh.\n*Your previous conversation context is preserved, but Claude needs to re-read it.*`, state.threadId);
+            }
+            catch {
+                // Ignore if we can't post
+            }
+        }
+    }
+    /**
+     * Persist a session to disk
+     */
+    persistSession(session) {
+        const state = {
+            threadId: session.threadId,
+            claudeSessionId: session.claudeSessionId,
+            startedBy: session.startedBy,
+            startedAt: session.startedAt.toISOString(),
+            sessionNumber: session.sessionNumber,
+            workingDir: session.workingDir,
+            sessionAllowedUsers: [...session.sessionAllowedUsers],
+            forceInteractivePermissions: session.forceInteractivePermissions,
+            sessionStartPostId: session.sessionStartPostId,
+            tasksPostId: session.tasksPostId,
+            lastActivityAt: session.lastActivityAt.toISOString(),
+            planApproved: session.planApproved,
+        };
+        this.sessionStore.save(session.threadId, state);
+    }
+    /**
+     * Remove a session from persistence
+     */
+    unpersistSession(threadId) {
+        this.sessionStore.remove(threadId);
+    }
+    // ---------------------------------------------------------------------------
     // Session Lookup Methods
     // ---------------------------------------------------------------------------
     /** Get a session by thread ID */
@@ -58,6 +201,10 @@ export class SessionManager {
     getSessionCount() {
         return this.sessions.size;
     }
+    /** Get all active session thread IDs */
+    getActiveThreadIds() {
+        return [...this.sessions.keys()];
+    }
     /** Register a post for reaction routing */
     registerPost(postId, threadId) {
         this.postIndex.set(postId, threadId);
@@ -101,16 +248,21 @@ export class SessionManager {
         // 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);
         const actualThreadId = replyToPostId || post.id;
+        // Generate a unique session ID for this Claude session
+        const claudeSessionId = randomUUID();
         // Create Claude CLI with options
         const cliOptions = {
             workingDir: this.workingDir,
             threadId: actualThreadId,
             skipPermissions: this.skipPermissions,
+            sessionId: claudeSessionId,
+            resume: false,
         };
         const claude = new ClaudeCli(cliOptions);
         // Create the session object
         const session = {
             threadId: actualThreadId,
+            claudeSessionId,
             startedBy: username,
             startedAt: new Date(),
             lastActivityAt: new Date(),
@@ -132,6 +284,7 @@ export class SessionManager {
             typingTimer: null,
             timeoutWarningPosted: false,
             isRestarting: false,
+            isResumed: false,
         };
         // Register session
         this.sessions.set(actualThreadId, session);
@@ -158,6 +311,8 @@ export class SessionManager {
         // Send the message to Claude (with images if present)
         const content = await this.buildMessageContent(options.prompt, options.files);
         claude.sendMessage(content);
+        // Persist session for resume after restart
+        this.persistSession(session);
     }
     handleEvent(threadId, event) {
         const session = this.sessions.get(threadId);
@@ -741,7 +896,12 @@ export class SessionManager {
     async flush(session) {
         if (!session.pendingContent.trim())
             return;
-        const content = session.pendingContent.replace(/\n{3,}/g, '\n\n').trim();
+        let content = session.pendingContent.replace(/\n{3,}/g, '\n\n').trim();
+        // Mattermost has a 16,383 character limit for posts
+        const MAX_POST_LENGTH = 16000; // Leave some margin
+        if (content.length > MAX_POST_LENGTH) {
+            content = content.substring(0, MAX_POST_LENGTH - 50) + '\n\n*... (truncated)*';
+        }
         if (session.currentPostId) {
             await this.mattermost.updatePost(session.currentPostId, content);
         }
@@ -778,6 +938,8 @@ export class SessionManager {
                 this.postIndex.delete(postId);
             }
         }
+        // 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`);
     }
@@ -870,11 +1032,14 @@ export class SessionManager {
         session.pendingContent = '';
         // Update session working directory
         session.workingDir = absoluteDir;
-        // Create new Claude CLI with new working directory
+        // Generate new session ID for the restarted CLI (or keep using --resume with same ID)
+        // We use --resume to maintain conversation context
         const cliOptions = {
             workingDir: absoluteDir,
             threadId: threadId,
             skipPermissions: this.skipPermissions || !session.forceInteractivePermissions,
+            sessionId: session.claudeSessionId,
+            resume: true, // Resume to keep conversation context
         };
         session.claude = new ClaudeCli(cliOptions);
         // Rebind event handlers
@@ -898,6 +1063,8 @@ export class SessionManager {
         // Update activity
         session.lastActivityAt = new Date();
         session.timeoutWarningPosted = false;
+        // Persist the updated session state
+        this.persistSession(session);
     }
     /** Invite a user to participate in a specific session */
     async inviteUser(threadId, invitedUser, invitedBy) {
@@ -913,6 +1080,7 @@ export class SessionManager {
         await this.mattermost.createPost(`✅ @${invitedUser} can now participate in this session (invited by @${invitedBy})`, threadId);
         console.log(`  👋 @${invitedUser} invited to session by @${invitedBy}`);
         await this.updateSessionHeader(session);
+        this.persistSession(session); // Persist collaboration change
     }
     /** Kick a user from a specific session */
     async kickUser(threadId, kickedUser, kickedBy) {
@@ -938,6 +1106,7 @@ export class SessionManager {
             await this.mattermost.createPost(`🚫 @${kickedUser} removed from this session by @${kickedBy}`, threadId);
             console.log(`  🚫 @${kickedUser} kicked from session by @${kickedBy}`);
             await this.updateSessionHeader(session);
+            this.persistSession(session); // Persist collaboration change
         }
         else {
             await this.mattermost.createPost(`⚠️ @${kickedUser} was not in this session`, threadId);
@@ -970,6 +1139,7 @@ export class SessionManager {
         await this.mattermost.createPost(`🔐 Interactive permissions enabled for this session by @${username}`, threadId);
         console.log(`  🔐 Interactive permissions enabled for session by @${username}`);
         await this.updateSessionHeader(session);
+        this.persistSession(session); // Persist permission change
     }
     /** Check if a session should use interactive permissions */
     isSessionInteractive(threadId) {
@@ -1010,9 +1180,14 @@ export class SessionManager {
         const updateNotice = updateInfo
             ? `\n> ⚠️ **Update available:** v${updateInfo.current} → v${updateInfo.latest} - Run \`npm install -g mattermost-claude-code\`\n`
             : '';
+        // Get "What's new" from release notes
+        const releaseNotes = getReleaseNotes(pkg.version);
+        const whatsNew = releaseNotes ? getWhatsNewSummary(releaseNotes) : '';
+        const whatsNewLine = whatsNew ? `\n> ✨ **What's new:** ${whatsNew}\n` : '';
         const msg = [
             `### 🤖 mm-claude \`v${pkg.version}\``,
             updateNotice,
+            whatsNewLine,
             `| | |`,
             `|:--|:--|`,
             ...rows,

package/dist/index.js

@@ -8,6 +8,7 @@ import { readFileSync } from 'fs';
 import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { checkForUpdates } from './update-notifier.js';
+import { getReleaseNotes, formatReleaseNotes } from './changelog.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf-8'));
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
@@ -101,6 +102,7 @@ async function main() {
                     `| 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` +
@@ -111,6 +113,17 @@ async function main() {
                     `- ❌ 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);
+                }
+                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) {
@@ -173,16 +186,31 @@ async function main() {
     mattermost.on('connected', () => { });
     mattermost.on('error', (e) => console.error('  ❌ Error:', e));
     await mattermost.connect();
+    // Resume any persisted sessions from before restart
+    await session.initialize();
     console.log(`  ✅ ${bold('Ready!')} Waiting for @${config.mattermost.botName} mentions...`);
     console.log('');
-    const shutdown = () => {
+    const shutdown = async () => {
         console.log('');
         console.log(`  👋 ${dim('Shutting down...')}`);
+        // Post shutdown message to active sessions
+        const activeThreads = session.getActiveThreadIds();
+        if (activeThreads.length > 0) {
+            console.log(`  📤 Notifying ${activeThreads.length} active session(s)...`);
+            for (const threadId of activeThreads) {
+                try {
+                    await mattermost.createPost(`⏸️ **Bot shutting down** - session will resume on restart`, threadId);
+                }
+                catch {
+                    // Ignore errors, we're shutting down
+                }
+            }
+        }
         session.killAllSessions();
         mattermost.disconnect();
         process.exit(0);
     };
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', () => { shutdown(); });
+    process.on('SIGTERM', () => { shutdown(); });
 }
 main().catch(e => { console.error(e); process.exit(1); });

package/dist/mattermost/client.d.ts

@@ -31,6 +31,7 @@ export declare class MattermostClient extends EventEmitter {
     addReaction(postId: string, emojiName: string): Promise<void>;
     downloadFile(fileId: string): Promise<Buffer>;
     getFileInfo(fileId: string): Promise<import('./types.js').MattermostFile>;
+    getPost(postId: string): Promise<MattermostPost | null>;
     connect(): Promise<void>;
     private handleEvent;
     private scheduleReconnect;

package/dist/mattermost/client.js

@@ -106,6 +106,15 @@ export class MattermostClient extends EventEmitter {
     async getFileInfo(fileId) {
         return this.api('GET', `/files/${fileId}/info`);
     }
+    // Get a post by ID (used to verify thread still exists on resume)
+    async getPost(postId) {
+        try {
+            return await this.api('GET', `/posts/${postId}`);
+        }
+        catch {
+            return null; // Post doesn't exist or was deleted
+        }
+    }
     // Connect to WebSocket
     async connect() {
         // Get bot user first

package/dist/persistence/session-store.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Persisted session state for resuming after bot restart
+ */
+export interface PersistedSession {
+    threadId: string;
+    claudeSessionId: string;
+    startedBy: string;
+    startedAt: string;
+    sessionNumber: number;
+    workingDir: string;
+    sessionAllowedUsers: string[];
+    forceInteractivePermissions: boolean;
+    sessionStartPostId: string | null;
+    tasksPostId: string | null;
+    lastActivityAt: string;
+    planApproved: boolean;
+}
+/**
+ * SessionStore - Persistence layer for session state
+ * Stores session data as JSON file for resume after restart
+ */
+export declare class SessionStore {
+    private debug;
+    constructor();
+    /**
+     * Load all persisted sessions
+     */
+    load(): Map<string, PersistedSession>;
+    /**
+     * Save a session (creates or updates)
+     */
+    save(threadId: string, session: PersistedSession): void;
+    /**
+     * Remove a session
+     */
+    remove(threadId: string): void;
+    /**
+     * Remove sessions older than maxAgeMs
+     */
+    cleanStale(maxAgeMs: number): string[];
+    /**
+     * Clear all sessions
+     */
+    clear(): void;
+    /**
+     * Load raw data from file
+     */
+    private loadRaw;
+    /**
+     * Write data atomically (write to temp file, then rename)
+     */
+    private writeAtomic;
+}

package/dist/persistence/session-store.js

@@ -0,0 +1,127 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const STORE_VERSION = 1;
+const CONFIG_DIR = join(homedir(), '.config', 'mm-claude');
+const SESSIONS_FILE = join(CONFIG_DIR, 'sessions.json');
+/**
+ * SessionStore - Persistence layer for session state
+ * Stores session data as JSON file for resume after restart
+ */
+export class SessionStore {
+    debug = process.env.DEBUG === '1' || process.argv.includes('--debug');
+    constructor() {
+        // Ensure config directory exists
+        if (!existsSync(CONFIG_DIR)) {
+            mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+    }
+    /**
+     * Load all persisted sessions
+     */
+    load() {
+        const sessions = new Map();
+        if (!existsSync(SESSIONS_FILE)) {
+            if (this.debug)
+                console.log('  [persist] No sessions file found');
+            return sessions;
+        }
+        try {
+            const data = JSON.parse(readFileSync(SESSIONS_FILE, 'utf-8'));
+            // Version check for future migrations
+            if (data.version !== STORE_VERSION) {
+                console.warn(`  [persist] Sessions file version mismatch (${data.version} vs ${STORE_VERSION}), starting fresh`);
+                return sessions;
+            }
+            for (const [threadId, session] of Object.entries(data.sessions)) {
+                sessions.set(threadId, session);
+            }
+            if (this.debug) {
+                console.log(`  [persist] Loaded ${sessions.size} session(s)`);
+            }
+        }
+        catch (err) {
+            console.error('  [persist] Failed to load sessions:', err);
+        }
+        return sessions;
+    }
+    /**
+     * Save a session (creates or updates)
+     */
+    save(threadId, session) {
+        const data = this.loadRaw();
+        data.sessions[threadId] = session;
+        this.writeAtomic(data);
+        if (this.debug) {
+            const shortId = threadId.substring(0, 8);
+            console.log(`  [persist] Saved session ${shortId}...`);
+        }
+    }
+    /**
+     * Remove a session
+     */
+    remove(threadId) {
+        const data = this.loadRaw();
+        if (data.sessions[threadId]) {
+            delete data.sessions[threadId];
+            this.writeAtomic(data);
+            if (this.debug) {
+                const shortId = threadId.substring(0, 8);
+                console.log(`  [persist] Removed session ${shortId}...`);
+            }
+        }
+    }
+    /**
+     * Remove sessions older than maxAgeMs
+     */
+    cleanStale(maxAgeMs) {
+        const data = this.loadRaw();
+        const now = Date.now();
+        const staleIds = [];
+        for (const [threadId, session] of Object.entries(data.sessions)) {
+            const lastActivity = new Date(session.lastActivityAt).getTime();
+            if (now - lastActivity > maxAgeMs) {
+                staleIds.push(threadId);
+                delete data.sessions[threadId];
+            }
+        }
+        if (staleIds.length > 0) {
+            this.writeAtomic(data);
+            if (this.debug) {
+                console.log(`  [persist] Cleaned ${staleIds.length} stale session(s)`);
+            }
+        }
+        return staleIds;
+    }
+    /**
+     * Clear all sessions
+     */
+    clear() {
+        this.writeAtomic({ version: STORE_VERSION, sessions: {} });
+        if (this.debug) {
+            console.log('  [persist] Cleared all sessions');
+        }
+    }
+    /**
+     * Load raw data from file
+     */
+    loadRaw() {
+        if (!existsSync(SESSIONS_FILE)) {
+            return { version: STORE_VERSION, sessions: {} };
+        }
+        try {
+            return JSON.parse(readFileSync(SESSIONS_FILE, 'utf-8'));
+        }
+        catch {
+            return { version: STORE_VERSION, sessions: {} };
+        }
+    }
+    /**
+     * Write data atomically (write to temp file, then rename)
+     */
+    writeAtomic(data) {
+        const tempFile = `${SESSIONS_FILE}.tmp`;
+        writeFileSync(tempFile, JSON.stringify(data, null, 2), 'utf-8');
+        renameSync(tempFile, SESSIONS_FILE);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mattermost-claude-code",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",
@@ -36,6 +36,7 @@
   "files": [
     "dist",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "package.json"
   ],