@hailer/mcp 0.0.1

package/dist/mcp/UserContextCache.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserContextCache = void 0;
+const hailer_clients_1 = require("./hailer-clients");
+const workspace_cache_1 = require("./workspace-cache");
+const config_1 = require("../config");
+const logger_1 = require("../lib/logger");
+const index_1 = require("./utils/index");
+const logger = (0, logger_1.createLogger)({ component: 'user-context-cache' });
+/**
+ * Cache for user-specific data (client connections, init data, workspace cache)
+ *
+ * Replaces per-user ClassBasedToolManager instances with efficient caching:
+ * - Reuses shared connection pool from hailer-clients.ts
+ * - Caches user-specific data (init, workspaceCache) separately from tool logic
+ * - Used by both MCP Server and Client for consistent user context
+ */
+class UserContextCache {
+    static cache = new Map();
+    /** Life of each cache unit. */
+    static DEFAULT_TTL_MS = 15 * 60 * 1000; // 15 minutes
+    /**
+     * Get or create user context (client, init, workspaceCache) for an API key
+     * This data is user-specific and should be cached per user
+     *
+     * @param apiKey - Hailer API key for authentication
+     * @param forceRefresh - If true, bypasses cache and creates fresh context (useful for testing or after permission changes)
+     * @param ttlMs - Custom TTL in milliseconds, defaults to 15 minutes
+     */
+    static async getContext(apiKey, forceRefresh = false, ttlMs = this.DEFAULT_TTL_MS) {
+        console.log(`🔍 getContext called: apiKey=${apiKey.substring(0, 8)}..., forceRefresh=${forceRefresh}, cacheHas=${this.cache.has(apiKey)}`);
+        // Check cache first (unless forceRefresh is requested)
+        if (!forceRefresh && this.cache.has(apiKey)) {
+            const cachedContext = this.cache.get(apiKey);
+            const age = Date.now() - cachedContext.createdAt;
+            // Check if cache is still fresh
+            if (age < ttlMs) {
+                logger.debug('Using cached user context', {
+                    apiKey: apiKey.substring(0, 8) + '...',
+                    ageMinutes: Math.round(age / (1000 * 60)),
+                    ttlMinutes: Math.round(ttlMs / (1000 * 60))
+                });
+                return cachedContext;
+            }
+            else {
+                // Cache expired, remove stale entry
+                this.cache.delete(apiKey);
+                logger.info('Cache expired, refreshing user context', {
+                    apiKey: apiKey.substring(0, 8) + '...',
+                    ageMinutes: Math.round(age / (1000 * 60))
+                });
+            }
+        }
+        else if (forceRefresh && this.cache.has(apiKey)) {
+            // Force refresh requested, clear existing cache
+            this.cache.delete(apiKey);
+            logger.info('Force refresh requested, clearing cached user context', {
+                apiKey: apiKey.substring(0, 8) + '...'
+            });
+        }
+        logger.info('Creating new user context', { apiKey: apiKey.substring(0, 8) + '...' });
+        try {
+            // Create client connection (uses existing connection pool)
+            const client = await (0, hailer_clients_1.createHailerClientByApiKey)(apiKey);
+            // Create API client (host extracted from client automatically)
+            const hailer = new index_1.HailerApiClient(client);
+            // Fetch user's workspace initialization data
+            const init = await client.socket.request('v2.core.init', [
+                ['processes', 'users', 'network', 'networks']
+            ]);
+            // Create workspace cache from init data
+            const appConfig = (0, config_1.createApplicationConfig)(); // TODO: small concern here: it creates a new instance of config instaed of reusing it, is it wise?
+            const workspaceCache = (0, workspace_cache_1.createWorkspaceCache)(init, appConfig.mcpConfig);
+            const context = {
+                client,
+                hailer,
+                init,
+                workspaceCache,
+                apiKey,
+                createdAt: Date.now()
+            };
+            // Calculate cache sizes
+            const rawInitSize = Buffer.byteLength(JSON.stringify(init), 'utf8');
+            const workspaceCacheSize = Buffer.byteLength(JSON.stringify(workspaceCache), 'utf8');
+            const totalContextSize = Buffer.byteLength(JSON.stringify({
+                init,
+                workspaceCache
+            }), 'utf8');
+            // Log cache sizes to console
+            console.log('\n📊 === WORKSPACE CACHE SIZE ANALYSIS ===');
+            console.log(`Raw init response: ${rawInitSize.toLocaleString()} bytes (${(rawInitSize / 1024).toFixed(2)} KB)`);
+            console.log(`Workspace cache:   ${workspaceCacheSize.toLocaleString()} bytes (${(workspaceCacheSize / 1024).toFixed(2)} KB)`);
+            console.log(`Total context:     ${totalContextSize.toLocaleString()} bytes (${(totalContextSize / 1024).toFixed(2)} KB)`);
+            console.log(`Reduction:         ${((1 - workspaceCacheSize / rawInitSize) * 100).toFixed(1)}%`);
+            console.log(`Workflows:         ${init.processes?.length || 0}`);
+            console.log(`Users:             ${workspaceCache.users.length}`);
+            console.log(`Workspaces:        ${Object.keys(workspaceCache.allWorkspaces).length}`);
+            console.log('=====================================\n');
+            // Cache for future requests
+            this.cache.set(apiKey, context);
+            logger.info('User context created and cached', {
+                apiKey: apiKey.substring(0, 8) + '...',
+                workflowCount: init.processes?.length || 0,
+                userCount: workspaceCache.users.length,
+                rawInitBytes: rawInitSize,
+                workspaceCacheBytes: workspaceCacheSize,
+                totalContextBytes: totalContextSize,
+                rawInitKB: (rawInitSize / 1024).toFixed(2),
+                workspaceCacheKB: (workspaceCacheSize / 1024).toFixed(2),
+                totalContextKB: (totalContextSize / 1024).toFixed(2)
+            });
+            return context;
+        }
+        catch (error) {
+            logger.error('Failed to create user context', error, {
+                apiKey: apiKey.substring(0, 8) + '...'
+            });
+            throw error;
+        }
+    }
+    /**
+     * Clear cache entry for specific API key (for cleanup/testing)
+     */
+    static clearContext(apiKey) {
+        this.cache.delete(apiKey);
+        logger.debug('Cleared user context from cache', {
+            apiKey: apiKey.substring(0, 8) + '...'
+        });
+    }
+    /**
+     * Clear all cached contexts (for cleanup/testing)
+     */
+    static clearAll() {
+        const size = this.cache.size;
+        this.cache.clear();
+        logger.info('Cleared all user contexts from cache', { clearedCount: size });
+    }
+    /**
+     * Get cache statistics (for monitoring and debugging)
+     *
+     * @returns Cache stats including size, API keys, and age information
+     */
+    static getCacheStats() {
+        const now = Date.now();
+        const entries = Array.from(this.cache.entries()).map(([key, context]) => {
+            const ageMs = now - context.createdAt;
+            const ageMinutes = Math.round(ageMs / (1000 * 60));
+            const isExpired = ageMs > this.DEFAULT_TTL_MS;
+            return {
+                apiKey: key.substring(0, 8) + '...',
+                ageMinutes,
+                isExpired
+            };
+        });
+        return {
+            size: this.cache.size,
+            apiKeys: Array.from(this.cache.keys()).map(key => key.substring(0, 8) + '...'),
+            entries
+        };
+    }
+}
+exports.UserContextCache = UserContextCache;
+//# sourceMappingURL=UserContextCache.js.map

