mattermost-claude-code 0.2.0

package/dist/claude/session.js

@@ -0,0 +1,582 @@
+import { ClaudeCli } from './cli.js';
+const REACTION_EMOJIS = ['one', 'two', 'three', 'four'];
+const EMOJI_TO_INDEX = {
+    'one': 0, '1️⃣': 0,
+    'two': 1, '2️⃣': 1,
+    'three': 2, '3️⃣': 2,
+    'four': 3, '4️⃣': 3,
+};
+export class SessionManager {
+    claude = null;
+    mattermost;
+    workingDir;
+    skipPermissions;
+    session = null;
+    updateTimer = null;
+    typingTimer = null;
+    pendingQuestionSet = null;
+    pendingApproval = null;
+    planApproved = false; // Track if we already approved this session
+    tasksPostId = null; // Track the tasks display post
+    activeSubagents = new Map(); // taskId -> postId for subagent status
+    debug = process.env.DEBUG === '1' || process.argv.includes('--debug');
+    constructor(mattermost, workingDir, skipPermissions = false) {
+        this.mattermost = mattermost;
+        this.workingDir = workingDir;
+        this.skipPermissions = skipPermissions;
+        // Listen for reactions to answer questions
+        this.mattermost.on('reaction', (reaction, user) => {
+            this.handleReaction(reaction.post_id, reaction.emoji_name, user?.username || 'unknown');
+        });
+    }
+    async startSession(options, username, replyToPostId) {
+        // Start Claude if not running
+        if (!this.claude?.isRunning()) {
+            const msg = `🚀 **Session started**\n> Working directory: \`${this.workingDir}\``;
+            const post = await this.mattermost.createPost(msg, replyToPostId);
+            const threadId = replyToPostId || post.id;
+            this.session = { threadId, postId: null, content: '' };
+            this.planApproved = false; // Reset for new session
+            this.tasksPostId = null; // Reset tasks display
+            this.activeSubagents.clear(); // Clear subagent tracking
+            // Create Claude CLI with options (including threadId for permissions)
+            const cliOptions = {
+                workingDir: this.workingDir,
+                threadId: threadId,
+                skipPermissions: this.skipPermissions,
+            };
+            this.claude = new ClaudeCli(cliOptions);
+            this.claude.on('event', (e) => this.handleEvent(e));
+            this.claude.on('exit', (code) => this.handleExit(code));
+            try {
+                this.claude.start();
+            }
+            catch (err) {
+                console.error('[Session] Start error:', err);
+                await this.mattermost.createPost(`❌ ${err}`, threadId);
+                this.session = null;
+                return;
+            }
+        }
+        // Send the message and start typing indicator
+        this.claude.sendMessage(options.prompt);
+        this.startTyping();
+    }
+    handleEvent(event) {
+        // Check for special tool uses that need custom handling
+        if (event.type === 'assistant') {
+            const msg = event.message;
+            let hasSpecialTool = false;
+            for (const block of msg?.content || []) {
+                if (block.type === 'tool_use') {
+                    if (block.name === 'ExitPlanMode') {
+                        this.handleExitPlanMode();
+                        hasSpecialTool = true;
+                    }
+                    else if (block.name === 'TodoWrite') {
+                        this.handleTodoWrite(block.input);
+                        // Don't set hasSpecialTool - let other content through
+                    }
+                    else if (block.name === 'Task') {
+                        this.handleTaskStart(block.id, block.input);
+                        // Don't set hasSpecialTool - let other content through
+                    }
+                    else if (block.name === 'AskUserQuestion') {
+                        this.handleAskUserQuestion(block.id, block.input);
+                        hasSpecialTool = true;
+                    }
+                }
+            }
+            // Skip normal output if we handled a special tool (we post it ourselves)
+            if (hasSpecialTool)
+                return;
+        }
+        // Check for tool_result to update subagent status
+        if (event.type === 'user') {
+            const msg = event.message;
+            for (const block of msg?.content || []) {
+                if (block.type === 'tool_result' && block.tool_use_id) {
+                    const postId = this.activeSubagents.get(block.tool_use_id);
+                    if (postId) {
+                        this.handleTaskComplete(block.tool_use_id, postId);
+                    }
+                }
+            }
+        }
+        const formatted = this.formatEvent(event);
+        if (this.debug) {
+            console.log(`[DEBUG] handleEvent: ${event.type} -> ${formatted ? formatted.substring(0, 100) : '(null)'}`);
+        }
+        if (formatted)
+            this.appendContent(formatted);
+    }
+    async handleTaskComplete(toolUseId, postId) {
+        try {
+            await this.mattermost.updatePost(postId, this.activeSubagents.has(toolUseId)
+                ? `🤖 **Subagent** ✅ *completed*`
+                : `🤖 **Subagent** ✅`);
+            this.activeSubagents.delete(toolUseId);
+        }
+        catch (err) {
+            console.error('[Session] Failed to update subagent completion:', err);
+        }
+    }
+    async handleExitPlanMode() {
+        if (!this.session)
+            return;
+        // If already approved in this session, auto-continue
+        if (this.planApproved) {
+            console.log('[Session] Plan already approved, auto-continuing...');
+            if (this.claude?.isRunning()) {
+                this.claude.sendMessage('Continue with the implementation.');
+                this.startTyping();
+            }
+            return;
+        }
+        // If we already have a pending approval, don't post another one
+        if (this.pendingApproval && this.pendingApproval.type === 'plan') {
+            console.log('[Session] Plan approval already pending, waiting...');
+            return;
+        }
+        // Flush any pending content first
+        await this.flush();
+        this.session.postId = null;
+        this.session.content = '';
+        // Post approval message with reactions
+        const message = `✅ **Plan ready for approval**\n\n` +
+            `👍 Approve and start building\n` +
+            `👎 Request changes\n\n` +
+            `*React to respond*`;
+        const post = await this.mattermost.createPost(message, this.session.threadId);
+        // Add approval reactions
+        try {
+            await this.mattermost.addReaction(post.id, '+1');
+            await this.mattermost.addReaction(post.id, '-1');
+        }
+        catch (err) {
+            console.error('[Session] Failed to add approval reactions:', err);
+        }
+        // Track this for reaction handling
+        this.pendingApproval = { postId: post.id, type: 'plan' };
+        // Stop typing while waiting
+        this.stopTyping();
+    }
+    async handleTodoWrite(input) {
+        if (!this.session)
+            return;
+        const todos = input.todos;
+        if (!todos || todos.length === 0) {
+            // Clear tasks display if empty
+            if (this.tasksPostId) {
+                try {
+                    await this.mattermost.updatePost(this.tasksPostId, '📋 ~~Tasks~~ *(completed)*');
+                }
+                catch (err) {
+                    console.error('[Session] Failed to update tasks:', err);
+                }
+            }
+            return;
+        }
+        // Format tasks nicely
+        let message = '📋 **Tasks**\n\n';
+        for (const todo of todos) {
+            let icon;
+            let text;
+            switch (todo.status) {
+                case 'completed':
+                    icon = '✅';
+                    text = `~~${todo.content}~~`;
+                    break;
+                case 'in_progress':
+                    icon = '🔄';
+                    text = `**${todo.activeForm}**`;
+                    break;
+                default: // pending
+                    icon = '⬜';
+                    text = todo.content;
+            }
+            message += `${icon} ${text}\n`;
+        }
+        // Update or create tasks post
+        try {
+            if (this.tasksPostId) {
+                await this.mattermost.updatePost(this.tasksPostId, message);
+            }
+            else {
+                const post = await this.mattermost.createPost(message, this.session.threadId);
+                this.tasksPostId = post.id;
+            }
+        }
+        catch (err) {
+            console.error('[Session] Failed to update tasks:', err);
+        }
+    }
+    async handleTaskStart(toolUseId, input) {
+        if (!this.session)
+            return;
+        const description = input.description || 'Working...';
+        const subagentType = input.subagent_type || 'general';
+        // Post subagent status
+        const message = `🤖 **Subagent** *(${subagentType})*\n` +
+            `> ${description}\n` +
+            `⏳ Running...`;
+        try {
+            const post = await this.mattermost.createPost(message, this.session.threadId);
+            this.activeSubagents.set(toolUseId, post.id);
+        }
+        catch (err) {
+            console.error('[Session] Failed to post subagent status:', err);
+        }
+    }
+    async handleAskUserQuestion(toolUseId, input) {
+        if (!this.session)
+            return;
+        // If we already have pending questions, don't start another set
+        if (this.pendingQuestionSet) {
+            console.log('[Session] Questions already pending, waiting...');
+            return;
+        }
+        // Flush any pending content first
+        await this.flush();
+        this.session.postId = null;
+        this.session.content = '';
+        const questions = input.questions;
+        if (!questions || questions.length === 0)
+            return;
+        // Create a new question set - we'll ask one at a time
+        this.pendingQuestionSet = {
+            toolUseId,
+            currentIndex: 0,
+            currentPostId: null,
+            questions: questions.map(q => ({
+                header: q.header,
+                question: q.question,
+                options: q.options,
+                answer: null,
+            })),
+        };
+        // Post the first question
+        await this.postCurrentQuestion();
+        // Stop typing while waiting for answer
+        this.stopTyping();
+    }
+    async postCurrentQuestion() {
+        if (!this.session || !this.pendingQuestionSet)
+            return;
+        const { currentIndex, questions } = this.pendingQuestionSet;
+        if (currentIndex >= questions.length)
+            return;
+        const q = questions[currentIndex];
+        const total = questions.length;
+        // Format the question message - show "Question (1/3)" not the header
+        let message = `❓ **Question** *(${currentIndex + 1}/${total})*\n`;
+        message += `**${q.header}:** ${q.question}\n\n`;
+        for (let i = 0; i < q.options.length && i < 4; i++) {
+            const emoji = ['1️⃣', '2️⃣', '3️⃣', '4️⃣'][i];
+            message += `${emoji} **${q.options[i].label}**`;
+            if (q.options[i].description) {
+                message += ` - ${q.options[i].description}`;
+            }
+            message += '\n';
+        }
+        // Post the question
+        const post = await this.mattermost.createPost(message, this.session.threadId);
+        this.pendingQuestionSet.currentPostId = post.id;
+        // Add reaction emojis
+        for (let i = 0; i < q.options.length && i < 4; i++) {
+            try {
+                await this.mattermost.addReaction(post.id, REACTION_EMOJIS[i]);
+            }
+            catch (err) {
+                console.error(`[Session] Failed to add reaction ${REACTION_EMOJIS[i]}:`, err);
+            }
+        }
+    }
+    async handleReaction(postId, emojiName, username) {
+        // Check if user is allowed
+        if (!this.mattermost.isUserAllowed(username))
+            return;
+        // Handle approval reactions
+        if (this.pendingApproval && this.pendingApproval.postId === postId) {
+            await this.handleApprovalReaction(emojiName, username);
+            return;
+        }
+        // Handle question reactions - must be for current question
+        if (!this.pendingQuestionSet || this.pendingQuestionSet.currentPostId !== postId)
+            return;
+        const { currentIndex, questions } = this.pendingQuestionSet;
+        const question = questions[currentIndex];
+        if (!question)
+            return;
+        const optionIndex = EMOJI_TO_INDEX[emojiName];
+        if (optionIndex === undefined || optionIndex >= question.options.length)
+            return;
+        const selectedOption = question.options[optionIndex];
+        question.answer = selectedOption.label;
+        console.log(`[Session] User ${username} answered "${question.header}": ${selectedOption.label}`);
+        // Update the post to show answer
+        try {
+            await this.mattermost.updatePost(postId, `✅ **${question.header}**: ${selectedOption.label}`);
+        }
+        catch (err) {
+            console.error('[Session] Failed to update answered question:', err);
+        }
+        // Move to next question or finish
+        this.pendingQuestionSet.currentIndex++;
+        if (this.pendingQuestionSet.currentIndex < questions.length) {
+            // Post next question
+            await this.postCurrentQuestion();
+        }
+        else {
+            // All questions answered - send as follow-up message
+            // (CLI auto-responds with error to AskUserQuestion, so tool_result won't work)
+            let answersText = 'Here are my answers:\n';
+            for (const q of questions) {
+                answersText += `- **${q.header}**: ${q.answer}\n`;
+            }
+            console.log(`[Session] All questions answered, sending as message:`, answersText);
+            // Clear and send as regular message
+            this.pendingQuestionSet = null;
+            if (this.claude?.isRunning()) {
+                this.claude.sendMessage(answersText);
+                this.startTyping();
+            }
+        }
+    }
+    async handleApprovalReaction(emojiName, username) {
+        if (!this.pendingApproval)
+            return;
+        const isApprove = emojiName === '+1' || emojiName === 'thumbsup';
+        const isReject = emojiName === '-1' || emojiName === 'thumbsdown';
+        if (!isApprove && !isReject)
+            return;
+        const postId = this.pendingApproval.postId;
+        console.log(`[Session] User ${username} ${isApprove ? 'approved' : 'rejected'} the plan`);
+        // Update the post to show the decision
+        try {
+            const statusMessage = isApprove
+                ? `✅ **Plan approved** by @${username} - starting implementation...`
+                : `❌ **Changes requested** by @${username}`;
+            await this.mattermost.updatePost(postId, statusMessage);
+        }
+        catch (err) {
+            console.error('[Session] Failed to update approval post:', err);
+        }
+        // Clear pending approval and mark as approved
+        this.pendingApproval = null;
+        if (isApprove) {
+            this.planApproved = true;
+        }
+        // Send response to Claude
+        if (this.claude?.isRunning()) {
+            const response = isApprove
+                ? 'Approved. Please proceed with the implementation.'
+                : 'Please revise the plan. I would like some changes.';
+            this.claude.sendMessage(response);
+            this.startTyping();
+        }
+    }
+    formatEvent(e) {
+        switch (e.type) {
+            case 'assistant': {
+                const msg = e.message;
+                const parts = [];
+                for (const block of msg?.content || []) {
+                    if (block.type === 'text' && block.text) {
+                        parts.push(block.text);
+                    }
+                    else if (block.type === 'tool_use' && block.name) {
+                        const formatted = this.formatToolUse(block.name, block.input || {});
+                        if (formatted)
+                            parts.push(formatted);
+                    }
+                    else if (block.type === 'thinking' && block.thinking) {
+                        // Extended thinking - show abbreviated version
+                        const thinking = block.thinking;
+                        const preview = thinking.length > 100 ? thinking.substring(0, 100) + '...' : thinking;
+                        parts.push(`💭 *Thinking: ${preview}*`);
+                    }
+                    else if (block.type === 'server_tool_use' && block.name) {
+                        // Server-managed tools like web search
+                        parts.push(`🌐 **${block.name}** ${block.input ? JSON.stringify(block.input).substring(0, 50) : ''}`);
+                    }
+                }
+                return parts.length > 0 ? parts.join('\n') : null;
+            }
+            case 'tool_use': {
+                const tool = e.tool_use;
+                return this.formatToolUse(tool.name, tool.input || {}) || null;
+            }
+            case 'tool_result': {
+                const result = e.tool_result;
+                if (result.is_error)
+                    return `  ↳ ❌ Error`;
+                return null;
+            }
+            case 'result': {
+                // Response complete - stop typing and start new post for next message
+                this.stopTyping();
+                if (this.session) {
+                    this.flush();
+                    this.session.postId = null;
+                    this.session.content = '';
+                }
+                return null;
+            }
+            case 'system':
+                if (e.subtype === 'error')
+                    return `❌ ${e.error}`;
+                return null;
+            default:
+                return null;
+        }
+    }
+    formatToolUse(name, input) {
+        const short = (p) => {
+            const home = process.env.HOME || '';
+            return p?.startsWith(home) ? '~' + p.slice(home.length) : p;
+        };
+        switch (name) {
+            case 'Read': return `📄 **Read** \`${short(input.file_path)}\``;
+            case 'Edit': {
+                const filePath = short(input.file_path);
+                const oldStr = (input.old_string || '').trim();
+                const newStr = (input.new_string || '').trim();
+                // Show diff if we have old/new strings
+                if (oldStr || newStr) {
+                    const maxLines = 8;
+                    const oldLines = oldStr.split('\n').slice(0, maxLines);
+                    const newLines = newStr.split('\n').slice(0, maxLines);
+                    let diff = `✏️ **Edit** \`${filePath}\`\n\`\`\`diff\n`;
+                    for (const line of oldLines) {
+                        diff += `- ${line}\n`;
+                    }
+                    if (oldStr.split('\n').length > maxLines)
+                        diff += `- ... (${oldStr.split('\n').length - maxLines} more lines)\n`;
+                    for (const line of newLines) {
+                        diff += `+ ${line}\n`;
+                    }
+                    if (newStr.split('\n').length > maxLines)
+                        diff += `+ ... (${newStr.split('\n').length - maxLines} more lines)\n`;
+                    diff += '```';
+                    return diff;
+                }
+                return `✏️ **Edit** \`${filePath}\``;
+            }
+            case 'Write': {
+                const filePath = short(input.file_path);
+                const content = input.content || '';
+                const lines = content.split('\n');
+                const lineCount = lines.length;
+                // Show preview of content
+                if (content && lineCount > 0) {
+                    const maxLines = 6;
+                    const previewLines = lines.slice(0, maxLines);
+                    let preview = `📝 **Write** \`${filePath}\` *(${lineCount} lines)*\n\`\`\`\n`;
+                    preview += previewLines.join('\n');
+                    if (lineCount > maxLines)
+                        preview += `\n... (${lineCount - maxLines} more lines)`;
+                    preview += '\n```';
+                    return preview;
+                }
+                return `📝 **Write** \`${filePath}\``;
+            }
+            case 'Bash': {
+                const cmd = (input.command || '').substring(0, 50);
+                return `💻 **Bash** \`${cmd}${cmd.length >= 50 ? '...' : ''}\``;
+            }
+            case 'Glob': return `🔍 **Glob** \`${input.pattern}\``;
+            case 'Grep': return `🔎 **Grep** \`${input.pattern}\``;
+            case 'Task': return null; // Handled specially with subagent display
+            case 'EnterPlanMode': return `📋 **Planning...**`;
+            case 'ExitPlanMode': return null; // Handled specially with approval buttons
+            case 'AskUserQuestion': return null; // Don't show, the question text follows
+            case 'TodoWrite': return null; // Handled specially with task list display
+            case 'WebFetch': return `🌐 **Fetching** \`${(input.url || '').substring(0, 40)}\``;
+            case 'WebSearch': return `🔍 **Searching** \`${input.query}\``;
+            default: {
+                // Handle MCP tools: mcp__server__tool -> 🔌 tool (server)
+                if (name.startsWith('mcp__')) {
+                    const parts = name.split('__');
+                    if (parts.length >= 3) {
+                        const server = parts[1];
+                        const tool = parts.slice(2).join('__');
+                        return `🔌 **${tool}** *(${server})*`;
+                    }
+                }
+                return `● **${name}**`;
+            }
+        }
+    }
+    appendContent(text) {
+        if (!this.session || !text)
+            return;
+        this.session.content += text + '\n';
+        this.scheduleUpdate();
+    }
+    scheduleUpdate() {
+        if (this.updateTimer)
+            return;
+        this.updateTimer = setTimeout(() => {
+            this.updateTimer = null;
+            this.flush();
+        }, 500);
+    }
+    startTyping() {
+        if (this.typingTimer)
+            return;
+        // Send typing immediately, then every 3 seconds
+        this.mattermost.sendTyping(this.session?.threadId);
+        this.typingTimer = setInterval(() => {
+            this.mattermost.sendTyping(this.session?.threadId);
+        }, 3000);
+    }
+    stopTyping() {
+        if (this.typingTimer) {
+            clearInterval(this.typingTimer);
+            this.typingTimer = null;
+        }
+    }
+    async flush() {
+        if (!this.session || !this.session.content.trim())
+            return;
+        const content = this.session.content.replace(/\n{3,}/g, '\n\n').trim();
+        if (this.session.postId) {
+            await this.mattermost.updatePost(this.session.postId, content);
+        }
+        else {
+            const post = await this.mattermost.createPost(content, this.session.threadId);
+            this.session.postId = post.id;
+        }
+    }
+    async handleExit(code) {
+        this.stopTyping();
+        if (this.updateTimer) {
+            clearTimeout(this.updateTimer);
+            this.updateTimer = null;
+        }
+        await this.flush();
+        if (code !== 0 && this.session) {
+            await this.mattermost.createPost(`**[Exited: ${code}]**`, this.session.threadId);
+        }
+        this.session = null;
+    }
+    isSessionActive() {
+        return this.session !== null;
+    }
+    isInCurrentSessionThread(threadRoot) {
+        return this.session?.threadId === threadRoot;
+    }
+    async sendFollowUp(message) {
+        if (!this.claude?.isRunning() || !this.session)
+            return;
+        this.claude.sendMessage(message);
+        this.startTyping();
+    }
+    killSession() {
+        this.stopTyping();
+        this.claude?.kill();
+        this.claude = null;
+        this.session = null;
+    }
+}

