@hailer/mcp 1.0.29 → 1.1.2

package/dist/bot/services/message-classifier.js

@@ -0,0 +1,228 @@
+"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;
+    botConnection;
+    logger;
+    // Pre-compiled mention pattern for performance
+    mentionPattern;
+    constructor(botUserId, botConnection, logger) {
+        this.botUserId = botUserId;
+        this.botConnection = botConnection;
+        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;
+        }
+        // Validate uid before using it downstream
+        if (!uid || typeof uid !== 'string') {
+            return null;
+        }
+        // Fetch the actual message content
+        let messageContent = "";
+        let senderName = "Unknown";
+        let fileAttachments = [];
+        let messages = [];
+        try {
+            const response = await this.botConnection.client.socket.request("v3.discussion.message.latest", [discussion]);
+            messages = response?.messages || [];
+            let targetMessage = messages.find((msg) => msg._id === msg_id);
+            if (!targetMessage) {
+                this.logger.warn("Target message not in latest batch", { discussionId: discussion, messageId: msg_id });
+                // Retry once after a short delay — the message may not have been committed to DB yet
+                await new Promise(r => setTimeout(r, 500));
+                const retryResponse = await this.botConnection.client.socket.request("v3.discussion.message.latest", [discussion]);
+                const retryMessages = retryResponse?.messages || [];
+                targetMessage = retryMessages.find((msg) => msg._id === msg_id);
+                if (!targetMessage) {
+                    this.logger.error("Target message not found after retry", { discussionId: discussion, messageId: msg_id });
+                    return null;
+                }
+                // Update messages array for downstream use (reply detection, etc.)
+                messages = retryMessages;
+            }
+            messageContent = targetMessage.msg || targetMessage.content || "";
+            // Extract file attachments if present
+            if (targetMessage.files && Array.isArray(targetMessage.files) && targetMessage.files.length > 0) {
+                fileAttachments = targetMessage.files.map((file) => ({
+                    fileId: file._id,
+                    filename: file.filename || file.name || "unknown",
+                    size: file.size,
+                    mime: file.mime || file.type,
+                }));
+                this.logger.debug("File attachments detected", {
+                    messageId: msg_id,
+                    fileCount: fileAttachments.length,
+                    fileIds: fileAttachments.map(f => f.fileId).join(","),
+                });
+            }
+            // Get sender name: try workspace cache first, then message field
+            const cachedUser = this.botConnection.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;
+        }
+        // Load discussion metadata (used for DM check, activity link, and workspace ID)
+        let linkedActivityId;
+        let linkedActivityName;
+        let discussionWorkspaceId;
+        let discData = null;
+        try {
+            const discussionResponse = await this.botConnection.client.socket.request("messenger.load_discussions", [[discussion]]);
+            if (discussionResponse && Object.hasOwn(discussionResponse, discussion)) {
+                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),
+            });
+        }
+        // Classify priority (reuse already-fetched messages and discussion data to avoid double API calls)
+        const isMention = this.checkMention(messageContent);
+        const isReplyToBot = this.checkReplyInMessages(messages, msg_id);
+        const isDirectMessage = discData
+            ? this.checkDirectMessageFromData(discData, uid)
+            : await this.checkDirectMessage(discussion, uid);
+        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,
+            discussionName: linkedActivityName,
+            linkedActivityId,
+            linkedActivityName,
+            senderId: uid,
+            senderName,
+            content: messageContent,
+            timestamp: signal.timestamp,
+            priority,
+            priorityReason,
+            isReplyToBot,
+            isMention,
+            isDirectMessage,
+            fileAttachments: fileAttachments.length > 0 ? fileAttachments : undefined,
+        };
+    }
+    /**
+     * 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 using pre-fetched messages.
+     * Avoids a redundant API call by reusing the messages already fetched in extractIncomingMessage.
+     */
+    checkReplyInMessages(messages, messageId) {
+        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;
+        }
+        return false;
+    }
+    /**
+     * Check if this is a 1:1 DM with the bot using pre-loaded discussion data.
+     * Avoids a redundant API call by reusing discussion data already fetched in extractIncomingMessage.
+     */
+    checkDirectMessageFromData(discData, senderId) {
+        const participants = discData.participants || [];
+        if (participants.length === 2) {
+            return participants.includes(this.botUserId) && participants.includes(senderId);
+        }
+        return false;
+    }
+    /**
+     * Check if this is a 1:1 DM with the bot (fallback - fetches discussion from API)
+     */
+    async checkDirectMessage(discussionId, senderId) {
+        try {
+            const response = await this.botConnection.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/bot/services/message-formatter.d.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 { Logger } from "../../lib/logger";
+import { BotConnection, McpToolCallback } from "./types";
+export declare class MessageFormatterService {
+    private botConnection;
+    private logger;
+    private callMcpTool;
+    constructor(botConnection: BotConnection, 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