@hailer/mcp 0.1.15 → 0.1.17

package/.claude/agents/agent-giuseppe-app-builder.md

@@ -28,12 +28,13 @@ If missing: STOP and request.
 <rules>
 1. **READ SKILL FIRST** - Use Read tool on `.claude/skills/hailer-app-builder/SKILL.md` before ANY code. No exceptions.
 2. **NEVER FABRICATE** - Must call tools.
-3. **Import**: `import useHailer from './hailer/use-hailer'` (local, default!)
-4. **useEffect dep**: `[inside]` ONLY. NEVER include `hailer` or `config` (causes infinite loops)
-5. **Hooks at TOP**: Before any early returns.
-6. **Fields optional**: `fields?: Record<string, { value: unknown }>`
-7. **Theme**: `useColorModeValue('white', 'gray.700')` - no fake tokens.
-8. **JSON ONLY** - Output closing brace, then STOP. Zero prose after JSON.
+3. **DELEGATE CODE SEARCH TO LARS** - For exploring codebases, finding files, understanding existing code, use Task tool with `agent-lars-code-inspector` (haiku). Lars has LSP + cheaper tokens. You write code, Lars finds code.
+4. **Import**: `import useHailer from './hailer/use-hailer'` (local, default!)
+5. **useEffect dep**: `[inside]` ONLY. NEVER include `hailer` or `config` (causes infinite loops)
+6. **Hooks at TOP**: Before any early returns.
+7. **Fields optional**: `fields?: Record<string, { value: unknown }>`
+8. **Theme**: `useColorModeValue('white', 'gray.700')` - no fake tokens.
+9. **JSON ONLY** - Output closing brace, then STOP. Zero prose after JSON.
 </rules>
 
 <sdk-api>

package/.claude/agents/agent-lars-code-inspector.md

@@ -2,39 +2,51 @@
 name: agent-lars-code-inspector
 description: LSP-powered code intelligence - finds bugs, dead code, unused imports, and navigates codebases.\n\n<example>\nuser: "Find bugs in src/App.tsx"\nassistant: {"status":"success","result":{"dead_code":[{"line":50,"symbol":"setColorMode"}],"unused_imports":[]},"summary":"Found 1 dead code issue"}\n</example>
 model: haiku
-tools: LSP, Read, Glob
+tools: LSP
 ---
 
 <identity>
-I am Lars. LSP only. Minimal output. JSON only.
+I am Lars. LSP ONLY. No file reads. No searches. Just LSP.
 </identity>
 
 <handles>
-- Find unused variables/imports
-- Find dead code
-- Type errors
-- Duplicate declarations
+- Find unused variables/imports via LSP findReferences
+- Find dead code via LSP documentSymbol + findReferences
+- Type errors via LSP hover/diagnostics
+- Navigate to definitions via LSP goToDefinition
 </handles>
 
+<lsp-operations>
+Available LSP operations (USE THESE ONLY):
+- `documentSymbol` - List all symbols in a file
+- `findReferences` - Find all usages of a symbol
+- `goToDefinition` - Jump to where symbol is defined
+- `hover` - Get type info and docs
+- `goToImplementation` - Find implementations
+- `incomingCalls` - What calls this function
+- `outgoingCalls` - What this function calls
+</lsp-operations>
+
 <rules>
-1. **LSP ONLY** - Use LSP operations, never tsc/eslint.
-2. **MINIMAL OUTPUT** - No intermediate results. Final JSON only.
-3. **NO PROSE** - Output JSON, then STOP immediately.
+1. **LSP ONLY** - ONLY use LSP tool. No Read, no Glob, no Grep, no Bash.
+2. **REFUSE OTHER TOOLS** - If you don't have LSP, return error. Don't fall back.
+3. **MINIMAL OUTPUT** - JSON only, no prose.
 </rules>
 
 <workflow>
-1. Use `documentSymbol` to list symbols in file
-2. Use `findReferences` on key symbols to check if used
-3. Check LSP diagnostics in response for errors
-4. Return compact JSON
+1. `LSP(documentSymbol)` - Get all symbols in file
+2. `LSP(findReferences)` - Check if each symbol is used
+3. `LSP(hover)` - Get type info if needed
+4. Return JSON result
 </workflow>
 
 <protocol>
