mattermost-claude-code 0.7.2 → 0.8.0

package/dist/claude/cli.d.ts

@@ -3,6 +3,19 @@ export interface ClaudeEvent {
     type: string;
     [key: string]: unknown;
 }
+export interface TextContentBlock {
+    type: 'text';
+    text: string;
+}
+export interface ImageContentBlock {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+}
+export type ContentBlock = TextContentBlock | ImageContentBlock;
 export interface ClaudeCliOptions {
     workingDir: string;
     threadId?: string;
@@ -15,7 +28,7 @@ export declare class ClaudeCli extends EventEmitter {
     debug: boolean;
     constructor(options: ClaudeCliOptions);
     start(): void;
-    sendMessage(content: string): void;
+    sendMessage(content: string | ContentBlock[]): void;
     sendToolResult(toolUseId: string, content: unknown): void;
     private parseOutput;
     isRunning(): boolean;

package/dist/claude/cli.js

@@ -77,6 +77,7 @@ export class ClaudeCli extends EventEmitter {
         });
     }
     // Send a user message via JSON stdin
+    // content can be a string or an array of content blocks (for images)
     sendMessage(content) {
         if (!this.process?.stdin)
             throw new Error('Not running');
@@ -85,7 +86,10 @@ export class ClaudeCli extends EventEmitter {
             message: { role: 'user', content }
         }) + '\n';
         if (this.debug) {
-            console.log(`  [claude] Sending: ${content.substring(0, 50)}...`);
+            const preview = typeof content === 'string'
+                ? content.substring(0, 50)
+                : `[${content.length} blocks]`;
+            console.log(`  [claude] Sending: ${preview}...`);
         }
         this.process.stdin.write(msg);
     }

package/dist/claude/session.d.ts

@@ -1,5 +1,6 @@
 import { ClaudeCli } from './cli.js';
 import { MattermostClient } from '../mattermost/client.js';
