@hailer/mcp 0.0.1

package/dist/config.js

@@ -0,0 +1,296 @@
+"use strict";
+/**
+ * Universal Application Configuration
+ *
+ * Single source of truth that replaces all scattered config files:
+ * - lib/env.ts - Environment variable loading
+ * - mcp/config.ts - getClientConfig() function
+ * - client/config.ts - Client configuration creation
+ * - mcp/mcp-config.ts - MCP context optimization settings
+ *
+ * Key Features:
+ * - Map-based CLIENT_CONFIGS for O(1) API key lookups
+ * - Preserves existing excellent connection architecture
+ * - Comprehensive Zod validation with clear error messages
+ * - Development defaults for seamless local setup
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationConfig = exports.environment = void 0;
+exports.createApplicationConfig = createApplicationConfig;
+const zod_1 = require("zod");
+const dotenv_1 = require("dotenv");
+// Load environment variables
+(0, dotenv_1.config)({ path: '.env.local' });
+// ================================================================================
+// ENVIRONMENT VALIDATION
+// ================================================================================
+/**
+ * Hailer account configuration
+ */
+const hailerAccountSchema = zod_1.z.object({
+    email: zod_1.z.string().email(),
+    password: zod_1.z.string().min(1),
+    apiBaseUrl: zod_1.z.string().url().default('https://api.hailer.com'),
+});
+/**
+ * Transform CLIENT_CONFIGS to efficient Map format
+ * Supports both legacy array and new object formats
+ */
+const clientConfigsSchema = zod_1.z.string()
+    .transform((value, ctx) => {
+    try {
+        const parsed = JSON.parse(value);
+        // Convert legacy array format: [{ email, password, mcpServerApiKey, apiBaseUrl }]
+        // to new map format: { "api-key": { email, password, apiBaseUrl } }
+        if (Array.isArray(parsed)) {
+            const configMap = {};
+            for (const item of parsed) {
+                if (item.mcpServerApiKey) {
+                    const { mcpServerApiKey, ...accountData } = item;
+                    configMap[mcpServerApiKey] = accountData;
+                }
+            }
+            return configMap;
+        }
+        return parsed;
+    }
+    catch (error) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Invalid CLIENT_CONFIGS JSON: ${error.message}`,
+        });
+        return zod_1.z.NEVER;
+    }
+})
+    .pipe(zod_1.z.record(zod_1.z.string(), hailerAccountSchema));
+/**
+ * JSON array helper
+ */
+const jsonArraySchema = (itemSchema) => zod_1.z.string()
+    .default('[]')
+    .transform((value, ctx) => {
+    try {
+        return zod_1.z.array(itemSchema).parse(JSON.parse(value));
+    }
+    catch (error) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Invalid JSON array: ${error.message}`,
+        });
+        return zod_1.z.NEVER;
+    }
+});
+/**
+ * Complete environment schema
+ */
+const environmentSchema = zod_1.z.object({
+    // Core
+    NODE_ENV: zod_1.z.enum(['development', 'production', 'test']).default('development'),
+    LOG_LEVEL: zod_1.z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+    // Service control
+    DISABLE_MCP_SERVER: zod_1.z.string().transform(v => v === 'true').default('false'),
+    MCP_CLIENT_ENABLED: zod_1.z.string().transform(v => v === 'true').default('false'),
+    ENABLE_NUCLEAR_TOOLS: zod_1.z.string().transform(v => v === 'true').default('false'),
+    // Server
+    PORT: zod_1.z.string().transform(v => parseInt(v) || 3030).default('3030'),
+    CORS_ORIGINS: jsonArraySchema(zod_1.z.string().url()).default('[]'),
+    // Hailer integration - now as efficient Map
+    CLIENT_CONFIGS: clientConfigsSchema,
+    // Workspace configuration path (for reading workspace configs from external projects)
+    WORKSPACE_CONFIG_PATH: zod_1.z.string().optional(),
+    // Development apps path (for scaffolding Hailer apps outside the repo)
+    DEV_APPS_PATH: zod_1.z.string().optional(),
+    // LLM providers
+    OPENAI_API_KEY: zod_1.z.string().min(1).optional(),
+    ANTHROPIC_API_KEY: zod_1.z.string().min(1).optional(),
+    // MCP client settings
+    MCP_SERVER_URL: zod_1.z.string().url().default('http://localhost:3030/api/mcp'),
+    MCP_CLIENT_API_KEY: zod_1.z.string(),
+    MCP_CLIENT_AGENT_IDS: jsonArraySchema(zod_1.z.string()).default('[]'),
+    // Bot features
+    TOKEN_USAGE_BOT_ENABLED: zod_1.z.string().transform(v => v !== 'false').default('true'),
+    AGENT_ACTIVITY_BOT_ENABLED: zod_1.z.string().transform(v => v !== 'false').default('true'),
+    ADAPTIVE_DOCUMENTATION_BOT_ENABLED: zod_1.z.string().transform(v => v === 'true').default('false'),
+    ADAPTIVE_AUTO_UPDATE: zod_1.z.string().transform(v => v === 'true').default('false'),
+    ADAPTIVE_UPDATE_INTERVAL: zod_1.z.string().transform(v => parseInt(v) || 60000).default('60000'),
+    ADAPTIVE_MIN_ERROR_COUNT: zod_1.z.string().transform(v => parseInt(v) || 3).default('3'),
+    ADAPTIVE_SKILL_GENERATION: zod_1.z.string().transform(v => v === 'true').default('false'), // Chat bot can't use skills
+    // MCP context optimization (replaces mcp-config.ts)
+    MCP_EXCLUDE_TRANSLATIONS: zod_1.z.string().transform(v => v !== 'false').default('true'),
+    MCP_COMPACT_DATA: zod_1.z.string().transform(v => v !== 'false').default('true'),
+    MCP_INCLUDE_WORKSPACE_NAMES: zod_1.z.string().transform(v => v !== 'false').default('true'),
+    // Context management & token limits
+    CONTEXT_SAFETY_MARGIN_PERCENT: zod_1.z.string().transform(v => parseInt(v) || 25).default('25'),
+    CONTEXT_ENABLE_AUTO_SUMMARIZATION: zod_1.z.string().transform(v => v !== 'false').default('true'),
+    CONTEXT_MAX_SUMMARIZATION_CHUNKS: zod_1.z.string().transform(v => parseInt(v) || 10).default('10'),
+});
+/**
+ * Get process environment (no defaults - CLIENT_CONFIGS is required)
+ */
+function getProcessEnv() {
+    return { ...process.env };
+}
+/**
+ * Validated environment - single source of truth
+ */
+exports.environment = environmentSchema.parse(getProcessEnv());
+// ================================================================================
+// UNIVERSAL APPLICATION CONFIG
+// ================================================================================
+/**
+ * Universal Application Configuration
+ *
+ * Single class that provides all configuration for the entire application.
+ * Replaces all scattered config files with one clean interface.
+ */
+class ApplicationConfig {
+    constructor() {
+        // Simple constructor - configuration is determined by environment variables
+    }
+    // ===== CORE CONFIGURATION =====
+    get server() {
+        return {
+            port: exports.environment.PORT,
+            corsOrigins: exports.environment.CORS_ORIGINS,
+            enableMcpServer: !exports.environment.DISABLE_MCP_SERVER,
+            enableClient: exports.environment.MCP_CLIENT_ENABLED,
+        };
+    }
+    /**
+     * Efficient Map-based Hailer accounts (replaces CLIENT_CONFIGS array)
+     */
+    get hailerAccounts() {
+        return exports.environment.CLIENT_CONFIGS;
+    }
+    get llmProviders() {
+        const providers = [];
+        if (exports.environment.OPENAI_API_KEY) {
+            providers.push({
+                name: 'openai-gpt4o',
+                type: 'openai',
+                apiKey: exports.environment.OPENAI_API_KEY,
+                model: 'gpt-4o',
+                enabled: true,
+            });
+        }
+        if (exports.environment.ANTHROPIC_API_KEY) {
+            providers.push({
+                name: 'anthropic-claude',
+                type: 'anthropic',
+                apiKey: exports.environment.ANTHROPIC_API_KEY,
+                model: 'claude-3-5-haiku-20241022', // Haiku - faster, testing instruction following
+                enabled: true,
+            });
+        }
+        return providers;
+    }
+    // ===== MCP CONFIGURATION (replaces mcp-config.ts) =====
+    /**
+     * MCP context optimization settings
+     */
+    get mcpConfig() {
+        return {
+            excludeTranslations: exports.environment.MCP_EXCLUDE_TRANSLATIONS,
+            excludeSystemMessages: true, // Always enabled for cleaner responses
+            excludeEmptyFields: true, // Always enabled to reduce context
+            compactUserData: exports.environment.MCP_COMPACT_DATA,
+            includeWorkspaceNamesInTools: exports.environment.MCP_INCLUDE_WORKSPACE_NAMES,
+        };
+    }
+    /**
+     * Context management settings for token limits and summarization
+     */
+    get contextConfig() {
+        return {
+            safetyMarginPercent: exports.environment.CONTEXT_SAFETY_MARGIN_PERCENT,
+            enableAutoSummarization: exports.environment.CONTEXT_ENABLE_AUTO_SUMMARIZATION,
+            maxSummarizationChunks: exports.environment.CONTEXT_MAX_SUMMARIZATION_CHUNKS,
+        };
+    }
+    /**
+     * Adaptive Documentation Bot configuration
+     */
+    get adaptiveDocumentation() {
+        return {
+            enabled: exports.environment.ADAPTIVE_DOCUMENTATION_BOT_ENABLED,
+            autoUpdate: exports.environment.ADAPTIVE_AUTO_UPDATE,
+            updateInterval: exports.environment.ADAPTIVE_UPDATE_INTERVAL,
+            minErrorCount: exports.environment.ADAPTIVE_MIN_ERROR_COUNT,
+            skillGeneration: exports.environment.ADAPTIVE_SKILL_GENERATION,
+        };
+    }
+    // ===== CLIENT CONFIGURATION (replaces client/config.ts) =====
+    /**
+     * Create MCP Client configuration (replaces createMcpClientConfig())
+     */
+    get mcpClient() {
+        const accounts = this.hailerAccounts;
+        const providers = this.llmProviders;
+        if (Object.keys(accounts).length === 0) {
+            console.warn('No Hailer accounts configured - MCP Client will be disabled');
+            return null;
+        }
+        if (providers.length === 0) {
+            console.warn('No LLM providers configured - MCP Client will be disabled');
+            return null;
+        }
+        // Convert Map format to BotClientConfig array for MultiBotManager compatibility
+        const botConfigs = Object.entries(accounts).map(([apiKey, account]) => ({
+            email: account.email,
+            password: account.password,
+            apiBaseUrl: account.apiBaseUrl,
+            mcpServerApiKey: apiKey,
+        }));
+        return {
+            enabled: exports.environment.MCP_CLIENT_ENABLED,
+            mcpServerUrl: exports.environment.MCP_SERVER_URL,
+            mcpServerApiKey: exports.environment.MCP_CLIENT_API_KEY,
+            providers,
+            mcpAgentIds: exports.environment.MCP_CLIENT_AGENT_IDS,
+            botConfigs,
+            enableDirectMessages: true,
+            tokenUsageBotEnabled: exports.environment.TOKEN_USAGE_BOT_ENABLED,
+            agentActivityBotEnabled: exports.environment.AGENT_ACTIVITY_BOT_ENABLED,
+        };
+    }
+    // ===== UTILITY METHODS =====
+    /**
+     * Find account by API key - O(1) lookup (replaces getClientConfig())
+     * This is the key efficiency improvement that eliminates array filtering
+     */
+    getClientConfig(apiKey) {
+        if (!apiKey) {
+            throw new Error('API key is required');
+        }
+        const account = this.hailerAccounts[apiKey];
+        if (!account) {
+            throw new Error(`No client configuration found for API key: ${apiKey}`);
+        }
+        return account;
+    }
+    /**
+     * Alternative method with null return (safer)
+     */
+    findAccountByApiKey(apiKey) {
+        return this.hailerAccounts[apiKey] || null;
+    }
+    /**
+     * Get enabled LLM providers only
+     */
+    getEnabledLlmProviders() {
+        return this.llmProviders.filter(provider => provider.enabled);
+    }
+}
+exports.ApplicationConfig = ApplicationConfig;
+// ================================================================================
+// FACTORY FUNCTIONS
+// ================================================================================
+/**
+ * Create application configuration
+ * Configuration is determined by environment variables (DISABLE_MCP_SERVER, MCP_CLIENT_ENABLED)
+ */
+function createApplicationConfig() {
+    return new ApplicationConfig();
+}
+// All types are already exported above - no need for duplicate exports
+//# sourceMappingURL=config.js.map

