@hailer/mcp 1.2.0 → 1.3.9

package/dist/agents/factory.js

@@ -1,706 +0,0 @@
-"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