@hailer/mcp 0.1.15 → 0.1.16

package/dist/agents/factory.js

@@ -0,0 +1,650 @@
+"use strict";
+/**
+ * Daemon Factory
+ *
+ * Creates and manages agent daemons in orchestrator mode:
+ * - One orchestrator (HAL) handles general conversation
+ * - Specialist daemons handle complex domain-specific tasks
+ */
+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.DaemonManager = void 0;
+exports.createDaemonManager = createDaemonManager;
+exports.startDaemonMode = startDaemonMode;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const daemon_1 = require("./hal/daemon");
+const specialist_1 = require("./shared/specialist");
+const definitions_1 = require("./hal/definitions");
+const bot_manager_1 = require("./bot-manager");
+const config_1 = require("../config");
+const logger_1 = require("../lib/logger");
+const bot_config_1 = require("../mcp/tools/bot-config");
+const hailer_clients_1 = require("../mcp/hailer-clients");
+const logger = (0, logger_1.createLogger)({ component: "DaemonFactory" });
+/**
+ * Load workspace configurations from .bot-config/*.json files
+ */
+function loadWorkspaceConfigs() {
+    const configDir = path.join(process.cwd(), '.bot-config');
+    if (!fs.existsSync(configDir)) {
+        logger.warn('No .bot-config directory found');
+        return [];
+    }
+    const files = fs.readdirSync(configDir).filter(f => f.endsWith('.json'));
+    const configs = [];
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(path.join(configDir, file), 'utf-8');
+            configs.push(JSON.parse(content));
+        }
+        catch (error) {
+            logger.warn('Failed to load workspace config', { file, error });
+        }
+    }
+    return configs;
+}
+/**
+ * Map botType from Agent Directory to specialist key
+ * botType values come from the Agent Directory workflow
+ */
+function mapBotTypeToSpecialistKey(botType) {
+    if (!botType)
+        return null;
+    const mapping = {
+        'workflow-expert': 'hailerExpert',
+        'bug-fixer': 'giuseppe',
+        // Add more mappings as new specialists are added
+    };
+    return mapping[botType] || null;
+}
+/**
+ * Manages orchestrator + specialist daemons
+ */
+class DaemonManager {
+    daemons = new Map();
+    orchestrator = null;
+    specialists = new Map();
+    botManager;
+    options;
+    botTypeMap;
+    displayNameMap;
+    constructor(botManager, options) {
+        this.botManager = botManager;
+        this.options = options;
+        this.botTypeMap = options.botTypeMap || new Map();
+        this.displayNameMap = options.displayNameMap || new Map();
+    }
+    /**
+     * Get botType for a userId from the workspace config
+     */
+    getBotType(userId) {
+        return this.botTypeMap.get(userId) || null;
+    }
+    /**
+     * Get displayName for a userId from the workspace config (Agent Directory activity name)
+     * Falls back to Hailer profile name if not set
+     */
+    getDisplayName(userId) {
+        return this.displayNameMap.get(userId) || this.botManager.getUserName(userId);
+    }
+    /**
+     * Start all daemons (orchestrator + specialists)
+     */
+    async startAll() {
+        await this.startOrchestratorMode();
+    }
+    /**
+     * Orchestrator mode: one orchestrator (HAL) + specialist daemons
+     */
+    async startOrchestratorMode() {
+        const botClients = this.botManager.getAllBotClients();
+        logger.info("Starting daemons in ORCHESTRATOR mode", {
+            botCount: botClients.length,
+        });
+        // Find orchestrator bot
+        let orchestratorClient;
+        const specialistClients = new Map();
+        for (const botClient of botClients) {
+            const email = botClient.config.email;
+            const botType = this.getBotType(botClient.userId);
+            // Check if this is the orchestrator (by email match, botType, or first bot fallback)
+            if (this.options.orchestratorEmail === email ||
+                botType === 'orchestrator' ||
+                (!this.options.orchestratorEmail && !orchestratorClient)) {
+                orchestratorClient = botClient;
+                logger.info("Orchestrator assigned", {
+                    userId: botClient.userId,
+                    email: (0, config_1.maskEmail)(email),
+                    botType,
+                    reason: this.options.orchestratorEmail === email ? 'email_match' :
+                        botType === 'orchestrator' ? 'botType' : 'first_bot_fallback'
+                });
+                continue;
+            }
+            // Check if this matches a specialist
+            if (this.options.specialistEmails) {
+                for (const [specialistKey, specialistEmail] of Object.entries(this.options.specialistEmails)) {
+                    if (email === specialistEmail) {
+                        specialistClients.set(specialistKey, botClient);
+                        break;
+                    }
+                }
+            }
+            else {
+                // Auto-assign based on botType from workspace config
+                const specialistKey = mapBotTypeToSpecialistKey(botType);
+                if (specialistKey && definitions_1.SPECIALISTS[specialistKey]) {
+                    specialistClients.set(specialistKey, botClient);
+                    logger.info("Specialist assigned by botType", {
+                        userId: botClient.userId,
+                        botType,
+                        specialistKey
+                    });
+                }
+                else {
+                    // Fallback: assign to first available specialist
+                    for (const key of Object.keys(definitions_1.SPECIALISTS)) {
+                        if (!specialistClients.has(key)) {
+                            specialistClients.set(key, botClient);
+                            logger.info("Specialist assigned by fallback", {
+                                userId: botClient.userId,
+                                specialistKey: key
+                            });
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (!orchestratorClient) {
+            throw new Error("No orchestrator bot found");
+        }
+        // Create specialist user ID map for orchestrator
+        const specialistUserIds = new Map();
+        for (const [key, client] of specialistClients) {
+            specialistUserIds.set(key, client.userId);
+        }
+        // Start orchestrator
+        const orchestratorConfig = {
+            botClient: orchestratorClient,
+            mcpServerUrl: this.options.mcpServerUrl,
+            anthropicApiKey: this.options.anthropicApiKey,
+            model: this.options.model,
+            specialistUserIds,
+        };
+        this.orchestrator = new daemon_1.OrchestratorDaemon(orchestratorConfig);
+        await this.orchestrator.initialize();
+        // Register specialist user IDs with orchestrator (with display names from workspace)
+        for (const [key, userId] of specialistUserIds) {
+            const displayName = this.getDisplayName(userId);
+            this.orchestrator.registerSpecialistUserId(key, userId, displayName);
+        }
+        this.daemons.set(orchestratorClient.userId, this.orchestrator);
+        logger.info("Orchestrator started", {
+            botId: orchestratorClient.userId,
+            email: (0, config_1.maskEmail)(orchestratorClient.config.email),
+            specialistCount: specialistClients.size,
+        });
+        // Subscribe to bot state changes to update specialist availability
+        (0, bot_config_1.onBotStateChange)((userId, enabled) => {
+            const botType = this.getBotType(userId);
+            // Skip orchestrator changes (handled by daemon restart)
+            if (botType === 'orchestrator')
+                return;
+            // Find the specialist key for this user
+            const specialistKey = mapBotTypeToSpecialistKey(botType);
+            if (!specialistKey) {
+                logger.debug('No specialist mapping for botType', { userId, botType });
+                return;
+            }
+            if (enabled) {
+                // Re-register the specialist (with display name from workspace)
+                const displayName = this.getDisplayName(userId);
+                this.orchestrator?.registerSpecialistUserId(specialistKey, userId, displayName);
+                logger.info('Specialist re-enabled', { specialistKey, userId, displayName });
+            }
+            else {
+                // Unregister the specialist
+                this.orchestrator?.unregisterSpecialist(specialistKey);
+                logger.info('Specialist disabled', { specialistKey, userId });
+            }
+        });
+        // Start specialist daemons
+        for (const [specialistKey, botClient] of specialistClients) {
+            const specialistDef = definitions_1.SPECIALISTS[specialistKey];
+            if (!specialistDef) {
+                logger.warn("Unknown specialist key", { key: specialistKey });
+                continue;
+            }
+            // Clone the specialist to avoid cross-workspace contamination
+            const specialist = { ...specialistDef, botUserId: botClient.userId };
+            const specialistConfig = {
+                botClient,
+                mcpServerUrl: this.options.mcpServerUrl,
+                anthropicApiKey: this.options.anthropicApiKey,
+                model: specialist.model || this.options.model,
+                specialist,
+            };
+            const specialistDaemon = new specialist_1.SpecialistDaemon(specialistConfig);
+            await specialistDaemon.initialize();
+            this.specialists.set(specialistKey, specialistDaemon);
+            this.daemons.set(botClient.userId, specialistDaemon);
+            logger.info("Specialist daemon started", {
+                key: specialistKey,
+                name: specialist.name,
+                botId: botClient.userId,
+                email: (0, config_1.maskEmail)(botClient.config.email),
+            });
+        }
+        logger.info("Orchestrator mode started", {
+            orchestratorId: orchestratorClient.userId,
+            specialistCount: this.specialists.size,
+            totalDaemons: this.daemons.size,
+        });
+    }
+    /**
+     * Stop all daemons
+     * Flushes session logs for each daemon before stopping
+     */
+    async stopAll() {
+        const stopPromises = Array.from(this.daemons.entries()).map(async ([botId, daemon]) => {
+            await daemon.stop();
+            logger.info("Daemon stopped", { botId });
+        });
+        await Promise.all(stopPromises);
+        this.daemons.clear();
+    }
+    /**
+     * Get daemon for a specific bot
+     */
+    getDaemon(botId) {
+        return this.daemons.get(botId);
+    }
+    /**
+     * Get status of all daemons
+     */
+    getStatus() {
+        return Array.from(this.daemons.entries()).map(([botId, daemon]) => ({
+            botId,
+            state: daemon.getConversationState(),
+        }));
+    }
+    /**
+     * Log current status to console (for monitoring)
+     */
+    logStatus() {
+        const status = this.getStatus();
+        if (this.options.orchestratorMode) {
+            logger.info("=== ORCHESTRATOR MODE STATUS ===");
+            // Log orchestrator
+            if (this.orchestrator) {
+                const orchStatus = this.orchestrator.getOrchestratorStatus();
+                logger.info("ORCHESTRATOR (HAL):", {
+                    discussions: orchStatus.conversationState.discussionCount,
+                    messages: orchStatus.conversationState.currentMessageCount,
+                    queue: orchStatus.conversationState.queueLength,
+                    processing: orchStatus.conversationState.isProcessing,
+                    specialists: orchStatus.specialists.filter(s => s.available).length,
+                });
+            }
+            // Log specialists
+            for (const [key, specialist] of this.specialists) {
+                const specStatus = specialist.getSpecialistStatus();
+                logger.info(`SPECIALIST [${key}] ${specStatus.name}:`, {
+                    discussions: specStatus.conversationState.discussionCount,
+                    messages: specStatus.conversationState.currentMessageCount,
+                    queue: specStatus.conversationState.queueLength,
+                    processing: specStatus.conversationState.isProcessing,
+                });
+            }
+        }
+        else {
+            logger.info("=== DAEMON STATUS ===");
+            for (const { botId, state } of status) {
+                logger.info(`Bot ${botId.substring(0, 8)}...`, {
+                    discussions: state.discussionCount,
+                    messages: state.currentMessageCount,
+                    queue: state.queueLength,
+                    processing: state.isProcessing,
+                });
+                if (state.lastMessages.length > 0) {
+                    logger.info("Last messages:");
+                    for (const msg of state.lastMessages) {
+                        logger.info(`  [${msg.role}] ${msg.preview}`);
+                    }
+                }
+            }
+        }
+        logger.info("=====================");
+    }
+    /**
+     * Get orchestrator instance (only in orchestrator mode)
+     */
+    getOrchestrator() {
+        return this.orchestrator;
+    }
+    /**
+     * Get specialist by key (only in orchestrator mode)
+     */
+    getSpecialist(key) {
+        return this.specialists.get(key);
+    }
+    /**
+     * Check if running in orchestrator mode
+     */
+    isOrchestratorMode() {
+        return !!this.options.orchestratorMode;
+    }
+    /**
+     * Trigger HAL to respond in a discussion with context
+     */
+    async triggerHalResponse(discussionId, activityId, context) {
+        if (!this.orchestrator) {
+            logger.warn('Cannot trigger HAL response - orchestrator not running');
+            return;
+        }
+        await this.orchestrator.respondWithContext(discussionId, activityId, context);
+    }
+    /**
+     * Hot-reload: Start a specialist daemon dynamically
+     * Preserves orchestrator conversation context
+     */
+    async startSpecialist(email, password, botType, userId) {
+        const specialistKey = mapBotTypeToSpecialistKey(botType);
+        if (!specialistKey) {
+            logger.warn('Unknown botType for specialist', { botType });
+            return false;
+        }
+        // Check if already running
+        if (this.specialists.has(specialistKey)) {
+            logger.info('Specialist already running', { specialistKey });
+            return true;
+        }
+        const specialistDef = definitions_1.SPECIALISTS[specialistKey];
+        if (!specialistDef) {
+            logger.warn('Specialist definition not found', { specialistKey });
+            return false;
+        }
+        try {
+            // Initialize bot client
+            const actualUserId = userId || email;
+            const apiKey = (0, hailer_clients_1.registerBotCredentials)(actualUserId, email, password);
+            await this.botManager.initializeBotClient(email, password, apiKey);
+            const botClient = this.botManager.getBotClientByBotId(specialistKey) ||
+                Array.from(this.botManager.getAllBotClients())
+                    .find(bc => bc.config.email === email);
+            if (!botClient) {
+                logger.error('Failed to get bot client after initialization', { email: (0, config_1.maskEmail)(email) });
+                return false;
+            }
+            // Update botType map
+            this.botTypeMap.set(botClient.userId, botType);
+            // Clone the specialist to avoid cross-workspace contamination
+            const specialist = { ...specialistDef, botUserId: botClient.userId };
+            // Create and start specialist daemon
+            const specialistConfig = {
+                botClient,
+                mcpServerUrl: this.options.mcpServerUrl,
+                anthropicApiKey: this.options.anthropicApiKey,
+                model: specialist.model || this.options.model,
+                specialist,
+            };
+            const specialistDaemon = new specialist_1.SpecialistDaemon(specialistConfig);
+            await specialistDaemon.initialize();
+            this.specialists.set(specialistKey, specialistDaemon);
+            this.daemons.set(botClient.userId, specialistDaemon);
+            // Register with orchestrator (with display name from workspace)
+            const displayName = this.getDisplayName(botClient.userId);
+            this.orchestrator?.registerSpecialistUserId(specialistKey, botClient.userId, displayName);
+            logger.info('Specialist hot-loaded successfully', {
+                specialistKey,
+                name: specialist.name,
+                botId: botClient.userId,
+                email,
+            });
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to hot-load specialist', {
+                specialistKey,
+                email,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    /**
+     * Hot-reload: Stop a specialist daemon dynamically
+     * Preserves orchestrator conversation context
+     */
+    async stopSpecialist(botType) {
+        const specialistKey = mapBotTypeToSpecialistKey(botType);
+        if (!specialistKey) {
+            logger.warn('Unknown botType for specialist', { botType });
+            return false;
+        }
+        const specialistDaemon = this.specialists.get(specialistKey);
+        if (!specialistDaemon) {
+            logger.info('Specialist not running', { specialistKey });
+            return true;
+        }
+        try {
+            // Find botId by looking through daemons map
+            let botId;
+            for (const [id, daemon] of this.daemons) {
+                if (daemon === specialistDaemon) {
+                    botId = id;
+                    break;
+                }
+            }
+            // Unregister from orchestrator first
+            this.orchestrator?.unregisterSpecialist(specialistKey);
+            // Stop the daemon
+            await specialistDaemon.stop();
+            // Remove from maps
+            this.specialists.delete(specialistKey);
+            if (botId) {
+                this.daemons.delete(botId);
+                this.botTypeMap.delete(botId);
+                // Remove bot client connection
+                await this.botManager.removeBotClient(botId);
+            }
+            logger.info('Specialist stopped successfully', {
+                specialistKey,
+                botId,
+            });
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to stop specialist', {
+                specialistKey,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    /**
+     * Hot-reload a specialist (stop if running, start if enabled)
+     */
+    async hotReloadSpecialist(email, password, botType, enabled, userId) {
+        if (enabled) {
+            return this.startSpecialist(email, password, botType, userId);
+        }
+        else {
+            return this.stopSpecialist(botType);
+        }
+    }
+    /**
+     * Start periodic status logging
+     */
+    startStatusLogging(intervalMs = 30000) {
+        return setInterval(() => {
+            this.logStatus();
+        }, intervalMs);
+    }
+}
+exports.DaemonManager = DaemonManager;
+/**
+ * Create and start the daemon manager
+ * This is the main entry point for daemon mode
+ *
+ * @param options - Optional settings for orchestrator mode
+ */
+async function createDaemonManager(options) {
+    const appConfig = (0, config_1.createApplicationConfig)();
+    const mcpClientConfig = appConfig.mcpClient;
+    if (!mcpClientConfig) {
+        logger.error("MCP Client not configured - cannot start daemon mode");
+        return null;
+    }
+    // Find Anthropic API key from providers
+    const anthropicProvider = mcpClientConfig.providers.find(p => p.type === "anthropic");
+    if (!anthropicProvider) {
+        logger.error("Anthropic provider not configured - daemon mode requires Anthropic");
+        return null;
+    }
+    // Create bot manager
+    const botManager = new bot_manager_1.MultiBotManager([]);
+    // Load workspace configs from .bot-config/*.json
+    const workspaceConfigs = loadWorkspaceConfigs();
+    if (workspaceConfigs.length === 0) {
+        logger.warn('No workspace configs found in .bot-config/ - run npm run seed-config first');
+        return null;
+    }
+    // For now, use first workspace with an orchestrator
+    // TODO: Support multiple workspaces
+    const workspaceConfig = options?.workspaceId
+        ? workspaceConfigs.find(c => c.workspaceId === options.workspaceId && c.orchestrator)
+        : workspaceConfigs.find(c => c.orchestrator);
+    if (!workspaceConfig) {
+        logger.error('No workspace with orchestrator found');
+        return null;
+    }
+    logger.info('Using workspace config', {
+        workspaceId: workspaceConfig.workspaceId,
+        workspaceName: workspaceConfig.workspaceName
+    });
+    // Build botTypeMap and displayNameMap for runtime lookups
+    const botTypeMap = new Map();
+    const displayNameMap = new Map();
+    // Initialize orchestrator
+    const orch = workspaceConfig.orchestrator;
+    const orchestratorEmail = orch.email;
+    try {
+        logger.info('Loading orchestrator', { email: (0, config_1.maskEmail)(orch.email), displayName: orch.displayName });
+        const orchestratorUserId = orch.userId || 'orchestrator';
+        const apiKey = (0, hailer_clients_1.registerBotCredentials)(orchestratorUserId, orch.email, orch.password);
+        await botManager.initializeBotClient(orch.email, orch.password, apiKey);
+        // Register orchestrator botType and displayName
+        botTypeMap.set(orchestratorUserId, 'orchestrator');
+        if (orch.displayName) {
+            displayNameMap.set(orchestratorUserId, orch.displayName);
+        }
+    }
+    catch (error) {
+        logger.error('Failed to initialize orchestrator', { error });
+        return null;
+    }
+    // Initialize enabled specialists
+    for (const spec of workspaceConfig.specialists) {
+        if (!spec.enabled) {
+            logger.debug('Skipping disabled specialist', { email: (0, config_1.maskEmail)(spec.email), botType: spec.botType });
+            continue;
+        }
+        try {
+            logger.info('Loading specialist', { email: (0, config_1.maskEmail)(spec.email), botType: spec.botType, displayName: spec.displayName });
+            const specialistUserId = spec.userId || spec.email;
+            const apiKey = (0, hailer_clients_1.registerBotCredentials)(specialistUserId, spec.email, spec.password);
+            await botManager.initializeBotClient(spec.email, spec.password, apiKey);
+            // Register specialist botType and displayName
+            if (spec.botType) {
+                botTypeMap.set(specialistUserId, spec.botType);
+            }
+            if (spec.displayName) {
+                displayNameMap.set(specialistUserId, spec.displayName);
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to initialize specialist', {
+                email: spec.email,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    // Check environment for orchestrator mode (defaults to TRUE)
+    const orchestratorMode = options?.orchestratorMode ??
+        process.env.DAEMON_ORCHESTRATOR_MODE !== "false";
+    // Create daemon manager
+    const daemonManager = new DaemonManager(botManager, {
+        mcpServerUrl: mcpClientConfig.mcpServerUrl,
+        anthropicApiKey: anthropicProvider.apiKey,
+        model: anthropicProvider.model,
+        orchestratorMode,
+        orchestratorEmail: orchestratorEmail || options?.orchestratorEmail,
+        specialistEmails: options?.specialistEmails,
+        botTypeMap,
+        displayNameMap,
+    });
+    // Start all daemons
+    await daemonManager.startAll();
+    return daemonManager;
+}
+/**
+ * Quick start function for testing
+ *
+ * @param orchestratorMode - Enable orchestrator mode (default: true)
+ */
+async function startDaemonMode(orchestratorMode = true) {
+    logger.info("Starting Chat Agent Daemon Mode (ORCHESTRATOR)...");
+    const manager = await createDaemonManager({ orchestratorMode });
+    if (!manager) {
+        logger.error("Failed to create daemon manager");
+        process.exit(1);
+    }
+    // Handle shutdown - await async stopAll() to flush session logs
+    process.on("SIGINT", () => {
+        logger.info("Shutting down daemons...");
+        manager.stopAll().then(() => process.exit(0));
+    });
+    process.on("SIGTERM", () => {
+        logger.info("Shutting down daemons...");
+        manager.stopAll().then(() => process.exit(0));
+    });
+    logger.info("Chat Agent Daemon Mode (ORCHESTRATOR) running. Press Ctrl+C to stop.");
+    // Start periodic status logging
+    manager.startStatusLogging(60000);
+}
+//# sourceMappingURL=factory.js.map