package/dist/core.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Core class for Hailer MCP Server
+ * Pure orchestrator - manages application lifecycle and service coordination
+ * Separated from Express server implementation for better architecture
+ */
+import { Tool } from './mcp/tool-registry';
+export declare class Core {
+    private logger;
+    private appConfig;
+    private toolRegistry;
+    private mcpServer?;
+    private mcpClient;
+    constructor();
+    /**
+     * Public API for external tool registration
+     * Tools are registered explicitly from app.ts
+     */
+    addTool(tool: Tool): void;
+    start(): Promise<void>;
+    private startMCPServer;
+    private startMCPClient;
+    private initializeMcpClient;
+    stop(): Promise<void>;
+    setupGracefulShutdown(): void;
+}
+//# sourceMappingURL=core.d.ts.map

package/dist/core.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Core class for Hailer MCP Server
+ * Pure orchestrator - manages application lifecycle and service coordination
+ * Separated from Express server implementation for better architecture
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Core = void 0;
+const logger_1 = require("./lib/logger");
+const config_1 = require("./config");
+const mcp_client_1 = require("./client/mcp-client");
+const mcp_server_1 = require("./mcp-server");
+const tool_registry_1 = require("./mcp/tool-registry");
+class Core {
+    logger;
+    appConfig;
+    toolRegistry;
+    mcpServer;
+    mcpClient = null;
+    constructor() {
+        // Initialize logger first
+        this.logger = (0, logger_1.createLogger)({
+            component: 'core',
+            service: 'hailer-mcp-server'
+        });
+        // Create tool registry with nuclear tools control
+        this.toolRegistry = new tool_registry_1.ToolRegistry({
+            enableNuclearTools: config_1.environment.ENABLE_NUCLEAR_TOOLS
+        });
+        // Use unified application configuration
+        this.appConfig = (0, config_1.createApplicationConfig)();
+        this.logger.info('Core orchestrator initialized', {
+            nodeEnv: process.env.NODE_ENV,
+            enableMcpServer: this.appConfig.server.enableMcpServer,
+            enableClient: this.appConfig.server.enableClient,
+            enableNuclearTools: config_1.environment.ENABLE_NUCLEAR_TOOLS
+        });
+    }
+    /**
+     * Public API for external tool registration
+     * Tools are registered explicitly from app.ts
+     */
+    addTool(tool) {
+        this.toolRegistry.addTool(tool);
+    }
+    async start() {
+        this.logger.info('Starting Hailer MCP application');
+        try {
+            // Start services based on configuration      
+            if (this.appConfig.server.enableClient) {
+                await this.startMCPClient();
+            }
+            if (this.appConfig.server.enableMcpServer) {
+                // Check if accounts are configured
+                const hasAccounts = Object.keys(this.appConfig.hailerAccounts).length > 0;
+                if (!hasAccounts) {
+                    this.logger.warn('MCP Server enabled but no accounts configured in CLIENT_CONFIGS. Server will not start.');
+                    this.logger.warn('Add at least one account to CLIENT_CONFIGS in .env.local to use the MCP Server.');
+                }
+                else {
+                    await this.startMCPServer();
+                }
+            }
+            this.setupGracefulShutdown();
+            this.logger.info('All configured services started successfully');
+        }
+        catch (error) {
+            this.logger.error('Failed to start application', error);
+            throw error;
+        }
+    }
+    async startMCPServer() {
+        // Server configuration is provided by unified config
+        this.logger.info('Starting MCP Server service');
+        this.mcpServer = new mcp_server_1.MCPServerService({
+            port: this.appConfig.server.port,
+            corsOrigins: this.appConfig.server.corsOrigins,
+            toolRegistry: this.toolRegistry // ← Dependency injection
+        });
+        await this.mcpServer.start();
+        this.logger.info('MCP Server service started');
+    }
+    async startMCPClient() {
+        this.logger.info('Starting MCP Client service');
+        try {
+            await this.initializeMcpClient();
+            this.logger.info('MCP Client service started');
+        }
+        catch (error) {
+            this.logger.warn('MCP Client service failed to start - server will continue without client capabilities', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    async initializeMcpClient() {
+        this.logger.info('Initializing MCP Client');
+        const clientConfig = this.appConfig.mcpClient;
+        if (!clientConfig) {
+            throw new Error('MCP Client configuration not available');
+        }
+        this.mcpClient = new mcp_client_1.McpClient(clientConfig);
+        await this.mcpClient.initialize();
+        this.mcpClient.start();
+        const status = this.mcpClient.getStatus();
+        this.logger.info('MCP Client initialized and ready', {
+            enabledProviders: status.enabledProviders,
+            providersCount: status.providersCount
+        });
+    }
+    async stop() {
+        this.logger.info('Stopping Hailer MCP application');
+        try {
+            if (this.mcpClient) {
+                await this.mcpClient.shutdown();
+                this.logger.info('MCP Client stopped');
+            }
+            if (this.mcpServer) {
+                await this.mcpServer.stop();
+                this.logger.info('MCP Server stopped');
+            }
+            this.logger.info('Application stopped gracefully');
+        }
+        catch (error) {
+            this.logger.error('Error during application shutdown', error);
+            throw error;
+        }
+    }
+    // Graceful shutdown handling
+    setupGracefulShutdown() {
+        const shutdown = async (signal) => {
+            this.logger.info(`Received ${signal}, shutting down gracefully`);
+            try {
+                await this.stop();
+                process.exit(0);
+            }
+            catch (error) {
+                this.logger.error('Error during shutdown', error);
+                process.exit(1);
+            }
+        };
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        this.logger.debug('Graceful shutdown handlers registered');
+    }
+}
+exports.Core = Core;
+//# sourceMappingURL=core.js.map

package/dist/lib/context-manager.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Context Manager
+ *
+ * Handles token counting and automatic summarization to prevent "prompt too long" errors.
+ * Uses character-based token estimation and provider-specific limits with safety margins.
+ */
+export type ProviderType = 'anthropic' | 'openai';
+export interface TokenLimits {
+    maxTokens: number;
+    safeTokens: number;
+    safetyMargin: number;
+}
+export interface TokenCountResult {
+    totalTokens: number;
+    systemPromptTokens: number;
+    messagesTokens: number;
+    toolsTokens: number;
+    exceedsLimit: boolean;
+    provider: ProviderType;
+    limit: TokenLimits;
+}
+export interface ToolResultGroup {
+    messages: any[];
+    tokens: number;
+    startIndex: number;
+    endIndex: number;
+}
+export interface SummarizationResult {
+    summarizedMessages: any[];
+    originalTokens: number;
+    summarizedTokens: number;
+    chunksProcessed: number;
+    reductionPercent: number;
+}
+export interface ContextManagerConfig {
+    safetyMarginPercent: number;
+    enableAutoSummarization: boolean;
+    maxSummarizationChunks: number;
+    anthropicApiKey?: string;
+    openaiApiKey?: string;
+}
+export declare class ContextManager {
+    private logger;
+    private config;
+    private readonly PROVIDER_LIMITS;
+    constructor(config?: Partial<ContextManagerConfig>);
+    /**
+     * Estimate tokens from text using character-based approximation
+     * Formula: 1 token ≈ 4 characters
+     */
+    private estimateTokens;
+    /**
+     * Calculate token limits for a provider with safety margin
+     */
+    private getTokenLimits;
+    /**
+     * Count tokens for system prompt
+     */
+    private countSystemPromptTokens;
+    /**
+     * Count tokens for messages array
+     */
+    private countMessagesTokens;
+    /**
+     * Count tokens for tools definitions
+     */
+    private countToolsTokens;
+    /**
+     * Count total tokens for a complete prompt
+     */
+    countTokens(systemPrompt: string | any, messages: any[], tools: any[], provider: ProviderType): TokenCountResult;
+    /**
+     * Split messages into logical groups based on tool call patterns
+     * Groups together: assistant message with tool_use -> tool results
+     */
+    private splitIntoToolResultGroups;
+    /**
+     * Split tool result groups into chunks that fit within safe limits
+     */
+    private splitIntoChunks;
+    /**
+     * Summarize a chunk of tool results using the LLM
+     */
+    private summarizeChunk;
+    /**
+     * Summarize using Anthropic
+     */
+    private summarizeWithAnthropic;
+    /**
+     * Summarize using OpenAI
+     */
+    private summarizeWithOpenAI;
+    /**
+     * Main summarization orchestration
+     */
+    summarizeContext(systemPrompt: string, messages: any[], provider: ProviderType, userQuery?: string): Promise<SummarizationResult>;
+    /**
+     * Check if token count exceeds safe limit
+     */
+    exceedsLimit(tokenCount: number, provider: ProviderType): boolean;
+    /**
+     * Get warning threshold (80% of safe limit)
+     */
+    approachingLimit(tokenCount: number, provider: ProviderType): boolean;
+    /**
+     * Get provider limits info
+     */
+    getProviderLimits(provider: ProviderType): TokenLimits;
+}
+export declare function getContextManager(config?: Partial<ContextManagerConfig>): ContextManager;
+//# sourceMappingURL=context-manager.d.ts.map