@hailer/mcp 1.0.29 → 1.1.2

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

@@ -0,0 +1,411 @@
+"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 {
+    botConnection;
+    logger;
+    callMcpTool;
+    constructor(botConnection, logger, callMcpTool) {
+        this.botConnection = botConnection;
+        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.botConnection.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.botConnection.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.botConnection.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.debug("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.debug("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 targetId = match[1];
+            try {
+                this.logger.debug("Resolving tag by ID", { targetId });
+                // Try as activity first
+                const result = await this.callMcpTool("show_activity_by_id", {
+                    activityId: targetId,
+                });
+                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(targetId, activityName);
+                            content = content.replace(match[0], tag);
+                            this.logger.debug("Created activity tag", { targetId, activityName });
+                            continue;
+                        }
+                    }
+                }
+                // Fallback: try as discussion ID
+                this.logger.debug("Activity lookup failed, trying as discussion", { targetId });
+                const discResult = await this.callMcpTool("get_activity_from_discussion", {
+                    discussionId: targetId,
+                });
+                const discText = discResult?.content?.[0]?.text;
+                if (discText) {
+                    const discJson = discText.match(/\{[\s\S]*\}/);
+                    if (discJson) {
+                        const discParsed = JSON.parse(discJson[0]);
+                        const discName = discParsed.name || discParsed.activityName;
+                        if (discName) {
+                            const tag = this.formatHailerTag(targetId, discName);
+                            content = content.replace(match[0], tag);
+                            this.logger.debug("Created discussion tag", { targetId, discName });
+                            continue;
+                        }
+                    }
+                }
+                // Last resort: try loading discussion directly for its name
+                try {
+                    const discLoad = await this.botConnection.client.socket.request("messenger.load_discussions", [[targetId]]);
+                    if (discLoad?.[targetId]?.name) {
+                        const tag = this.formatHailerTag(targetId, discLoad[targetId].name);
+                        content = content.replace(match[0], tag);
+                        this.logger.debug("Created discussion tag from load", { targetId, name: discLoad[targetId].name });
+                    }
+                }
+                catch {
+                    this.logger.debug("Discussion load also failed", { targetId });
+                }
+            }
+            catch (error) {
+                this.logger.warn("Failed to resolve ID tag", { targetId, error });
+            }
+        }
+        // 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.botConnection.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
+            }
+        }
+        // Pattern for process/workflow URLs
+        const processUrlPattern = /https?:\/\/app\.hailer\.com\/#\/processes\/([a-f0-9]{24})/gi;
+        const processMatches = [...content.matchAll(processUrlPattern)];
+        for (const match of processMatches) {
+            const workflowId = match[1];
+            try {
+                // Look up workflow name from cache (processes = workflows in Hailer)
+                const workflow = this.botConnection.workspaceCache?.rawInit?.processes?.find((w) => w._id === workflowId);
+                if (workflow?.name) {
+                    const tag = this.formatHailerTag(workflowId, workflow.name);
+                    content = content.replace(match[0], tag);
+                    this.logger.debug("Converted process URL to tag", { workflowId, workflowName: workflow.name });
+                }
+            }
+            catch (error) {
+                this.logger.debug("Failed to resolve process URL", { workflowId, 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.botConnection.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/bot/services/session-logger.d.ts

@@ -0,0 +1,162 @@
+/**
+ * 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 "./types";
+import { WorkspaceSchemaCacheService } from "./workspace-schema-cache";
+/** Memory entry loaded from SESSION_LOG */
+export interface MemoryEntry {
+    sessionId: string;
+    timestamp: number;
+    summary: string;
+    linkedActivityId?: string;
+}
+/** Memory metadata generated from conversation for smart retrieval */
+export interface SessionMemoryMetadata {
+    headline: string;
+    topics: string;
+    entities: string;
+    outcome: string;
+    summary: string;
+}
+/** Memory headline for quick context injection */
+export interface MemoryHeadline {
+    sessionId: string;
+    timestamp: number;
+    headline: string;
+    topics: string;
+    outcome: 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
+     * Set DISABLE_SESSION_LOG=true to skip persistence (saves 20+ tokens per session)
+     */
+    flushActivitySession(_key: string, session: ActivitySession): Promise<void>;
+    /**
+     * Flush all active sessions (called on shutdown)
+     */
+    flushAllSessions(): Promise<void>;
+    /**
+     * Build summary for an activity session
+     * Uses pre-generated metadata if available
+     */
+    private buildActivitySessionSummary;
+    /**
+     * Calculate cost in USD based on Haiku 4.5 pricing
+     * - Input (uncached): $0.80 / 1M tokens
+     * - Output: $4.00 / 1M tokens
+     * - Cache creation: $1.00 / 1M tokens (125% of input)
+     * - Cache read: $0.08 / 1M tokens (10% of input)
+     */
+    private calculateCost;
+    /**
+     * Start periodic idle session checking
+     */
+    startIdleCheckTimer(intervalMs?: number): void;
+    /**
+     * Stop idle check timer
+     */
+    stopIdleCheckTimer(): void;
+    /**
+     * Sanitize string to remove invalid Unicode surrogate pairs
+     * These can cause JSON parsing errors in the Anthropic API
+     */
+    private sanitizeString;
+    /**
+     * Generate conversation summary AND metadata for memory retrieval
+     * Returns structured data for smart session recall
+     */
+    private generateSessionMetadata;
+    /**
+     * Generate a conversation summary using LLM (legacy, uses new method internally)
+     */
+    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;
+    /**
+     * Load memory headlines for a discussion (for smart context injection)
+     * Returns lightweight headlines instead of full summaries
+     *
+     * @param discussionId - Discussion to load memory for
+     * @param workspaceId - Workspace context
+     * @param options - Search options
+     */
+    loadMemoryForDiscussion(discussionId: string, workspaceId: string, options?: {
+        limit?: number;
+        keywords?: string;
+        maxAgeDays?: number;
+    }): Promise<MemoryHeadline[]>;
+    /**
+     * Format memory headlines for context injection (lightweight)
+     * Returns ~50 tokens for 3 entries
+     */
+    formatHeadlinesForContext(entries: MemoryHeadline[]): string;
+    /**
+     * Format timestamp as relative time (e.g., "2h ago", "yesterday")
+     */
+    private formatTimeAgo;
+}
+//# sourceMappingURL=session-logger.d.ts.map