@hailer/mcp 0.1.16 → 0.2.1

package/dist/mcp/utils/response-builder.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Response Builder Utility
+ *
+ * Centralized response formatting for MCP tools.
+ * Eliminates duplication of { type: 'text', text: '...' } patterns.
+ */
+import type { McpResponse } from './types';
+/**
+ * Build a text response (most common pattern)
+ */
+export declare function textResponse(text: string): McpResponse;
+/**
+ * Build an error response
+ */
+export declare function errorResponse(message: string, details?: string): McpResponse;
+/**
+ * Build a success response with optional emoji
+ */
+export declare function successResponse(message: string, emoji?: string): McpResponse;
+/**
+ * Build a JSON response (formatted with indentation)
+ */
+export declare function jsonResponse(data: unknown, prefix?: string): McpResponse;
+/**
+ * Build a paginated response
+ */
+export declare function paginatedResponse(items: unknown[], options: {
+    currentPage: number;
+    limit: number;
+    totalCount?: number;
+    title?: string;
+}): McpResponse;
+/**
+ * Build a list response with header
+ */
+export declare function listResponse(items: unknown[], header: string, emptyMessage?: string): McpResponse;
+/**
+ * Extract error message from unknown error type
+ * Centralizes the common pattern: error instanceof Error ? error.message : String(error)
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Wrap an async operation with standard error handling
+ * Returns McpResponse on error, or result on success
+ */
+export declare function withErrorHandling<T>(operation: () => Promise<T>, errorContext?: string): Promise<T | McpResponse>;
+/**
+ * Type guard to check if result is an error response
+ */
+export declare function isErrorResponse(result: unknown): result is McpResponse & {
+    isError: true;
+};
+//# sourceMappingURL=response-builder.d.ts.map

package/dist/mcp/utils/response-builder.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Response Builder Utility
+ *
+ * Centralized response formatting for MCP tools.
+ * Eliminates duplication of { type: 'text', text: '...' } patterns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textResponse = textResponse;
+exports.errorResponse = errorResponse;
+exports.successResponse = successResponse;
+exports.jsonResponse = jsonResponse;
+exports.paginatedResponse = paginatedResponse;
+exports.listResponse = listResponse;
+exports.getErrorMessage = getErrorMessage;
+exports.withErrorHandling = withErrorHandling;
+exports.isErrorResponse = isErrorResponse;
+/**
+ * Build a text response (most common pattern)
+ */
+function textResponse(text) {
+    return {
+        content: [{ type: 'text', text }]
+    };
+}
+/**
+ * Build an error response
+ */
+function errorResponse(message, details) {
+    const text = details ? `${message}\n\n${details}` : message;
+    return {
+        content: [{ type: 'text', text }],
+        isError: true
+    };
+}
+/**
+ * Build a success response with optional emoji
+ */
+function successResponse(message, emoji = '✅') {
+    return textResponse(`${emoji} ${message}`);
+}
+/**
+ * Build a JSON response (formatted with indentation)
+ */
+function jsonResponse(data, prefix) {
+    const json = JSON.stringify(data, null, 2);
+    const text = prefix ? `${prefix}\n\n${json}` : json;
+    return textResponse(text);
+}
+/**
+ * Build a paginated response
+ */
+function paginatedResponse(items, options) {
+    const { currentPage, limit, totalCount, title } = options;
+    const hasMore = items.length === limit;
+    let text = '';
+    if (title)
+        text += `${title}\n\n`;
+    text += `📊 **Page ${currentPage + 1}**\n`;
+    text += `- Items: ${items.length}\n`;
+    if (totalCount !== undefined)
+        text += `- Total: ${totalCount}\n`;
+    text += `- Has more: ${hasMore ? 'Yes' : 'No'}\n\n`;
+    text += JSON.stringify(items, null, 2);
+    return textResponse(text);
+}
+/**
+ * Build a list response with header
+ */
+function listResponse(items, header, emptyMessage = 'No items found') {
+    if (items.length === 0) {
+        return textResponse(emptyMessage);
+    }
+    return textResponse(`${header}\n\n${JSON.stringify(items, null, 2)}`);
+}
+/**
+ * Extract error message from unknown error type
+ * Centralizes the common pattern: error instanceof Error ? error.message : String(error)
+ */
+function getErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    return String(error);
+}
+/**
+ * Wrap an async operation with standard error handling
+ * Returns McpResponse on error, or result on success
+ */
+async function withErrorHandling(operation, errorContext) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        const fullMessage = errorContext ? `${errorContext}: ${message}` : message;
+        return errorResponse('Error', fullMessage);
+    }
+}
+/**
+ * Type guard to check if result is an error response
+ */
+function isErrorResponse(result) {
+    return (typeof result === 'object' &&
+        result !== null &&
+        'isError' in result &&
+        result.isError === true);
+}
+//# sourceMappingURL=response-builder.js.map

