@hailer/mcp 0.1.15 → 0.1.16

package/dist/agents/shared/services/conversation-manager.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Conversation Manager Service
+ *
+ * Manages per-discussion conversation state:
+ * - LRU cache of conversation histories
+ * - Context size management with summarization
+ * - Conversation state access
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationManager = void 0;
+class ConversationManager {
+    maxConversations;
+    maxContextMessages;
+    anthropicClient;
+    logger;
+    conversationsByDiscussion = new Map();
+    constructor(maxConversations, maxContextMessages, anthropicClient, logger) {
+        this.maxConversations = maxConversations;
+        this.maxContextMessages = maxContextMessages;
+        this.anthropicClient = anthropicClient;
+        this.logger = logger;
+    }
+    /**
+     * Get or create conversation history for a specific discussion
+     * Each discussion has its own isolated context to prevent bloat
+     * Uses LRU eviction when map exceeds maxConversations
+     */
+    getConversation(discussionId) {
+        let conversation = this.conversationsByDiscussion.get(discussionId);
+        if (conversation) {
+            // Move to end for LRU (delete and re-add to update insertion order)
+            this.conversationsByDiscussion.delete(discussionId);
+            this.conversationsByDiscussion.set(discussionId, conversation);
+            return conversation;
+        }
+        // Evict oldest conversations if at capacity
+        if (this.conversationsByDiscussion.size >= this.maxConversations) {
+            const toEvict = this.conversationsByDiscussion.size - this.maxConversations + 1;
+            const keys = [...this.conversationsByDiscussion.keys()].slice(0, toEvict);
+            for (const key of keys) {
+                this.conversationsByDiscussion.delete(key);
+            }
+            this.logger.debug("Evicted old conversations", { evicted: toEvict, remaining: this.conversationsByDiscussion.size });
+        }
+        conversation = [];
+        this.conversationsByDiscussion.set(discussionId, conversation);
+        this.logger.debug("Created new conversation context", { discussionId });
+        return conversation;
+    }
+    /**
+     * Add a message to a conversation
+     */
+    addMessage(discussionId, message) {
+        const conversation = this.getConversation(discussionId);
+        conversation.push(message);
+    }
+    /**
+     * Manage conversation context size - summarize if too large
+     */
+    async manageContextSize(discussionId) {
+        const conversation = this.getConversation(discussionId);
+        if (conversation.length > this.maxContextMessages) {
+            this.logger.info("Context size limit reached, summarizing", {
+                discussionId,
+                messageCount: conversation.length,
+            });
+            // Keep last 10 messages, summarize the rest
+            const toSummarize = conversation.slice(0, -10);
+            const toKeep = conversation.slice(-10);
+            // Create summary using LLM with structured content to mitigate prompt injection
+            const summaryResponse = await this.anthropicClient.messages.create({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 1000,
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            { type: "text", text: "Summarize this conversation context concisely, preserving key information. The conversation data follows in JSON format:" },
+                            { type: "text", text: JSON.stringify(toSummarize) },
+                        ],
+                    },
+                ],
+            });
+            const summary = summaryResponse.content
+                .filter((b) => b.type === "text")
+                .map(b => b.text)
+                .join("\n");
+            // Replace conversation with summary + recent messages
+            const newConversation = [
+                {
+                    role: "user",
+                    content: `<context_summary>${summary}</context_summary>`,
+                },
+                ...toKeep,
+            ];
+            this.conversationsByDiscussion.set(discussionId, newConversation);
+            this.logger.info("Context summarized", {
+                discussionId,
+                originalCount: toSummarize.length + toKeep.length,
+                newCount: newConversation.length,
+            });
+        }
+    }
+    /**
+     * Get conversation state for debugging
+     */
+    getState(currentDiscussionId) {
+        const currentConvo = currentDiscussionId
+            ? this.conversationsByDiscussion.get(currentDiscussionId)
+            : null;
+        return {
+            discussionCount: this.conversationsByDiscussion.size,
+            currentMessageCount: currentConvo?.length ?? 0,
+        };
+    }
+    /**
+     * Get full conversation for a discussion (for debugging)
+     */
+    getFullConversation(discussionId) {
+        if (!discussionId) {
+            // Return first conversation if no ID specified
+            const first = this.conversationsByDiscussion.values().next().value;
+            return first || [];
+        }
+        return this.conversationsByDiscussion.get(discussionId) || [];
+    }
+    /**
+     * Clear all conversations
+     */
+    clear() {
+        this.conversationsByDiscussion.clear();
+    }
+}
+exports.ConversationManager = ConversationManager;
+//# sourceMappingURL=conversation-manager.js.map

