mattermost-claude-code 0.2.0

package/dist/config.js

@@ -0,0 +1,41 @@
+import { config } from 'dotenv';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+// Load .env file from multiple locations (in order of priority)
+const envPaths = [
+    resolve(process.cwd(), '.env'), // Current directory
+    resolve(homedir(), '.config', 'mm-claude', '.env'), // ~/.config/mm-claude/.env
+    resolve(homedir(), '.mm-claude.env'), // ~/.mm-claude.env
+];
+for (const envPath of envPaths) {
+    if (existsSync(envPath)) {
+        console.log(`📄 Loading config from: ${envPath}`);
+        config({ path: envPath });
+        break;
+    }
+}
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        throw new Error(`Missing required environment variable: ${name}`);
+    }
+    return value;
+}
+export function loadConfig() {
+    return {
+        mattermost: {
+            url: requireEnv('MATTERMOST_URL').replace(/\/$/, ''), // Remove trailing slash
+            token: requireEnv('MATTERMOST_TOKEN'),
+            channelId: requireEnv('MATTERMOST_CHANNEL_ID'),
+            botName: process.env.MATTERMOST_BOT_NAME || 'claude-code',
+        },
+        allowedUsers: (process.env.ALLOWED_USERS || '')
+            .split(',')
+            .map(u => u.trim())
+            .filter(u => u.length > 0),
+        // SKIP_PERMISSIONS=true or --dangerously-skip-permissions flag
+        skipPermissions: process.env.SKIP_PERMISSIONS === 'true' ||
+            process.argv.includes('--dangerously-skip-permissions'),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { loadConfig } from './config.js';
+import { MattermostClient } from './mattermost/client.js';
+import { SessionManager } from './claude/session.js';
+async function main() {
+    if (process.argv.includes('--help') || process.argv.includes('-h')) {
+        console.log(`mm-claude - Share Claude Code sessions in Mattermost
+
+Usage: cd /your/project && mm-claude`);
+        process.exit(0);
+    }
+    const workingDir = process.cwd();
+    const config = loadConfig();
+    console.log(`🚀 mm-claude starting...`);
+    console.log(`📂 ${workingDir}`);
+    console.log(`📝 @${config.mattermost.botName} on ${config.mattermost.url}`);
+    const mattermost = new MattermostClient(config);
+    const session = new SessionManager(mattermost, workingDir, config.skipPermissions);
+    if (config.skipPermissions) {
+        console.log('⚠️  Permissions skipped (--dangerously-skip-permissions)');
+    }
+    else {
+        console.log('🔐 Interactive permissions enabled');
+    }
+    mattermost.on('message', async (post, user) => {
+        const username = user?.username || 'unknown';
+        const message = post.message;
+        const threadRoot = post.root_id || post.id;
+        // Follow-up in active thread
+        if (session.isInCurrentSessionThread(threadRoot)) {
+            if (!mattermost.isUserAllowed(username))
+                return;
+            const content = mattermost.isBotMentioned(message)
+                ? mattermost.extractPrompt(message)
+                : message.trim();
+            if (content)
+                await session.sendFollowUp(content);
+            return;
+        }
+        // New session requires @mention
+        if (!mattermost.isBotMentioned(message))
+            return;
+        if (!mattermost.isUserAllowed(username)) {
+            await mattermost.createPost(`⚠️ @${username} is not authorized`, threadRoot);
+            return;
+        }
+        const prompt = mattermost.extractPrompt(message);
+        if (!prompt) {
+            await mattermost.createPost(`Mention me with your request`, threadRoot);
+            return;
+        }
+        await session.startSession({ prompt }, username, threadRoot);
+    });
+    mattermost.on('connected', () => console.log('✅ Connected'));
+    mattermost.on('error', (e) => console.error('❌', e));
+    await mattermost.connect();
+    console.log(`🎉 Ready! @${config.mattermost.botName}`);
+    const shutdown = () => {
+        console.log('\n👋 Bye');
+        session.killSession();
+        mattermost.disconnect();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch(e => { console.error(e); process.exit(1); });

package/dist/mattermost/client.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter } from 'events';
+import type { Config } from '../config.js';
+import type { MattermostPost, MattermostUser, MattermostReaction } from './types.js';
+export interface MattermostClientEvents {
+    connected: () => void;
+    disconnected: () => void;
+    error: (error: Error) => void;
+    message: (post: MattermostPost, user: MattermostUser | null) => void;
+    reaction: (reaction: MattermostReaction, user: MattermostUser | null) => void;
+}
+export declare class MattermostClient extends EventEmitter {
+    private ws;
+    private config;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private userCache;
+    private botUserId;
+    constructor(config: Config);
+    private api;
+    getBotUser(): Promise<MattermostUser>;
+    getUser(userId: string): Promise<MattermostUser | null>;
+    createPost(message: string, threadId?: string): Promise<MattermostPost>;
+    updatePost(postId: string, message: string): Promise<MattermostPost>;
+    addReaction(postId: string, emojiName: string): Promise<void>;
+    connect(): Promise<void>;
+    private handleEvent;
+    private scheduleReconnect;
+    isUserAllowed(username: string): boolean;
+    isBotMentioned(message: string): boolean;
+    extractPrompt(message: string): string;
+    getBotName(): string;
+    sendTyping(parentId?: string): void;
+    disconnect(): void;
+}

package/dist/mattermost/client.js

@@ -0,0 +1,226 @@
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+export class MattermostClient extends EventEmitter {
+    ws = null;
+    config;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 10;
+    reconnectDelay = 1000;
+    userCache = new Map();
+    botUserId = null;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    // REST API helper
+    async api(method, path, body) {
+        const url = `${this.config.mattermost.url}/api/v4${path}`;
+        const response = await fetch(url, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.config.mattermost.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Mattermost API error ${response.status}: ${text}`);
+        }
+        return response.json();
+    }
+    // Get current bot user info
+    async getBotUser() {
+        const user = await this.api('GET', '/users/me');
+        this.botUserId = user.id;
+        return user;
+    }
+    // Get user by ID (cached)
+    async getUser(userId) {
+        if (this.userCache.has(userId)) {
+            return this.userCache.get(userId);
+        }
+        try {
+            const user = await this.api('GET', `/users/${userId}`);
+            this.userCache.set(userId, user);
+            return user;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Post a message
+    async createPost(message, threadId) {
+        const request = {
+            channel_id: this.config.mattermost.channelId,
+            message,
+            root_id: threadId,
+        };
+        return this.api('POST', '/posts', request);
+    }
+    // Update a message (for streaming updates)
+    async updatePost(postId, message) {
+        const request = {
+            id: postId,
+            message,
+        };
+        return this.api('PUT', `/posts/${postId}`, request);
+    }
+    // Add a reaction to a post
+    async addReaction(postId, emojiName) {
+        await this.api('POST', '/reactions', {
+            user_id: this.botUserId,
+            post_id: postId,
+            emoji_name: emojiName,
+        });
+    }
+    // Connect to WebSocket
+    async connect() {
+        // Get bot user first
+        await this.getBotUser();
+        console.log(`[MM] Bot user ID: ${this.botUserId}`);
+        const wsUrl = this.config.mattermost.url
+            .replace(/^http/, 'ws')
+            .concat('/api/v4/websocket');
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(wsUrl);
+            this.ws.on('open', () => {
+                console.log('[MM] WebSocket connected');
+                // Authenticate
+                this.ws.send(JSON.stringify({
+                    seq: 1,
+                    action: 'authentication_challenge',
+                    data: { token: this.config.mattermost.token },
+                }));
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const event = JSON.parse(data.toString());
+                    this.handleEvent(event);
+                    // Authentication success
+                    if (event.event === 'hello') {
+                        this.reconnectAttempts = 0;
+                        this.emit('connected');
+                        resolve();
+                    }
+                }
+                catch (err) {
+                    console.error('[MM] Failed to parse WebSocket message:', err);
+                }
+            });
+            this.ws.on('close', () => {
+                console.log('[MM] WebSocket disconnected');
+                this.emit('disconnected');
+                this.scheduleReconnect();
+            });
+            this.ws.on('error', (err) => {
+                console.error('[MM] WebSocket error:', err);
+                this.emit('error', err);
+                reject(err);
+            });
+        });
+    }
+    handleEvent(event) {
+        // Handle posted events
+        if (event.event === 'posted') {
+            const data = event.data;
+            if (!data.post)
+                return;
+            try {
+                const post = JSON.parse(data.post);
+                // Ignore messages from ourselves
+                if (post.user_id === this.botUserId)
+                    return;
+                // Only handle messages in our channel
+                if (post.channel_id !== this.config.mattermost.channelId)
+                    return;
+                // Get user info and emit
+                this.getUser(post.user_id).then((user) => {
+                    this.emit('message', post, user);
+                });
+            }
+            catch (err) {
+                console.error('[MM] Failed to parse post:', err);
+            }
+            return;
+        }
+        // Handle reaction_added events
+        if (event.event === 'reaction_added') {
+            const data = event.data;
+            if (!data.reaction)
+                return;
+            try {
+                const reaction = JSON.parse(data.reaction);
+                // Ignore reactions from ourselves
+                if (reaction.user_id === this.botUserId)
+                    return;
+                // Get user info and emit
+                this.getUser(reaction.user_id).then((user) => {
+                    this.emit('reaction', reaction, user);
+                });
+            }
+            catch (err) {
+                console.error('[MM] Failed to parse reaction:', err);
+            }
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error('[MM] Max reconnection attempts reached');
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        console.log(`[MM] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        setTimeout(() => {
+            this.connect().catch((err) => {
+                console.error('[MM] Reconnection failed:', err);
+            });
+        }, delay);
+    }
+    // Check if user is allowed to use the bot
+    isUserAllowed(username) {
+        if (this.config.allowedUsers.length === 0) {
+            // If no allowlist configured, allow all
+            return true;
+        }
+        return this.config.allowedUsers.includes(username);
+    }
+    // Check if message mentions the bot
+    isBotMentioned(message) {
+        const botName = this.config.mattermost.botName;
+        // Match @botname at start or with space before
+        const mentionPattern = new RegExp(`(^|\\s)@${botName}\\b`, 'i');
+        return mentionPattern.test(message);
+    }
+    // Extract prompt from message (remove bot mention)
+    extractPrompt(message) {
+        const botName = this.config.mattermost.botName;
+        return message
+            .replace(new RegExp(`(^|\\s)@${botName}\\b`, 'gi'), ' ')
+            .trim();
+    }
+    // Get the bot name
+    getBotName() {
+        return this.config.mattermost.botName;
+    }
+    // Send typing indicator via WebSocket
+    sendTyping(parentId) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        this.ws.send(JSON.stringify({
+            action: 'user_typing',
+            seq: Date.now(),
+            data: {
+                channel_id: this.config.mattermost.channelId,
+                parent_id: parentId || '',
+            },
+        }));
+    }
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+}

package/dist/mattermost/message-formatter.d.ts

@@ -0,0 +1,28 @@
+import type { AssistantEvent, ToolUseEvent, ToolResultEvent, ResultEvent } from '../claude/types.js';
+/**
+ * Format Claude events into Mattermost-friendly messages
+ * Styled to look similar to Claude Code CLI output
+ */
+export declare class MessageFormatter {
+    private pendingToolUses;
+    formatUserPrompt(username: string, prompt: string): string;
+    formatSessionStart(workingDir: string): string;
+    formatSessionEnd(result?: ResultEvent): string;
+    formatAssistantMessage(event: AssistantEvent): string;
+    formatToolUse(event: ToolUseEvent): string;
+    private formatReadTool;
+    private formatEditTool;
+    private formatWriteTool;
+    private formatBashTool;
+    private formatGlobTool;
+    private formatGrepTool;
+    private formatTaskTool;
+    private formatWebSearchTool;
+    private formatWebFetchTool;
+    private formatTodoWriteTool;
+    formatToolResult(event: ToolResultEvent): string | null;
+    formatUnauthorized(username: string): string;
+    formatError(error: string): string;
+    private truncate;
+    private shortenPath;
+}

package/dist/mattermost/message-formatter.js

@@ -0,0 +1,244 @@
+/**
+ * Format Claude events into Mattermost-friendly messages
+ * Styled to look similar to Claude Code CLI output
+ */
+export class MessageFormatter {
+    // Store tool results to show line counts, etc.
+    pendingToolUses = new Map();
+    // Format a user's prompt for display (like Claude Code's user input)
+    formatUserPrompt(username, prompt) {
+        return `> **${username}:** ${prompt}`;
+    }
+    // Format session start
+    formatSessionStart(workingDir) {
+        const shortPath = this.shortenPath(workingDir);
+        return [
+            '```',
+            `🚀 Session started`,
+            `   Working directory: ${shortPath}`,
+            '```',
+        ].join('\n');
+    }
+    // Format session end with stats
+    formatSessionEnd(result) {
+        if (result?.cost_usd) {
+            const duration = result.duration_ms
+                ? `${(result.duration_ms / 1000).toFixed(1)}s`
+                : '';
+            const cost = `$${result.cost_usd.toFixed(4)}`;
+            return [
+                '```',
+                `✓ Session completed`,
+                `   Duration: ${duration} | Cost: ${cost}`,
+                '```',
+            ].join('\n');
+        }
+        return '```\n✓ Session completed\n```';
+    }
+    // Format assistant message content
+    formatAssistantMessage(event) {
+        const content = event.message.content;
+        const parts = [];
+        for (const block of content) {
+            if (block.type === 'text') {
+                parts.push(block.text);
+            }
+        }
+        return parts.join('\n');
+    }
+    // Format tool use - Claude Code style: ● ToolName(args)
+    formatToolUse(event) {
+        const { id, name, input } = event.tool_use;
+        // Store for later when we get the result
+        this.pendingToolUses.set(id, event);
+        switch (name) {
+            case 'Read':
+                return this.formatReadTool(input);
+            case 'Edit':
+                return this.formatEditTool(input);
+            case 'Write':
+                return this.formatWriteTool(input);
+            case 'Bash':
+                return this.formatBashTool(input);
+            case 'Glob':
+                return this.formatGlobTool(input);
+            case 'Grep':
+                return this.formatGrepTool(input);
+            case 'Task':
+                return this.formatTaskTool(input);
+            case 'WebSearch':
+                return this.formatWebSearchTool(input);
+            case 'WebFetch':
+                return this.formatWebFetchTool(input);
+            case 'TodoWrite':
+                return this.formatTodoWriteTool(input);
+            default:
+                return `● **${name}**`;
+        }
+    }
+    formatReadTool(input) {
+        const path = input.file_path;
+        const shortPath = this.shortenPath(path);
+        return `● **Read**(\`${shortPath}\`)`;
+    }
+    formatEditTool(input) {
+        const path = input.file_path;
+        const shortPath = this.shortenPath(path);
+        const oldStr = input.old_string;
+        const newStr = input.new_string;
+        // Count lines changed
+        const oldLines = oldStr.split('\n').length;
+        const newLines = newStr.split('\n').length;
+        // Create diff preview
+        const diffLines = [];
+        const oldPreview = oldStr.split('\n').slice(0, 3);
+        const newPreview = newStr.split('\n').slice(0, 3);
+        for (const line of oldPreview) {
+            diffLines.push(`- ${line}`);
+        }
+        if (oldLines > 3)
+            diffLines.push(`  ... (${oldLines - 3} more lines)`);
+        for (const line of newPreview) {
+            diffLines.push(`+ ${line}`);
+        }
+        if (newLines > 3)
+            diffLines.push(`  ... (${newLines - 3} more lines)`);
+        return [
+            `● **Edit**(\`${shortPath}\`)`,
+            '```diff',
+            ...diffLines,
+            '```',
+        ].join('\n');
+    }
+    formatWriteTool(input) {
+        const path = input.file_path;
+        const shortPath = this.shortenPath(path);
+        const content = input.content;
+        const lines = content.split('\n').length;
+        return `● **Write**(\`${shortPath}\`) - ${lines} lines`;
+    }
+    formatBashTool(input) {
+        const command = input.command;
+        const desc = input.description;
+        // Truncate long commands
+        const cmdPreview = command.length > 80
+            ? command.substring(0, 77) + '...'
+            : command;
+        if (desc) {
+            return [
+                `● **Bash**(${desc})`,
+                '```bash',
+                cmdPreview,
+                '```',
+            ].join('\n');
+        }
+        return [
+            `● **Bash**`,
+            '```bash',
+            cmdPreview,
+            '```',
+        ].join('\n');
+    }
+    formatGlobTool(input) {
+        const pattern = input.pattern;
+        return `● **Glob**(\`${pattern}\`)`;
+    }
+    formatGrepTool(input) {
+        const pattern = input.pattern;
+        const path = input.path;
+        if (path) {
+            return `● **Grep**(\`${pattern}\` in \`${this.shortenPath(path)}\`)`;
+        }
+        return `● **Grep**(\`${pattern}\`)`;
+    }
+    formatTaskTool(input) {
+        const desc = input.description;
+        const type = input.subagent_type;
+        if (desc) {
+            return `● **Task**(${type || 'agent'}: ${desc})`;
+        }
+        return `● **Task**(${type || 'agent'})`;
+    }
+    formatWebSearchTool(input) {
+        const query = input.query;
+        return `● **WebSearch**(\`${query}\`)`;
+    }
+    formatWebFetchTool(input) {
+        const url = input.url;
+        const shortUrl = url.length > 50 ? url.substring(0, 47) + '...' : url;
+        return `● **WebFetch**(\`${shortUrl}\`)`;
+    }
+    formatTodoWriteTool(input) {
+        const todos = input.todos;
+        if (todos && todos.length > 0) {
+            const summary = todos.slice(0, 2).map(t => t.content).join(', ');
+            const more = todos.length > 2 ? ` +${todos.length - 2} more` : '';
+            return `● **TodoWrite**(${summary}${more})`;
+        }
+        return `● **TodoWrite**`;
+    }
+    // Format tool result with line counts, etc.
+    formatToolResult(event) {
+        const { tool_use_id, content, is_error } = event.tool_result;
+        const toolUse = this.pendingToolUses.get(tool_use_id);
+        if (is_error) {
+            const errorMsg = typeof content === 'string'
+                ? content
+                : JSON.stringify(content);
+            return `  ↳ ❌ ${this.truncate(errorMsg, 150)}`;
+        }
+        // Get result as string
+        const resultStr = typeof content === 'string'
+            ? content
+            : JSON.stringify(content, null, 2);
+        // For Read tool, show line count
+        if (toolUse?.tool_use.name === 'Read') {
+            const lines = resultStr.split('\n').length;
+            return `  ↳ Read ${lines} lines`;
+        }
+        // For Glob, show file count
+        if (toolUse?.tool_use.name === 'Glob') {
+            const files = resultStr.split('\n').filter(l => l.trim()).length;
+            return `  ↳ Found ${files} files`;
+        }
+        // For Grep, show match count
+        if (toolUse?.tool_use.name === 'Grep') {
+            const matches = resultStr.split('\n').filter(l => l.trim()).length;
+            return `  ↳ Found ${matches} matches`;
+        }
+        // For Bash, show truncated output if not too long
+        if (toolUse?.tool_use.name === 'Bash' && resultStr.length > 0) {
+            const lines = resultStr.split('\n');
+            if (lines.length <= 5 && resultStr.length < 300) {
+                return '  ↳ ```\n' + resultStr + '\n  ```';
+            }
+            return `  ↳ Output: ${lines.length} lines`;
+        }
+        // Skip showing most results to avoid noise
+        return null;
+    }
+    // Format unauthorized user message
+    formatUnauthorized(username) {
+        return `⚠️ Sorry @${username}, you're not authorized to use this bot.`;
+    }
+    // Format error message
+    formatError(error) {
+        return `❌ **Error:** ${error}`;
+    }
+    // Helper to truncate strings
+    truncate(str, maxLength) {
+        const clean = str.replace(/\n/g, ' ').trim();
+        if (clean.length <= maxLength)
+            return clean;
+        return clean.substring(0, maxLength - 3) + '...';
+    }
+    // Helper to shorten file paths
+    shortenPath(path) {
+        // Replace home directory with ~
+        const home = process.env.HOME || '/Users/anneschuth';
+        if (path.startsWith(home)) {
+            return '~' + path.substring(home.length);
+        }
+        return path;
+    }
+}