@hailer/mcp 0.1.10 → 0.1.12

package/dist/mcp/tools/bot-config.js

@@ -0,0 +1,442 @@
+"use strict";
+/**
+ * Bot Configuration MCP Tools
+ *
+ * Manages which bots are enabled/disabled in the workspace.
+ * Config is stored in the Agent Directory workflow - agents are activities.
+ * - Deployed agents phase = enabled
+ * - Retired agents phase = disabled
+ *
+ * Architecture:
+ * - In-memory state is primary (for speed)
+ * - Agent Directory workflow is persistence layer (agents as activities, phases for state)
+ * - On startup: Load config from Hailer by checking which phase each agent is in
+ * - On change: Move agent activity between phases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.botConfigTools = exports.disableBotTool = exports.enableBotTool = exports.listBotsConfigTool = exports.AVAILABLE_BOTS = void 0;
+exports.onBotStateChange = onBotStateChange;
+exports.getBotState = getBotState;
+exports.setBotEnabled = setBotEnabled;
+exports.initBotConfigPersistence = initBotConfigPersistence;
+exports.isPersistenceInitialized = isPersistenceInitialized;
+exports.getPersistenceStatus = getPersistenceStatus;
+const zod_1 = require("zod");
+const tool_registry_1 = require("../tool-registry");
+const index_1 = require("../utils/index");
+const logger = (0, index_1.createLogger)({ component: 'bot-config-tools' });
+// ============================================================================
+// Agent Directory Workflow Configuration
+// ============================================================================
+// Agent Directory workflow config
+const AGENT_DIRECTORY_WORKFLOW_ID = '695784898d347a6c707ee365';
+const DEPLOYED_PHASE_ID = '695784898d347a6c707ee37d'; // enabled
+const RETIRED_PHASE_ID = '695784898d347a6c707ee37e'; // disabled
+// Mapping from bot IDs to their activity IDs in the Agent Directory workflow
+const AGENT_ACTIVITY_IDS = {
+    hal: '6957848b8d347a6c707ee3f6',
+    hailerExpert: '695784913c659fc4d8fe0e02',
+    giuseppe: '695e42deca61319424bc8b23',
+    vastuullisuus: '695e42dfca61319424bc8b2e'
+};
+// Persistence state
+let persistenceInitialized = false;
+let hailerClient = null; // Will be set during initialization
+/**
+ * Available bots - single source of truth
+ *
+ * All bots that can be enabled/disabled in the workspace.
+ * This list should match the AI Hub app and agent definitions.
+ */
+exports.AVAILABLE_BOTS = [
+    {
+        id: 'hal',
+        name: 'HAL',
+        description: 'Main orchestrator - handles general chat and coordinates specialists',
+        icon: '🤖'
+    },
+    {
+        id: 'giuseppe',
+        name: 'Giuseppe',
+        description: 'Bug fixing specialist - analyzes and repairs Hailer app issues',
+        icon: '🔧'
+    },
+    {
+        id: 'hailerExpert',
+        name: 'Hailer Expert',
+        description: 'Workflow & data specialist - bulk operations, insights, reports',
+        icon: '📊'
+    },
+    {
+        id: 'vastuullisuus',
+        name: 'Vastuullisuus',
+        description: 'Sustainability analysis for SMEs',
+        icon: '🌱'
+    }
+];
+// In-memory bot state (will be synced with workflow)
+const botState = {
+    hal: true, // HAL enabled by default
+    giuseppe: false,
+    hailerExpert: false,
+    vastuullisuus: false
+};
+// Callbacks for when bot state changes
+const stateChangeCallbacks = [];
+function onBotStateChange(callback) {
+    stateChangeCallbacks.push(callback);
+}
+function getBotState() {
+    return { ...botState };
+}
+/**
+ * Set bot enabled state
+ *
+ * Updates in-memory state and persists to Agent Directory by moving
+ * the agent activity to the appropriate phase (deployed/retired).
+ */
+function setBotEnabled(botId, enabled) {
+    if (!exports.AVAILABLE_BOTS.find(b => b.id === botId)) {
+        throw new Error(`Unknown bot: ${botId}`);
+    }
+    botState[botId] = enabled;
+    // Notify listeners
+    stateChangeCallbacks.forEach(cb => cb(botId, enabled));
+    logger.info('Bot state changed', { botId, enabled });
+    // Persist single bot to Hailer asynchronously (more efficient than full sync)
+    persistBotToHailer(botId, enabled).catch(err => logger.warn('Persistence failed', { botId, err: err instanceof Error ? err.message : String(err) }));
+}
+// ============================================================================
+// Persistence Layer Functions
+// ============================================================================
+/**
+ * Initialize persistence layer
+ * Called once during MCP server startup
+ *
+ * Loads agent enabled state from the Agent Directory workflow:
+ * - Agents in DEPLOYED_PHASE_ID are enabled
+ * - Agents in RETIRED_PHASE_ID are disabled
+ *
+ * @param client - HailerApiClient instance for API calls
+ */
+async function initBotConfigPersistence(client) {
+    if (persistenceInitialized) {
+        logger.debug('Bot config persistence already initialized');
+        return;
+    }
+    hailerClient = client;
+    try {
+        logger.info('Initializing bot config persistence from Agent Directory...', {
+            workflowId: AGENT_DIRECTORY_WORKFLOW_ID,
+            deployedPhaseId: DEPLOYED_PHASE_ID,
+            retiredPhaseId: RETIRED_PHASE_ID
+        });
+        // Load agent state from Agent Directory workflow
+        const existingConfig = await loadConfigFromHailer();
+        if (existingConfig) {
+            // Update in-memory state with persisted values
+            Object.keys(existingConfig).forEach(botId => {
+                if (exports.AVAILABLE_BOTS.find(b => b.id === botId)) {
+                    botState[botId] = existingConfig[botId];
+                }
+            });
+            logger.info('Bot config loaded from Agent Directory', {
+                config: botState
+            });
+        }
+        logger.info('Bot config persistence initialized');
+        persistenceInitialized = true;
+    }
+    catch (error) {
+        logger.warn('Failed to initialize bot config persistence, using defaults', {
+            error: error instanceof Error ? error.message : String(error)
+        });
+        // Still mark as initialized to prevent repeated failures
+        persistenceInitialized = true;
+    }
+}
+/**
+ * Load config from Agent Directory workflow
+ *
+ * Checks which phase each agent activity is in:
+ * - DEPLOYED_PHASE_ID = enabled
+ * - RETIRED_PHASE_ID = disabled
+ *
+ * @returns bot config or null if not found
+ */
+async function loadConfigFromHailer() {
+    if (!hailerClient) {
+        logger.debug('Cannot load config: missing Hailer client');
+        return null;
+    }
+    try {
+        const config = {};
+        // Create reverse mapping: activityId -> botId
+        const activityIdToBotId = {};
+        for (const [botId, activityId] of Object.entries(AGENT_ACTIVITY_IDS)) {
+            activityIdToBotId[activityId] = botId;
+        }
+        // Fetch activities from deployed phase (enabled agents)
+        logger.debug('Fetching deployed agents...', { phaseId: DEPLOYED_PHASE_ID });
+        const deployedActivities = await hailerClient.fetchActivityList(AGENT_DIRECTORY_WORKFLOW_ID, DEPLOYED_PHASE_ID, 100, // limit
+        { returnFlat: true });
+        // Mark agents in deployed phase as enabled
+        const deployedList = Array.isArray(deployedActivities)
+            ? deployedActivities
+            : (deployedActivities?.activities || []);
+        for (const activity of deployedList) {
+            const botId = activityIdToBotId[activity._id];
+            if (botId) {
+                config[botId] = true;
+                logger.debug('Agent found in deployed phase (enabled)', { botId, activityId: activity._id });
+            }
+        }
+        // Fetch activities from retired phase (disabled agents)
+        logger.debug('Fetching retired agents...', { phaseId: RETIRED_PHASE_ID });
+        const retiredActivities = await hailerClient.fetchActivityList(AGENT_DIRECTORY_WORKFLOW_ID, RETIRED_PHASE_ID, 100, // limit
+        { returnFlat: true });
+        // Mark agents in retired phase as disabled
+        const retiredList = Array.isArray(retiredActivities)
+            ? retiredActivities
+            : (retiredActivities?.activities || []);
+        for (const activity of retiredList) {
+            const botId = activityIdToBotId[activity._id];
+            if (botId) {
+                config[botId] = false;
+                logger.debug('Agent found in retired phase (disabled)', { botId, activityId: activity._id });
+            }
+        }
+        // For any bots not found in either phase, default based on AVAILABLE_BOTS defaults
+        for (const bot of exports.AVAILABLE_BOTS) {
+            if (config[bot.id] === undefined) {
+                // Default: HAL enabled, others disabled
+                config[bot.id] = bot.id === 'hal';
+                logger.debug('Agent not found in any phase, using default', {
+                    botId: bot.id,
+                    default: config[bot.id]
+                });
+            }
+        }
+        logger.info('Bot config loaded from Agent Directory', {
+            deployedCount: deployedList.length,
+            retiredCount: retiredList.length,
+            config
+        });
+        return config;
+    }
+    catch (error) {
+        logger.warn('Failed to load bot config from Agent Directory', {
+            error: error instanceof Error ? error.message : String(error)
+        });
+        return null;
+    }
+}
+/**
+ * Persist a single bot's state to Hailer
+ *
+ * Moves the bot's agent activity between phases:
+ * - enabled = move to DEPLOYED_PHASE_ID
+ * - disabled = move to RETIRED_PHASE_ID
+ *
+ * @param botId - The bot ID to persist
+ * @param enabled - Whether the bot is enabled
+ */
+async function persistBotToHailer(botId, enabled) {
+    if (!hailerClient || !persistenceInitialized) {
+        logger.debug('Persistence not initialized, skipping save');
+        return;
+    }
+    const activityId = AGENT_ACTIVITY_IDS[botId];
+    if (!activityId) {
+        logger.warn('No activity ID found for bot', { botId });
+        return;
+    }
+    const targetPhaseId = enabled ? DEPLOYED_PHASE_ID : RETIRED_PHASE_ID;
+    try {
+        logger.debug('Moving agent to phase...', {
+            botId,
+            activityId,
+            enabled,
+            targetPhaseId
+        });
+        // Use updateActivities to move the agent activity to the appropriate phase
+        await hailerClient.updateActivities([{ _id: activityId }], { phaseId: targetPhaseId });
+        logger.info('Agent moved to phase', {
+            botId,
+            activityId,
+            phase: enabled ? 'deployed' : 'retired',
+            phaseId: targetPhaseId
+        });
+    }
+    catch (error) {
+        logger.warn('Failed to persist bot state to Hailer', {
+            botId,
+            activityId,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+}
+/**
+ * Save current bot state to Hailer (legacy function for full sync)
+ * Called asynchronously after state changes
+ *
+ * Note: This syncs all bots. For single bot changes, persistBotToHailer is more efficient.
+ */
+async function persistToHailer() {
+    if (!hailerClient || !persistenceInitialized) {
+        logger.debug('Persistence not initialized, skipping save');
+        return;
+    }
+    try {
+        logger.debug('Persisting all bot config to Hailer...', { state: botState });
+        // Build updates for all bots
+        const enabledUpdates = [];
+        const disabledUpdates = [];
+        for (const [botId, enabled] of Object.entries(botState)) {
+            const activityId = AGENT_ACTIVITY_IDS[botId];
+            if (!activityId) {
+                logger.debug('No activity ID for bot, skipping', { botId });
+                continue;
+            }
+            if (enabled) {
+                enabledUpdates.push({ _id: activityId });
+            }
+            else {
+                disabledUpdates.push({ _id: activityId });
+            }
+        }
+        // Move enabled agents to deployed phase
+        if (enabledUpdates.length > 0) {
+            await hailerClient.updateActivities(enabledUpdates, { phaseId: DEPLOYED_PHASE_ID });
+            logger.debug('Moved agents to deployed phase', {
+                count: enabledUpdates.length,
+                phaseId: DEPLOYED_PHASE_ID
+            });
+        }
+        // Move disabled agents to retired phase
+        if (disabledUpdates.length > 0) {
+            await hailerClient.updateActivities(disabledUpdates, { phaseId: RETIRED_PHASE_ID });
+            logger.debug('Moved agents to retired phase', {
+                count: disabledUpdates.length,
+                phaseId: RETIRED_PHASE_ID
+            });
+        }
+        logger.info('Bot config persisted to Agent Directory', {
+            enabledCount: enabledUpdates.length,
+            disabledCount: disabledUpdates.length
+        });
+    }
+    catch (error) {
+        logger.warn('Failed to persist bot config to Hailer', {
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+}
+/**
+ * Check if persistence is initialized
+ */
+function isPersistenceInitialized() {
+    return persistenceInitialized;
+}
+/**
+ * Get persistence status info (for debugging)
+ */
+function getPersistenceStatus() {
+    return {
+        initialized: persistenceInitialized,
+        workflowId: AGENT_DIRECTORY_WORKFLOW_ID,
+        deployedPhaseId: DEPLOYED_PHASE_ID,
+        retiredPhaseId: RETIRED_PHASE_ID,
+        agentActivityIds: { ...AGENT_ACTIVITY_IDS },
+        hasClient: hailerClient !== null
+    };
+}
+/**
+ * List available bots and their status
+ */
+exports.listBotsConfigTool = {
+    name: 'list_bots_config',
+    group: tool_registry_1.ToolGroup.READ,
+    description: 'List available AI bots and their enabled/disabled status',
+    schema: zod_1.z.object({}),
+    execute: async (_params, _context) => {
+        const bots = exports.AVAILABLE_BOTS.map(bot => ({
+            ...bot,
+            enabled: botState[bot.id] || false
+        }));
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ bots }, null, 2)
+                }]
+        };
+    }
+};
+/**
+ * Enable a bot
+ */
+exports.enableBotTool = {
+    name: 'enable_bot',
+    group: tool_registry_1.ToolGroup.WRITE,
+    description: 'Enable an AI bot in this workspace',
+    schema: zod_1.z.object({
+        botId: zod_1.z.string().describe('Bot ID to enable (hal, giuseppe, hailerExpert, vastuullisuus)')
+    }),
+    execute: async (params, _context) => {
+        const { botId } = params;
+        if (!exports.AVAILABLE_BOTS.find(b => b.id === botId)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Unknown bot: ${botId}. Available: ${exports.AVAILABLE_BOTS.map(b => b.id).join(', ')}`
+                    }],
+                isError: true
+            };
+        }
+        // Use setBotEnabled to trigger persistence
+        setBotEnabled(botId, true);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${botId} bot enabled`
+                }]
+        };
+    }
+};
+/**
+ * Disable a bot
+ */
+exports.disableBotTool = {
+    name: 'disable_bot',
+    group: tool_registry_1.ToolGroup.WRITE,
+    description: 'Disable an AI bot in this workspace',
+    schema: zod_1.z.object({
+        botId: zod_1.z.string().describe('Bot ID to disable (hal, giuseppe, hailerExpert, vastuullisuus)')
+    }),
+    execute: async (params, _context) => {
+        const { botId } = params;
+        if (!exports.AVAILABLE_BOTS.find(b => b.id === botId)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Unknown bot: ${botId}. Available: ${exports.AVAILABLE_BOTS.map(b => b.id).join(', ')}`
+                    }],
+                isError: true
+            };
+        }
+        // Use setBotEnabled to trigger persistence
+        setBotEnabled(botId, false);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${botId} bot disabled`
+                }]
+        };
+    }
+};
+exports.botConfigTools = [
+    exports.listBotsConfigTool,
+    exports.enableBotTool,
+    exports.disableBotTool
+];
+//# sourceMappingURL=bot-config.js.map