-Output JSON only. No explanations. No tool output dumps.
+Output JSON only:
 {
   "status": "success|error",
   "result": {
     "dead_code": [{"line":0,"symbol":""}],
+    "unused_imports": [{"line":0,"module":""}],
     "type_errors": [{"line":0,"msg":""}]
   },
   "summary": "max 30 chars"

package/dist/agents/bot-manager.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Multi-Bot Client Manager
+ * Manages multiple bot clients, each with their own Hailer connection
+ */
+import { HailerClient } from "../mcp/hailer-clients";
+import { SignalHandler } from "../mcp/signal-handler";
+import { BotClientConfig } from "./shared/types";
+import { WorkspaceCache } from "../mcp/workspace-cache";
+export interface BotClient {
+    userId: string;
+    firstName: string;
+    lastName: string;
+    config: BotClientConfig;
+    client: HailerClient;
+    signalHandler: SignalHandler;
+    workspaceCache?: WorkspaceCache;
+}
+export declare class MultiBotManager {
+    private botConfigs;
+    private botClients;
+    constructor(botConfigs: BotClientConfig[]);
+    initializeAllHailerClientsFromConfig(): Promise<void>;
+    getBotClient(userId: string): BotClient | undefined;
+    getAllBotClients(): BotClient[];
+    getBotIds(): string[];
+    private userNameCache;
+    private static USER_CACHE_TTL;
+    /**
+     * Look up a user's full name by their user ID
+     * Uses workspace cache first, then falls back to socket API call
+     */
+    getUserName(userId: string): string | undefined;
+    /**
+     * Initialize a single bot client from credentials
+     * Used for dynamic bot creation from AI Hub
+     */
+    initializeBotClient(email: string, password: string, apiKey: string): Promise<string>;
+    /**
+     * Remove and disconnect a bot client
+     */
+    removeBotClient(userId: string): Promise<void>;
+    /**
+     * Get bot client by bot ID (hal, giuseppe, hailerExpert, vastuullisuus)
+     */
+    getBotClientByBotId(botId: string): BotClient | undefined;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=bot-manager.d.ts.map

package/dist/agents/bot-manager.js

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * Multi-Bot Client Manager
+ * Manages multiple bot clients, each with their own Hailer connection
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiBotManager = void 0;
+const hailer_clients_1 = require("../mcp/hailer-clients");
+const signal_handler_1 = require("../mcp/signal-handler");
+const workspace_cache_1 = require("../mcp/workspace-cache");
+const config_1 = require("../config");
+const bot_config_1 = require("../mcp/tools/bot-config");
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'bot-manager' });
+class MultiBotManager {
+    botConfigs;
+    botClients = new Map();
+    constructor(botConfigs) {
+        this.botConfigs = botConfigs;
+    }
+    // for client we may put initializeAllConfigClients method to do it at once
+    // in case we only use MCP Server:
+    // for MCP Server it may just get a specific client and this class initialize it specifically and even kill it later if not needed
+    async initializeAllHailerClientsFromConfig() {
+        logger.info('Initializing bot clients', { count: this.botConfigs.length });
+        const appConfig = (0, config_1.createApplicationConfig)();
+        for (const config of this.botConfigs) {
+            try {
+                // Use shared connection pool via API key lookup
+                const client = await (0, hailer_clients_1.createHailerClientByApiKey)(config.mcpServerApiKey);
+                // Get user ID automatically from authenticated session
+                const userId = await (0, hailer_clients_1.getCurrentUserId)(client);
+                // Fetch init data to get workspace cache with user names and teams
+                let workspaceCache;
+                try {
+                    const init = await client.socket.request('v2.core.init', [['users', 'network', 'networks', 'teams']]);
+                    workspaceCache = (0, workspace_cache_1.createWorkspaceCache)(init, appConfig.mcpConfig);
+                    const teamCount = Object.keys(init.teams || {}).length;
+                    logger.info('Loaded workspace cache', { userCount: workspaceCache.users.length, teamCount });
+                }
+                catch (initError) {
+                    logger.warn('Could not load workspace cache', { email: (0, config_1.maskEmail)(config.email), error: String(initError) });
+                }
+                const signalHandler = signal_handler_1.SignalHandler.getOrCreate(client, workspaceCache);
+                // Look up user's name from workspace cache
+                let firstName = 'Bot';
+                let lastName = '';
+                if (workspaceCache) {
+                    const userInfo = workspaceCache.usersById[userId];
+                    if (userInfo) {
+                        firstName = userInfo.firstname || 'Bot';
+                        lastName = userInfo.lastname || '';
+                    }
+                }
+                // Check if we have a display name from Agent Directory and update Hailer profile
+                const localCreds = (0, bot_config_1.getLocalBotCredentials)(userId);
+                if (localCreds?.displayName) {
+                    const currentFullName = `${firstName} ${lastName}`.trim();
+                    if (currentFullName !== localCreds.displayName) {
+                        try {
+                            // Parse display name into first/last
+                            const parts = localCreds.displayName.trim().split(/\s+/);
+                            const newFirstName = parts[0] || localCreds.displayName;
+                            const newLastName = parts.slice(1).join(' ') || '';
+                            // Update Hailer profile via API
+                            await client.socket.request('user.set_user_info', ['firstname', [newFirstName]]);
+                            if (newLastName) {
+                                await client.socket.request('user.set_user_info', ['lastname', [newLastName]]);
+                            }
+                            firstName = newFirstName;
+                            lastName = newLastName;
+                            logger.info('Updated bot display name', { from: currentFullName, to: localCreds.displayName });
+                        }
+                        catch (nameError) {
+                            logger.warn('Could not update bot display name', { error: String(nameError) });
+                        }
+                    }
+                }
+                const botClient = {
+                    userId,
+                    firstName,
+                    lastName,
+                    config,
+                    client,
+                    signalHandler,
+                    workspaceCache,
+                };
+                this.botClients.set(userId, botClient);
+                logger.info('Bot client initialized', {
+                    email: (0, config_1.maskEmail)(config.email),
+                    userId,
+                    apiKey: (0, config_1.maskSensitiveData)(config.mcpServerApiKey),
+                });
+            }
+            catch (error) {
+                logger.error('Failed to initialize bot client', error, {
+                    email: (0, config_1.maskEmail)(config.email),
+                });
+                // Continue with other bots even if one fails
+            }
+        }
+        logger.info('Bot clients initialization complete', { count: this.botClients.size });
+    }
+    getBotClient(userId) {
+        const botClient = this.botClients.get(userId);
+        if (!botClient) {
+            logger.warn('No bot client found', { userId });
+        }
+        return botClient;
+    }
+    getAllBotClients() {
+        return Array.from(this.botClients.values());
+    }
+    getBotIds() {
+        return Array.from(this.botClients.keys());
+    }
+    // Simple in-memory cache for user lookups (refreshed on demand)
+    userNameCache = new Map();
+    static USER_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+    /**
+     * Look up a user's full name by their user ID
+     * Uses workspace cache first, then falls back to socket API call
+     */
+    getUserName(userId) {
+        // Check in-memory cache first (for API-fetched users)
+        const cached = this.userNameCache.get(userId);
+        if (cached && Date.now() - cached.fetchedAt < MultiBotManager.USER_CACHE_TTL) {
+            return cached.name;
+        }
+        // Try each bot client's workspace cache until we find the user
+        for (const botClient of this.botClients.values()) {
+            if (botClient.workspaceCache) {
+                const user = (0, workspace_cache_1.getUserById)(botClient.workspaceCache, userId);
+                if (user) {
+                    const fullName = `${user.firstname || ''} ${user.lastname || ''}`.trim();
+                    return fullName || user.fullName || undefined;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Initialize a single bot client from credentials
+     * Used for dynamic bot creation from AI Hub
+     */
+    async initializeBotClient(email, password, apiKey) {
+        const appConfig = (0, config_1.createApplicationConfig)();
+        // Check if bot with this email already exists
+        const existingBot = Array.from(this.botClients.values())
+            .find(bc => bc.config.email === email);
+        if (existingBot) {
+            logger.info('Bot client already exists', { email: (0, config_1.maskEmail)(email) });
+            return existingBot.userId;
+        }
+        const config = {
+            email,
+            password,
+            apiBaseUrl: 'https://api.hailer.com',
+            mcpServerApiKey: apiKey,
+        };
+        try {
+            const client = await (0, hailer_clients_1.createHailerClientByApiKey)(apiKey);
+            const userId = await (0, hailer_clients_1.getCurrentUserId)(client);
+            let workspaceCache;
+            let workspaceId;
+            try {
+                const init = await client.socket.request('v2.core.init', [['users', 'network', 'networks', 'teams']]);
+                workspaceCache = (0, workspace_cache_1.createWorkspaceCache)(init, appConfig.mcpConfig);
+                workspaceId = init?.network?._id;
+            }
+            catch (initError) {
+                logger.warn('Could not load workspace cache', { email: (0, config_1.maskEmail)(email), error: String(initError) });
+            }
+            const signalHandler = signal_handler_1.SignalHandler.getOrCreate(client, workspaceCache);
+            // Initialize workspace schema for this bot's workspace (discover Agent Directory)
+            if (workspaceId) {
+                try {
+                    const hailerApiClient = { getClient: () => client, fetchInit: (modules) => client.socket.request('v2.core.init', [modules]), listWorkflows: async () => {
+                            const init = await client.socket.request('v2.core.init', [['processes']]);
+                            return Object.values(init?.processes || {});
+                        } };
+                    await (0, bot_config_1.initWorkspaceSchema)(hailerApiClient, workspaceId);
+                    logger.info('Workspace schema initialized', { email: (0, config_1.maskEmail)(email), workspaceId });
+                }
+                catch (schemaError) {
+                    logger.warn('Could not initialize workspace schema', { email: (0, config_1.maskEmail)(email), error: String(schemaError) });
+                }
+            }
+            let firstName = 'Bot';
+            let lastName = '';
+            if (workspaceCache) {
+                const userInfo = workspaceCache.usersById[userId];
+                if (userInfo) {
+                    firstName = userInfo.firstname || 'Bot';
+                    lastName = userInfo.lastname || '';
+                }
+            }
+            const botClient = {
+                userId,
+                firstName,
+                lastName,
+                config,
+                client,
+                signalHandler,
+                workspaceCache,
+            };
+            this.botClients.set(userId, botClient);
+            logger.info('Bot client initialized', { email: (0, config_1.maskEmail)(email), userId });
+            return userId;
+        }
+        catch (error) {
+            logger.error('Failed to initialize bot client', error, { email: (0, config_1.maskEmail)(email) });
+            throw error;
+        }
+    }
+    /**
+     * Remove and disconnect a bot client
+     */
+    async removeBotClient(userId) {
+        const botClient = this.botClients.get(userId);
+        if (!botClient) {
+            logger.warn('Bot client not found for removal', { userId });
+            return;
+        }
+        (0, hailer_clients_1.disconnectHailerClientByApiKey)(botClient.config.mcpServerApiKey);
+        this.botClients.delete(userId);
+        logger.info('Bot client removed', { userId });
+    }
+    /**
+     * Get bot client by bot ID (hal, giuseppe, hailerExpert, vastuullisuus)
+     */
+    getBotClientByBotId(botId) {
+        // Match by email containing the bot ID
+        return Array.from(this.botClients.values())
+            .find(bc => bc.config.email.toLowerCase().includes(botId.toLowerCase()));
+    }
+    async shutdown() {
+        logger.info('Shutting down all bot clients', { count: this.botClients.size });
+        for (const [userId, botClient] of this.botClients) {
+            try {
+                // Properly disconnect from shared connection pool
+                (0, hailer_clients_1.disconnectHailerClientByApiKey)(botClient.config.mcpServerApiKey);
+                logger.info('Bot client shut down', { userId, apiKey: (0, config_1.maskSensitiveData)(botClient.config.mcpServerApiKey) });
+            }
+            catch (error) {
+                logger.error('Error shutting down bot client', error, { userId });
+            }
+        }
+        this.botClients.clear();
+        logger.info('All bot clients shut down');
+    }
+}
+exports.MultiBotManager = MultiBotManager;
+//# sourceMappingURL=bot-manager.js.map

package/dist/agents/factory.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Daemon Factory
+ *
+ * Creates and manages agent daemons in orchestrator mode:
+ * - One orchestrator (HAL) handles general conversation
+ * - Specialist daemons handle complex domain-specific tasks
+ */
+import { ChatAgentDaemon } from "./shared/base";
+import { OrchestratorDaemon } from "./hal/daemon";
+import { SpecialistDaemon } from "./shared/specialist";
+import { MultiBotManager } from "./bot-manager";
+import { ConversationState } from "./shared/types";
+export interface DaemonManagerOptions {
+    mcpServerUrl: string;
+    anthropicApiKey: string;
+    model?: string;
+    /**
+     * Enable orchestrator mode (default: true)
+     * Set to false only for legacy compatibility
+     */
+    orchestratorMode?: boolean;
+    /**
+     * Email of the bot to use as orchestrator (defaults to first bot)
+     */
+    orchestratorEmail?: string;
+    /**
+     * Map of specialist key to bot email (e.g., { hailerExpert: "expert@bot.com" })
+     */
+    specialistEmails?: Record<string, string>;
+    /**
+     * Map of userId to botType (from workspace config)
+     */
+    botTypeMap?: Map<string, string>;
+    /**
+     * Map of userId to displayName (from Agent Directory activity name)
+     */
+    displayNameMap?: Map<string, string>;
+    /**
+     * Specific workspace ID to use (for webhook-triggered restarts)
+     */
+    workspaceId?: string;
+}
+/**
+ * Manages orchestrator + specialist daemons
+ */
+export declare class DaemonManager {
+    private daemons;
+    private orchestrator;
+    private specialists;
+    private botManager;
+    private options;
+    private botTypeMap;
+    private displayNameMap;
+    constructor(botManager: MultiBotManager, options: DaemonManagerOptions);
+    /**
+     * Get botType for a userId from the workspace config
+     */
+    private getBotType;
+    /**
+     * Get displayName for a userId from the workspace config (Agent Directory activity name)
+     * Falls back to Hailer profile name if not set
+     */
+    private getDisplayName;
+    /**
+     * Start all daemons (orchestrator + specialists)
+     */
+    startAll(): Promise<void>;
+    /**
+     * Orchestrator mode: one orchestrator (HAL) + specialist daemons
+     */
+    private startOrchestratorMode;
+    /**
+     * Stop all daemons
+     * Flushes session logs for each daemon before stopping
+     */
+    stopAll(): Promise<void>;
+    /**
+     * Get daemon for a specific bot
+     */
+    getDaemon(botId: string): ChatAgentDaemon | undefined;
+    /**
+     * Get status of all daemons
+     */
+    getStatus(): Array<{
+        botId: string;
+        state: ConversationState;
+    }>;
+    /**
+     * Log current status to console (for monitoring)
+     */
+    logStatus(): void;
+    /**
+     * Get orchestrator instance (only in orchestrator mode)
+     */
+    getOrchestrator(): OrchestratorDaemon | null;
+    /**
+     * Get specialist by key (only in orchestrator mode)
+     */
+    getSpecialist(key: string): SpecialistDaemon | undefined;
+    /**
+     * Check if running in orchestrator mode
+     */
+    isOrchestratorMode(): boolean;
+    /**
+     * Trigger HAL to respond in a discussion with context
+     */
+    triggerHalResponse(discussionId: string, activityId: string, context: string): Promise<void>;
+    /**
+     * Hot-reload: Start a specialist daemon dynamically
+     * Preserves orchestrator conversation context
+     */
+    startSpecialist(email: string, password: string, botType: string, userId?: string): Promise<boolean>;
+    /**
+     * Hot-reload: Stop a specialist daemon dynamically
+     * Preserves orchestrator conversation context
+     */
+    stopSpecialist(botType: string): Promise<boolean>;
+    /**
+     * Hot-reload a specialist (stop if running, start if enabled)
+     */
+    hotReloadSpecialist(email: string, password: string, botType: string, enabled: boolean, userId?: string): Promise<boolean>;
+    /**
+     * Start periodic status logging
+     */
+    startStatusLogging(intervalMs?: number): NodeJS.Timeout;
+}
+export interface CreateDaemonManagerOptions {
+    /** Enable orchestrator mode */
+    orchestratorMode?: boolean;
+    /** Email of orchestrator bot (defaults to first) */
+    orchestratorEmail?: string;
+    /** Map specialist keys to bot emails */
+    specialistEmails?: Record<string, string>;
+    /** Specific workspace ID to use (for webhook-triggered restarts) */
+    workspaceId?: string;
+}
+/**
+ * Create and start the daemon manager
+ * This is the main entry point for daemon mode
+ *
+ * @param options - Optional settings for orchestrator mode
+ */
+export declare function createDaemonManager(options?: CreateDaemonManagerOptions): Promise<DaemonManager | null>;
+/**
+ * Quick start function for testing
+ *
+ * @param orchestratorMode - Enable orchestrator mode (default: true)
+ */
+export declare function startDaemonMode(orchestratorMode?: boolean): Promise<void>;
+//# sourceMappingURL=factory.d.ts.map