@hailer/mcp 0.1.8 → 0.1.9

package/dist/client/daemon-factory.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Daemon Factory
+ *
+ * Creates and manages agent daemons in orchestrator mode:
+ * - One orchestrator (HAL) handles general conversation
+ * - Specialist daemons handle complex domain-specific tasks
+ */
+import { ChatAgentDaemon } from "./chat-agent-daemon";
+import { OrchestratorDaemon } from "./orchestrator-daemon";
+import { SpecialistDaemon } from "./specialist-daemon";
+import { MultiBotManager } from "./multi-bot-manager";
+export interface DaemonManagerOptions {
+    mcpServerUrl: string;
+    anthropicApiKey: string;
+    model?: string;
+    /**
+     * Enable orchestrator mode (default: true)
+     * Set to false only for legacy compatibility
+     */
+    orchestratorMode?: boolean;
+    /**
+     * Email of the bot to use as orchestrator (defaults to first bot)
+     */
+    orchestratorEmail?: string;
+    /**
+     * Map of specialist key to bot email (e.g., { hailerExpert: "expert@bot.com" })
+     */
+    specialistEmails?: Record<string, string>;
+}
+/**
+ * Manages orchestrator + specialist daemons
+ */
+export declare class DaemonManager {
+    private daemons;
+    private orchestrator;
+    private specialists;
+    private botManager;
+    private options;
+    constructor(botManager: MultiBotManager, options: DaemonManagerOptions);
+    /**
+     * Start all daemons (orchestrator + specialists)
+     */
+    startAll(): Promise<void>;
+    /**
+     * Orchestrator mode: one orchestrator (HAL) + specialist daemons
+     */
+    private startOrchestratorMode;
+    /**
+     * Stop all daemons
+     * Flushes session logs for each daemon before stopping
+     */
+    stopAll(): Promise<void>;
+    /**
+     * Get daemon for a specific bot
+     */
+    getDaemon(botId: string): ChatAgentDaemon | undefined;
+    /**
+     * Get status of all daemons
+     */
+    getStatus(): Array<{
+        botId: string;
+        state: any;
+    }>;
+    /**
+     * Log current status to console (for monitoring)
+     */
+    logStatus(): void;
+    /**
+     * Get orchestrator instance (only in orchestrator mode)
+     */
+    getOrchestrator(): OrchestratorDaemon | null;
+    /**
+     * Get specialist by key (only in orchestrator mode)
+     */
+    getSpecialist(key: string): SpecialistDaemon | undefined;
+    /**
+     * Check if running in orchestrator mode
+     */
+    isOrchestratorMode(): boolean;
+    /**
+     * Start periodic status logging
+     */
+    startStatusLogging(intervalMs?: number): NodeJS.Timeout;
+}
+export interface CreateDaemonManagerOptions {
+    /** Enable orchestrator mode */
+    orchestratorMode?: boolean;
+    /** Email of orchestrator bot (defaults to first) */
+    orchestratorEmail?: string;
+    /** Map specialist keys to bot emails */
+    specialistEmails?: Record<string, string>;
+}
+/**
+ * Create and start the daemon manager
+ * This is the main entry point for daemon mode
+ *
+ * @param options - Optional settings for orchestrator mode
+ */
+export declare function createDaemonManager(options?: CreateDaemonManagerOptions): Promise<DaemonManager | null>;
+/**
+ * Quick start function for testing
+ *
+ * @param orchestratorMode - Enable orchestrator mode (default: true)
+ */
+export declare function startDaemonMode(orchestratorMode?: boolean): Promise<void>;
+//# sourceMappingURL=daemon-factory.d.ts.map

package/dist/client/daemon-factory.js