package/dist/claude/types.d.ts

@@ -0,0 +1,76 @@
+export type ClaudeStreamEvent = SystemEvent | AssistantEvent | UserEvent | ToolUseEvent | ToolResultEvent | ResultEvent;
+export interface SystemEvent {
+    type: 'system';
+    subtype: 'init' | 'error';
+    session_id?: string;
+    message?: string;
+    error?: string;
+}
+export interface AssistantEvent {
+    type: 'assistant';
+    message: {
+        id: string;
+        type: 'message';
+        role: 'assistant';
+        content: ContentBlock[];
+        model: string;
+        stop_reason: string | null;
+        stop_sequence: string | null;
+    };
+    session_id: string;
+}
+export interface UserEvent {
+    type: 'user';
+    message: {
+        role: 'user';
+        content: string;
+    };
+    session_id: string;
+}
+export interface ToolUseEvent {
+    type: 'tool_use';
+    tool_use: {
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    };
+    session_id: string;
+}
+export interface ToolResultEvent {
+    type: 'tool_result';
+    tool_result: {
+        tool_use_id: string;
+        content: string | ContentBlock[];
+        is_error?: boolean;
+    };
+    session_id: string;
+}
+export interface ResultEvent {
+    type: 'result';
+    result: string;
+    session_id: string;
+    cost_usd?: number;
+    duration_ms?: number;
+    is_error?: boolean;
+}
+export type ContentBlock = TextBlock | ToolUseBlock | ToolResultBlock;
+export interface TextBlock {
+    type: 'text';
+    text: string;
+}
+export interface ToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+export interface ToolResultBlock {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+}
+export interface ClaudeUserInput {
+    type: 'user';
+    content: string;
+}

package/dist/claude/types.js

@@ -0,0 +1,3 @@
+// Claude Code stream-json output types
+// Based on https://code.claude.com/docs/en/cli-reference
+export {};

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+export interface Config {
+    mattermost: {
+        url: string;
+        token: string;
+        channelId: string;
+        botName: string;
+    };
+    allowedUsers: string[];
+    skipPermissions: boolean;
+}
+export declare function loadConfig(): Config;