claude-threads 0.15.0 → 0.16.3

package/dist/platform/mattermost/client.js

@@ -1,404 +0,0 @@
-import WebSocket from 'ws';
-import { EventEmitter } from 'events';
-import { wsLogger } from '../../utils/logger.js';
-import { MattermostFormatter } from './formatter.js';
-// Escape special regex characters to prevent regex injection
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-export class MattermostClient extends EventEmitter {
-    // Platform identity (required by PlatformClient)
-    platformId;
-    platformType = 'mattermost';
-    displayName;
-    ws = null;
-    url;
-    token;
-    channelId;
-    botName;
-    allowedUsers;
-    reconnectAttempts = 0;
-    maxReconnectAttempts = 10;
-    reconnectDelay = 1000;
-    userCache = new Map();
-    botUserId = null;
-    formatter = new MattermostFormatter();
-    // 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(platformConfig) {
-        super();
-        this.platformId = platformConfig.id;
-        this.displayName = platformConfig.displayName;
-        this.url = platformConfig.url;
-        this.token = platformConfig.token;
-        this.channelId = platformConfig.channelId;
-        this.botName = platformConfig.botName;
-        this.allowedUsers = platformConfig.allowedUsers;
-    }
-    // ============================================================================
-    // Type Normalization (Mattermost → Platform)
-    // ============================================================================
-    normalizePlatformUser(mattermostUser) {
-        return {
-            id: mattermostUser.id,
-            username: mattermostUser.username,
-            email: mattermostUser.email,
-        };
-    }
-    normalizePlatformPost(mattermostPost) {
-        // Normalize metadata.files if present
-        const metadata = mattermostPost.metadata
-            ? {
-                ...mattermostPost.metadata,
-                files: mattermostPost.metadata.files?.map((f) => this.normalizePlatformFile(f)),
-            }
-            : undefined;
-        return {
-            id: mattermostPost.id,
-            platformId: this.platformId,
-            channelId: mattermostPost.channel_id,
-            userId: mattermostPost.user_id,
-            message: mattermostPost.message,
-            rootId: mattermostPost.root_id,
-            createAt: mattermostPost.create_at,
-            metadata,
-        };
-    }
-    normalizePlatformReaction(mattermostReaction) {
-        return {
-            userId: mattermostReaction.user_id,
-            postId: mattermostReaction.post_id,
-            emojiName: mattermostReaction.emoji_name,
-            createAt: mattermostReaction.create_at,
-        };
-    }
-    normalizePlatformFile(mattermostFile) {
-        return {
-            id: mattermostFile.id,
-            name: mattermostFile.name,
-            size: mattermostFile.size,
-            mimeType: mattermostFile.mime_type,
-            extension: mattermostFile.extension,
-        };
-    }
-    // REST API helper
-    async api(method, path, body) {
-        const url = `${this.url}/api/v4${path}`;
-        const response = await fetch(url, {
-            method,
-            headers: {
-                Authorization: `Bearer ${this.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 this.normalizePlatformUser(user);
-    }
-    // Get user by ID (cached)
-    async getUser(userId) {
-        const cached = this.userCache.get(userId);
-        if (cached) {
-            return this.normalizePlatformUser(cached);
-        }
-        try {
-            const user = await this.api('GET', `/users/${userId}`);
-            this.userCache.set(userId, user);
-            return this.normalizePlatformUser(user);
-        }
-        catch {
-            return null;
-        }
-    }
-    // Post a message
-    async createPost(message, threadId) {
-        const request = {
-            channel_id: this.channelId,
-            message,
-            root_id: threadId,
-        };
-        const post = await this.api('POST', '/posts', request);
-        return this.normalizePlatformPost(post);
-    }
-    // Update a message (for streaming updates)
-    async updatePost(postId, message) {
-        const request = {
-            id: postId,
-            message,
-        };
-        const post = await this.api('PUT', `/posts/${postId}`, request);
-        return this.normalizePlatformPost(post);
-    }
-    // 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.url}/api/v4/files/${fileId}`;
-        const response = await fetch(url, {
-            headers: {
-                Authorization: `Bearer ${this.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) {
-        const file = await this.api('GET', `/files/${fileId}/info`);
-        return this.normalizePlatformFile(file);
-    }
-    // Get a post by ID (used to verify thread still exists on resume)
-    async getPost(postId) {
-        try {
-            const post = await this.api('GET', `/posts/${postId}`);
-            return this.normalizePlatformPost(post);
-        }
-        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.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
-                if (this.ws) {
-                    this.ws.send(JSON.stringify({
-                        seq: 1,
-                        action: 'authentication_challenge',
-                        data: { token: this.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.channelId)
-                    return;
-                // Get user info and emit (with normalized types)
-                this.getUser(post.user_id).then((user) => {
-                    this.emit('message', this.normalizePlatformPost(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 (with normalized types)
-                this.getUser(reaction.user_id).then((user) => {
-                    this.emit('reaction', this.normalizePlatformReaction(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.allowedUsers.length === 0) {
-            // If no allowlist configured, allow all
-            return true;
-        }
-        return this.allowedUsers.includes(username);
-    }
-    // Check if message mentions the bot
-    isBotMentioned(message) {
-        const botName = escapeRegExp(this.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.botName);
-        return message
-            .replace(new RegExp(`(^|\\s)@${botName}\\b`, 'gi'), ' ')
-            .trim();
-    }
-    // Get the bot name
-    getBotName() {
-        return this.botName;
-    }
-    // Get MCP config for permission server
-    getMcpConfig() {
-        return {
-            type: 'mattermost',
-            url: this.url,
-            token: this.token,
-            channelId: this.channelId,
-            allowedUsers: this.allowedUsers,
-        };
-    }
-    // Get platform-specific markdown formatter
-    getFormatter() {
-        return this.formatter;
-    }
-    // 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.channelId,
-                parent_id: parentId || '',
-            },
-        }));
-    }
-    disconnect() {
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
-        }
-    }
-}

package/dist/platform/mattermost/formatter.d.ts

@@ -1,20 +0,0 @@
-import type { PlatformFormatter } from '../formatter.js';
-/**
- * Mattermost markdown formatter
- *
- * Mattermost uses standard markdown syntax.
- */
-export declare class MattermostFormatter implements PlatformFormatter {
-    formatBold(text: string): string;
-    formatItalic(text: string): string;
-    formatCode(text: string): string;
-    formatCodeBlock(code: string, language?: string): string;
-    formatUserMention(username: string): string;
-    formatLink(text: string, url: string): string;
-    formatListItem(text: string): string;
-    formatNumberedListItem(number: number, text: string): string;
-    formatBlockquote(text: string): string;
-    formatHorizontalRule(): string;
-    formatHeading(text: string, level: number): string;
-    escapeText(text: string): string;
-}

package/dist/platform/mattermost/formatter.js

@@ -1,46 +0,0 @@
-/**
- * Mattermost markdown formatter
- *
- * Mattermost uses standard markdown syntax.
- */
-export class MattermostFormatter {
-    formatBold(text) {
-        return `**${text}**`;
-    }
-    formatItalic(text) {
-        return `_${text}_`;
-    }
-    formatCode(text) {
-        return `\`${text}\``;
-    }
-    formatCodeBlock(code, language) {
-        const lang = language || '';
-        return `\`\`\`${lang}\n${code}\n\`\`\``;
-    }
-    formatUserMention(username) {
-        return `@${username}`;
-    }
-    formatLink(text, url) {
-        return `[${text}](${url})`;
-    }
-    formatListItem(text) {
-        return `- ${text}`;
-    }
-    formatNumberedListItem(number, text) {
-        return `${number}. ${text}`;
-    }
-    formatBlockquote(text) {
-        return `> ${text}`;
-    }
-    formatHorizontalRule() {
-        return '---';
-    }
-    formatHeading(text, level) {
-        const hashes = '#'.repeat(Math.min(Math.max(level, 1), 6));
-        return `${hashes} ${text}`;
-    }
-    escapeText(text) {
-        // Escape markdown special characters
-        return text.replace(/([*_`[\]()#+\-.!])/g, '\\$1');
-    }
-}

package/dist/platform/mattermost/permission-api.d.ts

@@ -1,10 +0,0 @@
-/**
- * Mattermost implementation of Permission API
- *
- * Handles permission requests via Mattermost API and WebSocket.
- */
-import type { PermissionApi, PermissionApiConfig } from '../permission-api.js';
-/**
- * Create a Mattermost permission API instance
- */
-export declare function createMattermostPermissionApi(config: PermissionApiConfig): PermissionApi;

package/dist/platform/mattermost/permission-api.js

@@ -1,139 +0,0 @@
-/**
- * Mattermost implementation of Permission API
- *
- * Handles permission requests via Mattermost API and WebSocket.
- */
-import WebSocket from 'ws';
-import { MattermostFormatter } from './formatter.js';
-import { getMe, getUser, createInteractivePost, updatePost, isUserAllowed, } from '../../mattermost/api.js';
-import { mcpLogger } from '../../utils/logger.js';
-/**
- * Mattermost Permission API implementation
- */
-class MattermostPermissionApi {
-    apiConfig;
-    config;
-    formatter = new MattermostFormatter();
-    botUserIdCache = null;
-    constructor(config) {
-        this.config = config;
-        this.apiConfig = {
-            url: config.url,
-            token: config.token,
-        };
-    }
-    getFormatter() {
-        return this.formatter;
-    }
-    async getBotUserId() {
-        if (this.botUserIdCache)
-            return this.botUserIdCache;
-        const me = await getMe(this.apiConfig);
-        this.botUserIdCache = me.id;
-        return me.id;
-    }
-    async getUsername(userId) {
-        try {
-            const user = await getUser(this.apiConfig, userId);
-            return user?.username ?? null;
-        }
-        catch {
-            return null;
-        }
-    }
-    isUserAllowed(username) {
-        return isUserAllowed(username, this.config.allowedUsers);
-    }
-    async createInteractivePost(message, reactions, threadId) {
-        const botUserId = await this.getBotUserId();
-        const post = await createInteractivePost(this.apiConfig, this.config.channelId, message, reactions, threadId, botUserId);
-        return { id: post.id };
-    }
-    async updatePost(postId, message) {
-        await updatePost(this.apiConfig, postId, message);
-    }
-    async waitForReaction(postId, botUserId, timeoutMs) {
-        return new Promise((resolve) => {
-            // Parse WebSocket URL from HTTP URL
-            const wsUrl = this.config.url.replace(/^http/, 'ws') + '/api/v4/websocket';
-            mcpLogger.debug(`Connecting to WebSocket: ${wsUrl}`);
-            const ws = new WebSocket(wsUrl);
-            let resolved = false;
-            const cleanup = () => {
-                if (ws.readyState === WebSocket.OPEN) {
-                    ws.close();
-                }
-            };
-            const timeout = setTimeout(() => {
-                if (!resolved) {
-                    resolved = true;
-                    cleanup();
-                    resolve(null);
-                }
-            }, timeoutMs);
-            ws.on('open', () => {
-                mcpLogger.debug('WebSocket connected, sending auth...');
-                ws.send(JSON.stringify({
-                    seq: 1,
-                    action: 'authentication_challenge',
-                    data: { token: this.config.token },
-                }));
-            });
-            ws.on('message', async (data) => {
-                if (resolved)
-                    return;
-                try {
-                    const event = JSON.parse(data.toString());
-                    mcpLogger.debug(`WebSocket event: ${event.event}`);
-                    if (event.event === 'reaction_added') {
-                        // Mattermost sends reaction as JSON string
-                        const reaction = typeof event.data.reaction === 'string'
-                            ? JSON.parse(event.data.reaction)
-                            : event.data.reaction;
-                        // Must be on our post
-                        if (reaction.post_id !== postId)
-                            return;
-                        // Must not be the bot's own reaction (adding the options)
-                        if (reaction.user_id === botUserId)
-                            return;
-                        mcpLogger.debug(`Reaction received: ${reaction.emoji_name} from user: ${reaction.user_id}`);
-                        // Got a valid reaction
-                        resolved = true;
-                        clearTimeout(timeout);
-                        cleanup();
-                        resolve({
-                            postId: reaction.post_id,
-                            userId: reaction.user_id,
-                            emojiName: reaction.emoji_name,
-                        });
-                    }
-                }
-                catch (err) {
-                    mcpLogger.debug(`Error parsing WebSocket message: ${err}`);
-                }
-            });
-            ws.on('error', (error) => {
-                mcpLogger.error(`WebSocket error: ${error.message}`);
-                if (!resolved) {
-                    resolved = true;
-                    clearTimeout(timeout);
-                    resolve(null);
-                }
-            });
-            ws.on('close', () => {
-                mcpLogger.debug('WebSocket closed');
-                if (!resolved) {
-                    resolved = true;
-                    clearTimeout(timeout);
-                    resolve(null);
-                }
-            });
-        });
-    }
-}
-/**
- * Create a Mattermost permission API instance
- */
-export function createMattermostPermissionApi(config) {
-    return new MattermostPermissionApi(config);
-}

package/dist/platform/mattermost/types.d.ts

@@ -1,71 +0,0 @@
-export interface MattermostWebSocketEvent {
-    event: string;
-    data: Record<string, unknown>;
-    broadcast: {
-        channel_id?: string;
-        user_id?: string;
-        team_id?: string;
-    };
-    seq: number;
-}
-export interface MattermostFile {
-    id: string;
-    name: string;
-    size: number;
-    mime_type: string;
-    extension: string;
-    width?: number;
-    height?: number;
-}
-export interface MattermostPost {
-    id: string;
-    create_at: number;
-    update_at: number;
-    delete_at: number;
-    user_id: string;
-    channel_id: string;
-    root_id: string;
-    message: string;
-    type: string;
-    props: Record<string, unknown>;
-    metadata?: {
-        embeds?: unknown[];
-        files?: MattermostFile[];
-    };
-}
-export interface MattermostUser {
-    id: string;
-    username: string;
-    email: string;
-    first_name: string;
-    last_name: string;
-    nickname: string;
-}
-export interface PostedEventData {
-    channel_display_name: string;
-    channel_name: string;
-    channel_type: string;
-    post: string;
-    sender_name: string;
-    team_id: string;
-}
-export interface ReactionAddedEventData {
-    reaction: string;
-}
-export interface MattermostReaction {
-    user_id: string;
-    post_id: string;
-    emoji_name: string;
-    create_at: number;
-}
-export interface CreatePostRequest {
-    channel_id: string;
-    message: string;
-    root_id?: string;
-    props?: Record<string, unknown>;
-}
-export interface UpdatePostRequest {
-    id: string;
-    message: string;
-    props?: Record<string, unknown>;
-}

package/dist/platform/mattermost/types.js

@@ -1 +0,0 @@
-export {};