mattermost-claude-code 0.9.2 → 0.10.0

package/CHANGELOG.md

@@ -5,6 +5,42 @@ 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).
 
+## [Unreleased]
+
+## [0.10.0] - 2025-12-28
+
+### Added
+- **ASCII art logo** - Stylized "M" in Claude Code's block character style
+  - Shows on CLI startup with Mattermost blue and Claude orange colors
+  - Shows at the top of every Mattermost session thread
+  - Festive stars (✴) surround the logo
+- **`!kill` command** - Emergency shutdown that kills ALL sessions and exits the bot
+  - Only available to globally authorized users (ALLOWED_USERS)
+  - Unpersists all sessions (they won't resume on restart)
+  - Posts notification to all active session threads before exiting
+- **`!escape` / `!interrupt` commands** - Soft interrupt like pressing Escape in CLI
+  - Sends SIGINT to Claude CLI, stopping current task
+  - Session stays alive and user can continue the conversation
+  - Also available via ⏸️ reaction on any message in the session
+
+### Fixed
+- **Fix plan mode getting stuck after approval** - tool calls now get proper responses
+  - `ExitPlanMode` and `AskUserQuestion` now receive `tool_result` instead of user messages
+  - Claude was waiting for tool results that never came, causing sessions to hang
+  - Added `toolUseId` tracking to `PendingApproval` interface
+
+## [0.9.3] - 2025-12-28
+
+### Fixed
+- **Major fix for session persistence** - completely rewrote session lifecycle management
+  - Sessions now correctly survive bot restarts (was broken in 0.9.0-0.9.2)
+  - `killAllSessions()` now explicitly preserves persistence instead of relying on exit event timing
+  - `killSession()` now takes an `unpersist` parameter to control persistence behavior
+  - `handleExit()` now only unpersists on graceful exits (code 0), not on errors
+  - Resumed sessions that fail are preserved for retry instead of being removed
+  - Added comprehensive debug logging to trace session lifecycle
+  - Race condition between shutdown and exit events eliminated
+
 ## [0.9.2] - 2025-12-28
 
 ### Fixed

package/dist/claude/cli.d.ts

@@ -35,5 +35,7 @@ export declare class ClaudeCli extends EventEmitter {
     private parseOutput;
     isRunning(): boolean;
     kill(): void;
+    /** Interrupt current processing (like Escape in CLI) - keeps process alive */
+    interrupt(): boolean;
     private getMcpServerPath;
 }

package/dist/claude/cli.js

@@ -151,6 +151,13 @@ export class ClaudeCli extends EventEmitter {
         this.process?.kill('SIGTERM');
         this.process = null;
     }
+    /** Interrupt current processing (like Escape in CLI) - keeps process alive */
+    interrupt() {
+        if (!this.process)
+            return false;
+        this.process.kill('SIGINT');
+        return true;
+    }
     getMcpServerPath() {
         // Get the path to the MCP permission server
         // When running from source: src/mcp/permission-server.ts -> dist/mcp/permission-server.js

package/dist/claude/session.d.ts

@@ -19,6 +19,7 @@ interface PendingQuestionSet {
 interface PendingApproval {
     postId: string;
     type: 'plan' | 'action';
+    toolUseId: string;
 }
 /**
  * Pending message from unauthorized user awaiting approval
@@ -94,6 +95,8 @@ export declare class SessionManager {
     getSessionCount(): number;
     /** Get all active session thread IDs */
     getActiveThreadIds(): string[];
+    /** Mark that we're shutting down (prevents cleanup of persisted sessions) */
+    setShuttingDown(): void;
     /** Register a post for reaction routing */
     private registerPost;
     /** Find session by post ID (for reaction routing) */
@@ -138,9 +141,11 @@ export declare class SessionManager {
     /** Send a follow-up message to an existing session */
     sendFollowUp(threadId: string, message: string, files?: MattermostFile[]): Promise<void>;
     /** Kill a specific session */
-    killSession(threadId: string): void;
+    killSession(threadId: string, unpersist?: boolean): void;
     /** Cancel a session with user feedback */
     cancelSession(threadId: string, username: string): Promise<void>;
+    /** Interrupt current processing but keep session alive (like Escape in CLI) */
+    interruptSession(threadId: string, username: string): Promise<void>;
     /** Change working directory for a session (restarts Claude CLI) */
     changeDirectory(threadId: string, newDir: string, username: string): Promise<void>;
     /** Invite a user to participate in a specific session */
@@ -160,6 +165,8 @@ export declare class SessionManager {
     requestMessageApproval(threadId: string, username: string, message: string): Promise<void>;
     /** Kill all active sessions (for graceful shutdown) */
     killAllSessions(): void;
+    /** Kill all sessions AND unpersist them (for emergency shutdown - no resume) */
+    killAllSessionsAndUnpersist(): void;
     /** Cleanup idle sessions that have exceeded timeout */
     private cleanupIdleSessions;
 }

package/dist/claude/session.js

@@ -2,6 +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 { randomUUID } from 'crypto';
 import { readFileSync } from 'fs';
 import { dirname, resolve } from 'path';
@@ -180,6 +181,8 @@ export class SessionManager {
      * Persist a session to disk
      */
     persistSession(session) {
+        const shortId = session.threadId.substring(0, 8);
+        console.log(`  [persist] Saving session ${shortId}...`);
         const state = {
             threadId: session.threadId,
             claudeSessionId: session.claudeSessionId,
@@ -195,19 +198,14 @@ export class SessionManager {
             planApproved: session.planApproved,
         };
         this.sessionStore.save(session.threadId, state);
-        if (this.debug) {
-            const shortId = session.threadId.substring(0, 8);
-            console.log(`  [persist] Saved session ${shortId}... (claudeId: ${session.claudeSessionId.substring(0, 8)}...)`);
-        }
+        console.log(`  [persist] Saved session ${shortId}... (claudeId: ${session.claudeSessionId.substring(0, 8)}...)`);
     }
     /**
      * Remove a session from persistence
      */
     unpersistSession(threadId) {
-        if (this.debug) {
-            const shortId = threadId.substring(0, 8);
-            console.log(`  [persist] Removing session ${shortId}...`);
-        }
+        const shortId = threadId.substring(0, 8);
+        console.log(`  [persist] REMOVING session ${shortId}... (this should NOT happen during shutdown!)`);
         this.sessionStore.remove(threadId);
     }
     // ---------------------------------------------------------------------------
@@ -229,6 +227,11 @@ export class SessionManager {
     getActiveThreadIds() {
         return [...this.sessions.keys()];
     }
+    /** Mark that we're shutting down (prevents cleanup of persisted sessions) */
+    setShuttingDown() {
+        console.log('  [shutdown] Setting isShuttingDown = true');
+        this.isShuttingDown = true;
+    }
     /** Register a post for reaction routing */
     registerPost(postId, threadId) {
         this.postIndex.set(postId, threadId);
@@ -272,7 +275,7 @@ export class SessionManager {
         // Post initial session message (will be updated by updateSessionHeader)
         let post;
         try {
-            post = await this.mattermost.createPost(`### 🤖 mm-claude \`v${pkg.version}\`\n\n*Starting session...*`, replyToPostId);
+            post = await this.mattermost.createPost(`${MATTERMOST_LOGO}\n**v${pkg.version}**\n\n*Starting session...*`, replyToPostId);
         }
         catch (err) {
             console.error(`  ❌ Failed to create session post:`, err);
@@ -360,7 +363,7 @@ export class SessionManager {
             for (const block of msg?.content || []) {
                 if (block.type === 'tool_use') {
                     if (block.name === 'ExitPlanMode') {
-                        this.handleExitPlanMode(session);
+                        this.handleExitPlanMode(session, block.id);
                         hasSpecialTool = true;
                     }
                     else if (block.name === 'TodoWrite') {
@@ -408,12 +411,15 @@ export class SessionManager {
             console.error('  ⚠️ Failed to update subagent completion:', err);
         }
     }
-    async handleExitPlanMode(session) {
-        // If already approved in this session, silently ignore subsequent ExitPlanMode calls
-        // (Don't send another message - that causes Claude to loop)
+    async handleExitPlanMode(session, toolUseId) {
+        // If already approved in this session, send empty tool result to acknowledge
+        // (Claude needs a response to continue)
         if (session.planApproved) {
             if (this.debug)
-                console.log('  ↪ Plan already approved, ignoring ExitPlanMode');
+                console.log('  ↪ Plan already approved, sending acknowledgment');
+            if (session.claude.isRunning()) {
+                session.claude.sendToolResult(toolUseId, 'Plan already approved. Proceeding.');
+            }
             return;
         }
         // If we already have a pending approval, don't post another one
@@ -442,8 +448,8 @@ export class SessionManager {
         catch (err) {
             console.error('  ⚠️ Failed to add approval reactions:', err);
         }
-        // Track this for reaction handling
-        session.pendingApproval = { postId: post.id, type: 'plan' };
+        // Track this for reaction handling - include toolUseId for proper response
+        session.pendingApproval = { postId: post.id, type: 'plan', toolUseId };
         // Stop typing while waiting
         this.stopTyping(session);
     }
@@ -591,6 +597,11 @@ export class SessionManager {
             await this.cancelSession(session.threadId, username);
             return;
         }
+        // Handle interrupt reactions (⏸️) on any post in the session
+        if (emojiName === 'pause_button' || emojiName === 'double_vertical_bar') {
+            await this.interruptSession(session.threadId, username);
+            return;
+        }
         // Handle approval reactions
         if (session.pendingApproval && session.pendingApproval.postId === postId) {
             await this.handleApprovalReaction(session, emojiName, username);
@@ -635,17 +646,20 @@ export class SessionManager {
             await this.postCurrentQuestion(session);
         }
         else {
-            // All questions answered - send as follow-up message
+            // All questions answered - send tool result
             let answersText = 'Here are my answers:\n';
             for (const q of questions) {
                 answersText += `- **${q.header}**: ${q.answer}\n`;
             }
             if (this.debug)
                 console.log('  ✅ All questions answered');
-            // Clear and send as regular message
+            // Get the toolUseId before clearing
+            const toolUseId = session.pendingQuestionSet.toolUseId;
+            // Clear pending questions
             session.pendingQuestionSet = null;
+            // Send tool result to Claude (AskUserQuestion expects a tool_result, not a user message)
             if (session.claude.isRunning()) {
-                session.claude.sendMessage(answersText);
+                session.claude.sendToolResult(toolUseId, answersText);
                 this.startTyping(session);
             }
         }
@@ -657,7 +671,7 @@ export class SessionManager {
         const isReject = emojiName === '-1' || emojiName === 'thumbsdown';
         if (!isApprove && !isReject)
             return;
-        const postId = session.pendingApproval.postId;
+        const { postId, toolUseId } = session.pendingApproval;
         const shortId = session.threadId.substring(0, 8);
         console.log(`  ${isApprove ? '✅' : '❌'} Plan ${isApprove ? 'approved' : 'rejected'} (${shortId}…) by @${username}`);
         // Update the post to show the decision
@@ -675,12 +689,12 @@ export class SessionManager {
         if (isApprove) {
             session.planApproved = true;
         }
-        // Send response to Claude
+        // Send tool result to Claude (ExitPlanMode expects a tool_result, not a user message)
         if (session.claude.isRunning()) {
             const response = isApprove
                 ? 'Approved. Please proceed with the implementation.'
                 : 'Please revise the plan. I would like some changes.';
-            session.claude.sendMessage(response);
+            session.claude.sendToolResult(toolUseId, response);
             this.startTyping(session);
         }
     }
@@ -947,26 +961,52 @@ export class SessionManager {
     async handleExit(threadId, code) {
         const session = this.sessions.get(threadId);
         const shortId = threadId.substring(0, 8);
+        // Always log exit events to trace the flow
+        console.log(`  [exit] handleExit called for ${shortId}... code=${code} isShuttingDown=${this.isShuttingDown}`);
         if (!session) {
-            if (this.debug)
-                console.log(`  [exit] Session ${shortId}... not found (already cleaned up)`);
+            console.log(`  [exit] Session ${shortId}... not found (already cleaned up)`);
             return;
         }
         // If we're intentionally restarting (e.g., !cd), don't clean up or post exit message
         if (session.isRestarting) {
-            if (this.debug)
-                console.log(`  [exit] Session ${shortId}... restarting, skipping cleanup`);
+            console.log(`  [exit] Session ${shortId}... restarting, skipping cleanup`);
             session.isRestarting = false; // Reset flag here, after the exit event fires
             return;
         }
         // If bot is shutting down, suppress exit messages (shutdown message already sent)
+        // IMPORTANT: Check this flag FIRST before any cleanup. The session should remain
+        // persisted so it can be resumed after restart.
         if (this.isShuttingDown) {
-            if (this.debug)
-                console.log(`  [exit] Session ${shortId}... bot shutting down, preserving persistence`);
+            console.log(`  [exit] Session ${shortId}... bot shutting down, preserving persistence`);
+            // Still clean up from in-memory maps since we're shutting down anyway
+            this.stopTyping(session);
+            if (session.updateTimer) {
+                clearTimeout(session.updateTimer);
+                session.updateTimer = null;
+            }
+            this.sessions.delete(threadId);
             return;
         }
-        if (this.debug)
-            console.log(`  [exit] Session ${shortId}... exited with code ${code}, cleaning up`);
+        // For resumed sessions that exit quickly (e.g., Claude --resume fails),
+        // don't unpersist immediately - give it a chance to be retried
+        if (session.isResumed && code !== 0) {
+            console.log(`  [exit] Resumed session ${shortId}... failed with code ${code}, preserving for retry`);
+            this.stopTyping(session);
+            if (session.updateTimer) {
+                clearTimeout(session.updateTimer);
+                session.updateTimer = null;
+            }
+            this.sessions.delete(threadId);
+            // Post error message but keep persistence
+            try {
+                await this.mattermost.createPost(`⚠️ **Session resume failed** (exit code ${code}). The session data is preserved - try restarting the bot.`, session.threadId);
+            }
+            catch {
+                // Ignore if we can't post
+            }
+            return;
+        }
+        console.log(`  [exit] Session ${shortId}... normal exit, cleaning up`);
         this.stopTyping(session);
         if (session.updateTimer) {
             clearTimeout(session.updateTimer);
@@ -984,8 +1024,14 @@ export class SessionManager {
                 this.postIndex.delete(postId);
             }
         }
-        // Remove from persistence when session ends normally
-        this.unpersistSession(threadId);
+        // Only unpersist for normal exits (code 0 or null means graceful completion)
+        // Non-zero exits might be recoverable, so we keep the session persisted
+        if (code === 0 || code === null) {
+            this.unpersistSession(threadId);
+        }
+        else {
+            console.log(`  [exit] Session ${shortId}... non-zero exit, preserving for potential retry`);
+        }
         console.log(`  ■ Session ended (${shortId}…) — ${this.sessions.size} active`);
     }
     // ---------------------------------------------------------------------------
@@ -1011,10 +1057,16 @@ export class SessionManager {
         this.startTyping(session);
     }
     /** Kill a specific session */
-    killSession(threadId) {
+    killSession(threadId, unpersist = true) {
         const session = this.sessions.get(threadId);
         if (!session)
             return;
+        const shortId = threadId.substring(0, 8);
+        // Set restarting flag to prevent handleExit from also unpersisting
+        // (we'll do it explicitly here if requested)
+        if (!unpersist) {
+            session.isRestarting = true; // Reuse this flag to skip cleanup in handleExit
+        }
         this.stopTyping(session);
         session.claude.kill();
         // Clean up session from maps
@@ -1024,7 +1076,10 @@ export class SessionManager {
                 this.postIndex.delete(postId);
             }
         }
-        const shortId = threadId.substring(0, 8);
+        // Explicitly unpersist if requested (e.g., for timeout, cancel, etc.)
+        if (unpersist) {
+            this.unpersistSession(threadId);
+        }
         console.log(`  ✖ Session killed (${shortId}…) — ${this.sessions.size} active`);
     }
     /** Cancel a session with user feedback */
@@ -1037,6 +1092,22 @@ export class SessionManager {
         await this.mattermost.createPost(`🛑 **Session cancelled** by @${username}`, threadId);
         this.killSession(threadId);
     }
+    /** Interrupt current processing but keep session alive (like Escape in CLI) */
+    async interruptSession(threadId, username) {
+        const session = this.sessions.get(threadId);
+        if (!session)
+            return;
+        if (!session.claude.isRunning()) {
+            await this.mattermost.createPost(`ℹ️ Session is idle, nothing to interrupt`, threadId);
+            return;
+        }
+        const shortId = threadId.substring(0, 8);
+        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);
+        }
+    }
     /** Change working directory for a session (restarts Claude CLI) */
     async changeDirectory(threadId, newDir, username) {
         const session = this.sessions.get(threadId);
@@ -1230,7 +1301,8 @@ export class SessionManager {
         const whatsNew = releaseNotes ? getWhatsNewSummary(releaseNotes) : '';
         const whatsNewLine = whatsNew ? `\n> ✨ **What's new:** ${whatsNew}\n` : '';
         const msg = [
-            `### 🤖 mm-claude \`v${pkg.version}\``,
+            MATTERMOST_LOGO,
+            `**v${pkg.version}**`,
             updateNotice,
             whatsNewLine,
             `| | |`,
@@ -1274,12 +1346,33 @@ export class SessionManager {
     }
     /** Kill all active sessions (for graceful shutdown) */
     killAllSessions() {
-        // Set shutdown flag to suppress exit messages
+        console.log(`  [shutdown] killAllSessions called, isShuttingDown already=${this.isShuttingDown}`);
+        // Set shutdown flag to suppress exit messages (should already be true from setShuttingDown)
         this.isShuttingDown = true;
         const count = this.sessions.size;
-        for (const [, session] of this.sessions.entries()) {
-            this.stopTyping(session);
-            session.claude.kill();
+        console.log(`  [shutdown] About to kill ${count} session(s) (preserving persistence for resume)`);
+        // Kill each session WITHOUT unpersisting - we want them to resume after restart
+        for (const [threadId] of this.sessions.entries()) {
+            this.killSession(threadId, false); // false = don't unpersist
+        }
+        // Maps should already be cleared by killSession, but clear again to be safe
+        this.sessions.clear();
+        this.postIndex.clear();
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        if (count > 0) {
+            console.log(`  ✖ Killed ${count} session${count === 1 ? '' : 's'} (sessions preserved for resume)`);
+        }
+    }
+    /** Kill all sessions AND unpersist them (for emergency shutdown - no resume) */
+    killAllSessionsAndUnpersist() {
+        this.isShuttingDown = true;
+        const count = this.sessions.size;
+        // Kill each session WITH unpersisting - emergency shutdown, no resume
+        for (const [threadId] of this.sessions.entries()) {
+            this.killSession(threadId, true); // true = unpersist
         }
         this.sessions.clear();
         this.postIndex.clear();
@@ -1288,7 +1381,7 @@ export class SessionManager {
             this.cleanupTimer = null;
         }
         if (count > 0) {
-            console.log(`  ✖ Killed ${count} session${count === 1 ? '' : 's'}`);
+            console.log(`  🔴 Emergency killed ${count} session${count === 1 ? '' : 's'} (sessions NOT preserved)`);
         }
     }
     /** Cleanup idle sessions that have exceeded timeout */

package/dist/index.js

@@ -9,6 +9,7 @@ import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { checkForUpdates } from './update-notifier.js';
 import { getReleaseNotes, formatReleaseNotes } from './changelog.js';
+import { printLogo } from './logo.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`;
@@ -55,10 +56,11 @@ async function main() {
     }
     const workingDir = process.cwd();
     const config = loadConfig(cliArgs);
-    // Nice startup banner
+    // Print ASCII logo
+    printLogo();
+    // Startup info
+    console.log(dim(`  v${pkg.version}`));
     console.log('');
-    console.log(bold(`  🤖 mm-claude v${pkg.version}`));
-    console.log(dim('  ─────────────────────────────────'));
     console.log(`  📂 ${cyan(workingDir)}`);
     console.log(`  💬 ${cyan('@' + config.mattermost.botName)}`);
     console.log(`  🌐 ${dim(config.mattermost.url)}`);
@@ -97,6 +99,31 @@ async function main() {
                     }
                     return;
                 }
+                // Check for !escape/!interrupt commands (soft interrupt, keeps session alive)
+                if (lowerContent === '!escape' || lowerContent === '!interrupt') {
+                    if (session.isUserAllowedInSession(threadRoot, username)) {
+                        await session.interruptSession(threadRoot, username);
+                    }
+                    return;
+                }
+                // Check for !kill command (emergency shutdown - authorized users only)
+                if (lowerContent === '!kill') {
+                    if (!mattermost.isUserAllowed(username)) {
+                        await mattermost.createPost('⛔ Only authorized users can use `!kill`', threadRoot);
+                        return;
+                    }
+                    // Notify all active sessions before killing
+                    for (const tid of session.getActiveThreadIds()) {
+                        try {
+                            await mattermost.createPost(`🔴 **EMERGENCY SHUTDOWN** by @${username}`, tid);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    console.log(`  🔴 EMERGENCY SHUTDOWN initiated by @${username}`);
+                    session.killAllSessionsAndUnpersist();
+                    mattermost.disconnect();
+                    process.exit(1);
+                }
                 // Check for !help command
                 if (lowerContent === '!help' || lowerContent === 'help') {
                     await mattermost.createPost(`**Available commands:**\n\n` +
@@ -108,10 +135,13 @@ async function main() {
                         `| \`!invite @user\` | Invite a user to this session |\n` +
                         `| \`!kick @user\` | Remove an invited user |\n` +
                         `| \`!permissions interactive\` | Enable interactive permissions |\n` +
-                        `| \`!stop\` | Stop this session |\n\n` +
+                        `| \`!escape\` | Interrupt current task (session stays active) |\n` +
+                        `| \`!stop\` | Stop this session |\n` +
+                        `| \`!kill\` | Emergency shutdown (kills ALL sessions, exits bot) |\n\n` +
                         `**Reactions:**\n` +
                         `- 👍 Approve action · ✅ Approve all · 👎 Deny\n` +
-                        `- ❌ or 🛑 on any message to stop session`, threadRoot);
+                        `- ⏸️ Interrupt current task (session stays active)\n` +
+                        `- ❌ or 🛑 Stop session`, threadRoot);
                     return;
                 }
                 // Check for !release-notes command
@@ -211,6 +241,8 @@ async function main() {
         isShuttingDown = true;
         console.log('');
         console.log(`  👋 ${dim('Shutting down...')}`);
+        // Set shutdown flag FIRST to prevent race conditions with exit events
+        session.setShuttingDown();
         // Post shutdown message to active sessions
         const activeThreads = session.getActiveThreadIds();
         if (activeThreads.length > 0) {

package/dist/logo.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ASCII Art Logo for Mattermost Claude Code
+ *
+ * Stylized M in Claude Code's block character style.
+ */
+/**
+ * ASCII logo for CLI display (with ANSI colors)
+ * Stylized M in block characters
+ */
+export declare const CLI_LOGO: string;
+/**
+ * ASCII logo for Mattermost (plain text, no ANSI codes)
+ */
+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```";
+/**
+ * Compact inline logo for Mattermost headers
+ */
+export declare const MATTERMOST_LOGO_INLINE = "`\u2590\u259BM\u259C\u258C` **mm-claude**";
+/**
+ * Very compact logo for space-constrained contexts
+ */
+export declare const LOGO_COMPACT = "\u2590\u259BM\u259C\u258C mm-claude";
+/**
+ * Print CLI logo to stdout
+ */
+export declare function printLogo(): void;

package/dist/logo.js

@@ -0,0 +1,46 @@
+/**
+ * ASCII Art Logo for Mattermost Claude Code
+ *
+ * Stylized M in Claude Code's block character style.
+ */
+// ANSI color codes for terminal
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    // Mattermost blue (#1C58D9)
+    blue: '\x1b[38;5;27m',
+    // Claude orange/coral
+    orange: '\x1b[38;5;209m',
+};
+/**
+ * ASCII logo for CLI display (with ANSI colors)
+ * Stylized M in block characters
+ */
+export const CLI_LOGO = `
+${colors.orange} ✴${colors.reset} ${colors.blue}▐█▙ ▟█▌${colors.reset} ${colors.orange}✴${colors.reset}   ${colors.bold}mm-claude${colors.reset}
+${colors.orange}✴${colors.reset}  ${colors.blue}▐█▐█▌█▌${colors.reset}  ${colors.orange}✴${colors.reset}  ${colors.dim}Mattermost × Claude Code${colors.reset}
+ ${colors.orange}✴${colors.reset} ${colors.blue}▐█▌ ▐█▌${colors.reset} ${colors.orange}✴${colors.reset}
+`;
+/**
+ * ASCII logo for Mattermost (plain text, no ANSI codes)
+ */
+export const MATTERMOST_LOGO = `\`\`\`
+ ✴ ▐█▙ ▟█▌ ✴   mm-claude
+✴  ▐█▐█▌█▌  ✴  Mattermost × Claude Code
+ ✴ ▐█▌ ▐█▌ ✴
+\`\`\``;
+/**
+ * Compact inline logo for Mattermost headers
+ */
+export const MATTERMOST_LOGO_INLINE = '`▐▛M▜▌` **mm-claude**';
+/**
+ * Very compact logo for space-constrained contexts
+ */
+export const LOGO_COMPACT = '▐▛M▜▌ mm-claude';
+/**
+ * Print CLI logo to stdout
+ */
+export function printLogo() {
+    console.log(CLI_LOGO);
+}

package/package.json

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