@@ -0,0 +1,301 @@
+"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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonManager = void 0;
+exports.createDaemonManager = createDaemonManager;
+exports.startDaemonMode = startDaemonMode;
+const orchestrator_daemon_1 = require("./orchestrator-daemon");
+const specialist_daemon_1 = require("./specialist-daemon");
+const specialists_1 = require("./specialists");
+const multi_bot_manager_1 = require("./multi-bot-manager");
+const config_1 = require("../config");
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: "DaemonFactory" });
+/**
+ * Manages orchestrator + specialist daemons
+ */
+class DaemonManager {
+    daemons = new Map();
+    orchestrator = null;
+    specialists = new Map();
+    botManager;
+    options;
+    constructor(botManager, options) {
+        this.botManager = botManager;
+        this.options = options;
+    }
+    /**
+     * 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;
+            // Check if this is the orchestrator
+            if (this.options.orchestratorEmail === email ||
+                (!this.options.orchestratorEmail && !orchestratorClient)) {
+                orchestratorClient = botClient;
+                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 to first available specialist
+                for (const specialistKey of Object.keys(specialists_1.SPECIALISTS)) {
+                    if (!specialistClients.has(specialistKey)) {
+                        specialistClients.set(specialistKey, botClient);
+                        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 orchestrator_daemon_1.OrchestratorDaemon(orchestratorConfig);
+        await this.orchestrator.initialize();
+        // Register specialist user IDs with orchestrator
+        for (const [key, userId] of specialistUserIds) {
+            this.orchestrator.registerSpecialistUserId(key, userId);
+        }
+        this.daemons.set(orchestratorClient.userId, this.orchestrator);
+        logger.info("Orchestrator started", {
+            botId: orchestratorClient.userId,
+            email: orchestratorClient.config.email,
+            specialistCount: specialistClients.size,
+        });
+        // Start specialist daemons
+        for (const [specialistKey, botClient] of specialistClients) {
+            const specialist = specialists_1.SPECIALISTS[specialistKey];
+            if (!specialist) {
+                logger.warn("Unknown specialist key", { key: specialistKey });
+                continue;
+            }
+            // Set the bot user ID on the specialist config
+            specialist.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_daemon_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: 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):", {
+                    messages: orchStatus.conversationState.messageCount,
+                    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}:`, {
+                    messages: specStatus.conversationState.messageCount,
+                    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)}...`, {
+                    messages: state.messageCount,
+                    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;
+    }
+    /**
+     * 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 multi_bot_manager_1.MultiBotManager(mcpClientConfig.botConfigs);
+    await botManager.initializeAllHailerClientsFromConfig();
+    // 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: options?.orchestratorEmail,
+        specialistEmails: options?.specialistEmails,
+    });
+    // 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=daemon-factory.js.map

package/dist/client/factory.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Daemon Factory
+ *
+ * Creates and manages agent daemons in orchestrator mode:
+ * - One orchestrator (HAL) handles general conversation
+ * - Specialist daemons handle complex domain-specific tasks
+ */
+import { ChatAgentDaemon } from "./agents/base";
+import { OrchestratorDaemon } from "./agents/orchestrator";
+import { SpecialistDaemon } from "./agents/specialist";
+import { MultiBotManager } from "./bot-manager";
+import { ConversationState } from "./types";
+export interface DaemonManagerOptions {
+    mcpServerUrl: string;
+    anthropicApiKey: string;
+    model?: string;
+    /**
+     * Enable orchestrator mode (default: true)
+     * Set to false only for legacy compatibility
+     */
+    orchestratorMode?: boolean;
+    /**
+     * Email of the bot to use as orchestrator (defaults to first bot)
+     */
+    orchestratorEmail?: string;
+    /**
+     * Map of specialist key to bot email (e.g., { hailerExpert: "expert@bot.com" })
+     */
+    specialistEmails?: Record<string, string>;
+}
+/**
+ * Manages orchestrator + specialist daemons
+ */
+export declare class DaemonManager {
+    private daemons;
+    private orchestrator;
+    private specialists;
+    private botManager;
+    private options;
+    constructor(botManager: MultiBotManager, options: DaemonManagerOptions);
+    /**
+     * Start all daemons (orchestrator + specialists)
+     */
+    startAll(): Promise<void>;
+    /**
+     * Orchestrator mode: one orchestrator (HAL) + specialist daemons
+     */
+    private startOrchestratorMode;
+    /**
+     * Stop all daemons
+     * Flushes session logs for each daemon before stopping
+     */
+    stopAll(): Promise<void>;
+    /**
+     * Get daemon for a specific bot
+     */
+    getDaemon(botId: string): ChatAgentDaemon | undefined;
+    /**
+     * Get status of all daemons
+     */
+    getStatus(): Array<{
+        botId: string;
+        state: ConversationState;
+    }>;
+    /**
+     * Log current status to console (for monitoring)
+     */
+    logStatus(): void;
+    /**
+     * Get orchestrator instance (only in orchestrator mode)
+     */
+    getOrchestrator(): OrchestratorDaemon | null;
+    /**
+     * Get specialist by key (only in orchestrator mode)
+     */
+    getSpecialist(key: string): SpecialistDaemon | undefined;
+    /**
+     * Check if running in orchestrator mode
+     */
+    isOrchestratorMode(): boolean;
+    /**
+     * Start periodic status logging
+     */
+    startStatusLogging(intervalMs?: number): NodeJS.Timeout;
+}
+export interface CreateDaemonManagerOptions {
+    /** Enable orchestrator mode */
+    orchestratorMode?: boolean;
+    /** Email of orchestrator bot (defaults to first) */
+    orchestratorEmail?: string;
+    /** Map specialist keys to bot emails */
+    specialistEmails?: Record<string, string>;
+}
+/**
+ * Create and start the daemon manager
+ * This is the main entry point for daemon mode
+ *
+ * @param options - Optional settings for orchestrator mode
+ */
+export declare function createDaemonManager(options?: CreateDaemonManagerOptions): Promise<DaemonManager | null>;
+/**
+ * Quick start function for testing
+ *
+ * @param orchestratorMode - Enable orchestrator mode (default: true)
+ */
+export declare function startDaemonMode(orchestratorMode?: boolean): Promise<void>;
+//# sourceMappingURL=factory.d.ts.map