package/dist/agents/shared/services/mcp-client.d.ts

@@ -0,0 +1,56 @@
+/**
+ * MCP Client Service
+ *
+ * Handles all communication with the MCP server:
+ * - Tool schema loading
+ * - Tool execution
+ * - Response parsing
+ */
+import { Logger } from "../../../lib/logger";
+import { ToolInput, McpToolResult } from "../../shared/types";
+/** MCP tool schema definition */
+export interface McpToolSchema {
+    name: string;
+    description?: string;
+    inputSchema?: {
+        type: string;
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export declare class McpClientService {
+    private mcpServerUrl;
+    private mcpServerApiKey;
+    private loadedToolSchemas;
+    private logger;
+    constructor(mcpServerUrl: string, mcpServerApiKey: string, logger: Logger);
+    /**
+     * Mask sensitive data for safe logging
+     */
+    private maskApiKey;
+    /**
+     * Create safe error without exposing API key
+     */
+    private createSafeError;
+    /**
+     * Fetch tool schema from MCP server
+     */
+    fetchToolSchema(toolName: string): Promise<any>;
+    /**
+     * Call MCP tool
+     */
+    callMcpTool(name: string, args: ToolInput): Promise<McpToolResult>;
+    /**
+     * Load tool schema if not already loaded
+     */
+    loadToolSchemaIfNeeded(toolName: string): Promise<McpToolSchema | undefined>;
+    /**
+     * Get cached tool schema
+     */
+    getCachedToolSchema(toolName: string): McpToolSchema | undefined;
+    /**
+     * Clear tool schema cache
+     */
+    clearSchemaCache(): void;
+}
+//# sourceMappingURL=mcp-client.d.ts.map

package/dist/agents/shared/services/mcp-client.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * MCP Client Service
+ *
+ * Handles all communication with the MCP server:
+ * - Tool schema loading
+ * - Tool execution
+ * - Response parsing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClientService = void 0;
+class McpClientService {
+    mcpServerUrl;
+    mcpServerApiKey;
+    loadedToolSchemas = new Map();
+    logger;
+    constructor(mcpServerUrl, mcpServerApiKey, logger) {
+        this.mcpServerUrl = mcpServerUrl;
+        this.mcpServerApiKey = mcpServerApiKey;
+        this.logger = logger;
+    }
+    /**
+     * Mask sensitive data for safe logging
+     */
+    maskApiKey(key) {
+        if (!key || key.length < 8)
+            return '***';
+        return `${key.slice(0, 4)}...${key.slice(-4)}`;
+    }
+    /**
+     * Create safe error without exposing API key
+     */
+    createSafeError(message, originalError) {
+        const safeMessage = message.replace(this.mcpServerApiKey, this.maskApiKey(this.mcpServerApiKey));
+        const error = new Error(safeMessage);
+        if (originalError instanceof Error) {
+            error.stack = originalError.stack?.replace(this.mcpServerApiKey, this.maskApiKey(this.mcpServerApiKey));
+        }
+        return error;
+    }
+    /**
+     * Fetch tool schema from MCP server
+     */
+    async fetchToolSchema(toolName) {
+        const url = `${this.mcpServerUrl}?apiKey=${this.mcpServerApiKey}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: Math.random().toString(36).substring(2),
+                method: "tools/get_schema",
+                params: { name: toolName },
+            }),
+        });
+        const text = await response.text();
+        const lines = text.split("\n");
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                const data = JSON.parse(line.substring(6));
+                if (data.result) {
+                    return {
+                        name: data.result.name,
+                        description: data.result.description,
+                        input_schema: data.result.inputSchema,
+                    };
+                }
+            }
+        }
+        throw this.createSafeError(`Failed to load schema for ${toolName}`);
+    }
+    /**
+     * Call MCP tool
+     */
+    async callMcpTool(name, args) {
+        const url = `${this.mcpServerUrl}?apiKey=${this.mcpServerApiKey}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: Math.random().toString(36).substring(2),
+                method: "tools/call",
+                params: { name, arguments: args },
+            }),
+        });
+        const text = await response.text();
+        const lines = text.split("\n");
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                const data = JSON.parse(line.substring(6));
+                if (data.error) {
+                    throw this.createSafeError(data.error.message || String(data.error));
+                }
+                return data.result;
+            }
+        }
+        throw this.createSafeError("Failed to parse MCP response");
+    }
+    /**
+     * Load tool schema if not already loaded
+     */
+    async loadToolSchemaIfNeeded(toolName) {
+        if (!this.loadedToolSchemas.has(toolName)) {
+            const schema = await this.fetchToolSchema(toolName);
+            this.loadedToolSchemas.set(toolName, schema);
+        }
+        return this.loadedToolSchemas.get(toolName);
+    }
+    /**
+     * Get cached tool schema
+     */
+    getCachedToolSchema(toolName) {
+        return this.loadedToolSchemas.get(toolName);
+    }
+    /**
+     * Clear tool schema cache
+     */
+    clearSchemaCache() {
+        this.loadedToolSchemas.clear();
+    }
+}
+exports.McpClientService = McpClientService;
+//# sourceMappingURL=mcp-client.js.map

