@hailer/mcp 0.1.16 → 0.2.1

package/dist/client/bot-manager.js

@@ -1,173 +0,0 @@
-"use strict";
-/**
- * Multi-Bot Client Manager
- * Manages multiple bot clients, each with their own Hailer connection
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiBotManager = void 0;
-const hailer_clients_1 = require("../mcp/hailer-clients");
-const signal_handler_1 = require("../mcp/signal-handler");
-const workspace_cache_1 = require("../mcp/workspace-cache");
-const config_1 = require("../config");
-class MultiBotManager {
-    botConfigs;
-    botClients = new Map();
-    constructor(botConfigs) {
-        this.botConfigs = botConfigs;
-    }
-    // for client we may put initializeAllConfigClients method to do it at once
-    // in case we only use MCP Server:
-    // for MCP Server it may just get a specific client and this class initialize it specifically and even kill it later if not needed
-    async initializeAllHailerClientsFromConfig() {
-        console.log(`🤖 Initializing ${this.botConfigs.length} bot clients...`);
-        const appConfig = (0, config_1.createApplicationConfig)();
-        for (const config of this.botConfigs) {
-            try {
-                // Use shared connection pool via API key lookup
-                const client = await (0, hailer_clients_1.createHailerClientByApiKey)(config.mcpServerApiKey);
-                // Get user ID automatically from authenticated session
-                const userId = await (0, hailer_clients_1.getCurrentUserId)(client);
-                // Fetch init data to get workspace cache with user names and teams
-                let workspaceCache;
-                try {
-                    const init = await client.socket.request('v2.core.init', [['users', 'network', 'networks', 'teams']]);
-                    workspaceCache = (0, workspace_cache_1.createWorkspaceCache)(init, appConfig.mcpConfig);
-                    const teamCount = Object.keys(init.teams || {}).length;
-                    console.log(`📋 Loaded workspace cache with ${workspaceCache.users.length} users, ${teamCount} teams`);
-                }
-                catch (initError) {
-                    console.warn(`⚠️ Could not load workspace cache for ${config.email}:`, initError);
-                }
-                const signalHandler = new signal_handler_1.SignalHandler(client, workspaceCache);
-                // Look up user's name from workspace cache
-                let firstName = 'Bot';
-                let lastName = '';
-                if (workspaceCache) {
-                    const userInfo = workspaceCache.usersById[userId];
-                    if (userInfo) {
-                        firstName = userInfo.firstname || 'Bot';
-                        lastName = userInfo.lastname || '';
-                    }
-                }
-                const botClient = {
-                    userId,
-                    firstName,
-                    lastName,
-                    config,
-                    client,
-                    signalHandler,
-                    workspaceCache,
-                };
-                this.botClients.set(userId, botClient);
-                console.log(`✅ Bot client initialized for ${config.email} (${userId}) via API key ${config.mcpServerApiKey.substring(0, 8)}...`);
-            }
-            catch (error) {
-                console.error(`❌ Failed to initialize bot client for ${config.email}:`, error);
-                // Continue with other bots even if one fails
-            }
-        }
-        console.log(`✅ Initialized ${this.botClients.size} bot clients successfully`);
-    }
-    getBotClient(userId) {
-        const botClient = this.botClients.get(userId);
-        if (!botClient) {
-            console.warn(`❌ No bot client found for userId: ${userId}`);
-        }
-        return botClient;
-    }
-    getAllBotClients() {
-        return Array.from(this.botClients.values());
-    }
-    getBotIds() {
-        return Array.from(this.botClients.keys());
-    }
-    // Simple in-memory cache for user lookups (refreshed on demand)
-    userNameCache = new Map();
-    static USER_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-    /**
-     * Look up a user's full name by their user ID
-     * Uses workspace cache first, then falls back to socket API call
-     */
-    getUserName(userId) {
-        // Check in-memory cache first (for API-fetched users)
-        const cached = this.userNameCache.get(userId);
-        if (cached && Date.now() - cached.fetchedAt < MultiBotManager.USER_CACHE_TTL) {
-            return cached.name;
-        }
-        // Try each bot client's workspace cache until we find the user
-        for (const botClient of this.botClients.values()) {
-            if (botClient.workspaceCache) {
-                const user = (0, workspace_cache_1.getUserById)(botClient.workspaceCache, userId);
-                if (user) {
-                    const fullName = `${user.firstname || ''} ${user.lastname || ''}`.trim();
-                    return fullName || user.fullName || undefined;
-                }
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Look up a user's full name by their user ID (async version)
-     * Falls back to socket API if not in cache
-     */
-    async getUserNameAsync(userId) {
-        // Try sync lookup first
-        const syncResult = this.getUserName(userId);
-        if (syncResult) {
-            return syncResult;
-        }
-        // Fall back to socket API call
-        const botClient = this.botClients.values().next().value;
-        if (!botClient) {
-            return undefined;
-        }
-        try {
-            // Fetch fresh init data with users
-            const init = await botClient.client.socket.request('v2.core.init', [['users']]);
-            if (init.users && init.users[userId]) {
-                const user = init.users[userId];
-                const fullName = `${user.firstname || ''} ${user.lastname || ''}`.trim();
-                // Cache the result
-                if (fullName) {
-                    this.userNameCache.set(userId, { name: fullName, fetchedAt: Date.now() });
-                    return fullName;
-                }
-            }
-        }
-        catch (error) {
-            console.warn(`⚠️ Could not fetch user info for ${userId}:`, error);
-        }
-        return undefined;
-    }
-    /**
-     * Get user info by ID (returns full UserInfo object)
-     */
-    getUserInfo(userId) {
-        for (const botClient of this.botClients.values()) {
-            if (botClient.workspaceCache) {
-                const user = (0, workspace_cache_1.getUserById)(botClient.workspaceCache, userId);
-                if (user) {
-                    return user;
-                }
-            }
-        }
-        return undefined;
-    }
-    async shutdown() {
-        console.log("🤖 Shutting down all bot clients...");
-        for (const [userId, botClient] of this.botClients) {
-            try {
-                // Properly disconnect from shared connection pool
-                (0, hailer_clients_1.disconnectHailerClientByApiKey)(botClient.config.mcpServerApiKey);
-                console.log(`✅ Bot client ${userId} shut down (API key: ${botClient.config.mcpServerApiKey.substring(0, 8)}...)`);
-            }
-            catch (error) {
-                console.error(`❌ Error shutting down bot client ${userId}:`, error);
-            }
-        }
-        this.botClients.clear();
-        console.log("✅ All bot clients shut down");
-    }
-}
-exports.MultiBotManager = MultiBotManager;
-//# sourceMappingURL=bot-manager.js.map

package/dist/client/bot-runner.d.ts

@@ -1,35 +0,0 @@
-/**
- * Bot Runner - Manages isolated bot processes per workspace
- *
- * Uses API key authentication (resolved to email/password internally via CLIENT_CONFIGS)
- */
-import type { WorkspaceConfig } from './types';
-export declare class BotRunner {
-    private runningBots;
-    private botEntryPoint;
-    private maxRestarts;
-    private restartDelayMs;
-    constructor();
-    private getKey;
-    /**
-     * Start a bot for a workspace
-     */
-    startBot(workspace: WorkspaceConfig, botId: string): Promise<boolean>;
-    /**
-     * Stop a bot for a workspace
-     */
-    stopBot(workspaceId: string, botId: string): Promise<void>;
-    /**
-     * Check if a bot is running
-     */
-    isRunning(workspaceId: string, botId: string): boolean;
-    /**
-     * Get all running bots for a workspace
-     */
-    getRunningBots(workspaceId: string): string[];
-    /**
-     * Stop all bots
-     */
-    stopAll(): Promise<void>;
-}
-//# sourceMappingURL=bot-runner.d.ts.map

package/dist/client/bot-runner.js

@@ -1,188 +0,0 @@
-"use strict";
-/**
- * Bot Runner - Manages isolated bot processes per workspace
- *
- * Uses API key authentication (resolved to email/password internally via CLIENT_CONFIGS)
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BotRunner = void 0;
-const child_process_1 = require("child_process");
-const path = __importStar(require("path"));
-const logger_1 = require("../lib/logger");
-const logger = (0, logger_1.createLogger)({ component: 'bot-runner' });
-class BotRunner {
-    runningBots = new Map();
-    botEntryPoint;
-    maxRestarts = 5;
-    restartDelayMs = 5000;
-    constructor() {
-        // In production, this would be the compiled JS
-        this.botEntryPoint = path.join(__dirname, 'bot-entrypoint.js');
-    }
-    getKey(workspaceId, botId) {
-        return `${workspaceId}:${botId}`;
-    }
-    /**
-     * Start a bot for a workspace
-     */
-    async startBot(workspace, botId) {
-        const key = this.getKey(workspace.id, botId);
-        if (this.runningBots.has(key)) {
-            logger.warn('Bot already running', { workspaceId: workspace.id, botId });
-            return true;
-        }
-        logger.info('Starting bot', { workspaceId: workspace.id, botId });
-        try {
-            const child = (0, child_process_1.fork)(this.botEntryPoint, [], {
-                env: {
-                    ...process.env,
-                    BOT_WORKSPACE_ID: workspace.id,
-                    BOT_WORKSPACE_NAME: workspace.name,
-                    BOT_API_KEY: workspace.apiKey, // Use API key instead of email/password
-                    BOT_ID: botId,
-                    // Isolate per workspace
-                    NODE_UNIQUE_ID: workspace.id
-                },
-                stdio: ['pipe', 'pipe', 'pipe', 'ipc']
-            });
-            const running = {
-                workspaceId: workspace.id,
-                botId,
-                process: child,
-                startedAt: new Date(),
-                restartCount: 0
-            };
-            this.runningBots.set(key, running);
-            // Log output
-            child.stdout?.on('data', (data) => {
-                logger.info(`[${workspace.id}:${botId}] ${data.toString().trim()}`);
-            });
-            child.stderr?.on('data', (data) => {
-                logger.error(`[${workspace.id}:${botId}] ${data.toString().trim()}`);
-            });
-            // Handle exit
-            child.on('exit', (code, signal) => {
-                logger.warn('Bot process exited', { workspaceId: workspace.id, botId, code, signal });
-                this.runningBots.delete(key);
-                // Auto-restart on crash
-                if (code !== 0 && running.restartCount < this.maxRestarts) {
-                    running.restartCount++;
-                    setTimeout(() => {
-                        this.startBot(workspace, botId);
-                    }, this.restartDelayMs);
-                }
-            });
-            // Wait for ready signal
-            return new Promise((resolve) => {
-                const timeout = setTimeout(() => {
-                    logger.warn('Bot startup timeout', { workspaceId: workspace.id, botId });
-                    resolve(false);
-                }, 30000);
-                child.on('message', (msg) => {
-                    if (msg.type === 'ready') {
-                        clearTimeout(timeout);
-                        logger.info('Bot ready', { workspaceId: workspace.id, botId });
-                        resolve(true);
-                    }
-                    else if (msg.type === 'error') {
-                        clearTimeout(timeout);
-                        logger.error('Bot startup error', { workspaceId: workspace.id, botId, error: msg.error });
-                        resolve(false);
-                    }
-                });
-            });
-        }
-        catch (error) {
-            logger.error('Failed to start bot', { workspaceId: workspace.id, botId, error });
-            return false;
-        }
-    }
-    /**
-     * Stop a bot for a workspace
-     */
-    async stopBot(workspaceId, botId) {
-        const key = this.getKey(workspaceId, botId);
-        const running = this.runningBots.get(key);
-        if (!running) {
-            logger.warn('Bot not running', { workspaceId, botId });
-            return;
-        }
-        logger.info('Stopping bot', { workspaceId, botId });
-        // Prevent auto-restart
-        running.restartCount = this.maxRestarts;
-        // Send graceful shutdown
-        running.process.send({ type: 'shutdown' });
-        // Wait for exit or force kill
-        await new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                running.process.kill('SIGKILL');
-                resolve();
-            }, 10000);
-            running.process.once('exit', () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-        });
-        this.runningBots.delete(key);
-    }
-    /**
-     * Check if a bot is running
-     */
-    isRunning(workspaceId, botId) {
-        return this.runningBots.has(this.getKey(workspaceId, botId));
-    }
-    /**
-     * Get all running bots for a workspace
-     */
-    getRunningBots(workspaceId) {
-        const running = [];
-        for (const [, bot] of this.runningBots) {
-            if (bot.workspaceId === workspaceId) {
-                running.push(bot.botId);
-            }
-        }
-        return running;
-    }
-    /**
-     * Stop all bots
-     */
-    async stopAll() {
-        const stops = Array.from(this.runningBots.values()).map(bot => this.stopBot(bot.workspaceId, bot.botId));
-        await Promise.all(stops);
-    }
-}
-exports.BotRunner = BotRunner;
-//# sourceMappingURL=bot-runner.js.map