package/dist/mcp/auth.d.ts

@@ -0,0 +1,2 @@
+export declare const safeFetch: (url: string, options?: RequestInit) => Promise<Response>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/mcp/auth.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeFetch = void 0;
+// Custom fetch function that handles self-signed certificates
+const safeFetch = async (url, options = {}) => {
+    const isLocalDev = url.includes('local.gd') || url.includes('localhost');
+    if (isLocalDev) {
+        // For Next.js/Node.js environment with self-signed certs
+        // We need to set the environment variable before making the request
+        const originalValue = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+        try {
+            const response = await fetch(url, options);
+            return response;
+        }
+        finally {
+            // Restore the original value
+            if (originalValue !== undefined) {
+                process.env.NODE_TLS_REJECT_UNAUTHORIZED = originalValue;
+            }
+            else {
+                delete process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+            }
+        }
+    }
+    return fetch(url, options);
+};
+exports.safeFetch = safeFetch;
+//# sourceMappingURL=auth.js.map

package/dist/mcp/hailer-clients.d.ts

@@ -0,0 +1,42 @@
+import { Client } from "@hailer/cli";
+export interface HailerRestClient {
+    fetch: (url: string, options?: RequestInit) => Promise<Response>;
+    sessionKey: string;
+}
+export interface HailerClient {
+    socket: Client;
+    rest: HailerRestClient;
+    sessionKey: string;
+}
+/**
+ * Get the current user ID from the authenticated session
+ * This is called after authentication to retrieve the user ID automatically
+ */
+export declare function getCurrentUserId(client: HailerClient): Promise<string>;
+/** Hailer Client for a specific account with listeners and basic handling logic */
+export declare class HailerClientManager {
+    private host;
+    private username;
+    private password;
+    private socketClient;
+    private restClient;
+    private signalHandlers;
+    constructor(host: string, username: string, password: string);
+    connect(): Promise<HailerClient>;
+    private setupSignalHandling;
+    onSignal(eventType: string, handler: (data: any) => void): void;
+    offSignal(eventType: string, handler: (data: any) => void): void;
+    disconnect(): void;
+    isConnected(): boolean;
+    getClient(): HailerClient | null;
+}
+/**
+ * Create Hailer client by API key (O(1) lookup)
+ * This is the new efficient method for MCP Server to get connections
+ */
+export declare const createHailerClientByApiKey: (apiKey: string) => Promise<HailerClient>;
+/**
+ * Disconnect client by API key (new unified approach)
+ */
+export declare const disconnectHailerClientByApiKey: (apiKey: string) => void;
+//# sourceMappingURL=hailer-clients.d.ts.map