package/dist/agents/shared/services/message-classifier.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Message Classifier Service
+ *
+ * Handles incoming message extraction and classification:
+ * - Extracts message content from Hailer signals
+ * - Classifies message priority (high/normal)
+ * - Detects mentions, replies, and DMs
+ */
+import { Logger } from "../../../lib/logger";
+import { BotClient } from "../../bot-manager";
+import { HailerSignal } from "../../../mcp/signal-handler";
+import { IncomingMessage } from "../../shared/types";
+export declare class MessageClassifier {
+    private botUserId;
+    private botClient;
+    private logger;
+    private mentionPattern;
+    constructor(botUserId: string, botClient: BotClient, logger: Logger);
+    /**
+     * Extract and classify incoming message from signal
+     */
+    extractIncomingMessage(signal: HailerSignal): Promise<IncomingMessage | null>;
+    /**
+     * Check if message mentions this bot
+     * Uses pre-compiled regex pattern for performance
+     */
+    checkMention(content: string): boolean;
+    /**
+     * Check if message is a reply to one of our messages
+     */
+    checkReplyToBot(discussionId: string, messageId: string): Promise<boolean>;
+    /**
+     * Check if this is a 1:1 DM with the bot
+     */
+    checkDirectMessage(discussionId: string, senderId: string): Promise<boolean>;
+}
+//# sourceMappingURL=message-classifier.d.ts.map

