claude-threads 0.13.0 → 0.14.1

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

@@ -0,0 +1,139 @@
+/**
+ * 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.js

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

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

@@ -0,0 +1,11 @@
+/**
+ * Permission API Factory
+ *
+ * Creates platform-specific permission API implementations based on platform type.
+ * This isolates platform selection logic to the platform layer.
+ */
+import type { PermissionApi, PermissionApiConfig } from './permission-api.js';
+/**
+ * Create a permission API instance for the specified platform type
+ */
+export declare function createPermissionApi(platformType: string, config: PermissionApiConfig): PermissionApi;

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

@@ -0,0 +1,21 @@
+/**
+ * Permission API Factory
+ *
+ * Creates platform-specific permission API implementations based on platform type.
+ * This isolates platform selection logic to the platform layer.
+ */
+import { createMattermostPermissionApi } from './mattermost/permission-api.js';
+/**
+ * Create a permission API instance for the specified platform type
+ */
+export function createPermissionApi(platformType, config) {
+    switch (platformType) {
+        case 'mattermost':
+            return createMattermostPermissionApi(config);
+        // TODO: Add Slack support
+        // case 'slack':
+        //   return createSlackPermissionApi(config);
+        default:
+            throw new Error(`Unsupported platform type: ${platformType}`);
+    }
+}

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

@@ -0,0 +1,67 @@
+/**
+ * Permission API interface for MCP permission server
+ *
+ * This interface defines the operations needed by the permission server
+ * to post permission requests and receive user responses via reactions.
+ * Each platform implements this interface with its specific API.
+ */
+import type { PlatformFormatter } from './formatter.js';
+/**
+ * Reaction event from WebSocket
+ */
+export interface ReactionEvent {
+    postId: string;
+    userId: string;
+    emojiName: string;
+}
+/**
+ * Posted message with ID
+ */
+export interface PostedMessage {
+    id: string;
+}
+/**
+ * Platform-specific permission API
+ */
+export interface PermissionApi {
+    /**
+     * Get the markdown formatter for this platform
+     */
+    getFormatter(): PlatformFormatter;
+    /**
+     * Get the bot's user ID
+     */
+    getBotUserId(): Promise<string>;
+    /**
+     * Get a username from a user ID
+     */
+    getUsername(userId: string): Promise<string | null>;
+    /**
+     * Check if a username is in the allowed users list
+     */
+    isUserAllowed(username: string): boolean;
+    /**
+     * Create a post with reaction options
+     */
+    createInteractivePost(message: string, reactions: string[], threadId?: string): Promise<PostedMessage>;
+    /**
+     * Update an existing post
+     */
+    updatePost(postId: string, message: string): Promise<void>;
+    /**
+     * Wait for a reaction on a post
+     * Returns the reaction event or null on timeout
+     */
+    waitForReaction(postId: string, botUserId: string, timeoutMs: number): Promise<ReactionEvent | null>;
+}
+/**
+ * Configuration for permission API
+ */
+export interface PermissionApiConfig {
+    url: string;
+    token: string;
+    channelId: string;
+    threadId?: string;
+    allowedUsers: string[];
+    debug?: boolean;
+}

package/dist/platform/permission-api.js

@@ -0,0 +1,8 @@
+/**
+ * Permission API interface for MCP permission server
+ *
+ * This interface defines the operations needed by the permission server
+ * to post permission requests and receive user responses via reactions.
+ * Each platform implements this interface with its specific API.
+ */
+export {};

package/dist/platform/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Platform-agnostic types for multi-platform support
+ *
+ * These types normalize the differences between Mattermost, Slack, etc.
+ * into a common interface that SessionManager can work with.
+ */
+/**
+ * Normalized user representation across platforms
+ */
+export interface PlatformUser {
+    id: string;
+    username: string;
+    email?: string;
+}
+/**
+ * Normalized post/message representation across platforms
+ */
+export interface PlatformPost {
+    id: string;
+    platformId: string;
+    channelId: string;
+    userId: string;
+    message: string;
+    rootId?: string;
+    createAt?: number;
+    metadata?: {
+        files?: PlatformFile[];
+        [key: string]: unknown;
+    };
+}
+/**
+ * Normalized reaction representation across platforms
+ */
+export interface PlatformReaction {
+    userId: string;
+    postId: string;
+    emojiName: string;
+    createAt?: number;
+}
+/**
+ * Normalized file attachment representation across platforms
+ */
+export interface PlatformFile {
+    id: string;
+    name: string;
+    size: number;
+    mimeType: string;
+    extension?: string;
+}
+/**
+ * Request to create a new post
+ */
+export interface CreatePostRequest {
+    message: string;
+    threadId?: string;
+}
+/**
+ * Request to update an existing post
+ */
+export interface UpdatePostRequest {
+    postId: string;
+    message: string;
+}
+/**
+ * Request to add a reaction to a post
+ */
+export interface AddReactionRequest {
+    postId: string;
+    emojiName: string;
+}

package/dist/platform/types.js

@@ -0,0 +1,7 @@
+/**
+ * Platform-agnostic types for multi-platform support
+ *
+ * These types normalize the differences between Mattermost, Slack, etc.
+ * into a common interface that SessionManager can work with.
+ */
+export {};

package/dist/session/commands.d.ts

@@ -0,0 +1,52 @@
+/**
+ * User commands module
+ *
+ * Handles user commands like !cd, !invite, !kick, !permissions, !escape, !stop.
+ */
+import type { Session } from './types.js';
+import type { ClaudeEvent } from '../claude/cli.js';
+export interface CommandContext {
+    skipPermissions: boolean;
+    chromeEnabled: boolean;
+    maxSessions: number;
+    handleEvent: (sessionId: string, event: ClaudeEvent) => void;
+    handleExit: (sessionId: string, code: number) => Promise<void>;
+    flush: (session: Session) => Promise<void>;
+    startTyping: (session: Session) => void;
+    stopTyping: (session: Session) => void;
+    persistSession: (session: Session) => void;
+    killSession: (threadId: string) => void;
+    registerPost: (postId: string, threadId: string) => void;
+}
+/**
+ * Cancel a session completely (like !stop or ❌ reaction).
+ */
+export declare function cancelSession(session: Session, username: string, ctx: CommandContext): Promise<void>;
+/**
+ * Interrupt current processing but keep session alive (like !escape or ⏸️).
+ */
+export declare function interruptSession(session: Session, username: string): Promise<void>;
+/**
+ * Change working directory for a session (restarts Claude CLI).
+ */
+export declare function changeDirectory(session: Session, newDir: string, username: string, ctx: CommandContext): Promise<void>;
+/**
+ * Invite a user to participate in a session.
+ */
+export declare function inviteUser(session: Session, invitedUser: string, invitedBy: string, ctx: CommandContext): Promise<void>;
+/**
+ * Kick a user from a session.
+ */
+export declare function kickUser(session: Session, kickedUser: string, kickedBy: string, ctx: CommandContext): Promise<void>;
+/**
+ * Enable interactive permissions for a session.
+ */
+export declare function enableInteractivePermissions(session: Session, username: string, ctx: CommandContext): Promise<void>;
+/**
+ * Request approval for a message from an unauthorized user.
+ */
+export declare function requestMessageApproval(session: Session, username: string, message: string, ctx: CommandContext): Promise<void>;
+/**
+ * Update the session header post with current participants and status.
+ */
+export declare function updateSessionHeader(session: Session, ctx: CommandContext): Promise<void>;