package/dist/mcp/utils/tool-helpers.d.ts

@@ -91,12 +91,4 @@ export declare function getRequiredWorkspaceId(args: {
  * ```
  */
 export declare function extractErrorMessage(error: unknown): string;
-/**
- * Creates a standard success response with formatted text.
- */
-export declare function successResponse(text: string): McpResponse;
-/**
- * Creates a standard error response with formatted text.
- */
-export declare function errorResponse(text: string): McpResponse;
 //# sourceMappingURL=tool-helpers.d.ts.map

package/dist/mcp/utils/tool-helpers.js

@@ -11,8 +11,6 @@ exports.missingWorkspaceCacheResponse = missingWorkspaceCacheResponse;
 exports.getResolvedWorkspaceId = getResolvedWorkspaceId;
 exports.getRequiredWorkspaceId = getRequiredWorkspaceId;
 exports.extractErrorMessage = extractErrorMessage;
-exports.successResponse = successResponse;
-exports.errorResponse = errorResponse;
 const workspace_cache_1 = require("../workspace-cache");
 /**
  * Error thrown when workspace cache is not available
@@ -154,26 +152,4 @@ function extractErrorMessage(error) {
     }
     return String(error);
 }
-/**
- * Creates a standard success response with formatted text.
- */
-function successResponse(text) {
-    return {
-        content: [{
-                type: "text",
-                text,
-            }],
-    };
-}
-/**
- * Creates a standard error response with formatted text.
- */
-function errorResponse(text) {
-    return {
-        content: [{
-                type: "text",
-                text: `${text}`,
-            }],
-    };
-}
 //# sourceMappingURL=tool-helpers.js.map

package/dist/mcp/utils/types.d.ts

@@ -133,6 +133,7 @@ export interface McpTextContent {
 }
 export interface McpResponse {
     content: McpTextContent[];
+    isError?: boolean;
 }
 export interface ActivityListFilters {
     processId?: string;
@@ -168,13 +169,6 @@ export interface SearchOptions {
     limit?: number;
     workspaceId?: string;
 }
-export interface InitData {
-    processes: any[];
-    users: Record<string, HailerUser>;
-    currentUser?: HailerUser;
-    workspace?: WorkspaceInfo;
-    networks?: any[];
-}
 export interface WorkspaceInfo {
     _id: string;
     name: string;
@@ -182,32 +176,6 @@ export interface WorkspaceInfo {
     members?: string[];
     settings?: Record<string, any>;
 }
-export interface NetworkInfo {
-    _id: string;
-    name: string;
-    workspaces: string[];
-}
-export interface ClientConfig {
-    email: string;
-    password: string;
-    mcpServerApiKey: string;
-    apiBaseUrl?: string;
-}
-export interface McpConfig {
-    clients: ClientConfig[];
-    logging?: {
-        level: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
-        enableApiLogging: boolean;
-    };
-}
-export interface ApiErrorInfo {
-    status: number;
-    statusText: string;
-    message: string;
-    operation: string;
-    endpoint: string;
-    responseBody?: string;
-}
 export interface SignalData {
     type: string;
     data: any;

package/dist/mcp/webhook-handler.d.ts

@@ -19,11 +19,11 @@ export declare function verifyWebhookSignature(payload: string, signature: strin
  * Production: WEBHOOK_TOKEN env var (injected by AWS Secrets Manager)
  * Development: Falls back to file-based token for local testing
  */
-export declare function getWebhookToken(): string;
+export declare function getWebhookToken(): string | null;
 /**
  * Get the full webhook path with token (no prefix for security through obscurity)
  */
-export declare function getWebhookPath(): string;
+export declare function getWebhookPath(): string | null;
 interface WebhookField {
     id: string;
     type: string;

package/dist/mcp/webhook-handler.js

@@ -107,9 +107,10 @@ function getWebhookToken() {
         logger.debug('Using webhook token from environment');
         return process.env.WEBHOOK_TOKEN;
     }
-    // Development only: File-based fallback
+    // Production without WEBHOOK_TOKEN: webhooks disabled (optional feature)
     if (process.env.NODE_ENV === 'production') {
-        throw new Error('WEBHOOK_TOKEN environment variable is required in production');
+        logger.info('WEBHOOK_TOKEN not set - webhook endpoint disabled');
+        return null;
     }
     const configDir = path.join(process.cwd(), BOT_CONFIG_DIR);
     const secretPath = path.join(configDir, WEBHOOK_SECRET_FILE);
@@ -140,7 +141,8 @@ function getWebhookToken() {
  * Get the full webhook path with token (no prefix for security through obscurity)
  */
 function getWebhookPath() {
-    return `/${getWebhookToken()}`;
+    const token = getWebhookToken();
+    return token ? `/${token}` : null;
 }
 let botUpdateCallback = null;
 function onBotUpdate(callback) {

package/dist/mcp-server.d.ts

@@ -16,10 +16,10 @@ export interface MCPServerConfig {
     port: number;
     corsOrigins: string[];
     toolRegistry: ToolRegistry;
-    getDaemonStatus?: () => Array<{
+    getDaemonStatus?: () => Record<string, Array<{
         botId: string;
         state: any;
-    }> | null;
+    }>>;
 }
 export declare class MCPServerService {
     private app;

package/dist/mcp-server.js

@@ -166,23 +166,24 @@ class MCPServerService {
                             req.logger.debug('No config found for apiKey, returning all tools');
                         }
                     }
-                    // Apply NUCLEAR tools blocking if NOT explicitly enabled
-                    if (!config_1.environment.ENABLE_NUCLEAR_TOOLS) {
-                        if (!filterConfig) {
-                            // No filter yet - create one excluding NUCLEAR
-                            filterConfig = {
-                                allowedGroups: [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND]
-                            };
-                        }
-                        else if (filterConfig.allowedGroups) {
-                            // Filter has groups - remove NUCLEAR if present
-                            filterConfig.allowedGroups = filterConfig.allowedGroups.filter(g => g !== tool_registry_1.ToolGroup.NUCLEAR);
-                        }
-                        // Note: If filter has explicit allowedTools list, NUCLEAR tools won't be in it anyway
-                        req.logger.debug('NUCLEAR tools blocked (not explicitly enabled)');
+                    // Apply default tool group filtering
+                    // - NUCLEAR: Only if ENABLE_NUCLEAR_TOOLS=true
+                    // - BOT_INTERNAL: Never exposed to MCP clients (autonomous bot tools only)
+                    if (!filterConfig) {
+                        // No filter yet - create default excluding NUCLEAR and BOT_INTERNAL
+                        filterConfig = {
+                            allowedGroups: [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND]
+                        };
+                        req.logger.debug('Using default tool filter (excludes NUCLEAR and BOT_INTERNAL)');
                     }
-                    else {
-                        req.logger.debug('NUCLEAR tools enabled by environment variable');
+                    else if (filterConfig.allowedGroups) {
+                        // Filter has groups - always remove BOT_INTERNAL, remove NUCLEAR unless enabled
+                        filterConfig.allowedGroups = filterConfig.allowedGroups.filter(g => g !== tool_registry_1.ToolGroup.BOT_INTERNAL &&
+                            (config_1.environment.ENABLE_NUCLEAR_TOOLS || g !== tool_registry_1.ToolGroup.NUCLEAR));
+                        req.logger.debug('Filtered tool groups', {
+                            allowedGroups: filterConfig.allowedGroups,
+                            nuclearEnabled: config_1.environment.ENABLE_NUCLEAR_TOOLS
+                        });
                     }
                     result = {
                         tools: this.toolRegistry.getToolDefinitions(filterConfig)
@@ -248,141 +249,167 @@ class MCPServerService {
                 res.end();
             }
             catch (error) {
-                req.logger.error('MCP handler error', error, { apiKey: req.query.apiKey });
-                this.sendMcpError(res, req.body?.id || null, -32000, `Server error: ${error instanceof Error ? error.message : String(error)}`, 500);
-            }
-        });
-        // ===== Bot Configuration API =====
-        // GET /api/bots - List all bots and their status
-        this.app.get('/api/bots', async (req, res) => {
-            req.logger.debug('List bots requested');
-            try {
-                const { AVAILABLE_BOTS, getBotState } = await Promise.resolve().then(() => __importStar(require('./mcp/tools/bot-config')));
-                const state = getBotState();
-                const bots = AVAILABLE_BOTS.map(bot => ({
-                    ...bot,
-                    enabled: state[bot.id] || false
-                }));
-                res.json({ bots });
-            }
-            catch (error) {
-                req.logger.error('Failed to list bots', { error });
-                res.status(500).json({ error: 'Failed to list bots' });
-            }
-        });
-        // POST /api/bots/:id/enable - Enable a bot
-        this.app.post('/api/bots/:id/enable', async (req, res) => {
-            const { id } = req.params;
-            req.logger.info('Enable bot requested', { botId: id });
-            try {
-                const { AVAILABLE_BOTS, setBotEnabled } = await Promise.resolve().then(() => __importStar(require('./mcp/tools/bot-config')));
-                const bot = AVAILABLE_BOTS.find(b => b.id === id);
-                if (!bot) {
-                    return res.status(404).json({ error: `Unknown bot: ${id}` });
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // Check for multi-workspace credentials error - return user-friendly error
+                // Use HTTP 200 so the JSON-RPC error reaches the client properly
+                if (errorMessage.includes('Multi-workspace credentials detected')) {
+                    req.logger.warn('Multi-workspace credentials blocked', { apiKey: req.query.apiKey });
+                    this.sendMcpError(res, req.body?.id || null, -32001, errorMessage, 200 // JSON-RPC errors should use HTTP 200 for proper client handling
+                    );
                 }
-                setBotEnabled(id, true);
-                res.json({ success: true, botId: id, enabled: true });
-            }
-            catch (error) {
-                req.logger.error('Failed to enable bot', { botId: id, error });
-                res.status(500).json({ error: 'Failed to enable bot' });
-            }
-        });
-        // POST /api/bots/:id/disable - Disable a bot
-        this.app.post('/api/bots/:id/disable', async (req, res) => {
-            const { id } = req.params;
-            req.logger.info('Disable bot requested', { botId: id });
-            try {
-                const { AVAILABLE_BOTS, setBotEnabled } = await Promise.resolve().then(() => __importStar(require('./mcp/tools/bot-config')));
-                const bot = AVAILABLE_BOTS.find(b => b.id === id);
-                if (!bot) {
-                    return res.status(404).json({ error: `Unknown bot: ${id}` });
+                else {
+                    req.logger.error('MCP handler error', error, { apiKey: req.query.apiKey });
+                    this.sendMcpError(res, req.body?.id || null, -32000, `Server error: ${errorMessage}`, 500);
                 }
-                setBotEnabled(id, false);
-                res.json({ success: true, botId: id, enabled: false });
-            }
-            catch (error) {
-                req.logger.error('Failed to disable bot', { botId: id, error });
-                res.status(500).json({ error: 'Failed to disable bot' });
             }
         });
-        // POST /api/bots/:id/toggle - Toggle a bot
-        this.app.post('/api/bots/:id/toggle', async (req, res) => {
-            const { id } = req.params;
-            req.logger.info('Toggle bot requested', { botId: id });
-            try {
-                const { AVAILABLE_BOTS, getBotState, setBotEnabled } = await Promise.resolve().then(() => __importStar(require('./mcp/tools/bot-config')));
-                const bot = AVAILABLE_BOTS.find(b => b.id === id);
-                if (!bot) {
-                    return res.status(404).json({ error: `Unknown bot: ${id}` });
+        // ===== Bot Configuration API (only when MCP_CLIENT_ENABLED=true) =====
+        if (config_1.environment.MCP_CLIENT_ENABLED) {
+            // GET /api/bots - List all bots and their status
+            this.app.get('/api/bots', async (req, res) => {
+                req.logger.debug('List bots requested');
+                try {
+                    const { AVAILABLE_BOTS, getBotState } = await Promise.resolve().then(() => __importStar(require('./bot-config')));
+                    const state = getBotState();
+                    const bots = AVAILABLE_BOTS.map(bot => ({
+                        ...bot,
+                        enabled: state[bot.id] || false
+                    }));
+                    res.json({ bots });
+                }
+                catch (error) {
+                    req.logger.error('Failed to list bots', { error });
+                    res.status(500).json({ error: 'Failed to list bots' });
                 }
-                const currentState = getBotState();
-                const newState = !currentState[id];
-                setBotEnabled(id, newState);
-                res.json({ success: true, botId: id, enabled: newState });
-            }
-            catch (error) {
-                req.logger.error('Failed to toggle bot', { botId: id, error });
-                res.status(500).json({ error: 'Failed to toggle bot' });
-            }
-        });
-        // ===== Bot Config Webhook API =====
-        // Get secure webhook path (auto-generated token)
-        const webhookPath = (0, webhook_handler_1.getWebhookPath)();
-        // POST /webhook/{token} - Receives updates from Hailer workflow webhooks
-        this.app.post(webhookPath, (req, res) => {
-            req.logger.info('Bot config webhook received', {
-                activityId: req.body?._id,
-                activityName: req.body?.name,
-                workspaceId: req.body?.cid,
             });
-            try {
-                const result = (0, webhook_handler_1.handleBotConfigWebhook)(req.body);
-                if (result.success) {
-                    req.logger.info('Bot config updated via webhook', {
-                        action: result.action,
-                        workspaceId: result.workspaceId,
-                        botType: result.botType,
-                    });
-                    res.status(200).json(result);
+            // POST /api/bots/:id/enable - Enable a bot
+            this.app.post('/api/bots/:id/enable', async (req, res) => {
+                const { id } = req.params;
+                req.logger.info('Enable bot requested', { botId: id });
+                try {
+                    const { AVAILABLE_BOTS, setBotEnabled } = await Promise.resolve().then(() => __importStar(require('./bot-config')));
+                    const bot = AVAILABLE_BOTS.find(b => b.id === id);
+                    if (!bot) {
+                        return res.status(404).json({ error: `Unknown bot: ${id}` });
+                    }
+                    setBotEnabled(id, true);
+                    res.json({ success: true, botId: id, enabled: true });
                 }
-                else {
-                    req.logger.warn('Bot config webhook failed', { error: result.error });
-                    res.status(400).json(result);
+                catch (error) {
+                    req.logger.error('Failed to enable bot', { botId: id, error });
+                    res.status(500).json({ error: 'Failed to enable bot' });
                 }
-            }
-            catch (error) {
-                req.logger.error('Bot config webhook error', { error });
-                res.status(500).json({
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Internal error',
+            });
+            // POST /api/bots/:id/disable - Disable a bot
+            this.app.post('/api/bots/:id/disable', async (req, res) => {
+                const { id } = req.params;
+                req.logger.info('Disable bot requested', { botId: id });
+                try {
+                    const { AVAILABLE_BOTS, setBotEnabled } = await Promise.resolve().then(() => __importStar(require('./bot-config')));
+                    const bot = AVAILABLE_BOTS.find(b => b.id === id);
+                    if (!bot) {
+                        return res.status(404).json({ error: `Unknown bot: ${id}` });
+                    }
+                    setBotEnabled(id, false);
+                    res.json({ success: true, botId: id, enabled: false });
+                }
+                catch (error) {
+                    req.logger.error('Failed to disable bot', { botId: id, error });
+                    res.status(500).json({ error: 'Failed to disable bot' });
+                }
+            });
+            // POST /api/bots/:id/toggle - Toggle a bot
+            this.app.post('/api/bots/:id/toggle', async (req, res) => {
+                const { id } = req.params;
+                req.logger.info('Toggle bot requested', { botId: id });
+                try {
+                    const { AVAILABLE_BOTS, getBotState, setBotEnabled } = await Promise.resolve().then(() => __importStar(require('./bot-config')));
+                    const bot = AVAILABLE_BOTS.find(b => b.id === id);
+                    if (!bot) {
+                        return res.status(404).json({ error: `Unknown bot: ${id}` });
+                    }
+                    const currentState = getBotState();
+                    const newState = !currentState[id];
+                    setBotEnabled(id, newState);
+                    res.json({ success: true, botId: id, enabled: newState });
+                }
+                catch (error) {
+                    req.logger.error('Failed to toggle bot', { botId: id, error });
+                    res.status(500).json({ error: 'Failed to toggle bot' });
+                }
+            });
+            // ===== Bot Config Webhook API =====
+            // Get secure webhook path (auto-generated token) - null if disabled
+            const webhookPath = (0, webhook_handler_1.getWebhookPath)();
+            if (webhookPath) {
+                // POST /webhook/{token} - Receives updates from Hailer workflow webhooks
+                this.app.post(webhookPath, (req, res) => {
+                    req.logger.info('Bot config webhook received', {
+                        activityId: req.body?._id,
+                        activityName: req.body?.name,
+                        workspaceId: req.body?.cid,
+                    });
+                    try {
+                        const result = (0, webhook_handler_1.handleBotConfigWebhook)(req.body);
+                        if (result.success) {
+                            req.logger.info('Bot config updated via webhook', {
+                                action: result.action,
+                                workspaceId: result.workspaceId,
+                                botType: result.botType,
+                            });
+                            res.status(200).json(result);
+                        }
+                        else {
+                            req.logger.warn('Bot config webhook failed', { error: result.error });
+                            res.status(400).json(result);
+                        }
+                    }
+                    catch (error) {
+                        req.logger.error('Bot config webhook error', { error });
+                        res.status(500).json({
+                            success: false,
+                            error: error instanceof Error ? error.message : 'Internal error',
+                        });
+                    }
+                });
+                // GET /webhook/{token}/status - Status endpoint to see all workspace configs
+                this.app.get(`${webhookPath}/status`, (_req, res) => {
+                    const configs = (0, webhook_handler_1.listWorkspaceConfigs)();
+                    res.json({
+                        timestamp: new Date().toISOString(),
+                        workspaceCount: configs.length,
+                        workspaces: configs.map((c) => ({
+                            workspaceId: c.workspaceId,
+                            workspaceName: c.workspaceName,
+                            hasOrchestrator: !!c.orchestrator,
+                            specialistCount: c.specialists.length,
+                            enabledSpecialists: c.specialists.filter((s) => s.enabled).length,
+                            lastSynced: c.lastSynced,
+                        })),
+                    });
                 });
             }
-        });
-        // GET /webhook/{token}/status - Status endpoint to see all workspace configs
-        this.app.get(`${webhookPath}/status`, (_req, res) => {
-            const configs = (0, webhook_handler_1.listWorkspaceConfigs)();
-            res.json({
-                timestamp: new Date().toISOString(),
-                workspaceCount: configs.length,
-                workspaces: configs.map((c) => ({
-                    workspaceId: c.workspaceId,
-                    workspaceName: c.workspaceName,
-                    hasOrchestrator: !!c.orchestrator,
-                    specialistCount: c.specialists.length,
-                    enabledSpecialists: c.specialists.filter((s) => s.enabled).length,
-                    lastSynced: c.lastSynced,
-                })),
+            else {
+                this.logger.info('Webhook endpoint disabled (no WEBHOOK_TOKEN)');
+            }
+            this.logger.debug('Routes configured', {
+                routes: [
+                    '/health',
+                    '/daemon/status',
+                    '/api/mcp',
+                    '/api/bots'
+                ]
             });
-        });
-        this.logger.debug('Routes configured', {
-            routes: [
-                '/health',
-                '/daemon/status',
-                '/api/mcp',
-                '/api/bots'
-            ]
-        });
+        }
+        else {
+            this.logger.debug('Routes configured', {
+                routes: [
+                    '/health',
+                    '/daemon/status',
+                    '/api/mcp'
+                ]
+            });
+        }
     }
     /**
      * Check if agent has access to a specific tool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hailer/mcp",
-  "version": "0.1.16",
+  "version": "0.2.1",
   "config": {
     "docker": {
       "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"