@hailer/mcp 0.1.14 → 0.1.16

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

@@ -0,0 +1,371 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageFormatterService = void 0;
+class MessageFormatterService {
+    botClient;
+    logger;
+    callMcpTool;
+    constructor(botClient, logger, callMcpTool) {
+        this.botClient = botClient;
+        this.logger = logger;
+        this.callMcpTool = callMcpTool;
+    }
+    /**
+     * Sanitize display name to prevent tag injection attacks
+     * Removes/escapes characters that could break the tag format
+     */
+    sanitizeDisplayName(name) {
+        if (!name || typeof name !== 'string') {
+            return 'Unknown';
+        }
+        // Remove or escape characters that could break the tag format:
+        // [ ] | ( ) could break markdown-style tag parsing
+        // Control characters and ZWNBSP could cause rendering issues
+        return name
+            .replace(/[\[\]|()]/g, '') // Remove tag-breaking characters
+            .replace(/[\u0000-\u001F\uFEFF]/g, '') // Remove control chars and ZWNBSP
+            .replace(/\s+/g, ' ') // Normalize whitespace
+            .trim()
+            .slice(0, 100) || 'Unknown'; // Limit length
+    }
+    /**
+     * Validate that targetId is a valid MongoDB ObjectId format
+     */
+    isValidTargetId(id) {
+        return /^[a-f0-9]{24}$/i.test(id);
+    }
+    /**
+     * Format a Hailer tag for mentioning a user or activity
+     * Hailer requires ZWNBSP (U+FEFF) around the tag
+     */
+    formatHailerTag(targetId, displayName) {
+        // Validate targetId format
+        if (!this.isValidTargetId(targetId)) {
+            this.logger.warn('Invalid targetId format for Hailer tag', { targetId });
+            return displayName; // Return plain text if ID is invalid
+        }
+        const sanitizedName = this.sanitizeDisplayName(displayName);
+        const ZWNBSP = '\uFEFF';
+        return `${ZWNBSP}[hailerTag|${sanitizedName}](${targetId})${ZWNBSP}`;
+    }
+    /**
+     * Look up user by ID and create a Hailer tag
+     */
+    createUserTagById(userId) {
+        const cache = this.botClient.workspaceCache;
+        if (!cache)
+            return null;
+        const user = cache.usersById[userId];
+        if (!user)
+            return null;
+        const displayName = user.fullName || `${user.firstname} ${user.lastname}`.trim();
+        return this.formatHailerTag(userId, displayName);
+    }
+    /**
+     * Look up user by name and create a Hailer tag
+     */
+    createUserTagByName(name) {
+        const cache = this.botClient.workspaceCache;
+        if (!cache)
+            return null;
+        const nameLower = name.toLowerCase();
+        const user = cache.users.find(u => {
+            const fullName = u.fullName || `${u.firstname} ${u.lastname}`.trim();
+            return fullName.toLowerCase() === nameLower ||
+                u.firstname?.toLowerCase() === nameLower ||
+                u.lastname?.toLowerCase() === nameLower;
+        });
+        if (!user)
+            return null;
+        const displayName = user.fullName || `${user.firstname} ${user.lastname}`.trim();
+        return this.formatHailerTag(user.id, displayName);
+    }
+    /**
+     * 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) {
+        // User mentions (from cache)
+        const cache = this.botClient.workspaceCache;
+        if (cache) {
+            // Pattern 1: @userId (24-char hex)
+            content = content.replace(/@([a-f0-9]{24})\b/gi, (match, userId) => {
+                const tag = this.createUserTagById(userId);
+                return tag || match;
+            });
+            // Pattern 2: @"Full Name" (quoted)
+            content = content.replace(/@"([^"]+)"/g, (match, name) => {
+                const tag = this.createUserTagByName(name);
+                return tag || match;
+            });
+            // Pattern 3: @FirstName (single word, capitalized)
+            content = content.replace(/@([A-Z][a-z]+)\b/g, (match, name) => {
+                const tag = this.createUserTagByName(name);
+                return tag || match;
+            });
+        }
+        // Activity tags (#activityId and #"Name") are handled by
+        // resolveActivityTags (async) which runs before this
+        return content;
+    }
+    /**
+     * Resolve user tags - look up names for IDs via API when not in cache
+     * Handles @userId (24-char hex) format
+     */
+    async resolveUserTags(content) {
+        const pattern = /@([a-f0-9]{24})\b/gi;
+        const matches = [...content.matchAll(pattern)];
+        for (const match of matches) {
+            const userId = match[1];
+            // Try cache first
+            const cachedTag = this.createUserTagById(userId);
+            if (cachedTag) {
+                content = content.replace(match[0], cachedTag);
+                this.logger.debug("User tag from cache", { userId });
+                continue;
+            }
+            // Fallback to API
+            try {
+                this.logger.info("Resolving user tag via API", { userId });
+                const result = await this.callMcpTool("search_workspace_users", { query: userId });
+                const resultText = result?.content?.[0]?.text;
+                if (resultText) {
+                    // Parse the JSON array from the response
+                    // Response format: "Found X users:\n\n```json\n[...]\n```"
+                    const jsonMatch = resultText.match(/```json\s*([\s\S]*?)\s*```/);
+                    if (jsonMatch) {
+                        const users = JSON.parse(jsonMatch[1]);
+                        const user = users.find((u) => u._id === userId);
+                        if (user) {
+                            const displayName = `${user.firstname || ''} ${user.lastname || ''}`.trim() || user.fullName || userId;
+                            const tag = this.formatHailerTag(userId, displayName);
+                            content = content.replace(match[0], tag);
+                            this.logger.info("Created user tag from API", { userId, displayName });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.warn("Failed to resolve user tag", { userId, error });
+                // Leave as @userId - won't be clickable but visible
+            }
+        }
+        return content;
+    }
+    /**
+     * Resolve activity tags - look up names for IDs and IDs for names
+     * Handles both #activityId and #"Activity Name" formats
+     */
+    async resolveActivityTags(content) {
+        // Pattern 1: #activityId (24-char hex) - need to look up the name
+        const activityIdPattern = /#([a-f0-9]{24})\b/gi;
+        const idMatches = [...content.matchAll(activityIdPattern)];
+        for (const match of idMatches) {
+            const activityId = match[1];
+            try {
+                this.logger.info("Resolving activity tag by ID", { activityId });
+                // Fetch activity by ID to get its name
+                const result = await this.callMcpTool("show_activity_by_id", {
+                    activityId: activityId,
+                });
+                const resultText = result?.content?.[0]?.text;
+                this.logger.debug("show_activity_by_id response", {
+                    hasResult: !!resultText,
+                    preview: resultText?.substring(0, 200)
+                });
+                if (resultText) {
+                    // Response format: "✅ Loaded activity with ID "xxx":\n\n{ JSON }"
+                    // Extract the JSON part after the header
+                    const jsonMatch = resultText.match(/\{[\s\S]*\}/);
+                    if (jsonMatch) {
+                        const parsed = JSON.parse(jsonMatch[0]);
+                        const activityName = parsed.name;
+                        this.logger.info("Extracted activity name", { activityId, activityName });
+                        if (activityName) {
+                            const tag = this.formatHailerTag(activityId, activityName);
+                            content = content.replace(match[0], tag);
+                            this.logger.info("Created activity tag", { tag });
+                        }
+                    }
+                    else {
+                        this.logger.warn("Could not extract JSON from response", { preview: resultText.substring(0, 100) });
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.warn("Failed to resolve activity ID tag", { activityId, error });
+                // Leave as #id - won't be clickable but at least visible
+            }
+        }
+        // Pattern 2: #"Activity Name" - need to look up the ID
+        // This is harder because list_activities requires workflowId/phaseId
+        // For now, search in each workflow until we find a match
+        const activityNamePattern = /#"([^"]+)"/g;
+        const nameMatches = [...content.matchAll(activityNamePattern)];
+        for (const match of nameMatches) {
+            const activityName = match[1];
+            try {
+                // Get list of workflows first
+                const workflowsResult = await this.callMcpTool("list_workflows_minimal", {});
+                const workflowsText = workflowsResult?.content?.[0]?.text;
+                if (workflowsText) {
+                    // Extract workflow IDs from the response (format varies)
+                    const workflowIdMatches = workflowsText.matchAll(/"_id":\s*"([a-f0-9]{24})"/gi);
+                    const workflowIds = [...workflowIdMatches].map(m => m[1]);
+                    // Search each workflow for the activity
+                    for (const workflowId of workflowIds.slice(0, 5)) { // Limit to first 5 workflows
+                        try {
+                            const phasesResult = await this.callMcpTool("list_workflow_phases", { workflowId });
+                            const phasesText = phasesResult?.content?.[0]?.text;
+                            if (phasesText) {
+                                const phaseIdMatches = phasesText.matchAll(/"_id":\s*"([a-f0-9]{24})"/gi);
+                                const phaseIds = [...phaseIdMatches].map(m => m[1]);
+                                for (const phaseId of phaseIds.slice(0, 3)) { // Limit to first 3 phases
+                                    const activitiesResult = await this.callMcpTool("list_activities", {
+                                        workflowId,
+                                        phaseId,
+                                        search: activityName,
+                                        limit: 1,
+                                    });
+                                    const activitiesText = activitiesResult?.content?.[0]?.text;
+                                    if (activitiesText) {
+                                        // Look for activity ID and name in the response
+                                        const activityIdMatch = activitiesText.match(/"_id":\s*"([a-f0-9]{24})"/i);
+                                        if (activityIdMatch) {
+                                            const foundId = activityIdMatch[1];
+                                            const tag = this.formatHailerTag(foundId, activityName);
+                                            content = content.replace(match[0], tag);
+                                            break; // Found it, stop searching
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch {
+                            // Continue to next workflow
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.warn("Failed to resolve activity name tag", { activityName, error });
+                // Leave the original #"Name" in place
+            }
+        }
+        return content;
+    }
+    /**
+     * Convert Hailer URLs to Hailer tags
+     * Handles:
+     * - https://app.hailer.com/#/activities/{activityId}
+     * - https://app.hailer.com/#/discussions/{discussionId}
+     */
+    async resolveHailerUrls(content) {
+        // Pattern for activity URLs
+        const activityUrlPattern = /https?:\/\/app\.hailer\.com\/#\/activities\/([a-f0-9]{24})/gi;
+        const activityMatches = [...content.matchAll(activityUrlPattern)];
+        for (const match of activityMatches) {
+            const activityId = match[1];
+            try {
+                const result = await this.callMcpTool("show_activity_by_id", { activityId });
+                const resultText = result?.content?.[0]?.text;
+                if (resultText) {
+                    const jsonMatch = resultText.match(/\{[\s\S]*\}/);
+                    if (jsonMatch) {
+                        const parsed = JSON.parse(jsonMatch[0]);
+                        const activityName = parsed.name;
+                        if (activityName) {
+                            const tag = this.formatHailerTag(activityId, activityName);
+                            content = content.replace(match[0], tag);
+                            this.logger.debug("Converted activity URL to tag", { activityId, activityName });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.debug("Failed to resolve activity URL", { activityId, error });
+                // Leave URL as-is
+            }
+        }
+        // Pattern for discussion URLs - need to look up the linked activity
+        const discussionUrlPattern = /https?:\/\/app\.hailer\.com\/#\/discussions\/([a-f0-9]{24})/gi;
+        const discussionMatches = [...content.matchAll(discussionUrlPattern)];
+        for (const match of discussionMatches) {
+            const discussionId = match[1];
+            try {
+                // Load discussion to get linked activity
+                const discussionResponse = await this.botClient.client.socket.request("messenger.load_discussions", [[discussionId]]);
+                if (discussionResponse && discussionResponse[discussionId]) {
+                    const discData = discussionResponse[discussionId];
+                    const linkedActivityId = discData.linked_activity;
+                    const discussionName = discData.name;
+                    if (linkedActivityId) {
+                        // It's an activity discussion - use the activity ID for the tag
+                        const tag = this.formatHailerTag(linkedActivityId, discussionName || "Activity");
+                        content = content.replace(match[0], tag);
+                        this.logger.debug("Converted discussion URL to activity tag", { discussionId, linkedActivityId, discussionName });
+                    }
+                    else if (discussionName) {
+                        // It's a standalone discussion - use discussion name but discussion ID
+                        const tag = this.formatHailerTag(discussionId, discussionName);
+                        content = content.replace(match[0], tag);
+                        this.logger.debug("Converted discussion URL to discussion tag", { discussionId, discussionName });
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.debug("Failed to resolve discussion URL", { discussionId, error });
+                // Leave URL as-is
+            }
+        }
+        return content;
+    }
+    /**
+     * Extract link metadata from hailerTag formatted content
+     * Returns array of links for the messenger.send API
+     */
+    extractTagLinks(content) {
+        const links = [];
+        // Match all hailerTag patterns: [hailerTag|Name](id)
+        const tagPattern = /\[hailerTag\|[^\]]+\]\(([a-f0-9]{24})\)/gi;
+        const matches = content.matchAll(tagPattern);
+        for (const match of matches) {
+            const targetId = match[1];
+            // Determine if it's a user or activity based on context
+            // For now, check if it's in the user cache
+            const isUser = this.botClient.workspaceCache?.usersById[targetId];
+            links.push({
+                target: targetId,
+                targetType: isUser ? 'user' : 'activity',
+                type: 'linked-to'
+            });
+        }
+        return links;
+    }
+    /**
+     * Format incoming message for LLM consumption
+     */
+    formatIncomingMessage(message) {
+        const priorityTag = message.priority === "high" ? " priority=\"high\"" : "";
+        const reasonAttr = message.priority === "high" ? ` reason="${message.priorityReason}"` : "";
+        const activityAttr = message.linkedActivityId ? ` activity_id="${message.linkedActivityId}"` : "";
+        return `<incoming discussion="${message.discussionId}"${activityAttr} from="${message.senderName}" user_id="${message.senderId}" timestamp="${new Date(message.timestamp).toISOString()}"${priorityTag}${reasonAttr}>
+${message.content}
+</incoming>`;
+    }
+}
+exports.MessageFormatterService = MessageFormatterService;
+//# sourceMappingURL=message-formatter.js.map

package/dist/agents/shared/services/session-logger.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Session Logger Service
+ *
+ * Manages per-activity session tracking and logging to Hailer workflows:
+ * - Tracks metrics (tokens, tool calls, messages)
+ * - Logs completed sessions to SESSION_LOG workflow
+ * - Manages idle session detection and flushing
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { Logger } from "../../../lib/logger";
+import { ActivitySession, McpToolCallback } from "../../shared/types";
+import { WorkspaceSchemaCacheService } from "./workspace-schema-cache";
+/** Memory entry loaded from SESSION_LOG */
+export interface MemoryEntry {
+    sessionId: string;
+    timestamp: number;
+    summary: string;
+    linkedActivityId?: string;
+}
+export declare class SessionLoggerService {
+    private agentDirectoryId;
+    private logger;
+    private callMcpTool;
+    private getDefaultTeamId;
+    private activitySessions;
+    private lastGlobalLogId;
+    private idleCheckTimer;
+    private anthropicClient;
+    private schemaCache;
+    private _currentWorkspaceId;
+    constructor(agentDirectoryId: string | null, logger: Logger, callMcpTool: McpToolCallback, getDefaultTeamId: () => string | undefined);
+    /**
+     * Set the workspace schema cache for dynamic ID lookup
+     */
+    setSchemaCache(cache: WorkspaceSchemaCacheService, workspaceId: string): void;
+    /**
+     * Get Session Log schema from cache for a specific workspace
+     */
+    private getSessionLogSchema;
+    /**
+     * Set Anthropic client for generating summaries
+     */
+    setAnthropicClient(client: Anthropic): void;
+    /**
+     * Get or create an activity session for tracking
+     * Multi-tenant: workspaceId is required for proper schema lookup
+     */
+    getOrCreateActivitySession(message: {
+        linkedActivityId?: string;
+        linkedActivityName?: string;
+        discussionId: string;
+        workspaceId: string;
+    }): ActivitySession;
+    /**
+     * Get session by key
+     */
+    getSession(key: string): ActivitySession | undefined;
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions(): Map<string, ActivitySession>;
+    /**
+     * Check for idle sessions and flush them
+     * Called periodically by timer
+     */
+    checkAndFlushIdleSessions(): Promise<void>;
+    /**
+     * Flush a single activity session to the session log
+     */
+    flushActivitySession(_key: string, session: ActivitySession): Promise<void>;
+    /**
+     * Flush all active sessions (called on shutdown)
+     */
+    flushAllSessions(): Promise<void>;
+    /**
+     * Build summary for an activity session
+     * Now includes conversation summary for memory recall
+     */
+    private buildActivitySessionSummary;
+    /**
+     * Start periodic idle session checking
+     */
+    startIdleCheckTimer(intervalMs?: number): void;
+    /**
+     * Stop idle check timer
+     */
+    stopIdleCheckTimer(): void;
+    /**
+     * Generate a conversation summary using LLM
+     * Creates a condensed memory of what was discussed
+     */
+    private generateConversationSummary;
+    /**
+     * Load memory entries for an activity from SESSION_LOG
+     * Returns past conversation summaries for context injection
+     *
+     * NOTE: ActivityLink fields store objects {_id, name}, so we fetch recent
+     * session logs and filter client-side by checking the nested _id.
+     */
+    loadMemoryForActivity(activityId: string, workspaceId: string, limit?: number): Promise<MemoryEntry[]>;
+    /**
+     * Format memory entries for injection into conversation context
+     */
+    formatMemoryForContext(entries: MemoryEntry[]): string;
+}
+//# sourceMappingURL=session-logger.d.ts.map