@hailer/mcp 1.1.14 → 1.1.16

package/dist/agents/factory.js

@@ -0,0 +1,706 @@
+"use strict";
+/**
+ * Daemon Factory
+ *
+ * Creates and manages agent daemons in orchestrator mode:
+ * - One orchestrator (HAL) handles general conversation
+ * - Specialist daemons handle complex domain-specific tasks
+ *
+ * Uses BotContext for credential management (workspace isolation).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonManager = void 0;
+exports.createDaemonManager = createDaemonManager;
+exports.startDaemonMode = startDaemonMode;
+exports.createStandaloneBugFixer = createStandaloneBugFixer;
+const daemon_1 = require("./hal/daemon");
+const specialist_1 = require("./shared/specialist");
+const specialist_daemon_1 = require("./bug-fixer/specialist-daemon");
+const definitions_1 = require("./hal/definitions");
+const bot_manager_1 = require("./bot-manager");
+const config_1 = require("../config");
+const logger_1 = require("../lib/logger");
+const bot_config_1 = require("../bot-config");
+const hailer_clients_1 = require("../mcp/hailer-clients");
+const UserContextCache_1 = require("../mcp/UserContextCache");
+const bot_config_2 = require("../bot-config");
+const tool_registry_1 = require("../mcp/tool-registry");
+const logger = (0, logger_1.createLogger)({ component: "DaemonFactory" });
+/**
+ * Map botType from Agent Directory to specialist key
+ * botType values come from the Agent Directory workflow
+ */
+function mapBotTypeToSpecialistKey(botType) {
+    if (!botType)
+        return null;
+    const mapping = {
+        'workflow-expert': 'hailerExpert',
+        'bug-fixer': 'bugFixer',
+        // Add more mappings as new specialists are added
+    };
+    return mapping[botType] || null;
+}
+/**
+ * Manages orchestrator + specialist daemons
+ */
+class DaemonManager {
+    daemons = new Map();
+    orchestrator = null;
+    specialists = new Map();
+    botManager;
+    options;
+    botTypeMap;
+    displayNameMap;
+    constructor(botManager, options) {
+        this.botManager = botManager;
+        this.options = options;
+        this.botTypeMap = options.botTypeMap || new Map();
+        this.displayNameMap = options.displayNameMap || new Map();
+    }
+    /**
+     * Get the workspace ID this daemon manager is running for
+     */
+    getWorkspaceId() {
+        return this.options.workspaceId;
+    }
+    /**
+     * Orchestrator mode: one orchestrator (HAL) + specialist daemons
+     */
+    async startOrchestratorMode() {
+        const botClients = this.botManager.getAllBotClients();
+        logger.info("Starting daemons in ORCHESTRATOR mode", {
+            botCount: botClients.length,
+        });
+        // Find orchestrator bot
+        let orchestratorClient;
+        const specialistClients = new Map();
+        for (const botClient of botClients) {
+            const email = botClient.config.email;
+            const botType = this.botTypeMap.get(botClient.userId) || null;
+            // Check if this is the orchestrator (by email match, botType, or first bot fallback)
+            if (this.options.orchestratorEmail === email ||
+                botType === 'orchestrator' ||
+                (!this.options.orchestratorEmail && !orchestratorClient)) {
+                orchestratorClient = botClient;
+                continue;
+            }
+            // Check if this matches a specialist
+            if (this.options.specialistEmails) {
+                for (const [specialistKey, specialistEmail] of Object.entries(this.options.specialistEmails)) {
+                    if (email === specialistEmail) {
+                        specialistClients.set(specialistKey, botClient);
+                        break;
+                    }
+                }
+            }
+            else {
+                // Auto-assign based on botType from workspace config
+                const specialistKey = mapBotTypeToSpecialistKey(botType);
+                if (specialistKey && definitions_1.SPECIALISTS[specialistKey]) {
+                    specialistClients.set(specialistKey, botClient);
+                }
+                else {
+                    // Fallback: assign to first available specialist
+                    for (const key of Object.keys(definitions_1.SPECIALISTS)) {
+                        if (!specialistClients.has(key)) {
+                            specialistClients.set(key, botClient);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (!orchestratorClient) {
+            throw new Error("No orchestrator bot found");
+        }
+        // Create specialist user ID map for orchestrator
+        const specialistUserIds = new Map();
+        for (const [key, client] of specialistClients) {
+            specialistUserIds.set(key, client.userId);
+        }
+        // Start orchestrator
+        const orchestratorConfig = {
+            botClient: orchestratorClient,
+            mcpServerUrl: this.options.mcpServerUrl,
+            anthropicApiKey: this.options.anthropicApiKey,
+            model: this.options.model,
+            specialistUserIds,
+            useStructuredOutputs: this.options.useStructuredOutputs,
+        };
+        this.orchestrator = new daemon_1.OrchestratorDaemon(orchestratorConfig);
+        await this.orchestrator.initialize();
+        // Register specialist user IDs with orchestrator (with display names from workspace)
+        for (const [key, userId] of specialistUserIds) {
+            const displayName = this.displayNameMap.get(userId) || this.botManager.getUserName(userId);
+            this.orchestrator.registerSpecialistUserId(key, userId, displayName);
+        }
+        this.daemons.set(orchestratorClient.userId, this.orchestrator);
+        // Subscribe to bot state changes to update specialist availability
+        (0, bot_config_1.onBotStateChange)((userId, enabled) => {
+            const botType = this.botTypeMap.get(userId) || null;
+            // Skip orchestrator changes (handled by daemon restart)
+            if (botType === 'orchestrator')
+                return;
+            // Find the specialist key for this user
+            const specialistKey = mapBotTypeToSpecialistKey(botType);
+            if (!specialistKey) {
+                logger.debug('No specialist mapping for botType', { userId, botType });
+                return;
+            }
+            if (enabled) {
+                // Re-register the specialist (with display name from workspace)
+                const displayName = this.displayNameMap.get(userId) || this.botManager.getUserName(userId);
+                this.orchestrator?.registerSpecialistUserId(specialistKey, userId, displayName);
+                logger.info('Specialist re-enabled', { specialistKey, userId, displayName });
+            }
+            else {
+                // Unregister the specialist
+                this.orchestrator?.unregisterSpecialist(specialistKey);
+                logger.info('Specialist disabled', { specialistKey, userId });
+            }
+        });
+        // Start specialist daemons
+        for (const [specialistKey, botClient] of specialistClients) {
+            const specialistDef = definitions_1.SPECIALISTS[specialistKey];
+            if (!specialistDef) {
+                logger.warn("Unknown specialist key", { key: specialistKey });
+                continue;
+            }
+            // Clone the specialist to avoid cross-workspace contamination
+            const specialist = { ...specialistDef, botUserId: botClient.userId };
+            let specialistDaemon;
+            // Create BugFixerSpecialistDaemon for bugFixer (has actual bug fixing code)
+            if (specialistKey === 'bugFixer') {
+                const userContext = await UserContextCache_1.UserContextCache.getContext(botClient.config.mcpServerApiKey);
+                const bugFixerConfig = {
+                    botClient,
+                    mcpServerUrl: this.options.mcpServerUrl,
+                    anthropicApiKey: this.options.anthropicApiKey,
+                    model: specialist.model || this.options.model,
+                    specialist,
+                    userContext,
+                };
+                specialistDaemon = new specialist_daemon_1.BugFixerSpecialistDaemon(bugFixerConfig);
+            }
+            else {
+                const specialistConfig = {
+                    botClient,
+                    mcpServerUrl: this.options.mcpServerUrl,
+                    anthropicApiKey: this.options.anthropicApiKey,
+                    model: specialist.model || this.options.model,
+                    specialist,
+                };
+                specialistDaemon = new specialist_1.SpecialistDaemon(specialistConfig);
+            }
+            await specialistDaemon.initialize();
+            this.specialists.set(specialistKey, specialistDaemon);
+            this.daemons.set(botClient.userId, specialistDaemon);
+            logger.info("Specialist daemon started", {
+                key: specialistKey,
+                name: specialist.name,
+            });
+        }
+        logger.info("Orchestrator started", {
+            specialistCount: this.specialists.size,
+            totalDaemons: this.daemons.size,
+        });
+    }
+    /**
+     * Stop all daemons
+     * Flushes session logs for each daemon before stopping
+     */
+    async stopAll() {
+        const stopPromises = Array.from(this.daemons.entries()).map(async ([botId, daemon]) => {
+            await daemon.stop();
+            logger.info("Daemon stopped", { botId });
+        });
+        await Promise.all(stopPromises);
+        this.daemons.clear();
+    }
+    /**
+     * Get daemon for a specific bot
+     */
+    getDaemon(botId) {
+        return this.daemons.get(botId);
+    }
+    /**
+     * Get status of all daemons
+     */
+    getStatus() {
+        return Array.from(this.daemons.entries()).map(([botId, daemon]) => ({
+            botId,
+            state: daemon.getConversationState(),
+        }));
+    }
+    /**
+     * Log current status to console (for monitoring)
+     */
+    logStatus() {
+        const orchStatus = this.orchestrator?.getOrchestratorStatus();
+        logger.info("Daemon status", {
+            orchestrator: orchStatus ? {
+                discussions: orchStatus.conversationState.discussionCount,
+                processing: orchStatus.conversationState.isProcessing,
+                specialists: orchStatus.specialists.filter(s => s.available).length,
+            } : null,
+            specialistCount: this.specialists.size,
+            totalDaemons: this.daemons.size,
+        });
+    }
+    /**
+     * Get orchestrator instance (only in orchestrator mode)
+     */
+    getOrchestrator() {
+        return this.orchestrator;
+    }
+    /**
+     * Get the workspace schema cache from the orchestrator
+     * Used by other modules that need dynamic workflow/field ID lookup
+     */
+    getSchemaCache() {
+        return this.orchestrator?.getSchemaCache() ?? null;
+    }
+    /**
+     * Get specialist by key (only in orchestrator mode)
+     */
+    getSpecialist(key) {
+        return this.specialists.get(key);
+    }
+    /**
+     * Register a standalone daemon (for standalone Bug Fixer mode)
+     */
+    registerStandaloneDaemon(userId, daemon) {
+        this.daemons.set(userId, daemon);
+        logger.info("Registered standalone daemon", { userId });
+    }
+    /**
+     * Check if running in orchestrator mode
+     */
+    isOrchestratorMode() {
+        return !!this.options.orchestratorMode;
+    }
+    /**
+     * Trigger HAL to respond in a discussion with context
+     */
+    async triggerHalResponse(discussionId, activityId, context) {
+        if (!this.orchestrator) {
+            logger.warn('Cannot trigger HAL response - orchestrator not running');
+            return;
+        }
+        await this.orchestrator.respondWithContext(discussionId, activityId, context);
+    }
+    /**
+     * Hot-reload: Start a specialist daemon dynamically
+     * Preserves orchestrator conversation context
+     */
+    async startSpecialist(email, password, botType, userId) {
+        const specialistKey = mapBotTypeToSpecialistKey(botType);
+        if (!specialistKey) {
+            logger.warn('Unknown botType for specialist', { botType });
+            return false;
+        }
+        // Check if already running
+        if (this.specialists.has(specialistKey)) {
+            logger.info('Specialist already running', { specialistKey });
+            return true;
+        }
+        const specialistDef = definitions_1.SPECIALISTS[specialistKey];
+        if (!specialistDef) {
+            logger.warn('Specialist definition not found', { specialistKey });
+            return false;
+        }
+        try {
+            // Initialize bot client
+            const actualUserId = userId || email;
+            // Bug Fixer specialists need BOT_INTERNAL tool access
+            const isBugFixer = botType === 'bugFixer' || botType === 'bug-fixer' || specialistKey === 'bugFixer';
+            const allowedGroups = isBugFixer
+                ? [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.BOT_INTERNAL]
+                : undefined;
+            const apiKey = (0, hailer_clients_1.registerBotCredentials)(actualUserId, email, password, { allowedGroups });
+            await this.botManager.initializeBotClient(email, password, apiKey);
+            const botClient = this.botManager.getBotClientByBotId(specialistKey) ||
+                Array.from(this.botManager.getAllBotClients())
+                    .find(bc => bc.config.email === email);
+            if (!botClient) {
+                logger.error('Failed to get bot client after initialization', { email: (0, config_1.maskEmail)(email) });
+                return false;
+            }
+            // Update botType map
+            this.botTypeMap.set(botClient.userId, botType);
+            // Clone the specialist to avoid cross-workspace contamination
+            const specialist = { ...specialistDef, botUserId: botClient.userId };
+            // Create and start specialist daemon
+            let specialistDaemon;
+            // Create BugFixerSpecialistDaemon for bugFixer (has actual bug fixing code)
+            if (specialistKey === 'bugFixer') {
+                const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
+                const bugFixerConfig = {
+                    botClient,
+                    mcpServerUrl: this.options.mcpServerUrl,
+                    anthropicApiKey: this.options.anthropicApiKey,
+                    model: specialist.model || this.options.model,
+                    specialist,
+                    userContext,
+                };
+                specialistDaemon = new specialist_daemon_1.BugFixerSpecialistDaemon(bugFixerConfig);
+            }
+            else {
+                const specialistConfig = {
+                    botClient,
+                    mcpServerUrl: this.options.mcpServerUrl,
+                    anthropicApiKey: this.options.anthropicApiKey,
+                    model: specialist.model || this.options.model,
+                    specialist,
+                };
+                specialistDaemon = new specialist_1.SpecialistDaemon(specialistConfig);
+            }
+            await specialistDaemon.initialize();
+            this.specialists.set(specialistKey, specialistDaemon);
+            this.daemons.set(botClient.userId, specialistDaemon);
+            // Register with orchestrator (with display name from workspace)
+            const displayName = this.displayNameMap.get(botClient.userId) || this.botManager.getUserName(botClient.userId);
+            this.orchestrator?.registerSpecialistUserId(specialistKey, botClient.userId, displayName);
+            // Register bot as enabled in state so message processing works
+            const workspaceId = this.getWorkspaceId();
+            if (workspaceId) {
+                (0, bot_config_1.setBotEnabled)(workspaceId, botClient.userId, true);
+                (0, bot_config_1.setBotUserId)(workspaceId, botClient.userId, botType);
+            }
+            logger.info('Specialist hot-loaded successfully', {
+                specialistKey,
+                name: specialist.name,
+                botId: botClient.userId,
+                email,
+            });
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to hot-load specialist', {
+                specialistKey,
+                email,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    /**
+     * Hot-reload: Stop a specialist daemon dynamically
+     * Preserves orchestrator conversation context
+     */
+    async stopSpecialist(botType) {
+        const specialistKey = mapBotTypeToSpecialistKey(botType);
+        if (!specialistKey) {
+            logger.warn('Unknown botType for specialist', { botType });
+            return false;
+        }
+        const specialistDaemon = this.specialists.get(specialistKey);
+        if (!specialistDaemon) {
+            logger.info('Specialist not running', { specialistKey });
+            return true;
+        }
+        try {
+            // Find botId by looking through daemons map
+            let botId;
+            for (const [id, daemon] of this.daemons) {
+                if (daemon === specialistDaemon) {
+                    botId = id;
+                    break;
+                }
+            }
+            // Unregister from orchestrator first
+            this.orchestrator?.unregisterSpecialist(specialistKey);
+            // Stop the daemon
+            await specialistDaemon.stop();
+            // Remove from maps
+            this.specialists.delete(specialistKey);
+            if (botId) {
+                this.daemons.delete(botId);
+                this.botTypeMap.delete(botId);
+                // Remove bot client connection
+                await this.botManager.removeBotClient(botId);
+            }
+            logger.info('Specialist stopped successfully', {
+                specialistKey,
+                botId,
+            });
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to stop specialist', {
+                specialistKey,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    /**
+     * Hot-reload a specialist (stop if running, start if enabled)
+     */
+    async hotReloadSpecialist(email, password, botType, enabled, userId) {
+        if (enabled) {
+            return this.startSpecialist(email, password, botType, userId);
+        }
+        else {
+            return this.stopSpecialist(botType);
+        }
+    }
+    /**
+     * Start periodic status logging
+     */
+    startStatusLogging(intervalMs = 30000) {
+        return setInterval(() => {
+            this.logStatus();
+        }, intervalMs);
+    }
+}
+exports.DaemonManager = DaemonManager;
+/**
+ * Create and start the daemon manager
+ * This is the main entry point for daemon mode
+ *
+ * Uses WorkspaceContext for credential management (workspace isolation).
+ *
+ * @param options - Optional settings for orchestrator mode
+ */
+async function createDaemonManager(options) {
+    const appConfig = (0, config_1.createApplicationConfig)();
+    const mcpClientConfig = appConfig.mcpClient;
+    if (!mcpClientConfig) {
+        logger.error("MCP Client not configured - cannot start daemon mode");
+        return null;
+    }
+    // Find Anthropic API key from providers
+    const anthropicProvider = mcpClientConfig.providers.find(p => p.type === "anthropic");
+    if (!anthropicProvider) {
+        logger.error("Anthropic provider not configured - daemon mode requires Anthropic");
+        return null;
+    }
+    // Create bot manager
+    const botManager = new bot_manager_1.MultiBotManager([]);
+    // Load workspaces from .bot-config/*.json via BotContext
+    const botContexts = (0, bot_config_2.loadBotConfigs)();
+    if (botContexts.length === 0) {
+        logger.warn('No workspace configs found in .bot-config/ - run npm run seed-config first');
+        return null;
+    }
+    // Find workspace with orchestrator
+    const botCtx = options?.workspaceId
+        ? botContexts.find(ctx => ctx.workspaceId === options.workspaceId && ctx.getOrchestratorCredentials())
+        : botContexts.find(ctx => ctx.getOrchestratorCredentials());
+    if (!botCtx) {
+        logger.error('No workspace with orchestrator found');
+        return null;
+    }
+    logger.info('Using workspace', {
+        workspaceId: botCtx.workspaceId,
+        workspaceName: botCtx.workspaceName
+    });
+    // Build botTypeMap and displayNameMap for runtime lookups
+    const botTypeMap = new Map();
+    const displayNameMap = new Map();
+    // Get orchestrator from BotContext
+    const orchCreds = botCtx.getOrchestratorCredentials();
+    if (!orchCreds) {
+        logger.error('Orchestrator credentials not found');
+        return null;
+    }
+    let orchestratorEmail;
+    try {
+        logger.info('Loading orchestrator', {
+            email: (0, config_1.maskEmail)(orchCreds.email),
+            displayName: orchCreds.displayName
+        });
+        const orchestratorUserId = orchCreds.userId;
+        orchestratorEmail = orchCreds.email;
+        const apiKey = (0, hailer_clients_1.registerBotCredentials)(orchestratorUserId, orchCreds.email, orchCreds.password);
+        await botManager.initializeBotClient(orchCreds.email, orchCreds.password, apiKey);
+        // Register orchestrator botType and displayName
+        botTypeMap.set(orchestratorUserId, 'orchestrator');
+        if (orchCreds.displayName) {
+            displayNameMap.set(orchestratorUserId, orchCreds.displayName);
+        }
+    }
+    catch (error) {
+        logger.error('Failed to initialize orchestrator', { error });
+        return null;
+    }
+    // Initialize specialists (disabled by default - HAL handles everything)
+    // Set SPECIALISTS_ENABLED=true to enable specialist bots from AI Hub
+    const specialistsEnabled = process.env.SPECIALISTS_ENABLED === 'true';
+    if (specialistsEnabled) {
+        const specialists = botCtx.getSpecialistCredentials();
+        // If Bug Fixer env vars are set, use them instead of AI Hub
+        const bugFixerFromEnv = process.env.BUG_MONITOR_ENABLED === 'true' && process.env.BUG_FIXER_EMAIL;
+        if (bugFixerFromEnv) {
+            // Remove any AI Hub Bug Fixer config (env vars take priority)
+            const existingIdx = specialists.findIndex(s => s.botType === 'bugFixer');
+            if (existingIdx >= 0) {
+                specialists.splice(existingIdx, 1);
+            }
+            // Add Bug Fixer from env vars
+            specialists.push({
+                userId: '', // Set after login
+                email: process.env.BUG_FIXER_EMAIL,
+                password: process.env.BUG_FIXER_PASSWORD || '',
+                botType: 'bugFixer',
+                enabled: true,
+                displayName: 'Bug Fixer',
+                workspaceId: botCtx.workspaceId,
+            });
+            logger.info('Bug Fixer configured from env vars (AI Hub bypassed)');
+        }
+        for (const spec of specialists) {
+            try {
+                logger.info('Loading specialist', {
+                    email: (0, config_1.maskEmail)(spec.email),
+                    botType: spec.botType,
+                    displayName: spec.displayName
+                });
+                const specialistUserId = spec.userId;
+                // Bug Fixer specialists need BOT_INTERNAL tool access
+                const isBugFixer = spec.botType === 'bugFixer' || spec.botType === 'bug-fixer';
+                const allowedGroups = isBugFixer
+                    ? [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.BOT_INTERNAL]
+                    : undefined;
+                const apiKey = (0, hailer_clients_1.registerBotCredentials)(specialistUserId, spec.email, spec.password, { allowedGroups });
+                await botManager.initializeBotClient(spec.email, spec.password, apiKey);
+                // Register specialist botType and displayName
+                if (spec.botType) {
+                    botTypeMap.set(specialistUserId, spec.botType);
+                }
+                if (spec.displayName) {
+                    displayNameMap.set(specialistUserId, spec.displayName);
+                }
+            }
+            catch (error) {
+                logger.warn('Failed to initialize specialist', {
+                    email: spec.email,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+    }
+    else {
+        logger.info('Specialists disabled (SPECIALISTS_ENABLED=false) - HAL running solo');
+    }
+    // Check environment for orchestrator mode (defaults to TRUE)
+    const orchestratorMode = options?.orchestratorMode ??
+        process.env.DAEMON_ORCHESTRATOR_MODE !== "false";
+    // Check environment for structured outputs mode (defaults to FALSE for safety)
+    // Set USE_STRUCTURED_OUTPUTS=true to save ~100K tokens per request
+    const useStructuredOutputs = options?.useStructuredOutputs ??
+        process.env.USE_STRUCTURED_OUTPUTS === "true";
+    // Create daemon manager
+    const daemonManager = new DaemonManager(botManager, {
+        mcpServerUrl: mcpClientConfig.mcpServerUrl,
+        anthropicApiKey: anthropicProvider.apiKey,
+        model: anthropicProvider.model,
+        orchestratorMode,
+        orchestratorEmail: orchestratorEmail || options?.orchestratorEmail,
+        specialistEmails: options?.specialistEmails,
+        botTypeMap,
+        displayNameMap,
+        workspaceId: botCtx.workspaceId,
+        useStructuredOutputs,
+    });
+    // Start all daemons
+    await daemonManager.startOrchestratorMode();
+    return daemonManager;
+}
+/**
+ * Quick start function for testing
+ *
+ * @param orchestratorMode - Enable orchestrator mode (default: true)
+ */
+async function startDaemonMode(orchestratorMode = true) {
+    logger.info("Starting Chat Agent Daemon Mode (ORCHESTRATOR)...");
+    const manager = await createDaemonManager({ orchestratorMode });
+    if (!manager) {
+        logger.error("Failed to create daemon manager");
+        process.exit(1);
+    }
+    // Handle shutdown - await async stopAll() to flush session logs
+    process.on("SIGINT", () => {
+        logger.info("Shutting down daemons...");
+        manager.stopAll().then(() => process.exit(0));
+    });
+    process.on("SIGTERM", () => {
+        logger.info("Shutting down daemons...");
+        manager.stopAll().then(() => process.exit(0));
+    });
+    logger.info("Chat Agent Daemon Mode (ORCHESTRATOR) running. Press Ctrl+C to stop.");
+    // Start periodic status logging
+    manager.startStatusLogging(60000);
+}
+/**
+ * Create standalone Bug Fixer daemon (no orchestrator/AI Hub needed)
+ * For testing Bug Fixer independently
+ */
+async function createStandaloneBugFixer(email, password) {
+    const appConfig = (0, config_1.createApplicationConfig)();
+    const mcpClientConfig = appConfig.mcpClient;
+    if (!mcpClientConfig) {
+        logger.error("MCP Client not configured - cannot start standalone Bug Fixer");
+        return null;
+    }
+    const anthropicProvider = mcpClientConfig.providers.find(p => p.type === 'anthropic');
+    if (!anthropicProvider?.apiKey) {
+        logger.error("Anthropic API key not configured");
+        return null;
+    }
+    logger.info("Creating standalone Bug Fixer", { email: (0, config_1.maskEmail)(email) });
+    // Create bot manager with empty config (we'll add the bot dynamically)
+    const botManager = new bot_manager_1.MultiBotManager([]);
+    // Register credentials and get API key
+    const bugFixerApiKey = (0, hailer_clients_1.registerBotCredentials)('standalone-bugfixer', email, password, { allowedGroups: [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.BOT_INTERNAL] });
+    // Initialize the bot client - returns userId
+    const bugFixerUserId = await botManager.initializeBotClient(email, password, bugFixerApiKey);
+    if (!bugFixerUserId) {
+        logger.error("Failed to initialize Bug Fixer client");
+        return null;
+    }
+    // Get the actual BotClient object
+    const bugFixerClient = botManager.getBotClient(bugFixerUserId);
+    if (!bugFixerClient) {
+        logger.error("Failed to get Bug Fixer client after init");
+        return null;
+    }
+    logger.info("Bug Fixer logged in", { userId: bugFixerUserId });
+    // Get user context for API calls
+    const userContext = await UserContextCache_1.UserContextCache.getContext(bugFixerApiKey);
+    // Enable bot in bot state - CRITICAL for message processing
+    const workspaceId = bugFixerClient.workspaceCache?.currentWorkspace?._id;
+    if (workspaceId) {
+        (0, bot_config_1.setBotEnabled)(workspaceId, bugFixerUserId, true);
+        logger.info("Bug Fixer bot enabled in state", { workspaceId, userId: bugFixerUserId });
+    }
+    else {
+        logger.warn("No workspace ID for Bug Fixer - bot state may not work correctly");
+    }
+    // Create minimal daemon manager for Bug Fixer only
+    const daemonManager = new DaemonManager(botManager, {
+        mcpServerUrl: mcpClientConfig.mcpServerUrl,
+        anthropicApiKey: anthropicProvider.apiKey,
+        model: anthropicProvider.model,
+        orchestratorMode: false,
+    });
+    // Create Bug Fixer specialist definition
+    const bugFixerSpecialist = definitions_1.SPECIALISTS.bugFixer;
+    // Create BugFixerSpecialistDaemon directly
+    const bugFixerConfig = {
+        botClient: bugFixerClient,
+        mcpServerUrl: mcpClientConfig.mcpServerUrl,
+        anthropicApiKey: anthropicProvider.apiKey,
+        model: anthropicProvider.model,
+        specialist: bugFixerSpecialist,
+        userContext,
+    };
+    const bugFixerDaemon = new specialist_daemon_1.BugFixerSpecialistDaemon(bugFixerConfig);
+    await bugFixerDaemon.initialize();
+    // Track the daemon for cleanup
+    daemonManager.registerStandaloneDaemon(bugFixerUserId, bugFixerDaemon);
+    logger.info("Standalone Bug Fixer daemon started", { userId: bugFixerUserId });
+    return daemonManager;
+}
+//# sourceMappingURL=factory.js.map