package/dist/mcp-server.js

@@ -5,6 +5,39 @@
  * Implements JSON-RPC 2.0 MCP protocol over HTTP with Server-Sent Events (SSE)
  * for LLM clients (Claude Desktop, etc.)
  */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -218,11 +251,86 @@ class MCPServerService {
                 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}` });
+                }
+                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}` });
+                }
+                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}` });
+                }
+                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' });
+            }
+        });
         this.logger.info('Routes configured', {
             routes: [
                 '/health - Server health check',
                 '/daemon/status - Daemon context monitor',
-                '/api/mcp - MCP protocol (JSON-RPC 2.0)'
+                '/api/mcp - MCP protocol (JSON-RPC 2.0)',
+                '/api/bots - Bot configuration API'
             ]
         });
     }

package/dist/modules/bug-reports/bug-config.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bug Reports Module - Configuration Discovery
+ *
+ * Discovers Bug Reports workflow by name pattern.
+ * No hardcoded IDs - works in any workspace.
+ */
+import type { UserContext } from '../../mcp/UserContextCache';
+import type { BugReportsConfig, WorkflowDiscoveryResult } from './types';
+/**
+ * Discover Bug Reports workflow in a workspace
+ */
+export declare function discoverWorkflow(userContext: UserContext, config: BugReportsConfig): Promise<WorkflowDiscoveryResult | null>;
+/**
+ * Load config from MCP Config workflow or environment
+ */
+export declare function loadConfig(userContext: UserContext): Promise<BugReportsConfig>;
+/**
+ * Get default configuration
+ */
+export declare function getDefaultConfig(): BugReportsConfig;
+/**
+ * Save config back to Hailer (creates/updates config activity)
+ */
+export declare function saveConfig(userContext: UserContext, config: BugReportsConfig): Promise<boolean>;
+//# sourceMappingURL=bug-config.d.ts.map