claude-threads 0.12.0

package/dist/mattermost/api.test.js

@@ -0,0 +1,319 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mattermostApi, getMe, getUser, createPost, updatePost, addReaction, isUserAllowed, createInteractivePost, } from './api.js';
+const mockConfig = {
+    url: 'https://mattermost.example.com',
+    token: 'test-token',
+};
+describe('mattermostApi', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it('adds authorization header', async () => {
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ id: '123' }),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await mattermostApi(mockConfig, 'GET', '/users/me');
+        expect(mockFetch).toHaveBeenCalledWith('https://mattermost.example.com/api/v4/users/me', expect.objectContaining({
+            headers: expect.objectContaining({
+                Authorization: 'Bearer test-token',
+            }),
+        }));
+    });
+    it('includes Content-Type header', async () => {
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({}),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await mattermostApi(mockConfig, 'POST', '/posts', { message: 'test' });
+        expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            headers: expect.objectContaining({
+                'Content-Type': 'application/json',
+            }),
+        }));
+    });
+    it('stringifies body for POST requests', async () => {
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({}),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await mattermostApi(mockConfig, 'POST', '/posts', { message: 'hello' });
+        expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            body: JSON.stringify({ message: 'hello' }),
+        }));
+    });
+    it('throws on non-ok response', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: false,
+            status: 401,
+            text: () => Promise.resolve('Unauthorized'),
+        }));
+        await expect(mattermostApi(mockConfig, 'GET', '/users/me')).rejects.toThrow('Mattermost API error 401');
+    });
+    it('includes error details in thrown error', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: false,
+            status: 403,
+            text: () => Promise.resolve('Access denied'),
+        }));
+        await expect(mattermostApi(mockConfig, 'GET', '/users/me')).rejects.toThrow('Access denied');
+    });
+});
+describe('getMe', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it('returns the current user', async () => {
+        const mockUser = { id: 'bot123', username: 'bot' };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockUser),
+        }));
+        const result = await getMe(mockConfig);
+        expect(result).toEqual(mockUser);
+    });
+});
+describe('getUser', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it('returns user when found', async () => {
+        const mockUser = { id: 'user123', username: 'testuser' };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockUser),
+        }));
+        const result = await getUser(mockConfig, 'user123');
+        expect(result).toEqual(mockUser);
+    });
+    it('returns null when user not found', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: false,
+            status: 404,
+            text: () => Promise.resolve('Not found'),
+        }));
+        const result = await getUser(mockConfig, 'nonexistent');
+        expect(result).toBeNull();
+    });
+});
+describe('createPost', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it('creates a post with correct parameters', async () => {
+        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Hello' };
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockPost),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await createPost(mockConfig, 'channel1', 'Hello');
+        expect(mockFetch).toHaveBeenCalledWith('https://mattermost.example.com/api/v4/posts', expect.objectContaining({
+            method: 'POST',
+            body: JSON.stringify({
+                channel_id: 'channel1',
+                message: 'Hello',
+                root_id: undefined,
+            }),
+        }));
+    });
+    it('includes root_id for thread replies', async () => {
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({}),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await createPost(mockConfig, 'channel1', 'Reply', 'thread123');
+        expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            body: JSON.stringify({
+                channel_id: 'channel1',
+                message: 'Reply',
+                root_id: 'thread123',
+            }),
+        }));
+    });
+});
+describe('updatePost', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it('updates a post with correct parameters', async () => {
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ id: 'post123', message: 'Updated' }),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await updatePost(mockConfig, 'post123', 'Updated');
+        expect(mockFetch).toHaveBeenCalledWith('https://mattermost.example.com/api/v4/posts/post123', expect.objectContaining({
+            method: 'PUT',
+            body: JSON.stringify({
+                id: 'post123',
+                message: 'Updated',
+            }),
+        }));
+    });
+});
+describe('addReaction', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it('adds a reaction with correct parameters', async () => {
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({}),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await addReaction(mockConfig, 'post123', 'bot123', '+1');
+        expect(mockFetch).toHaveBeenCalledWith('https://mattermost.example.com/api/v4/reactions', expect.objectContaining({
+            method: 'POST',
+            body: JSON.stringify({
+                user_id: 'bot123',
+                post_id: 'post123',
+                emoji_name: '+1',
+            }),
+        }));
+    });
+});
+describe('isUserAllowed', () => {
+    it('returns true when allowlist is empty', () => {
+        expect(isUserAllowed('anyone', [])).toBe(true);
+    });
+    it('returns true when user is in allowlist', () => {
+        expect(isUserAllowed('alice', ['alice', 'bob'])).toBe(true);
+    });
+    it('returns false when user is not in allowlist', () => {
+        expect(isUserAllowed('eve', ['alice', 'bob'])).toBe(false);
+    });
+    it('is case-sensitive', () => {
+        expect(isUserAllowed('Alice', ['alice'])).toBe(false);
+    });
+});
+describe('createInteractivePost', () => {
+    let consoleSpy;
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+        consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        consoleSpy.mockRestore();
+    });
+    it('creates a post and adds reactions', async () => {
+        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Hello' };
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockPost),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        const result = await createInteractivePost(mockConfig, 'channel1', 'Hello', ['+1', '-1'], undefined, 'bot123');
+        expect(result).toEqual(mockPost);
+        // First call: createPost, second+third: addReaction
+        expect(mockFetch).toHaveBeenCalledTimes(3);
+    });
+    it('creates post in a thread when rootId is provided', async () => {
+        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Reply' };
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockPost),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await createInteractivePost(mockConfig, 'channel1', 'Reply', ['+1'], 'thread123', 'bot123');
+        // Check the first call (createPost) includes root_id
+        expect(mockFetch).toHaveBeenNthCalledWith(1, 'https://mattermost.example.com/api/v4/posts', expect.objectContaining({
+            body: JSON.stringify({
+                channel_id: 'channel1',
+                message: 'Reply',
+                root_id: 'thread123',
+            }),
+        }));
+    });
+    it('continues adding reactions even if one fails', async () => {
+        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Hello' };
+        let callCount = 0;
+        const mockFetch = vi.fn().mockImplementation(() => {
+            callCount++;
+            if (callCount === 1) {
+                // createPost succeeds
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve(mockPost),
+                });
+            }
+            else if (callCount === 2) {
+                // First reaction fails
+                return Promise.resolve({
+                    ok: false,
+                    status: 500,
+                    text: () => Promise.resolve('Server error'),
+                });
+            }
+            else {
+                // Second reaction succeeds
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({}),
+                });
+            }
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        const result = await createInteractivePost(mockConfig, 'channel1', 'Hello', ['+1', '-1'], undefined, 'bot123');
+        // Should still return the post
+        expect(result).toEqual(mockPost);
+        // All three calls should have been made
+        expect(mockFetch).toHaveBeenCalledTimes(3);
+        // Error should have been logged
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to add reaction'), expect.any(Error));
+    });
+    it('returns the post even with no reactions', async () => {
+        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Hello' };
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockPost),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        const result = await createInteractivePost(mockConfig, 'channel1', 'Hello', [], undefined, 'bot123');
+        expect(result).toEqual(mockPost);
+        // Only createPost call, no reactions
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+    });
+    it('adds reactions in the correct order', async () => {
+        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Hello' };
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockPost),
+        });
+        vi.stubGlobal('fetch', mockFetch);
+        await createInteractivePost(mockConfig, 'channel1', 'Hello', ['+1', 'white_check_mark', '-1'], undefined, 'bot123');
+        // Check reaction calls are in order
+        expect(mockFetch).toHaveBeenNthCalledWith(2, 'https://mattermost.example.com/api/v4/reactions', expect.objectContaining({
+            body: expect.stringContaining('+1'),
+        }));
+        expect(mockFetch).toHaveBeenNthCalledWith(3, 'https://mattermost.example.com/api/v4/reactions', expect.objectContaining({
+            body: expect.stringContaining('white_check_mark'),
+        }));
+        expect(mockFetch).toHaveBeenNthCalledWith(4, 'https://mattermost.example.com/api/v4/reactions', expect.objectContaining({
+            body: expect.stringContaining('-1'),
+        }));
+    });
+});