+import { MattermostFile } from '../mattermost/types.js';
 interface QuestionOption {
     label: string;
     description: string;
@@ -81,6 +82,7 @@ export declare class SessionManager {
     isUserAllowedInSession(threadId: string, username: string): boolean;
     startSession(options: {
         prompt: string;
+        files?: MattermostFile[];
     }, username: string, replyToPostId?: string): Promise<void>;
     private handleEvent;
     private handleTaskComplete;
@@ -97,6 +99,11 @@ export declare class SessionManager {
     private formatToolUse;
     private appendContent;
     private scheduleUpdate;
+    /**
+     * Build message content for Claude, including images if present.
+     * Returns either a string or an array of content blocks.
+     */
+    private buildMessageContent;
     private startTyping;
     private stopTyping;
     private flush;
@@ -106,7 +113,7 @@ export declare class SessionManager {
     /** Check if a session exists for this thread */
     isInSessionThread(threadRoot: string): boolean;
     /** Send a follow-up message to an existing session */
-    sendFollowUp(threadId: string, message: string): Promise<void>;
+    sendFollowUp(threadId: string, message: string, files?: MattermostFile[]): Promise<void>;
     /** Kill a specific session */
     killSession(threadId: string): void;
     /** Cancel a session with user feedback */

package/dist/claude/session.js

@@ -90,7 +90,7 @@ export class SessionManager {
         const existingSession = this.sessions.get(threadId);
         if (existingSession && existingSession.claude.isRunning()) {
             // Send as follow-up instead
-            await this.sendFollowUp(threadId, options.prompt);
+            await this.sendFollowUp(threadId, options.prompt, options.files);
             return;
         }
         // Check max sessions limit
@@ -155,8 +155,9 @@ export class SessionManager {
             this.sessions.delete(actualThreadId);
             return;
         }
-        // Send the message to Claude
-        claude.sendMessage(options.prompt);
+        // Send the message to Claude (with images if present)
+        const content = await this.buildMessageContent(options.prompt, options.files);
+        claude.sendMessage(content);
     }
     handleEvent(threadId, event) {
         const session = this.sessions.get(threadId);
@@ -678,6 +679,50 @@ export class SessionManager {
             this.flush(session);
         }, 500);
     }
+    /**
+     * Build message content for Claude, including images if present.
+     * Returns either a string or an array of content blocks.
+     */
+    async buildMessageContent(text, files) {
+        // Filter to only image files
+        const imageFiles = files?.filter(f => f.mime_type.startsWith('image/') &&
+            ['image/jpeg', 'image/png', 'image/gif', 'image/webp'].includes(f.mime_type)) || [];
+        // If no images, return plain text
+        if (imageFiles.length === 0) {
+            return text;
+        }
+        // Build content blocks with images
+        const blocks = [];
+        // Download and add each image
+        for (const file of imageFiles) {
+            try {
+                const buffer = await this.mattermost.downloadFile(file.id);
+                const base64 = buffer.toString('base64');
+                blocks.push({
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: file.mime_type,
+                        data: base64,
+                    },
+                });
+                if (this.debug) {
+                    console.log(`  📷 Attached image: ${file.name} (${file.mime_type}, ${Math.round(buffer.length / 1024)}KB)`);
+                }
+            }
+            catch (err) {
+                console.error(`  ⚠️ Failed to download image ${file.name}:`, err);
+            }
+        }
+        // Add the text message
+        if (text) {
+            blocks.push({
+                type: 'text',
+                text,
+            });
+        }
+        return blocks;
+    }
     startTyping(session) {
         if (session.typingTimer)
             return;
@@ -713,6 +758,7 @@ export class SessionManager {
             return;
         // If we're intentionally restarting (e.g., !cd), don't clean up or post exit message
         if (session.isRestarting) {
+            session.isRestarting = false; // Reset flag here, after the exit event fires
             return;
         }
         this.stopTyping(session);
@@ -748,11 +794,12 @@ export class SessionManager {
         return session !== undefined && session.claude.isRunning();
     }
     /** Send a follow-up message to an existing session */
-    async sendFollowUp(threadId, message) {
+    async sendFollowUp(threadId, message, files) {
         const session = this.sessions.get(threadId);
         if (!session || !session.claude.isRunning())
             return;
-        session.claude.sendMessage(message);
+        const content = await this.buildMessageContent(message, files);
+        session.claude.sendMessage(content);
         session.lastActivityAt = new Date();
         this.startTyping(session);
     }
@@ -836,10 +883,10 @@ export class SessionManager {
         // Start the new Claude CLI
         try {
             session.claude.start();
-            session.isRestarting = false; // Successfully restarted
+            // Note: isRestarting is reset in handleExit when the old process exit event fires
         }
         catch (err) {
-            session.isRestarting = false; // Reset flag even on failure
+            session.isRestarting = false; // Reset flag on failure since exit won't fire
             console.error('  ❌ Failed to restart Claude:', err);
             await this.mattermost.createPost(`❌ Failed to restart Claude: ${err}`, threadId);
             return;

package/dist/index.js

@@ -149,8 +149,10 @@ async function main() {
                     await session.requestMessageApproval(threadRoot, username, content);
                 return;
             }
-            if (content)
-                await session.sendFollowUp(threadRoot, content);
+            // Get any attached files (images)
+            const files = post.metadata?.files;
+            if (content || files?.length)
+                await session.sendFollowUp(threadRoot, content, files);
             return;
         }
         // New session requires @mention
@@ -161,11 +163,12 @@ async function main() {
             return;
         }
         const prompt = mattermost.extractPrompt(message);
-        if (!prompt) {
+        const files = post.metadata?.files;
+        if (!prompt && !files?.length) {
             await mattermost.createPost(`Mention me with your request`, threadRoot);
             return;
         }
-        await session.startSession({ prompt }, username, threadRoot);
+        await session.startSession({ prompt, files }, username, threadRoot);
     });
     mattermost.on('connected', () => { });
     mattermost.on('error', (e) => console.error('  ❌ Error:', e));

package/dist/mattermost/client.d.ts

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

package/dist/mattermost/client.js

@@ -102,6 +102,10 @@ export class MattermostClient extends EventEmitter {
         const arrayBuffer = await response.arrayBuffer();
         return Buffer.from(arrayBuffer);
     }
+    // Get file info (metadata)
+    async getFileInfo(fileId) {
+        return this.api('GET', `/files/${fileId}/info`);
+    }
     // Connect to WebSocket
     async connect() {
         // Get bot user first

package/package.json

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