@hailer/mcp 1.0.29 → 1.1.3

package/dist/core.d.ts

@@ -1,6 +1,7 @@
 /**
  * Core class for Hailer MCP Server
  * Pure orchestrator - manages application lifecycle and service coordination
+ * Separated from Express server implementation for better architecture
  */
 import { Tool } from './mcp/tool-registry';
 export declare class Core {
@@ -8,6 +9,8 @@ export declare class Core {
     private appConfig;
     private toolRegistry;
     private mcpServer?;
+    private botManager?;
+    private shutdownRegistered;
     constructor();
     /**
      * Public API for external tool registration
@@ -16,6 +19,8 @@ export declare class Core {
     addTool(tool: Tool): void;
     start(): Promise<void>;
     private startMCPServer;
+    private startBotClient;
+    getDaemonStatus(): any;
     stop(): Promise<void>;
     setupGracefulShutdown(): void;
 }

package/dist/core.js

@@ -2,6 +2,7 @@
 /**
  * Core class for Hailer MCP Server
  * Pure orchestrator - manages application lifecycle and service coordination
+ * Separated from Express server implementation for better architecture
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Core = void 0;
@@ -9,11 +10,15 @@ const logger_1 = require("./lib/logger");
 const config_1 = require("./config");
 const mcp_server_1 = require("./mcp-server");
 const tool_registry_1 = require("./mcp/tool-registry");
+const bot_manager_1 = require("./bot/bot-manager");
+const webhook_handler_1 = require("./mcp/webhook-handler");
 class Core {
     logger;
     appConfig;
     toolRegistry;
     mcpServer;
+    botManager;
+    shutdownRegistered = false;
     constructor() {
         // Initialize logger first
         this.logger = (0, logger_1.createLogger)({
@@ -26,9 +31,10 @@ class Core {
         });
         // Use unified application configuration
         this.appConfig = (0, config_1.createApplicationConfig)();
-        this.logger.info('Core orchestrator initialized', {
+        this.logger.debug('Core orchestrator initialized', {
             nodeEnv: process.env.NODE_ENV,
             enableMcpServer: this.appConfig.server.enableMcpServer,
+            enableClient: this.appConfig.server.enableClient,
             enableNuclearTools: config_1.environment.ENABLE_NUCLEAR_TOOLS
         });
     }
@@ -40,9 +46,9 @@ class Core {
         this.toolRegistry.addTool(tool);
     }
     async start() {
-        this.logger.info('Starting Hailer MCP application');
+        this.logger.debug('Starting Hailer MCP application');
         try {
-            // Start MCP Server
+            // Start MCP Server FIRST (daemon/client needs it for tool schemas)
             if (this.appConfig.server.enableMcpServer) {
                 const hasAccounts = Object.keys(this.appConfig.hailerAccounts).length > 0;
                 if (!hasAccounts) {
@@ -53,6 +59,10 @@ class Core {
                     await this.startMCPServer();
                 }
             }
+            // Start bot client ONLY if MCP_CLIENT_ENABLED=true
+            if (this.appConfig.server.enableClient) {
+                await this.startBotClient();
+            }
             this.setupGracefulShutdown();
             this.logger.info('All configured services started successfully');
         }
@@ -62,21 +72,53 @@ class Core {
         }
     }
     async startMCPServer() {
-        this.logger.info('Starting MCP Server service');
+        // Server configuration is provided by unified config
+        this.logger.debug('Starting MCP Server service');
         this.mcpServer = new mcp_server_1.MCPServerService({
             port: this.appConfig.server.port,
             corsOrigins: this.appConfig.server.corsOrigins,
-            toolRegistry: this.toolRegistry
+            toolRegistry: this.toolRegistry,
+            getDaemonStatus: () => this.getDaemonStatus() // Pass callback for daemon monitoring
         });
         await this.mcpServer.start();
-        this.logger.info('MCP Server service started');
+        this.logger.debug('MCP Server service started');
+    }
+    async startBotClient() {
+        const anthropicApiKey = process.env.ANTHROPIC_API_KEY;
+        if (!anthropicApiKey) {
+            this.logger.warn('ANTHROPIC_API_KEY not set - bot client disabled');
+            return;
+        }
+        this.logger.debug('Starting Bot Manager');
+        this.botManager = new bot_manager_1.BotManager(this.toolRegistry, anthropicApiKey);
+        await this.botManager.startAll();
+        // Wire up webhook hot reload — bot starts/stops when toggled in Agent Directory
+        const botManager = this.botManager;
+        (0, webhook_handler_1.onBotUpdate)(async (workspaceId, bot, action) => {
+            try {
+                await botManager.handleBotUpdate(workspaceId, bot, action);
+            }
+            catch (err) {
+                this.logger.error('Bot hot-reload failed', err);
+            }
+        });
+        this.logger.debug('Bot Manager started', { botCount: this.botManager.getBotCount() });
+    }
+    getDaemonStatus() {
+        if (!this.botManager)
+            return {};
+        return this.botManager.getStatus();
     }
     async stop() {
-        this.logger.info('Stopping Hailer MCP application');
+        this.logger.debug('Stopping Hailer MCP application');
         try {
+            if (this.botManager) {
+                await this.botManager.stopAll();
+                this.logger.debug('Bot Manager stopped');
+            }
             if (this.mcpServer) {
                 await this.mcpServer.stop();
-                this.logger.info('MCP Server stopped');
+                this.logger.debug('MCP Server stopped');
             }
             this.logger.info('Application stopped gracefully');
         }
@@ -87,6 +129,9 @@ class Core {
     }
     // Graceful shutdown handling
     setupGracefulShutdown() {
+        if (this.shutdownRegistered)
+            return;
+        this.shutdownRegistered = true;
         const shutdown = async (signal) => {
             this.logger.info(`Received ${signal}, shutting down gracefully`);
             try {
@@ -100,6 +145,14 @@ class Core {
         };
         process.on('SIGTERM', () => shutdown('SIGTERM'));
         process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('unhandledRejection', (reason) => {
+            this.logger.error('Unhandled rejection', reason);
+            this.stop().finally(() => process.exit(1));
+        });
+        process.on('uncaughtException', (error) => {
+            this.logger.error('Uncaught exception', error);
+            this.stop().finally(() => process.exit(1));
+        });
         this.logger.debug('Graceful shutdown handlers registered');
     }
 }

package/dist/lib/discussion-lock.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Discussion Lock Registry
+ *
+ * Prevents multiple bots from responding to the same discussion.
+ * When a specialist bot (like Giuseppe) is handling a discussion,
+ * it acquires a lock. Other bots (like Orchestrator) check the lock
+ * before responding.
+ */
+/**
+ * Acquire a lock on a discussion
+ * @param discussionId - The discussion to lock
+ * @param botName - Name of the bot acquiring the lock (for logging)
+ * @param ttlMs - Lock duration in milliseconds (default: 5 minutes)
+ * @returns true if lock acquired, false if already locked by another bot
+ */
+export declare function acquireDiscussionLock(discussionId: string, botName: string, ttlMs?: number): boolean;
+/**
+ * Release a lock on a discussion
+ * @param discussionId - The discussion to unlock
+ * @param botName - Name of the bot releasing (must match acquirer)
+ */
+export declare function releaseDiscussionLock(discussionId: string, botName: string): void;
+/**
+ * Check if a discussion is locked by another bot
+ * @param discussionId - The discussion to check
+ * @param myBotName - Name of the checking bot (own locks don't block)
+ * @returns true if locked by ANOTHER bot, false if free or own lock
+ */
+export declare function isDiscussionLocked(discussionId: string, myBotName: string): boolean;
+/**
+ * Clean up expired locks (call periodically)
+ */
+export declare function cleanupExpiredLocks(): number;
+/**
+ * Get current lock status (for debugging)
+ */
+export declare function getLockStatus(): Map<string, {
+    botName: string;
+    acquiredAt: number;
+    expiresAt: number;
+}>;
+//# sourceMappingURL=discussion-lock.d.ts.map

package/dist/lib/discussion-lock.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Discussion Lock Registry
+ *
+ * Prevents multiple bots from responding to the same discussion.
+ * When a specialist bot (like Giuseppe) is handling a discussion,
+ * it acquires a lock. Other bots (like Orchestrator) check the lock
+ * before responding.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acquireDiscussionLock = acquireDiscussionLock;
+exports.releaseDiscussionLock = releaseDiscussionLock;
+exports.isDiscussionLocked = isDiscussionLocked;
+exports.cleanupExpiredLocks = cleanupExpiredLocks;
+exports.getLockStatus = getLockStatus;
+const logger_1 = require("./logger");
+const logger = (0, logger_1.createLogger)({ component: 'discussion-lock' });
+// Singleton map of discussionId -> { botName, acquiredAt, expiresAt }
+const locks = new Map();
+// Default lock TTL: 5 minutes (allows for LLM processing time)
+const DEFAULT_LOCK_TTL_MS = 5 * 60 * 1000;
+/**
+ * Acquire a lock on a discussion
+ * @param discussionId - The discussion to lock
+ * @param botName - Name of the bot acquiring the lock (for logging)
+ * @param ttlMs - Lock duration in milliseconds (default: 5 minutes)
+ * @returns true if lock acquired, false if already locked by another bot
+ */
+function acquireDiscussionLock(discussionId, botName, ttlMs = DEFAULT_LOCK_TTL_MS) {
+    const now = Date.now();
+    const existing = locks.get(discussionId);
+    // Check if existing lock is still valid
+    if (existing && existing.expiresAt > now) {
+        if (existing.botName === botName) {
+            // Same bot - extend the lock
+            existing.expiresAt = now + ttlMs;
+            return true;
+        }
+        // Different bot has the lock
+        logger.debug('Discussion already locked', {
+            discussionId,
+            lockedBy: existing.botName,
+            requestedBy: botName
+        });
+        return false;
+    }
+    // Acquire lock
+    locks.set(discussionId, {
+        botName,
+        acquiredAt: now,
+        expiresAt: now + ttlMs
+    });
+    logger.debug('Discussion lock acquired', { discussionId, botName, ttlMs });
+    return true;
+}
+/**
+ * Release a lock on a discussion
+ * @param discussionId - The discussion to unlock
+ * @param botName - Name of the bot releasing (must match acquirer)
+ */
+function releaseDiscussionLock(discussionId, botName) {
+    const existing = locks.get(discussionId);
+    if (existing && existing.botName === botName) {
+        locks.delete(discussionId);
+        logger.debug('Discussion lock released', { discussionId, botName });
+    }
+}
+/**
+ * Check if a discussion is locked by another bot
+ * @param discussionId - The discussion to check
+ * @param myBotName - Name of the checking bot (own locks don't block)
+ * @returns true if locked by ANOTHER bot, false if free or own lock
+ */
+function isDiscussionLocked(discussionId, myBotName) {
+    const now = Date.now();
+    const existing = locks.get(discussionId);
+    // No lock or expired
+    if (!existing || existing.expiresAt <= now) {
+        return false;
+    }
+    // Own lock doesn't block
+    if (existing.botName === myBotName) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Clean up expired locks (call periodically)
+ */
+function cleanupExpiredLocks() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [discussionId, lock] of locks.entries()) {
+        if (lock.expiresAt <= now) {
+            locks.delete(discussionId);
+            cleaned++;
+        }
+    }
+    if (cleaned > 0) {
+        logger.debug('Cleaned up expired locks', { count: cleaned });
+    }
+    return cleaned;
+}
+/**
+ * Get current lock status (for debugging)
+ */
+function getLockStatus() {
+    return new Map(locks);
+}
+//# sourceMappingURL=discussion-lock.js.map

package/dist/lib/logger.d.ts

@@ -47,7 +47,6 @@ export declare class Logger {
     private generateRequestId;
     private logToOtel;
     private log;
-    private getEmoji;
     debug(message: string, context?: LogContext, tag?: LogTag): void;
     info(message: string, context?: LogContext, tag?: LogTag): void;
     warn(message: string, context?: LogContext, tag?: LogTag): void;

package/dist/lib/logger.js

@@ -15,6 +15,7 @@ const sdk_logs_1 = require("@opentelemetry/sdk-logs");
 const exporter_logs_otlp_proto_1 = require("@opentelemetry/exporter-logs-otlp-proto");
 const api_logs_1 = require("@opentelemetry/api-logs");
 const resources_1 = require("@opentelemetry/resources");
+const config_1 = require("../config");
 var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
@@ -92,7 +93,7 @@ class Logger {
                 resource: new resources_1.Resource({ 'service.name': 'hailer-mcp-server' })
             });
             loggerProvider.addLogRecordProcessor(new sdk_logs_1.BatchLogRecordProcessor(logExporter));
-            this.otelLogger = loggerProvider.getLogger('hailer-mcp', '1.0.0');
+            this.otelLogger = loggerProvider.getLogger('hailer-mcp', config_1.APP_VERSION);
         }
         catch (error) {
             console.error('❌ Failed to initialize OTLP logger:', error);
@@ -130,31 +131,46 @@ class Logger {
         if (!this.shouldLog(level))
             return;
         const fullContext = { ...this.context, ...context };
-        // Always log to console for immediate feedback
-        const emoji = this.getEmoji(level);
-        const levelName = LogLevel[level];
-        const contextStr = Object.keys(fullContext).length > 0
-            ? ` [${Object.entries(fullContext)
-                .filter(([_, value]) => value !== undefined && value !== null)
-                .map(([key, value]) => `${key}=${value}`)
-                .join(', ')}]`
-            : '';
-        const consoleMessage = `${emoji} ${levelName}: [${tag}] ${message}${contextStr}`;
-        // IMPORTANT: All logs MUST go to stderr for MCP stdio transport compatibility
-        // stdout is reserved for JSON-RPC protocol messages
-        console.error(consoleMessage);
-        // Log to OTLP in production (console only in development)
+        // Log to OTLP in production
         if (this.isProduction && this.otelLogger) {
             this.logToOtel(level, message, tag, fullContext);
         }
-    }
-    getEmoji(level) {
-        switch (level) {
-            case LogLevel.DEBUG: return '🔍';
-            case LogLevel.INFO: return '📡';
-            case LogLevel.WARN: return '⚠️';
-            case LogLevel.ERROR: return '❌';
-            default: return '📝';
+        // Console output: compact single-line format with ANSI colors
+        // DEBUG lines are dim so INFO story lines pop out visually
+        const now = new Date();
+        const time = now.toTimeString().slice(0, 8);
+        const comp = fullContext.component || 'app';
+        // Build context suffix from non-standard keys (skip noise)
+        const skipKeys = new Set(['component', 'service', 'operation']);
+        const pairs = [];
+        for (const [k, v] of Object.entries(fullContext)) {
+            if (skipKeys.has(k) || v === undefined || v === null)
+                continue;
+            const raw = typeof v === 'object' ? JSON.stringify(v) : String(v);
+            // Truncate long values
+            const val = raw.length > 80 ? raw.slice(0, 80) + '...' : raw;
+            pairs.push(`${k}:${val}`);
+        }
+        const suffix = pairs.length > 0 ? ` | ${pairs.join(' ')}` : '';
+        // ANSI color codes
+        const DIM = '\x1b[2m';
+        const RESET = '\x1b[0m';
+        const YELLOW = '\x1b[33m';
+        const RED = '\x1b[31m';
+        const BOLD = '\x1b[1m';
+        const CYAN = '\x1b[36m';
+        const body = `[${comp}] ${message}${suffix}`;
+        if (level === LogLevel.DEBUG) {
+            console.log(`${DIM}${time} DEBUG ${body}${RESET}`);
+        }
+        else if (level === LogLevel.INFO) {
+            console.log(`${CYAN}${time}${RESET} ${BOLD}INFO ${RESET} ${body}`);
+        }
+        else if (level === LogLevel.WARN) {
+            console.warn(`${YELLOW}${time} WARN  ${body}${RESET}`);
+        }
+        else {
+            console.error(`${RED}${time} ERROR ${body}${RESET}`);
         }
     }
     // Core logging methods

package/dist/lib/request-logger.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Request Logger - Combined request/response logging
+ *
+ * Bundles MSG, RESP, and TOOL events into one log entry emitted at the end of request processing.
+ * Provides cleaner logs and better correlation of request lifecycle.
+ */
+export interface ToolCallResult {
+    name: string;
+    status: 'success' | 'error' | 'warning';
+    duration?: string;
+    error?: string;
+}
+export interface RequestLogData {
+    workspaceName: string;
+    botName: string;
+    botId: string;
+    request: {
+        from: string;
+        discussion: string;
+        timestamp: string;
+    };
+    response?: {
+        duration: string;
+        tokens: number;
+        timestamp: string;
+    };
+    tools: ToolCallResult[];
+    errors: string[];
+}
+export declare class RequestLogger {
+    private data;
+    private startTime;
+    private currentToolStart;
+    private currentToolName;
+    constructor(workspaceName: string, botName: string, botId: string);
+    /**
+     * Called when message is received
+     */
+    messageReceived(from: string, discussionId: string): void;
+    /**
+     * Called when tool execution starts
+     */
+    toolStart(toolName: string): void;
+    /**
+     * Called when tool execution succeeds
+     */
+    toolSuccess(toolName?: string): void;
+    /**
+     * Called when tool execution fails
+     */
+    toolError(toolName: string, error: string): void;
+    /**
+     * Called when tool has validation warning
+     */
+    toolWarning(toolName: string, warning: string): void;
+    /**
+     * Called when a tool is used (legacy - for backward compatibility)
+     * @deprecated Use toolStart/toolSuccess/toolError instead
+     */
+    toolCall(toolName: string): void;
+    /**
+     * Called when an error occurs
+     */
+    error(message: string): void;
+    /**
+     * Called when response is sent - emits the combined log
+     */
+    responseSent(tokens: number): void;
+    /**
+     * Get current data (for debugging)
+     */
+    getData(): RequestLogData;
+    private static currentInstance;
+    static setCurrent(logger: RequestLogger | null): void;
+    static getCurrent(): RequestLogger | null;
+}
+//# sourceMappingURL=request-logger.d.ts.map

package/dist/lib/request-logger.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Request Logger - Combined request/response logging
+ *
+ * Bundles MSG, RESP, and TOOL events into one log entry emitted at the end of request processing.
+ * Provides cleaner logs and better correlation of request lifecycle.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestLogger = void 0;
+const logger_1 = require("./logger");
+const logger = (0, logger_1.createLogger)({ component: 'RequestLogger' });
+class RequestLogger {
+    data;
+    startTime;
+    currentToolStart = 0;
+    currentToolName = '';
+    constructor(workspaceName, botName, botId) {
+        this.startTime = Date.now();
+        this.data = {
+            workspaceName,
+            botName,
+            botId,
+            request: {
+                from: '',
+                discussion: '',
+                timestamp: new Date().toISOString(),
+            },
+            tools: [],
+            errors: [],
+        };
+    }
+    /**
+     * Called when message is received
+     */
+    messageReceived(from, discussionId) {
+        this.data.request.from = from;
+        this.data.request.discussion = discussionId.substring(0, 8);
+        this.data.request.timestamp = new Date().toISOString();
+    }
+    /**
+     * Called when tool execution starts
+     */
+    toolStart(toolName) {
+        this.currentToolName = toolName;
+        this.currentToolStart = Date.now();
+    }
+    /**
+     * Called when tool execution succeeds
+     */
+    toolSuccess(toolName) {
+        const name = toolName || this.currentToolName;
+        const duration = this.currentToolStart ? ((Date.now() - this.currentToolStart) / 1000).toFixed(1) + 's' : undefined;
+        this.data.tools.push({
+            name,
+            status: 'success',
+            duration,
+        });
+        this.currentToolName = '';
+        this.currentToolStart = 0;
+    }
+    /**
+     * Called when tool execution fails
+     */
+    toolError(toolName, error) {
+        const duration = this.currentToolStart ? ((Date.now() - this.currentToolStart) / 1000).toFixed(1) + 's' : undefined;
+        this.data.tools.push({
+            name: toolName || this.currentToolName,
+            status: 'error',
+            error,
+            duration,
+        });
+        this.currentToolName = '';
+        this.currentToolStart = 0;
+    }
+    /**
+     * Called when tool has validation warning
+     */
+    toolWarning(toolName, warning) {
+        this.data.tools.push({
+            name: toolName,
+            status: 'warning',
+            error: warning,
+        });
+    }
+    /**
+     * Called when a tool is used (legacy - for backward compatibility)
+     * @deprecated Use toolStart/toolSuccess/toolError instead
+     */
+    toolCall(toolName) {
+        // Only add if not already tracking this tool
+        if (!this.data.tools.find(t => t.name === toolName)) {
+            this.data.tools.push({
+                name: toolName,
+                status: 'success',
+            });
+        }
+    }
+    /**
+     * Called when an error occurs
+     */
+    error(message) {
+        this.data.errors.push(message);
+    }
+    /**
+     * Called when response is sent - emits the combined log
+     */
+    responseSent(tokens) {
+        const duration = ((Date.now() - this.startTime) / 1000).toFixed(1);
+        this.data.response = {
+            duration: `${duration}s`,
+            tokens,
+            timestamp: new Date().toISOString(),
+        };
+        // Build clean output - only include fields that have data
+        const logData = {
+            marker: 'REQUEST',
+            workspaceName: this.data.workspaceName,
+            botName: this.data.botName,
+            botId: this.data.botId,
+            request: this.data.request,
+            response: this.data.response,
+        };
+        if (this.data.tools.length > 0) {
+            logData.tools = this.data.tools;
+        }
+        if (this.data.errors.length > 0) {
+            logData.errors = this.data.errors;
+        }
+        logger.info('Request complete', logData);
+    }
+    /**
+     * Get current data (for debugging)
+     */
+    getData() {
+        return { ...this.data };
+    }
+    // Static instance for tool registry to access
+    static currentInstance = null;
+    static setCurrent(logger) {
+        RequestLogger.currentInstance = logger;
+    }
+    static getCurrent() {
+        return RequestLogger.currentInstance;
+    }
+}
+exports.RequestLogger = RequestLogger;
+//# sourceMappingURL=request-logger.js.map