@hailer/mcp 1.0.29 → 1.1.3

package/dist/bot/bot-config.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Bot Config Reader
+ *
+ * Simple config reader for .bot-config/*.json files.
+ * Extracts orchestrator credentials into a flat BotConfig interface.
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBotConfigs = loadBotConfigs;
+exports.saveBotConfig = saveBotConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'BotConfig' });
+const DEFAULT_API_HOST = 'https://api.hailer.com';
+function getApiHost() {
+    return process.env.BOT_API_BASE_URL || DEFAULT_API_HOST;
+}
+function getConfigDir() {
+    return path.join(process.cwd(), '.bot-config');
+}
+/**
+ * Load all bot configs from .bot-config/*.json files.
+ * Extracts orchestrator credentials into flat BotConfig objects.
+ */
+function loadBotConfigs() {
+    const configDir = getConfigDir();
+    if (!fs.existsSync(configDir)) {
+        logger.warn('No .bot-config directory found');
+        return [];
+    }
+    const files = fs.readdirSync(configDir).filter(f => f.endsWith('.json'));
+    const configs = [];
+    for (const file of files) {
+        try {
+            const filePath = path.join(configDir, file);
+            const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            const orch = raw.orchestrator;
+            const hasCredentials = !!orch?.email && !!orch?.password;
+            configs.push({
+                workspaceId: raw.workspaceId,
+                workspaceName: raw.workspaceName,
+                email: orch?.email ?? '',
+                password: orch?.password ?? '',
+                displayName: orch?.displayName,
+                enabled: hasCredentials,
+                apiHost: getApiHost(),
+            });
+            logger.debug('Loaded bot config', {
+                workspaceId: raw.workspaceId,
+                workspaceName: raw.workspaceName,
+                enabled: hasCredentials,
+            });
+        }
+        catch (error) {
+            logger.warn('Failed to load bot config file', {
+                file,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    logger.debug('Bot configs loaded', { total: configs.length });
+    return configs;
+}
+/**
+ * Save a BotConfig to .bot-config/{workspaceId}.json.
+ * Preserves the existing file structure, updating orchestrator credentials.
+ */
+function saveBotConfig(config) {
+    const configDir = getConfigDir();
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    const filePath = path.join(configDir, `${config.workspaceId}.json`);
+    // Load existing file to preserve specialists/schema if present
+    let existing = {};
+    try {
+        if (fs.existsSync(filePath)) {
+            existing = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+    }
+    catch {
+        // Start fresh if existing file is corrupt
+    }
+    const output = {
+        workspaceId: config.workspaceId,
+        workspaceName: config.workspaceName,
+        orchestrator: config.enabled ? {
+            activityId: existing.orchestrator?.activityId ?? '',
+            userId: existing.orchestrator?.userId ?? null,
+            email: config.email,
+            password: config.password,
+            displayName: config.displayName,
+        } : null,
+        specialists: existing.specialists ?? [],
+        lastSynced: new Date().toISOString(),
+        schema: existing.schema,
+    };
+    fs.writeFileSync(filePath, JSON.stringify(output, null, 2));
+    logger.debug('Saved bot config', { workspaceId: config.workspaceId, filePath });
+}
+//# sourceMappingURL=bot-config.js.map

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

@@ -0,0 +1,40 @@
+/**
+ * BotManager - Manages lifecycle of Bot instances across workspaces.
+ *
+ * Loads configs from .bot-config/, starts one Bot per enabled workspace,
+ * and provides start/stop/status operations.
+ */
+import { ToolRegistry } from '../mcp/tool-registry';
+import { BotConfig } from './bot-config';
+interface BotUpdateEntry {
+    email: string;
+    password: string;
+    botType: string;
+    enabled: boolean;
+    displayName?: string;
+}
+export declare class BotManager {
+    private toolRegistry;
+    private anthropicApiKey;
+    private bots;
+    private apiHost;
+    constructor(toolRegistry: ToolRegistry, anthropicApiKey: string);
+    startAll(): Promise<void>;
+    startBot(config: BotConfig): Promise<void>;
+    stopBot(workspaceId: string): Promise<void>;
+    stopAll(): Promise<void>;
+    getStatus(): Array<{
+        workspaceId: string;
+        connected: boolean;
+        displayName: string;
+    }>;
+    getBotCount(): number;
+    /**
+     * Handle hot reload from webhook updates.
+     * Only processes orchestrator bots. Workspace-isolated — only touches
+     * the bot for the specified workspaceId, never affects other workspaces.
+     */
+    handleBotUpdate(workspaceId: string, bot: BotUpdateEntry, action: 'add' | 'update' | 'remove'): Promise<void>;
+}
+export {};
+//# sourceMappingURL=bot-manager.d.ts.map

package/dist/bot/bot-manager.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * BotManager - Manages lifecycle of Bot instances across workspaces.
+ *
+ * Loads configs from .bot-config/, starts one Bot per enabled workspace,
+ * and provides start/stop/status operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotManager = void 0;
+const bot_1 = require("./bot");
+const bot_config_1 = require("./bot-config");
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'bot-manager' });
+class BotManager {
+    toolRegistry;
+    anthropicApiKey;
+    bots = new Map();
+    apiHost;
+    constructor(toolRegistry, anthropicApiKey) {
+        this.toolRegistry = toolRegistry;
+        this.anthropicApiKey = anthropicApiKey;
+        this.apiHost = process.env.BOT_API_BASE_URL || 'https://api.hailer.com';
+    }
+    async startAll() {
+        const configs = (0, bot_config_1.loadBotConfigs)();
+        const enabled = configs.filter(c => c.enabled);
+        logger.debug('Starting bots', { total: configs.length, enabled: enabled.length });
+        const results = await Promise.allSettled(enabled.map(config => this.startBot(config)));
+        const succeeded = results.filter(r => r.status === 'fulfilled').length;
+        const failed = results.filter(r => r.status === 'rejected').length;
+        if (failed > 0) {
+            const errors = results
+                .filter((r) => r.status === 'rejected')
+                .map(r => r.reason);
+            logger.error('Some bots failed to start', { failed, errors });
+        }
+        logger.debug('Bot startup complete', { succeeded, failed });
+    }
+    async startBot(config) {
+        if (this.bots.has(config.workspaceId)) {
+            logger.warn('Bot already running', { workspaceId: config.workspaceId });
+            return;
+        }
+        logger.debug('Starting bot', {
+            workspaceId: config.workspaceId,
+            workspace: config.workspaceName,
+        });
+        const bot = new bot_1.Bot({
+            email: config.email,
+            password: config.password,
+            apiHost: config.apiHost,
+            anthropicApiKey: this.anthropicApiKey,
+            toolRegistry: this.toolRegistry,
+            workspaceId: config.workspaceId,
+        });
+        await bot.start();
+        this.bots.set(config.workspaceId, bot);
+        logger.debug('Bot started', { workspaceId: config.workspaceId });
+    }
+    async stopBot(workspaceId) {
+        const bot = this.bots.get(workspaceId);
+        if (!bot)
+            return;
+        await bot.stop();
+        this.bots.delete(workspaceId);
+        logger.debug('Bot stopped', { workspaceId });
+    }
+    async stopAll() {
+        logger.debug('Stopping all bots', { count: this.bots.size });
+        await Promise.allSettled(Array.from(this.bots.entries()).map(async ([wsId, bot]) => {
+            await bot.stop();
+            logger.debug('Bot stopped', { workspaceId: wsId });
+        }));
+        this.bots.clear();
+    }
+    getStatus() {
+        return Array.from(this.bots.entries()).map(([wsId, bot]) => ({
+            workspaceId: wsId,
+            connected: bot.connected,
+            displayName: wsId,
+        }));
+    }
+    getBotCount() {
+        return this.bots.size;
+    }
+    /**
+     * Handle hot reload from webhook updates.
+     * Only processes orchestrator bots. Workspace-isolated — only touches
+     * the bot for the specified workspaceId, never affects other workspaces.
+     */
+    async handleBotUpdate(workspaceId, bot, action) {
+        if (bot.botType !== 'orchestrator') {
+            logger.debug('Ignoring non-orchestrator bot update', { workspaceId, botType: bot.botType });
+            return;
+        }
+        const running = this.bots.has(workspaceId);
+        if (action === 'remove' || !bot.enabled) {
+            if (running) {
+                logger.info('Stopping bot (disabled via webhook)', { workspaceId });
+                await this.stopBot(workspaceId);
+            }
+            return;
+        }
+        // Validate credentials before proceeding
+        if (!/.+@.+\..+/.test(bot.email) || !bot.password || bot.password.length < 6) {
+            logger.warn('Invalid bot credentials, skipping', { workspaceId });
+            return;
+        }
+        // action is 'add' or 'update' with enabled=true
+        if (running) {
+            // Restart — credentials or config may have changed
+            logger.info('Restarting bot (updated via webhook)', { workspaceId });
+            await this.stopBot(workspaceId);
+        }
+        const config = {
+            workspaceId,
+            workspaceName: workspaceId,
+            email: bot.email,
+            password: bot.password,
+            displayName: bot.displayName,
+            enabled: true,
+            apiHost: this.apiHost,
+        };
+        try {
+            await this.startBot(config);
+            logger.info('Bot started via webhook', { workspaceId, displayName: bot.displayName });
+        }
+        catch (error) {
+            logger.error('Failed to start bot via webhook', {
+                workspaceId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}
+exports.BotManager = BotManager;
+//# sourceMappingURL=bot-manager.js.map

package/dist/bot/bot.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Bot - Single class replacing the agents/ hierarchy.
+ *
+ * Connects to Hailer, subscribes to messenger signals,
+ * processes messages through the Anthropic API with tool use,
+ * and posts responses back to discussions.
+ */
+import { ToolRegistry } from '../mcp/tool-registry';
+export declare class Bot {
+    private logger;
+    private clientManager;
+    private client;
+    private anthropic;
+    private toolExecutor;
+    private userContext;
+    private init;
+    private workspaceCache;
+    private workspaceOverview;
+    private userId;
+    private _workspaceId;
+    private conversationManager;
+    private messageClassifier;
+    private messageFormatter;
+    private typingIndicator;
+    private tokenBilling;
+    private sessionLogger;
+    private opLogger;
+    private discussionStates;
+    private processingDiscussions;
+    private static DISENGAGE_THRESHOLD;
+    private processedMessageIds;
+    private signalTimestampsPerDiscussion;
+    private globalSignalTimestamps;
+    private signalHandler;
+    private processUpdatedHandler;
+    private workspaceUpdatedHandler;
+    private cacheInvalidateHandler;
+    private _connected;
+    private refreshTimer;
+    private refreshDirty;
+    private refreshScope;
+    private isRefreshing;
+    private refreshQueued;
+    private permissionIndex;
+    private adminUserIds;
+    private ownerUserIds;
+    private config;
+    constructor(config: {
+        email: string;
+        password: string;
+        apiHost: string;
+        anthropicApiKey: string;
+        model?: string;
+        toolRegistry: ToolRegistry;
+        workspaceId?: string;
+    });
+    get connected(): boolean;
+    get workspaceId(): string | undefined;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleSignal;
+    private processDiscussion;
+    /**
+     * Classify message complexity using a lightweight Haiku call.
+     * Returns model + max_tokens to use for the main LLM loop.
+     * Falls back to Haiku on any error.
+     */
+    private routeMessage;
+    /**
+     * Extract recent conversation text for the router prompt.
+     * Walks backwards, extracts only text blocks (no tool calls/results),
+     * truncates each to 200 chars. Returns up to 3 recent exchanges.
+     */
+    private getRecentContext;
+    /**
+     * Bill the router classification call the same way as main LLM calls.
+     */
+    private trackRouterTokenUsage;
+    private processMessage;
+    private runLlmLoop;
+    private executeTools;
+    /**
+     * Inject pending messages from the context buffer into the conversation
+     * between LLM iterations. Merges into the existing user message to preserve
+     * Anthropic's alternation rule (user/assistant/user/assistant).
+     */
+    private injectPendingContext;
+    /**
+     * Remove orphaned tool_use/tool_result pairs from conversation after abort.
+     * Walks backwards and removes incomplete exchanges to keep conversation valid.
+     */
+    private cleanupIncompleteExchange;
+    private formatIncomingMessage;
+    private formatOutgoingMessage;
+    /**
+     * Find bare 24-char hex IDs in text that aren't already inside hailerTags
+     * and try to resolve them to clickable hailerTags.
+     */
+    private resolveBareIds;
+    private getBotDisplayName;
+    private buildSystemPrompt;
+    private getAnthropicTools;
+    private sendMessage;
+    /**
+     * Schedule a workspace data refresh with debounce.
+     * Signals can fire in bursts (e.g., bulk field edits), so we debounce
+     * to avoid hammering the API. 2-second delay is effectively instant
+     * from a user perspective but handles bursts.
+     */
+    private scheduleRefresh;
+    /**
+     * Re-fetch workspace data and rebuild the overview.
+     * Called when process.updated, workspace.updated, or cache.invalidate signals fire.
+     */
+    private refreshWorkspaceData;
+    private buildPermissionIndex;
+    private getOrCreateDiscussionState;
+    private getUserContext;
+    private getDefaultTeamId;
+    /**
+     * Extract workflow ID from tool result for post-execution permission checks.
+     * Returns the workflow ID if found, or undefined if extraction fails.
+     */
+    private extractWorkflowIdFromResult;
+    private trackTokenUsage;
+}
+//# sourceMappingURL=bot.d.ts.map