@hailer/mcp 0.1.16 → 0.2.1

package/dist/client/factory.js

@@ -1,314 +0,0 @@
-"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_1 = require("./agents/orchestrator");
-const specialist_1 = require("./agents/specialist");
-const definitions_1 = require("./agents/definitions");
-const bot_manager_1 = require("./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(definitions_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_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 = definitions_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_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):", {
-                    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);
-    }
-    /**
-     * 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(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=factory.js.map

package/dist/client/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * Client Module - Public Exports
- *
- * Agent system for Hailer workspace automation
- */
-export * from "./types";
-export * from "./bot-manager";
-export * from "./factory";
-export * from "./agents/base";
-export * from "./agents/orchestrator";
-export * from "./agents/specialist";
-export * from "./agents/definitions";
-export * from "./services/message-formatter";
-export * from "./services/mcp-client";
-export * from "./services/session-logger";
-export * from "./services/agent-registry";
-//# sourceMappingURL=index.d.ts.map

package/dist/client/index.js

@@ -1,38 +0,0 @@
-"use strict";
-/**
- * Client Module - Public Exports
- *
- * Agent system for Hailer workspace automation
- */
-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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// Core types and constants
-__exportStar(require("./types"), exports);
-// Bot management
-__exportStar(require("./bot-manager"), exports);
-// Daemon factory and management
-__exportStar(require("./factory"), exports);
-// Base agent classes
-__exportStar(require("./agents/base"), exports);
-__exportStar(require("./agents/orchestrator"), exports);
-__exportStar(require("./agents/specialist"), exports);
-__exportStar(require("./agents/definitions"), exports);
-// Services
-__exportStar(require("./services/message-formatter"), exports);
-__exportStar(require("./services/mcp-client"), exports);
-__exportStar(require("./services/session-logger"), exports);
-__exportStar(require("./services/agent-registry"), exports);
-//# sourceMappingURL=index.js.map

package/dist/client/multi-bot-manager.d.ts

@@ -1,42 +0,0 @@
-/**
- * Multi-Bot Client Manager
- * Manages multiple bot clients, each with their own Hailer connection
- */
-import { HailerClient } from "../mcp/hailer-clients";
-import { SignalHandler } from "../mcp/signal-handler";
-import { BotClientConfig } from "./types";
-import { WorkspaceCache, UserInfo } from "../mcp/workspace-cache";
-export interface BotClient {
-    userId: string;
-    config: BotClientConfig;
-    client: HailerClient;
-    signalHandler: SignalHandler;
-    workspaceCache?: WorkspaceCache;
-}
-export declare class MultiBotManager {
-    private botConfigs;
-    private botClients;
-    constructor(botConfigs: BotClientConfig[]);
-    initializeAllHailerClientsFromConfig(): Promise<void>;
-    getBotClient(userId: string): BotClient | undefined;
-    getAllBotClients(): BotClient[];
-    getBotIds(): string[];
-    private userNameCache;
-    private static USER_CACHE_TTL;
-    /**
-     * Look up a user's full name by their user ID
-     * Uses workspace cache first, then falls back to socket API call
-     */
-    getUserName(userId: string): string | undefined;
-    /**
-     * Look up a user's full name by their user ID (async version)
-     * Falls back to socket API if not in cache
-     */
-    getUserNameAsync(userId: string): Promise<string | undefined>;
-    /**
-     * Get user info by ID (returns full UserInfo object)
-     */
-    getUserInfo(userId: string): UserInfo | undefined;
-    shutdown(): Promise<void>;
-}
-//# sourceMappingURL=multi-bot-manager.d.ts.map

package/dist/client/multi-bot-manager.js

@@ -1,161 +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);
-                const botClient = {
-                    userId,
-                    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=multi-bot-manager.js.map

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

@@ -1,87 +0,0 @@
-/**
- * Orchestrator Daemon (HAL)
- *
- * The main conversational bot that handles general chat and coordinates
- * with specialist bots when tasks are too complex.
- *
- * HAL can:
- * - Handle general conversation and simple queries
- * - Detect when a task needs specialist help
- * - Invite specialist bots to the discussion
- * - Hand off context to specialists
- * - Summarize specialist responses for users
- */
-import { ChatAgentDaemon, ChatAgentDaemonConfig, IncomingMessage } from "./chat-agent-daemon";
-import Anthropic from "@anthropic-ai/sdk";
-export interface OrchestratorDaemonConfig extends ChatAgentDaemonConfig {
-    /** Map of specialist key to their Hailer user ID */
-    specialistUserIds?: Map<string, string>;
-}
-export declare class OrchestratorDaemon extends ChatAgentDaemon {
-    private orchestratorLogger;
-    private specialists;
-    private activeSpecialistsInDiscussion;
-    private specialistUserIds;
-    private toolsUsedInCurrentMessage;
-    constructor(config: OrchestratorDaemonConfig);
-    /**
-     * Override agent name for Agent Directory
-     */
-    protected getAgentName(): {
-        firstName: string;
-        lastName: string;
-    };
-    /**
-     * Override agent description for Agent Directory
-     */
-    protected getAgentDescription(): string;
-    /**
-     * Override Position details for Orchestrator
-     */
-    protected getPositionDetails(): {
-        name: string;
-        purpose: string;
-        personaTone: string;
-        coreCapabilities: string;
-        boundaries: string;
-    };
-    /**
-     * Register a specialist's Hailer user ID
-     * Called during initialization when we know the specialist bot's user ID
-     */
-    registerSpecialistUserId(specialistKey: string, userId: string): void;
-    /**
-     * Check if a specialist is already active in a discussion
-     */
-    private isSpecialistActiveInDiscussion;
-    /**
-     * Mark a specialist as active in a discussion
-     */
-    private markSpecialistActive;
-    /**
-     * Invite a specialist to a discussion
-     */
-    private inviteSpecialist;
-    /**
-     * Override system prompt to include orchestrator capabilities
-     */
-    protected getSystemPrompt(): string;
-    /**
-     * Override response handling to detect specialist invitations
-     */
-    protected handleLlmResponse(response: Anthropic.Message, originalMessage: IncomingMessage): Promise<void>;
-    /**
-     * Get orchestrator status including specialist info
-     */
-    getOrchestratorStatus(): {
-        conversationState: ReturnType<ChatAgentDaemon["getConversationState"]>;
-        specialists: Array<{
-            key: string;
-            name: string;
-            available: boolean;
-            userId?: string;
-        }>;
-        activeInDiscussions: Record<string, string[]>;
-    };
-}
-//# sourceMappingURL=orchestrator-daemon.d.ts.map