@hailer/mcp 1.0.29 → 1.1.2

package/dist/mcp/UserContextCache.js

@@ -57,7 +57,7 @@ class UserContextCache {
             else {
                 // Cache expired, remove stale entry
                 this.cache.delete(apiKey);
-                logger.info('Cache expired, refreshing user context', {
+                logger.debug('Cache expired, refreshing user context', {
                     apiKey: apiKey.substring(0, 8) + '...',
                     ageMinutes: Math.round(age / (1000 * 60))
                 });
@@ -66,7 +66,7 @@ class UserContextCache {
         else if (forceRefresh && this.cache.has(apiKey)) {
             // Force refresh requested, clear existing cache
             this.cache.delete(apiKey);
-            logger.info('Force refresh requested, clearing cached user context', {
+            logger.debug('Force refresh requested, clearing cached user context', {
                 apiKey: apiKey.substring(0, 8) + '...'
             });
         }
@@ -105,20 +105,23 @@ class UserContextCache {
             const init = await client.socket.request('v2.core.init', [
                 ['processes', 'users', 'network', 'networks', 'teams']
             ]);
-            // Multi-workspace support: log available workspaces, use first one as default
-            // User can switch workspaces using list_my_workspaces tool and specifying workspaceId
-            const networks = (init.networks || {});
-            const workspaceCount = Object.keys(networks).length;
+            // Validate single workspace access - MCP requires bot credentials with access to one workspace only
+            const workspaceCount = Object.keys(init.networks || {}).length;
             if (workspaceCount > 1) {
-                const workspaceList = Object.entries(networks)
-                    .map(([id, ws]) => `${ws.name} (${id})`)
+                const networks = (init.networks || {});
+                const workspaceNames = Object.values(networks)
+                    .map((ws) => ws.name)
                     .join(', ');
-                logger.info('Multi-workspace user detected', {
+                logger.error('Multi-workspace credentials detected', {
                     workspaceCount,
-                    workspaces: workspaceList,
-                    apiKey: apiKey.substring(0, 8) + '...',
-                    hint: 'Use list_my_workspaces tool to see all workspaces and switch between them'
+                    workspaces: workspaceNames,
+                    apiKey: apiKey.substring(0, 8) + '...'
                 });
+                // Clean up the connection before throwing - prevents dangling socket
+                (0, hailer_clients_1.disconnectHailerClientByApiKey)(apiKey);
+                throw new Error(`Multi-workspace credentials detected (${workspaceCount} workspaces: ${workspaceNames}). ` +
+                    `MCP requires bot credentials with access to a single workspace. ` +
+                    `Please use the bot account created during 'hailer-sdk init'.`);
             }
             // Create workspace cache from init data
             const appConfig = (0, config_1.createApplicationConfig)();
@@ -173,7 +176,7 @@ class UserContextCache {
     static clearAll() {
         const size = this.cache.size;
         this.cache.clear();
-        logger.info('Cleared all user contexts from cache', { clearedCount: size });
+        logger.debug('Cleared all user contexts from cache', { clearedCount: size });
     }
     /**
      * Get cache statistics (for monitoring and debugging)

package/dist/mcp/hailer-clients.js

@@ -91,23 +91,24 @@ class HailerClientManager {
             password: this.password,
             ...(isLocalDev && { rejectUnauthorized: false }), // Add for local dev with self-signed certs
         };
-        // Track timeout for proper cleanup
+        // Track timeout with single settled flag to prevent race conditions
         let timeoutId = null;
-        let timeoutCleared = false;
+        let settled = false;
         try {
             // Create socket client using @hailer/cli with cancellable timeout
             this.socketClient = (await Promise.race([
                 cli_1.Client.create(clientOptions).then(client => {
-                    // Clear timeout on success
-                    if (timeoutId && !timeoutCleared) {
-                        clearTimeout(timeoutId);
-                        timeoutCleared = true;
+                    if (!settled) {
+                        settled = true;
+                        if (timeoutId)
+                            clearTimeout(timeoutId);
                     }
                     return client;
                 }),
                 new Promise((_, reject) => {
                     timeoutId = setTimeout(() => {
-                        if (!timeoutCleared) {
+                        if (!settled) {
+                            settled = true;
                             reject(new Error(`Timeout connecting to: ${this.host}`));
                         }
                     }, 30000);
@@ -115,10 +116,10 @@ class HailerClientManager {
             ]));
         }
         catch (error) {
-            // Ensure timeout is cleared on error too
-            if (timeoutId && !timeoutCleared) {
+            // Ensure timeout is cleared on error
+            if (timeoutId && !settled) {
+                settled = true;
                 clearTimeout(timeoutId);
-                timeoutCleared = true;
             }
             logger.error('Failed to create socket client', error, { username: this.username });
             throw error;
@@ -162,13 +163,13 @@ class HailerClientManager {
             logger.info('Socket reconnected and session resumed', { username: this.username });
         });
         this.socketClient.on("connect", () => {
-            logger.info('Socket connected', { username: this.username });
+            logger.debug('Socket connected', { username: this.username });
         });
         this.socketClient.on("connect_error", (error) => {
             logger.error('Socket connection error', { error: error.message, username: this.username });
         });
         this.socketClient.on("reconnect_attempt", (attempt) => {
-            logger.info('Socket reconnection attempt', { attempt, username: this.username });
+            logger.debug('Socket reconnection attempt', { attempt, username: this.username });
         });
         this.socketClient.on("reconnect_failed", () => {
             logger.error('Socket reconnection failed permanently', { username: this.username });
@@ -279,7 +280,7 @@ const createHailerClientByApiKey = async (apiKey) => {
         connectionPool.delete(connectionKey);
     }
     // Create new connection
-    logger.info('Creating new connection', {
+    logger.debug('Creating new connection', {
         apiKey: apiKey.substring(0, 8) + '...',
         email: (0, config_1.maskEmail)(account.email),
         host: account.apiBaseUrl
@@ -311,7 +312,7 @@ const clearAllConnections = () => {
         clientManager.disconnect();
     }
     connectionPool.clear();
-    logger.info('Cleared Hailer connections', { count });
+    logger.debug('Cleared Hailer connections', { count });
 };
 exports.clearAllConnections = clearAllConnections;
 /**
@@ -345,10 +346,10 @@ function registerBotCredentials(botId, email, password, options) {
     config_1.environment.CLIENT_CONFIGS[apiKey] = {
         email,
         password,
-        apiBaseUrl: 'https://api.hailer.com',
+        apiBaseUrl: config_1.environment.BOT_API_BASE_URL || 'https://api.hailer.com',
         ...(options?.allowedGroups && { allowedGroups: options.allowedGroups }),
     };
-    logger.info('Bot credentials registered', {
+    logger.debug('Bot credentials registered', {
         botId,
         hasAllowedGroups: !!options?.allowedGroups
     });
@@ -360,6 +361,6 @@ function registerBotCredentials(botId, email, password, options) {
 function unregisterBotCredentials(apiKey) {
     delete config_1.environment.CLIENT_CONFIGS[apiKey];
     (0, exports.disconnectHailerClientByApiKey)(apiKey);
-    logger.info('Bot credentials unregistered');
+    logger.debug('Bot credentials unregistered');
 }
 //# sourceMappingURL=hailer-clients.js.map

package/dist/mcp/signal-handler.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignalHandler = void 0;
 const logger_1 = require("../lib/logger");
+const bot_config_1 = require("../bot-config");
 const logger = (0, logger_1.createLogger)({ component: 'signal-handler' });
 class SignalHandler {
     client;
@@ -233,7 +234,7 @@ class SignalHandler {
             // Update workspace cache with fresh data
             if (init.processes) {
                 this.workspaceCache.rawInit.processes = init.processes;
-                logger.info('Workflows cache refreshed', {
+                logger.debug('Workflows cache refreshed', {
                     workflowCount: init.processes.length
                 });
                 // Check if Agent Directory workflow now exists (hot-load after template install)
@@ -244,23 +245,27 @@ class SignalHandler {
                     return agentDirectoryPatterns.some(pattern => name.includes(pattern));
                 });
                 if (hasAgentDirectory) {
-                    logger.info('Agent Directory workflow detected after cache refresh');
+                    logger.debug('Agent Directory workflow detected after cache refresh, triggering bot config reload');
+                    // Async reload - don't await to avoid blocking signal handling
+                    (0, bot_config_1.reloadConfigFromHailer)().catch(err => {
+                        logger.warn('Bot config reload failed after Agent Directory detection', { error: err });
+                    });
                 }
             }
             if (init.users) {
                 // Store raw users in rawInit - the users array is derived from this
                 this.workspaceCache.rawInit.users = init.users;
-                logger.info('Users cache refreshed', {
+                logger.debug('Users cache refreshed', {
                     userCount: Object.keys(init.users).length
                 });
             }
             if (init.network) {
                 this.workspaceCache.currentWorkspace = init.network;
-                logger.info('Current workspace cache refreshed');
+                logger.debug('Current workspace cache refreshed');
             }
             if (init.networks) {
                 this.workspaceCache.allWorkspaces = init.networks;
-                logger.info('All workspaces cache refreshed', {
+                logger.debug('All workspaces cache refreshed', {
                     workspaceCount: Object.keys(init.networks).length
                 });
             }
@@ -281,7 +286,7 @@ class SignalHandler {
                 logger.debug('No pending invitations to accept');
                 return;
             }
-            logger.info('Found pending invitations', { count: invites.length });
+            logger.debug('Found pending invitations', { count: invites.length });
             // Accept each invitation
             for (const invite of invites) {
                 try {
@@ -290,11 +295,22 @@ class SignalHandler {
                         workspaceId: invite.cid,
                         workspaceName: invite.network?.name
                     });
-                    // Switch to the new workspace
+                    // Switch to the new workspace so the existing automation can discover Agent Directory
                     try {
-                        logger.info('Switching to new workspace', { workspaceId: invite.cid });
+                        logger.debug('Switching to new workspace', { workspaceId: invite.cid });
                         await this.client.socket.request('core.switch_ecosystem', [invite.cid]);
                         logger.info('Switched to workspace successfully', { workspaceId: invite.cid });
+                        // Update active workspace for bot-config
+                        (0, bot_config_1.setActiveWorkspace)(invite.cid);
+                        // Trigger Agent Directory discovery and bot initialization
+                        try {
+                            logger.debug('Triggering bot config reload for new workspace');
+                            await (0, bot_config_1.reloadConfigFromHailer)();
+                            logger.debug('Bot config reload completed');
+                        }
+                        catch (reloadError) {
+                            logger.error('Failed to reload bot config', reloadError);
+                        }
                     }
                     catch (switchError) {
                         logger.error('Failed to switch to workspace', switchError, {
@@ -314,7 +330,7 @@ class SignalHandler {
                 const init = await this.client.socket.request('v2.core.init', [['networks']]);
                 if (init.networks) {
                     this.workspaceCache.allWorkspaces = init.networks;
-                    logger.info('Workspaces cache refreshed after accepting invitations', {
+                    logger.debug('Workspaces cache refreshed after accepting invitations', {
                         workspaceCount: Object.keys(init.networks).length
                     });
                 }
@@ -328,7 +344,7 @@ class SignalHandler {
     subscribe(id, types, handler, workspaceId) {
         // Check if subscription already exists
         if (this.subscriptions.has(id)) {
-            logger.info('Replacing existing signal subscription', { subscriptionId: id });
+            logger.debug('Replacing existing signal subscription', { subscriptionId: id });
         }
         const subscription = {
             id,
@@ -337,7 +353,7 @@ class SignalHandler {
             workspaceId,
         };
         this.subscriptions.set(id, subscription);
-        logger.info('Created signal subscription', {
+        logger.debug('Created signal subscription', {
             subscriptionId: id,
             signalTypes: types,
             workspaceId
@@ -346,7 +362,7 @@ class SignalHandler {
     unsubscribe(id) {
         const removed = this.subscriptions.delete(id);
         if (removed) {
-            logger.info('Removed signal subscription', { subscriptionId: id });
+            logger.debug('Removed signal subscription', { subscriptionId: id });
         }
         return removed;
     }
@@ -369,7 +385,7 @@ class SignalHandler {
     clearHistory() {
         const previousCount = this.signalHistory.length;
         this.signalHistory = [];
-        logger.info('Signal history cleared', { previousHistorySize: previousCount });
+        logger.debug('Signal history cleared', { previousHistorySize: previousCount });
     }
 }
 exports.SignalHandler = SignalHandler;

package/dist/mcp/tool-registry.d.ts

@@ -110,24 +110,13 @@ export declare class ToolRegistry {
      */
     executeTool(name: string, args: any, context: UserContext): Promise<any>;
     /**
-     * Get tool metadata (for access control checks)
+     * Pre-transform install_workflow args to fix common LLM mistakes BEFORE validation
      */
-    getTool(name: string): Tool | undefined;
+    private preTransformInstallWorkflow;
     /**
-     * Get tools with their original Zod schemas for MCP SDK registration.
-     * MCP SDK requires Zod schemas, not JSON Schema objects.
-     *
-     * @param filter - Optional filter configuration
-     * @returns Array of tools with name, description, and Zod schema
+     * Get tool metadata (for access control checks)
      */
-    getToolsWithZodSchemas(filter?: {
-        allowedGroups?: ToolGroup[];
-        allowedTools?: string[];
-    }): Array<{
-        name: string;
-        description: string;
-        schema: z.ZodType;
-    }>;
+    getTool(name: string): Tool | undefined;
     /**
      * Get total tool count
      */

package/dist/mcp/tool-registry.js

@@ -47,6 +47,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolRegistry = exports.ToolGroup = void 0;
 const zod_1 = require("zod");
 const logger_1 = require("../lib/logger");
+const request_logger_1 = require("../lib/request-logger");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const logger = (0, logger_1.createLogger)({ component: 'tool-registry' });
@@ -121,7 +122,7 @@ class ToolRegistry {
                 }
             }
             this.workspaceSchemasLoaded = true;
-            logger.info('Workspace schemas loaded for structured outputs', {
+            logger.debug('Workspace schemas loaded for structured outputs', {
                 count: this.workspaceSchemas.size,
                 schemas: Array.from(this.workspaceSchemas.keys()),
                 path: claudeSchemasPath
@@ -150,7 +151,7 @@ class ToolRegistry {
     addTool(tool) {
         // Short-circuit: Skip NUCLEAR tools when not enabled
         if (tool.group === ToolGroup.NUCLEAR && !this.enableNuclearTools) {
-            logger.info('Skipping NUCLEAR tool (not enabled)', {
+            logger.debug('Skipping NUCLEAR tool (not enabled)', {
                 name: tool.name,
                 group: tool.group
             });
@@ -214,7 +215,7 @@ class ToolRegistry {
             (toolName === 'create_activity' || toolName === 'update_activity')) {
             const masterSchema = this.workspaceSchemas.get('_master_activity');
             if (masterSchema) {
-                logger.info('Using master workspace schema with enum constraints', {
+                logger.debug('Using master workspace schema with enum constraints', {
                     toolName,
                     workflowCount: masterSchema.properties?.workflowId?.enum?.length || 0,
                     phaseCount: masterSchema.properties?.phaseId?.enum?.length || 0
@@ -277,19 +278,31 @@ class ToolRegistry {
             name,
             apiKey: context.apiKey.substring(0, 8) + '...'
         });
+        // Pre-transform for specific tools (fix common LLM mistakes before validation)
+        let transformedArgs = args;
+        if (name === 'install_workflow' && args.workflowTemplates) {
+            transformedArgs = this.preTransformInstallWorkflow(args);
+        }
         // Zod validation
         try {
-            const validated = tool.schema.parse(args);
+            const validated = tool.schema.parse(transformedArgs);
             return await tool.execute(validated, context);
         }
         catch (error) {
             if (error instanceof zod_1.z.ZodError) {
                 const errorDetails = error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ');
-                logger.warn('Tool validation failed', {
-                    toolName: name,
-                    errors: errorDetails,
-                    receivedArgs: JSON.stringify(args)
-                });
+                // Track in request logger or log separately
+                const reqLogger = request_logger_1.RequestLogger.getCurrent();
+                if (reqLogger) {
+                    reqLogger.toolError(name, errorDetails);
+                }
+                else {
+                    logger.warn('Tool validation failed', {
+                        toolName: name,
+                        errors: errorDetails,
+                        receivedArgs: JSON.stringify(args)
+                    });
+                }
                 // Check if tool has a skill hint
                 const hasSkillHint = tool.description.includes('Use Skill');
                 const skillName = hasSkillHint ? tool.description.match(/`([^`]+)-skill`/)?.[1] + '-skill' : null;
@@ -319,33 +332,82 @@ Then retry \`${name}\` with the correct format from the skill examples.` : `💡
         }
     }
     /**
-     * Get tool metadata (for access control checks)
+     * Pre-transform install_workflow args to fix common LLM mistakes BEFORE validation
      */
-    getTool(name) {
-        return this.tools.get(name);
+    preTransformInstallWorkflow(args) {
+        let templates = args.workflowTemplates;
+        // Fix: single object instead of array
+        if (!Array.isArray(templates)) {
+            templates = [templates];
+        }
+        // Transform each template
+        templates = templates.map((template, tIdx) => {
+            const result = { ...template };
+            // Fix: fields as array instead of object
+            if (Array.isArray(template.fields)) {
+                const fieldsObj = {};
+                template.fields.forEach((field, idx) => {
+                    const fieldId = `_${1000 + idx}`;
+                    const { name, ...rest } = field;
+                    fieldsObj[fieldId] = { ...rest, label: rest.label || name };
+                });
+                result.fields = fieldsObj;
+            }
+            else if (template.fields) {
+                // Fix: field IDs not matching pattern
+                const fieldsObj = {};
+                let idx = 0;
+                for (const [key, field] of Object.entries(template.fields)) {
+                    const fieldId = /^_\d{4}$/.test(key) ? key : `_${1000 + idx}`;
+                    const f = field;
+                    const { name, ...rest } = f;
+                    fieldsObj[fieldId] = { ...rest, label: rest.label || name || key };
+                    idx++;
+                }
+                result.fields = fieldsObj;
+            }
+            // Fix: phases as array instead of object
+            if (Array.isArray(template.phases)) {
+                const phasesObj = {};
+                template.phases.forEach((phase, idx) => {
+                    const phaseId = `_${2000 + idx}`;
+                    phasesObj[phaseId] = { name: phase.name };
+                });
+                result.phases = phasesObj;
+            }
+            else if (template.phases) {
+                // Fix: phase IDs not matching pattern
+                const phasesObj = {};
+                let idx = 0;
+                for (const [key, phase] of Object.entries(template.phases)) {
+                    const phaseId = /^_\d{4}$/.test(key) ? key : `_${2000 + idx}`;
+                    const p = phase;
+                    phasesObj[phaseId] = { name: p.name || key };
+                    idx++;
+                }
+                result.phases = phasesObj;
+            }
+            // Fix: wrong field types
+            if (result.fields) {
+                for (const fieldId of Object.keys(result.fields)) {
+                    const f = result.fields[fieldId];
+                    // select → textpredefinedoptions
+                    if (f.type === 'select')
+                        f.type = 'textpredefinedoptions';
+                    // user → users
+                    if (f.type === 'user')
+                        f.type = 'users';
+                }
+            }
+            return result;
+        });
+        return { ...args, workflowTemplates: templates };
     }
     /**
-     * Get tools with their original Zod schemas for MCP SDK registration.
-     * MCP SDK requires Zod schemas, not JSON Schema objects.
-     *
-     * @param filter - Optional filter configuration
-     * @returns Array of tools with name, description, and Zod schema
+     * Get tool metadata (for access control checks)
      */
-    getToolsWithZodSchemas(filter) {
-        let toolsToExpose = Array.from(this.tools.values());
-        if (filter) {
-            if (filter.allowedTools) {
-                toolsToExpose = toolsToExpose.filter(t => filter.allowedTools.includes(t.name));
-            }
-            else if (filter.allowedGroups) {
-                toolsToExpose = toolsToExpose.filter(t => filter.allowedGroups.includes(t.group));
-            }
-        }
-        return toolsToExpose.map(tool => ({
-            name: tool.name,
-            description: tool.description,
-            schema: tool.schema
-        }));
+    getTool(name) {
+        return this.tools.get(name);
     }
     /**
      * Get total tool count