package/dist/mattermost/client.d.ts

@@ -0,0 +1,56 @@
+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;
+    private pingInterval;
+    private lastMessageAt;
+    private readonly PING_INTERVAL_MS;
+    private readonly PING_TIMEOUT_MS;
+    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>;
+    /**
+     * Create a post with reaction options for user interaction
+     *
+     * This is a common pattern for interactive posts that need user response
+     * via reactions (e.g., approval prompts, questions, permission requests).
+     *
+     * @param message - Post message content
+     * @param reactions - Array of emoji names to add as reaction options
+     * @param threadId - Optional thread root ID
+     * @returns The created post
+     */
+    createInteractivePost(message: string, reactions: string[], threadId?: string): Promise<MattermostPost>;
+    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;
+    private startHeartbeat;
+    private stopHeartbeat;
+    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,321 @@
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+import { wsLogger } from '../utils/logger.js';
+// Escape special regex characters to prevent regex injection
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export class MattermostClient extends EventEmitter {
+    ws = null;
+    config;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 10;
+    reconnectDelay = 1000;
+    userCache = new Map();
+    botUserId = null;
+    // Heartbeat to detect dead connections
+    pingInterval = null;
+    lastMessageAt = Date.now();
+    PING_INTERVAL_MS = 30000; // Send ping every 30s
+    PING_TIMEOUT_MS = 60000; // Reconnect if no message for 60s
+    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,
+        });
+    }
+    /**
+     * Create a post with reaction options for user interaction
+     *
+     * This is a common pattern for interactive posts that need user response
+     * via reactions (e.g., approval prompts, questions, permission requests).
+     *
+     * @param message - Post message content
+     * @param reactions - Array of emoji names to add as reaction options
+     * @param threadId - Optional thread root ID
+     * @returns The created post
+     */
+    async createInteractivePost(message, reactions, threadId) {
+        const post = await this.createPost(message, threadId);
+        // Add each reaction option, continuing even if some fail
+        for (const emoji of reactions) {
+            try {
+                await this.addReaction(post.id, emoji);
+            }
+            catch (err) {
+                console.error(`  ⚠️ Failed to add reaction ${emoji}:`, err);
+            }
+        }
+        return post;
+    }
+    // Download a file attachment
+    async downloadFile(fileId) {
+        const url = `${this.config.mattermost.url}/api/v4/files/${fileId}`;
+        const response = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${this.config.mattermost.token}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to download file ${fileId}: ${response.status}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    // Get file info (metadata)
+    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
+        await this.getBotUser();
+        wsLogger.debug(`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', () => {
+                wsLogger.debug('WebSocket connected');
+                // Authenticate
+                this.ws.send(JSON.stringify({
+                    seq: 1,
+                    action: 'authentication_challenge',
+                    data: { token: this.config.mattermost.token },
+                }));
+            });
+            this.ws.on('message', (data) => {
+                this.lastMessageAt = Date.now(); // Track activity for heartbeat
+                try {
+                    const event = JSON.parse(data.toString());
+                    this.handleEvent(event);
+                    // Authentication success
+                    if (event.event === 'hello') {
+                        this.reconnectAttempts = 0;
+                        this.startHeartbeat();
+                        this.emit('connected');
+                        resolve();
+                    }
+                }
+                catch (err) {
+                    wsLogger.debug(`Failed to parse message: ${err}`);
+                }
+            });
+            this.ws.on('close', () => {
+                wsLogger.debug('WebSocket disconnected');
+                this.stopHeartbeat();
+                this.emit('disconnected');
+                this.scheduleReconnect();
+            });
+            this.ws.on('error', (err) => {
+                wsLogger.debug(`WebSocket error: ${err}`);
+                this.emit('error', err);
+                reject(err);
+            });
+            this.ws.on('pong', () => {
+                this.lastMessageAt = Date.now(); // Pong received, connection is alive
+                wsLogger.debug('Pong received');
+            });
+        });
+    }
+    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) {
+                wsLogger.debug(`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) {
+                wsLogger.debug(`Failed to parse reaction: ${err}`);
+            }
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error('  ⚠️  Max reconnection attempts reached');
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        console.log(`  🔄 Reconnecting... (attempt ${this.reconnectAttempts})`);
+        setTimeout(() => {
+            this.connect().catch((err) => {
+                console.error(`  ❌ Reconnection failed: ${err}`);
+            });
+        }, delay);
+    }
+    startHeartbeat() {
+        this.stopHeartbeat(); // Clear any existing
+        this.lastMessageAt = Date.now();
+        this.pingInterval = setInterval(() => {
+            const silentFor = Date.now() - this.lastMessageAt;
+            // If no message received for too long, connection is dead
+            if (silentFor > this.PING_TIMEOUT_MS) {
+                console.log(`  💔 Connection dead (no activity for ${Math.round(silentFor / 1000)}s), reconnecting...`);
+                this.stopHeartbeat();
+                if (this.ws) {
+                    this.ws.terminate(); // Force close (triggers reconnect via 'close' event)
+                }
+                return;
+            }
+            // Send ping to keep connection alive and verify it's working
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.ping();
+                wsLogger.debug(`Ping sent (last activity ${Math.round(silentFor / 1000)}s ago)`);
+            }
+        }, this.PING_INTERVAL_MS);
+    }
+    stopHeartbeat() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+    }
+    // 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 = escapeRegExp(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 = escapeRegExp(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;
+        }
+    }
+}