package/dist/mcp/hailer-clients.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disconnectHailerClientByApiKey = exports.createHailerClientByApiKey = exports.HailerClientManager = void 0;
+exports.getCurrentUserId = getCurrentUserId;
+const cli_1 = require("@hailer/cli");
+const auth_1 = require("./auth");
+const logger_1 = require("../lib/logger");
+const config_1 = require("../config");
+const logger = (0, logger_1.createLogger)({ component: 'hailer-clients' });
+/**
+ * Get the current user ID from the authenticated session
+ * This is called after authentication to retrieve the user ID automatically
+ */
+async function getCurrentUserId(client) {
+    try {
+        // Use the socket client to get initialization data with the current user
+        // According to the API docs, requesting "user" returns the current authenticated user
+        const init = (await client.socket.request("v2.core.init", [
+            ["user"],
+        ]));
+        // Check if there's a user field (this is the current authenticated user)
+        if (init.user && init.user._id) {
+            logger.info('Retrieved user ID from init', { userId: init.user._id });
+            return init.user._id;
+        }
+        // Fallback: Try with different parameters if the above doesn't work
+        logger.warn('User not found in init.user, trying alternative approach');
+        // Method 2: Try to get current user from a profile/me endpoint
+        try {
+            const profileResponse = await client.rest.fetch("/api/user/me", {
+                method: "GET",
+            });
+            if (profileResponse.ok) {
+                const profile = (await profileResponse.json());
+                if (profile && profile._id) {
+                    logger.info('Retrieved user ID from profile endpoint', { userId: profile._id });
+                    return profile._id;
+                }
+            }
+        }
+        catch (error) {
+            logger.warn('Profile endpoint not available, trying network method');
+        }
+        // Method 3: Try with network data to infer from workspace membership
+        const initWithNetwork = (await client.socket.request("v2.core.init", [
+            ["network"],
+        ]));
+        if (initWithNetwork.network && initWithNetwork.network.members) {
+            const members = initWithNetwork.network.members;
+            if (members.length === 1) {
+                // If there's only one member, it's likely the current user
+                const member = members[0];
+                const userId = member.uid || member._id || member.id;
+                if (userId) {
+                    logger.info('Inferred user ID from single workspace member', { userId });
+                    return userId;
+                }
+            }
+        }
+        // If all methods fail, throw an error with helpful information
+        throw new Error("Could not determine current user ID from any available method. Check API credentials and permissions.");
+    }
+    catch (error) {
+        logger.error('Failed to get current user ID', error);
+        throw new Error(`Failed to retrieve current user ID: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// manager is supposed to manage many instances, isn't it? a bit weird naming as for me but not sure
+/** Hailer Client for a specific account with listeners and basic handling logic */
+class HailerClientManager {
+    host;
+    username;
+    password;
+    socketClient = null;
+    restClient = null;
+    signalHandlers = new Map();
+    constructor(host, username, password) {
+        this.host = host;
+        this.username = username;
+        this.password = password;
+    }
+    async connect() {
+        // Check if this is a local development environment
+        const isLocalDev = this.host.includes("local.gd") || this.host.includes("localhost");
+        const clientOptions = {
+            host: this.host,
+            username: this.username,
+            password: this.password,
+            ...(isLocalDev && { rejectUnauthorized: false }), // Add for local dev with self-signed certs
+        };
+        try {
+            // Create socket client using @hailer/cli with timeout
+            this.socketClient = (await Promise.race([
+                cli_1.Client.create(clientOptions),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("Socket connection timeout after 30s")), 30000)),
+            ]));
+        }
+        catch (error) {
+            logger.error('Failed to create socket client', error, { username: this.username });
+            throw error;
+        }
+        if (!this.socketClient.sessionKey) {
+            throw new Error("Socket client connected but no session key received");
+        }
+        // Create REST client that uses the same session key
+        this.restClient = {
+            fetch: (url, options = {}) => {
+                const headers = {
+                    ...options.headers,
+                    hlrkey: this.socketClient.sessionKey,
+                    "Content-Type": "application/json",
+                };
+                return (0, auth_1.safeFetch)(url, { ...options, headers });
+            },
+            sessionKey: this.socketClient.sessionKey,
+        };
+        // Set up signal handling
+        this.setupSignalHandling();
+        return {
+            socket: this.socketClient,
+            rest: this.restClient,
+            sessionKey: this.socketClient.sessionKey,
+        };
+    }
+    setupSignalHandling() {
+        if (!this.socketClient)
+            return;
+        this.socketClient.on("signals", (signal) => {
+            const [eventType, eventData] = signal;
+            // Dispatch to registered handlers
+            const handlers = this.signalHandlers.get(eventType);
+            if (handlers) {
+                handlers.forEach((handler) => {
+                    try {
+                        handler(eventData);
+                    }
+                    catch (error) {
+                        logger.error('Signal handler failed', error);
+                    }
+                });
+            }
+        });
+    }
+    // Register a handler for specific signal types
+    onSignal(eventType, handler) {
+        if (!this.signalHandlers.has(eventType)) {
+            this.signalHandlers.set(eventType, []);
+        }
+        this.signalHandlers.get(eventType).push(handler);
+    }
+    // Remove a signal handler
+    offSignal(eventType, handler) {
+        const handlers = this.signalHandlers.get(eventType);
+        if (handlers) {
+            const index = handlers.indexOf(handler);
+            if (index > -1) {
+                handlers.splice(index, 1);
+            }
+        }
+    }
+    disconnect() {
+        if (this.socketClient) {
+            this.socketClient.disconnect();
+            this.socketClient = null;
+        }
+        this.restClient = null;
+        this.signalHandlers.clear();
+    }
+    isConnected() {
+        return this.socketClient !== null && this.restClient !== null;
+    }
+    getClient() {
+        if (!this.socketClient ||
+            !this.restClient ||
+            !this.socketClient.sessionKey) {
+            return null;
+        }
+        return {
+            socket: this.socketClient,
+            rest: this.restClient,
+            sessionKey: this.socketClient.sessionKey,
+        };
+    }
+}
+exports.HailerClientManager = HailerClientManager;
+// Connection pool for the MCP server
+const connectionPool = new Map();
+/**
+ * Create Hailer client by API key (O(1) lookup)
+ * This is the new efficient method for MCP Server to get connections
+ */
+const createHailerClientByApiKey = async (apiKey) => {
+    // O(1) lookup in Map-based CLIENT_CONFIGS
+    const account = config_1.environment.CLIENT_CONFIGS[apiKey];
+    if (!account) {
+        throw new Error(`No Hailer account found for API key: ${apiKey}`);
+    }
+    logger.debug('Creating clients for API key', {
+        apiKey: apiKey.substring(0, 8) + '...',
+        email: account.email,
+        host: account.apiBaseUrl
+    });
+    // Use API key as connection key for direct mapping
+    const connectionKey = apiKey;
+    // Check if we have an existing connection
+    let clientManager = connectionPool.get(connectionKey);
+    if (clientManager && clientManager.isConnected()) {
+        logger.info('Reusing existing connection', {
+            apiKey: apiKey.substring(0, 8) + '...',
+            email: account.email
+        });
+        return clientManager.getClient();
+    }
+    // Clear any stale connection
+    if (clientManager) {
+        logger.info('Cleaning up stale connection', {
+            apiKey: apiKey.substring(0, 8) + '...',
+            email: account.email
+        });
+        clientManager.disconnect();
+        connectionPool.delete(connectionKey);
+    }
+    // Create new connection
+    logger.info('Creating new connection', {
+        apiKey: apiKey.substring(0, 8) + '...',
+        email: account.email,
+        host: account.apiBaseUrl
+    });
+    clientManager = new HailerClientManager(account.apiBaseUrl, account.email, account.password);
+    await clientManager.connect();
+    connectionPool.set(connectionKey, clientManager);
+    return clientManager.getClient();
+};
+exports.createHailerClientByApiKey = createHailerClientByApiKey;
+/**
+ * Disconnect client by API key (new unified approach)
+ */
+const disconnectHailerClientByApiKey = (apiKey) => {
+    const clientManager = connectionPool.get(apiKey);
+    if (clientManager) {
+        clientManager.disconnect();
+        connectionPool.delete(apiKey);
+    }
+};
+exports.disconnectHailerClientByApiKey = disconnectHailerClientByApiKey;
+//# sourceMappingURL=hailer-clients.js.map

package/dist/mcp/signal-handler.d.ts

@@ -0,0 +1,45 @@
+import { WorkspaceCache } from './workspace-cache';
+import { HailerClient } from './hailer-clients';
+/**
+ * Signal types that Hailer emits via socket.io
+ */
+export type HailerSignalType = 'activities.updated' | 'activities.created' | 'activities.deleted' | 'discussion.message' | 'messenger.new' | 'user.joined' | 'user.left' | 'workspace.updated' | 'process.updated' | 'cache.invalidate';
+export interface HailerSignal {
+    type: HailerSignalType;
+    data: any;
+    timestamp: number;
+    workspaceId?: string;
+}
+export interface SignalSubscription {
+    id: string;
+    types: HailerSignalType[];
+    handler: (signal: HailerSignal) => void;
+    workspaceId?: string;
+}
+export declare class SignalHandler {
+    private client;
+    private workspaceCache?;
+    private subscriptions;
+    private signalHistory;
+    private maxHistorySize;
+    constructor(client: HailerClient, workspaceCache?: WorkspaceCache | undefined);
+    private initializeSignalHandling;
+    private handleIncomingSignal;
+    private addToHistory;
+    private dispatchSignal;
+    private processBuiltinSignals;
+    private handleActivityUpdated;
+    private handleActivityCreated;
+    private handleDiscussionMessage;
+    private handleWorkspaceUpdated;
+    private handleMessengerNew;
+    private handleCacheInvalidate;
+    subscribe(id: string, types: HailerSignalType[], handler: (signal: HailerSignal) => void, workspaceId?: string): void;
+    unsubscribe(id: string): boolean;
+    getSignalHistory(types?: HailerSignalType[], limit?: number, workspaceId?: string): HailerSignal[];
+    getActiveSubscriptions(): SignalSubscription[];
+    clearHistory(): void;
+    createMcpSignalTools(server: any): void;
+}
+export declare const createSignalHandler: (clients: HailerClient, workspaceCache?: WorkspaceCache) => SignalHandler;
+//# sourceMappingURL=signal-handler.d.ts.map