package/dist/agents/shared/services/message-classifier.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Message Classifier Service
+ *
+ * Handles incoming message extraction and classification:
+ * - Extracts message content from Hailer signals
+ * - Classifies message priority (high/normal)
+ * - Detects mentions, replies, and DMs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageClassifier = void 0;
+class MessageClassifier {
+    botUserId;
+    botClient;
+    logger;
+    // Pre-compiled mention pattern for performance
+    mentionPattern;
+    constructor(botUserId, botClient, logger) {
+        this.botUserId = botUserId;
+        this.botClient = botClient;
+        this.logger = logger;
+        // Compile mention pattern once
+        this.mentionPattern = new RegExp(`\\[hailerTag\\|[^\\]]+\\]\\(${this.botUserId}\\)`, "i");
+    }
+    /**
+     * Extract and classify incoming message from signal
+     */
+    async extractIncomingMessage(signal) {
+        const { discussion, msg_id, uid } = signal.data;
+        // Skip our own messages
+        if (uid === this.botUserId) {
+            return null;
+        }
+        // Fetch the actual message content
+        let messageContent = "";
+        let senderName = "Unknown";
+        try {
+            const response = await this.botClient.client.socket.request("v3.discussion.message.latest", [discussion]);
+            const messages = response?.messages || [];
+            const targetMessage = messages.find((msg) => msg._id === msg_id);
+            if (!targetMessage) {
+                return null;
+            }
+            messageContent = targetMessage.msg || targetMessage.content || "";
+            // Get sender name: try workspace cache first, then message field
+            const cachedUser = this.botClient.workspaceCache?.usersById[uid];
+            const cachedName = cachedUser?.fullName ?? `${cachedUser?.firstname || ''} ${cachedUser?.lastname || ''}`.trim();
+            senderName = cachedName || targetMessage.userName || "Unknown";
+            // Skip system messages
+            if (targetMessage.type && targetMessage.type !== "user") {
+                return null;
+            }
+        }
+        catch (error) {
+            this.logger.warn("Could not fetch message content", { error });
+            return null;
+        }
+        // Classify priority
+        const isMention = this.checkMention(messageContent);
+        const isReplyToBot = await this.checkReplyToBot(discussion, msg_id);
+        const isDirectMessage = await this.checkDirectMessage(discussion, uid);
+        // Get linked activity ID, name, and workspace ID from discussion metadata
+        let linkedActivityId;
+        let linkedActivityName;
+        let discussionWorkspaceId;
+        try {
+            const discussionResponse = await this.botClient.client.socket.request("messenger.load_discussions", [[discussion]]);
+            if (discussionResponse && discussionResponse[discussion]) {
+                const discData = discussionResponse[discussion];
+                linkedActivityId = discData.linked_activity;
+                linkedActivityName = discData.name; // Discussion name is usually the activity name
+                discussionWorkspaceId = discData.cid; // Workspace ID (cid = company ID in Hailer)
+                this.logger.debug("Discussion metadata loaded", {
+                    discussionId: discussion,
+                    linkedActivityId: linkedActivityId || "none",
+                    linkedActivityName: linkedActivityName || "none",
+                    hasLinkedActivity: !!linkedActivityId,
+                    cid: discussionWorkspaceId || "not in response",
+                    discDataKeys: Object.keys(discData).join(","),
+                });
+            }
+        }
+        catch (error) {
+            this.logger.debug("Failed to load discussion metadata", {
+                discussionId: discussion,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        let priority = "normal";
+        let priorityReason = "General chat message";
+        if (isDirectMessage) {
+            priority = "high";
+            priorityReason = "Direct message (1:1 conversation)";
+        }
+        else if (isMention) {
+            priority = "high";
+            priorityReason = "Bot mentioned in message";
+        }
+        else if (isReplyToBot) {
+            priority = "high";
+            priorityReason = "Reply to bot's message";
+        }
+        // Extract workspaceId - prefer discussion metadata (accurate), fallback to signal
+        // Discussion metadata contains authoritative workspace ID from Hailer
+        const workspaceId = discussionWorkspaceId || signal.workspaceId;
+        if (!workspaceId) {
+            this.logger.warn("Cannot determine workspace - rejecting message for isolation safety", {
+                discussionId: discussion,
+                messageId: msg_id,
+                discussionWorkspaceId: discussionWorkspaceId || "none",
+                signalWorkspaceId: signal.workspaceId || "none",
+            });
+            return null;
+        }
+        // Debug log workspace context (normal in multi-tenant setup)
+        if (discussionWorkspaceId) {
+            this.logger.debug("Message workspace context", {
+                discussionId: discussion,
+                workspaceId: discussionWorkspaceId,
+            });
+        }
+        return {
+            id: msg_id,
+            discussionId: discussion,
+            workspaceId,
+            linkedActivityId,
+            linkedActivityName,
+            senderId: uid,
+            senderName,
+            content: messageContent,
+            timestamp: signal.timestamp,
+            priority,
+            priorityReason,
+            isReplyToBot,
+            isMention,
+            isDirectMessage,
+        };
+    }
+    /**
+     * Check if message mentions this bot
+     * Uses pre-compiled regex pattern for performance
+     */
+    checkMention(content) {
+        return this.mentionPattern.test(content);
+    }
+    /**
+     * Check if message is a reply to one of our messages
+     */
+    async checkReplyToBot(discussionId, messageId) {
+        try {
+            const response = await this.botClient.client.socket.request("v3.discussion.message.latest", [discussionId]);
+            const messages = response?.messages || [];
+            const targetMessage = messages.find((msg) => msg._id === messageId);
+            if (targetMessage?.replyTo) {
+                const repliedToMessage = messages.find((msg) => msg._id === targetMessage.replyTo);
+                return repliedToMessage?.uid === this.botUserId;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return false;
+    }
+    /**
+     * Check if this is a 1:1 DM with the bot
+     */
+    async checkDirectMessage(discussionId, senderId) {
+        try {
+            const response = await this.botClient.client.socket.request("messenger.load_discussions", [[discussionId]]);
+            if (response && response[discussionId]) {
+                const discussion = response[discussionId];
+                const participants = discussion.participants || [];
+                // 1:1 = exactly 2 participants: sender and bot
+                if (participants.length === 2) {
+                    return participants.includes(this.botUserId) &&
+                        participants.includes(senderId);
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return false;
+    }
+}
+exports.MessageClassifier = MessageClassifier;
+//# sourceMappingURL=message-classifier.js.map

package/dist/agents/shared/services/message-formatter.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Message Formatter Service
+ *
+ * Handles formatting of messages for Hailer:
+ * - Converting @mentions and #activity tags to Hailer tags
+ * - Resolving user/activity IDs via API
+ * - Extracting tag links for messenger.send
+ */
+import { BotClient } from "../../bot-manager";
+import { Logger } from "../../../lib/logger";
+import { McpToolCallback } from "../../shared/types";
+export declare class MessageFormatterService {
+    private botClient;
+    private logger;
+    private callMcpTool;
+    constructor(botClient: BotClient, logger: Logger, callMcpTool: McpToolCallback);
+    /**
+     * Sanitize display name to prevent tag injection attacks
+     * Removes/escapes characters that could break the tag format
+     */
+    private sanitizeDisplayName;
+    /**
+     * Validate that targetId is a valid MongoDB ObjectId format
+     */
+    private isValidTargetId;
+    /**
+     * Format a Hailer tag for mentioning a user or activity
+     * Hailer requires ZWNBSP (U+FEFF) around the tag
+     */
+    private formatHailerTag;
+    /**
+     * Look up user by ID and create a Hailer tag
+     */
+    private createUserTagById;
+    /**
+     * Look up user by name and create a Hailer tag
+     */
+    private createUserTagByName;
+    /**
+     * Convert @mentions and #activity tags in response to Hailer tags
+     * Supports:
+     * - @userId (24-char hex MongoDB ID) → user tag
+     * - @"Full Name" (quoted name lookup) → user tag
+     * - @FirstName (single word name lookup) → user tag
+     * - #activityId (24-char hex) → activity tag
+     * - #"Activity Name" (quoted) → activity tag (requires lookup)
+     */
+    convertMentionsToTags(content: string): string;
+    /**
+     * Resolve user tags - look up names for IDs via API when not in cache
+     * Handles @userId (24-char hex) format
+     */
+    resolveUserTags(content: string): Promise<string>;
+    /**
+     * Resolve activity tags - look up names for IDs and IDs for names
+     * Handles both #activityId and #"Activity Name" formats
+     */
+    resolveActivityTags(content: string): Promise<string>;
+    /**
+     * Convert Hailer URLs to Hailer tags
+     * Handles:
+     * - https://app.hailer.com/#/activities/{activityId}
+     * - https://app.hailer.com/#/discussions/{discussionId}
+     */
+    resolveHailerUrls(content: string): Promise<string>;
+    /**
+     * Extract link metadata from hailerTag formatted content
+     * Returns array of links for the messenger.send API
+     */
+    extractTagLinks(content: string): Array<{
+        target: string;
+        targetType: string;
+        type: string;
+    }>;
+    /**
+     * Format incoming message for LLM consumption
+     */
+    formatIncomingMessage(message: {
+        discussionId: string;
+        linkedActivityId?: string;
+        senderName: string;
+        senderId: string;
+        timestamp: number;
+        priority: string;
+        priorityReason: string;
+        content: string;
+    }): string;
+}
+//# sourceMappingURL=message-formatter.d.ts.map