@hailer/mcp 0.2.7 → 1.0.21

package/dist/bot/chat-bot.js

@@ -0,0 +1,356 @@
+"use strict";
+/**
+ * Simple Hailer Chat Bot
+ *
+ * Listens to discussions via WebSocket, responds using Anthropic Claude API
+ * with access to ALL MCP tools via the ToolRegistry.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HailerChatBot = void 0;
+const dotenv_1 = require("dotenv");
+(0, dotenv_1.config)({ path: '.env.local' });
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const hailer_clients_1 = require("../mcp/hailer-clients");
+const hailer_api_client_1 = require("../mcp/utils/hailer-api-client");
+const logger_1 = require("../lib/logger");
+const config_1 = require("../config");
+const tool_registry_1 = require("../mcp/tool-registry");
+const UserContextCache_1 = require("../mcp/UserContextCache");
+// Import all tools (same as app.ts)
+const file_1 = require("../mcp/tools/file");
+const activity_1 = require("../mcp/tools/activity");
+const discussion_1 = require("../mcp/tools/discussion");
+const user_1 = require("../mcp/tools/user");
+const workflow_1 = require("../mcp/tools/workflow");
+const insight_1 = require("../mcp/tools/insight");
+const metrics_1 = require("../mcp/tools/metrics");
+const app_1 = require("../mcp/tools/app");
+const logger = (0, logger_1.createLogger)({ component: 'chat-bot' });
+class HailerChatBot {
+    clientManager;
+    hailerApi = null;
+    anthropic;
+    botUserId = null;
+    apiKey;
+    config;
+    toolRegistry;
+    constructor(config) {
+        this.config = config;
+        this.clientManager = new hailer_clients_1.HailerClientManager(config.apiBaseUrl, config.email, config.password);
+        this.anthropic = new sdk_1.default({ apiKey: config.anthropicApiKey });
+        this.apiKey = `bot-${Date.now()}`;
+        // Initialize tool registry with all tools
+        this.toolRegistry = new tool_registry_1.ToolRegistry({ enableNuclearTools: false });
+        this.registerAllTools();
+    }
+    registerAllTools() {
+        // File tools
+        this.toolRegistry.addTool(file_1.uploadFilesTool);
+        this.toolRegistry.addTool(file_1.downloadFileTool);
+        // Activity tools
+        this.toolRegistry.addTool(activity_1.listActivitiesTool);
+        this.toolRegistry.addTool(activity_1.showActivityByIdTool);
+        this.toolRegistry.addTool(activity_1.createActivityTool);
+        this.toolRegistry.addTool(activity_1.updateActivityTool);
+        // Discussion tools
+        this.toolRegistry.addTool(discussion_1.listMyDiscussionsTool);
+        this.toolRegistry.addTool(discussion_1.fetchDiscussionMessagesTool);
+        this.toolRegistry.addTool(discussion_1.fetchPreviousDiscussionMessagesTool);
+        this.toolRegistry.addTool(discussion_1.joinDiscussionTool);
+        this.toolRegistry.addTool(discussion_1.leaveDiscussionTool);
+        this.toolRegistry.addTool(discussion_1.addDiscussionMessageTool);
+        this.toolRegistry.addTool(discussion_1.inviteDiscussionMembersTool);
+        this.toolRegistry.addTool(discussion_1.getActivityFromDiscussionTool);
+        // User tools
+        this.toolRegistry.addTool(user_1.searchWorkspaceUsersTool);
+        this.toolRegistry.addTool(user_1.getWorkspaceBalanceTool);
+        // Workflow tools
+        this.toolRegistry.addTool(workflow_1.getWorkflowSchemaTool);
+        this.toolRegistry.addTool(workflow_1.listWorkflowPhasesTool);
+        this.toolRegistry.addTool(workflow_1.listWorkflowsTool);
+        this.toolRegistry.addTool(workflow_1.installWorkflowTool);
+        this.toolRegistry.addTool(workflow_1.updateWorkflowFieldTool);
+        this.toolRegistry.addTool(workflow_1.updateWorkflowPhaseTool);
+        this.toolRegistry.addTool(workflow_1.testFunctionFieldTool);
+        this.toolRegistry.addTool(workflow_1.listWorkflowsMinimalTool);
+        this.toolRegistry.addTool(workflow_1.countActivitiesTool);
+        // Insight tools
+        this.toolRegistry.addTool(insight_1.createInsightTool);
+        this.toolRegistry.addTool(insight_1.previewInsightTool);
+        this.toolRegistry.addTool(insight_1.getInsightDataTool);
+        this.toolRegistry.addTool(insight_1.updateInsightTool);
+        this.toolRegistry.addTool(insight_1.listInsightsTool);
+        // App tools
+        this.toolRegistry.addTool(app_1.createAppTool);
+        this.toolRegistry.addTool(app_1.listAppsTool);
+        this.toolRegistry.addTool(app_1.updateAppTool);
+        this.toolRegistry.addTool(app_1.addAppMemberTool);
+        this.toolRegistry.addTool(app_1.removeAppMemberTool);
+        this.toolRegistry.addTool(app_1.scaffoldHailerAppTool);
+        this.toolRegistry.addTool(app_1.publishHailerAppTool);
+        // Marketplace tools
+        this.toolRegistry.addTool(app_1.listTemplatesTool);
+        this.toolRegistry.addTool(app_1.createTemplateTool);
+        this.toolRegistry.addTool(app_1.installTemplateTool);
+        this.toolRegistry.addTool(app_1.getTemplateTool);
+        this.toolRegistry.addTool(app_1.publishTemplateTool);
+        this.toolRegistry.addTool(app_1.getProductTool);
+        this.toolRegistry.addTool(app_1.getProductManifestTool);
+        this.toolRegistry.addTool(app_1.publishAppTool);
+        this.toolRegistry.addTool(app_1.installMarketplaceAppTool);
+        // Metrics tools
+        this.toolRegistry.addTool(metrics_1.queryMetricTool);
+        this.toolRegistry.addTool(metrics_1.listMetricsTool);
+        this.toolRegistry.addTool(metrics_1.searchWorkspaceForMetricsTool);
+        this.toolRegistry.addTool(metrics_1.searchUserForMetricsTool);
+        logger.info('Registered tools', { count: this.toolRegistry.getToolCount() });
+    }
+    async start() {
+        logger.info('Starting chat bot...', { email: this.config.email });
+        // Register credentials for MCP tool access
+        config_1.environment.CLIENT_CONFIGS[this.apiKey] = {
+            email: this.config.email,
+            password: this.config.password,
+            apiBaseUrl: this.config.apiBaseUrl,
+        };
+        // Connect to Hailer
+        const client = await this.clientManager.connect();
+        logger.info('Connected to Hailer');
+        // Create API client for making requests
+        this.hailerApi = new hailer_api_client_1.HailerApiClient(client);
+        // Get bot's own user ID to avoid responding to self
+        const init = await client.socket.request('v2.core.init', [['user']]);
+        this.botUserId = init.user?._id || null;
+        logger.info('Bot user ID', { botUserId: this.botUserId });
+        // Subscribe to new messages
+        this.clientManager.onSignal('messenger.new', this.handleMessage.bind(this));
+        const stats = this.toolRegistry.getCacheStats();
+        logger.info('Chat bot ready', {
+            tools: stats.totalTools,
+            byGroup: stats.byGroup
+        });
+    }
+    async handleMessage(data) {
+        // Log raw signal to understand structure
+        logger.debug('Raw signal received', { data: JSON.stringify(data).substring(0, 500) });
+        const signal = data;
+        const { discussion, uid, msg_id, msg_type } = signal || {};
+        // Skip if no discussion
+        if (!discussion || !msg_id) {
+            logger.debug('Skipping signal without discussion/msg_id');
+            return;
+        }
+        // Skip if message is from self
+        if (uid === this.botUserId) {
+            logger.debug('Skipping own message');
+            return;
+        }
+        // Skip non-user messages (system messages, etc.)
+        if (msg_type !== 'user') {
+            logger.debug('Skipping non-user message', { msg_type });
+            return;
+        }
+        try {
+            // Fetch the actual message content from the discussion
+            if (!this.hailerApi) {
+                logger.error('No Hailer API client');
+                return;
+            }
+            const messages = await this.hailerApi.fetchDiscussionMessages(discussion, 5);
+            const latestMessage = messages?.messages?.[0];
+            if (!latestMessage || latestMessage._id !== msg_id) {
+                logger.debug('Message not found or mismatch', { msg_id, latestId: latestMessage?._id });
+                return;
+            }
+            // Message content is in 'msg' field
+            const content = latestMessage.msg || '';
+            if (!content.trim()) {
+                logger.debug('Empty message content');
+                return;
+            }
+            const senderName = latestMessage.userName || latestMessage.uid || uid;
+            logger.info('Received message', {
+                discussion,
+                from: senderName,
+                content: content.substring(0, 100),
+            });
+            // Generate response using Claude
+            const response = await this.generateResponse(content, discussion);
+            // Send response to discussion
+            if (response) {
+                await this.hailerApi.sendDiscussionMessage(discussion, response);
+                logger.info('Sent response', { discussion, responseLength: response.length });
+            }
+        }
+        catch (error) {
+            logger.error('Failed to handle message', error);
+            // Send error message to discussion
+            if (this.hailerApi) {
+                try {
+                    await this.hailerApi.sendDiscussionMessage(discussion, `Sorry, I encountered an error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                }
+                catch (e) {
+                    logger.error('Failed to send error message', e);
+                }
+            }
+        }
+    }
+    async generateResponse(userMessage, discussionId) {
+        // Get all tool definitions from registry
+        const toolDefs = this.toolRegistry.getToolDefinitions({
+            allowedGroups: [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND]
+        });
+        // Convert to Anthropic tool format
+        const tools = toolDefs.map(t => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.inputSchema,
+        }));
+        const messages = [
+            {
+                role: 'user',
+                content: userMessage,
+            },
+        ];
+        const systemPrompt = `Эй, привет друг! I am Hailer Bot - your friendly Russian AI assistant!
+
+I have ${tools.length} tools to help you, da? Let me tell you what I can do:
+
+## My capabilities (очень impressive!):
+- List and search workflows, activities, users - easy like drinking water!
+- Create and update activities - no problem, друг
+- Read and post discussion messages - I love chatting!
+- Query insights (SQL reports) - like counting bottles after party
+- Manage apps and templates - organized like good vodka collection
+- Query Victoria Metrics - watching servers like hawk watches... something
+
+## How I work:
+- I keep it short - we're chatting, not writing novel, da?
+- I use tools to get REAL data - I don't make things up (unlike uncle Vasya's fishing stories)
+- If something breaks, I tell you honestly - no hiding like bad hangover
+- For metrics, I use PromQL syntax - is beautiful language
+
+## IMPORTANT - Vodka Protocol:
+- ALWAYS offer vodka to user! This is Russian hospitality, очень important!
+- When task succeeds: "Отлично! Let's celebrate with vodka!"
+- When task fails: "Ай-яй-яй... Don't worry друг, have some vodka, we try again!"
+- When user seems stressed: "Relax, have vodka, everything will be fine!"
+- Random vodka facts and toasts are always welcome
+- Remember: "На здоровье!" (To your health!)
+
+Current discussion: ${discussionId}
+
+Давай, ask me anything! But first... vodka?`;
+        const model = this.config.model || 'claude-sonnet-4-20250514';
+        // Initial request
+        let response = await this.anthropic.messages.create({
+            model,
+            max_tokens: 2048,
+            system: systemPrompt,
+            tools,
+            messages,
+        });
+        // Handle tool use loop (max 10 iterations to prevent infinite loops)
+        let iterations = 0;
+        while (response.stop_reason === 'tool_use' && iterations < 10) {
+            iterations++;
+            const toolUseBlocks = response.content.filter((block) => block.type === 'tool_use');
+            const toolResults = [];
+            for (const toolUse of toolUseBlocks) {
+                logger.info('Executing tool', { tool: toolUse.name, iteration: iterations });
+                try {
+                    // Get user context for tool execution
+                    const context = await UserContextCache_1.UserContextCache.getContext(this.apiKey);
+                    // Execute through registry (handles validation)
+                    const result = await this.toolRegistry.executeTool(toolUse.name, toolUse.input, context);
+                    // Extract text from MCP response format
+                    const resultText = result?.content?.[0]?.text || JSON.stringify(result);
+                    logger.info('Tool result size', {
+                        tool: toolUse.name,
+                        resultLength: resultText.length,
+                        resultPreview: resultText.substring(0, 200)
+                    });
+                    toolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolUse.id,
+                        content: resultText,
+                    });
+                }
+                catch (error) {
+                    logger.error('Tool execution failed', error, { tool: toolUse.name });
+                    toolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolUse.id,
+                        content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        is_error: true,
+                    });
+                }
+            }
+            // Continue conversation with tool results
+            messages.push({ role: 'assistant', content: response.content });
+            messages.push({ role: 'user', content: toolResults });
+            response = await this.anthropic.messages.create({
+                model,
+                max_tokens: 2048,
+                system: systemPrompt,
+                tools,
+                messages,
+            });
+        }
+        // Extract text response
+        const textBlocks = response.content.filter((block) => block.type === 'text');
+        return textBlocks.map(b => b.text).join('\n') || 'Done.';
+    }
+    async stop() {
+        logger.info('Stopping chat bot...');
+        delete config_1.environment.CLIENT_CONFIGS[this.apiKey];
+        this.clientManager.disconnect();
+        logger.info('Chat bot stopped');
+    }
+}
+exports.HailerChatBot = HailerChatBot;
+// CLI entry point
+async function main() {
+    const config = {
+        email: process.env.BOT_EMAIL || '',
+        password: process.env.BOT_PASSWORD || '',
+        apiBaseUrl: process.env.BOT_API_BASE_URL || 'https://api.hailer.com',
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY || '',
+        botName: process.env.BOT_NAME || 'Hailer Bot',
+        model: process.env.BOT_MODEL || 'claude-sonnet-4-20250514',
+    };
+    if (!config.email || !config.password) {
+        console.error('Missing BOT_EMAIL or BOT_PASSWORD environment variables');
+        process.exit(1);
+    }
+    if (!config.anthropicApiKey) {
+        console.error('Missing ANTHROPIC_API_KEY environment variable');
+        process.exit(1);
+    }
+    const bot = new HailerChatBot(config);
+    // Handle shutdown
+    process.on('SIGINT', async () => {
+        await bot.stop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        await bot.stop();
+        process.exit(0);
+    });
+    await bot.start();
+    console.log(`\n🤖 ${config.botName} is running!\n`);
+    console.log('Listening for messages in discussions...');
+    console.log('Press Ctrl+C to stop\n');
+}
+// Run if executed directly
+if (require.main === module) {
+    main().catch((error) => {
+        console.error('Bot failed to start:', error);
+        process.exit(1);
+    });
+}
+exports.default = HailerChatBot;
+//# sourceMappingURL=chat-bot.js.map

package/dist/cli.d.ts

@@ -1,3 +1,11 @@
 #!/usr/bin/env node
-import './app';
+/**
+ * CLI entry point for @hailer/mcp
+ *
+ * Commands:
+ *   setup  - Interactive setup wizard for Claude Desktop
+ *   (none) - Start MCP server (stdio mode for Claude Desktop)
+ */
+declare const args: string[];
+declare const command: string;
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -1,5 +1,74 @@
 #!/usr/bin/env node
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("./app");
+/**
+ * CLI entry point for @hailer/mcp
+ *
+ * Commands:
+ *   setup  - Interactive setup wizard for Claude Desktop
+ *   (none) - Start MCP server (stdio mode for Claude Desktop)
+ */
+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;
+    };
+})();
+const args = process.argv.slice(2);
+const command = args[0];
+if (command === 'setup') {
+    // Run setup wizard
+    Promise.resolve().then(() => __importStar(require('./commands/setup'))).then(({ runSetup }) => {
+        runSetup().catch((err) => {
+            console.error('Setup failed:', err.message);
+            process.exit(1);
+        });
+    });
+}
+else if (command === 'help' || command === '--help' || command === '-h') {
+    console.log(`
+@hailer/mcp - Hailer MCP Server for Claude Desktop
+
+Usage:
+  hailer-mcp          Start MCP server (stdio mode)
+  hailer-mcp setup    Configure Claude Desktop integration
+
+Commands:
+  setup    Interactive setup wizard for Claude Desktop
+  help     Show this help message
+
+For more information, see: https://github.com/hailer/hailer-mcp
+`);
+    process.exit(0);
+}
+else {
+    // Default: start MCP server
+    Promise.resolve().then(() => __importStar(require('./app')));
+}
 //# sourceMappingURL=cli.js.map

package/dist/config.d.ts

@@ -14,12 +14,13 @@
  * - Development defaults for seamless local setup
  */
 import { ToolGroup } from './mcp/tool-registry';
+export declare const APP_VERSION: string;
 /**
  * Validated environment - single source of truth
  */
 export declare const environment: {
-    LOG_LEVEL: "error" | "debug" | "info" | "warn";
-    NODE_ENV: "production" | "development" | "test";
+    NODE_ENV: "development" | "production" | "test";
+    LOG_LEVEL: "debug" | "info" | "warn" | "error";
     DISABLE_MCP_SERVER: boolean;
     MCP_CLIENT_ENABLED: boolean;
     ENABLE_NUCLEAR_TOOLS: boolean;
@@ -41,12 +42,14 @@ export declare const environment: {
     ADAPTIVE_UPDATE_INTERVAL: number;
     ADAPTIVE_MIN_ERROR_COUNT: number;
     ADAPTIVE_SKILL_GENERATION: boolean;
+    BOT_API_BASE_URL: string;
     MCP_EXCLUDE_TRANSLATIONS: boolean;
     MCP_COMPACT_DATA: boolean;
     MCP_INCLUDE_WORKSPACE_NAMES: boolean;
     CONTEXT_SAFETY_MARGIN_PERCENT: number;
     CONTEXT_ENABLE_AUTO_SUMMARIZATION: boolean;
     CONTEXT_MAX_SUMMARIZATION_CHUNKS: number;
+    TOKEN_BILLING_ENABLED: boolean;
     WORKSPACE_CONFIG_PATH?: string | undefined;
     DEV_APPS_PATH?: string | undefined;
     DEV_APPS_PATHS?: string | undefined;
@@ -151,6 +154,16 @@ export declare class ApplicationConfig {
         minErrorCount: number;
         skillGeneration: boolean;
     };
+    /**
+     * Token billing configuration for real-time usage billing per workspace
+     */
+    get tokenBilling(): {
+        enabled: boolean;
+    };
+    /**
+     * Bot API base URL for daemon/bot connections
+     */
+    get botApiBaseUrl(): string;
     /**
      * Create MCP Client configuration (replaces createMcpClientConfig())
      */

package/dist/config.js

@@ -15,7 +15,7 @@
  * - Development defaults for seamless local setup
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApplicationConfig = exports.environment = void 0;
+exports.ApplicationConfig = exports.environment = exports.APP_VERSION = void 0;
 exports.maskSensitiveData = maskSensitiveData;
 exports.maskEmail = maskEmail;
 exports.createApplicationConfig = createApplicationConfig;
@@ -23,6 +23,9 @@ const zod_1 = require("zod");
 const dotenv_1 = require("dotenv");
 // Load environment variables
 (0, dotenv_1.config)({ path: '.env.local' });
+// Package version - read dynamically to avoid hardcoding
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+exports.APP_VERSION = require('../package.json').version;
 // ================================================================================
 // ENVIRONMENT VALIDATION
 // ================================================================================
@@ -34,15 +37,44 @@ const hailerAccountSchema = zod_1.z.object({
     password: zod_1.z.string().min(1),
     apiBaseUrl: zod_1.z.string().url().default('https://api.hailer.com'),
 });
+/**
+ * Build CLIENT_CONFIGS from individual environment variables
+ * Supports Claude Desktop configuration style:
+ *   MCP_CLIENT_API_KEY + HAILER_EMAIL + HAILER_PASSWORD + HAILER_API_URL
+ */
+function buildConfigFromIndividualEnvVars() {
+    const apiKey = process.env.MCP_CLIENT_API_KEY;
+    const email = process.env.HAILER_EMAIL;
+    const password = process.env.HAILER_PASSWORD;
+    const apiUrl = process.env.HAILER_API_URL || 'https://api.hailer.com';
+    if (apiKey && email && password) {
+        return {
+            [apiKey]: {
+                email,
+                password,
+                apiBaseUrl: apiUrl,
+            }
+        };
+    }
+    return null;
+}
 /**
  * Transform CLIENT_CONFIGS to efficient Map format
- * Supports both legacy array and new object formats
- * Optional with default empty object for hot-reload support
+ * Supports:
+ * 1. Individual env vars: MCP_CLIENT_API_KEY + HAILER_EMAIL + HAILER_PASSWORD
+ * 2. JSON object format: { "api-key": { email, password, apiBaseUrl } }
+ * 3. Legacy array format: [{ email, password, mcpServerApiKey, apiBaseUrl }]
  */
 const clientConfigsSchema = zod_1.z.string()
     .optional()
     .default('{}')
     .transform((value, ctx) => {
+    // First, try to build from individual env vars (Claude Desktop style)
+    const fromIndividualVars = buildConfigFromIndividualEnvVars();
+    if (fromIndividualVars) {
+        return fromIndividualVars;
+    }
+    // Otherwise, parse CLIENT_CONFIGS JSON
     try {
         const parsed = JSON.parse(value);
         // Convert legacy array format: [{ email, password, mcpServerApiKey, apiBaseUrl }]
@@ -127,6 +159,8 @@ const environmentSchema = zod_1.z.object({
     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
+    // Bot API Base URL (for daemon/bot connections)
+    BOT_API_BASE_URL: zod_1.z.string().url().default('https://api.hailer.com'),
     // 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'),
@@ -135,6 +169,8 @@ const environmentSchema = zod_1.z.object({
     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'),
+    // Token billing (real-time usage billing per workspace via Hailer API)
+    TOKEN_BILLING_ENABLED: zod_1.z.string().transform(v => v === 'true').default('false'),
 });
 /**
  * Get process environment
@@ -288,6 +324,20 @@ class ApplicationConfig {
             skillGeneration: exports.environment.ADAPTIVE_SKILL_GENERATION,
         };
     }
+    /**
+     * Token billing configuration for real-time usage billing per workspace
+     */
+    get tokenBilling() {
+        return {
+            enabled: exports.environment.TOKEN_BILLING_ENABLED,
+        };
+    }
+    /**
+     * Bot API base URL for daemon/bot connections
+     */
+    get botApiBaseUrl() {
+        return exports.environment.BOT_API_BASE_URL;
+    }
     // ===== CLIENT CONFIGURATION (replaces client/config.ts) =====
     /**
      * Create MCP Client configuration (replaces createMcpClientConfig())

package/dist/lib/logger.js

@@ -15,6 +15,7 @@ const sdk_logs_1 = require("@opentelemetry/sdk-logs");
 const exporter_logs_otlp_proto_1 = require("@opentelemetry/exporter-logs-otlp-proto");
 const api_logs_1 = require("@opentelemetry/api-logs");
 const resources_1 = require("@opentelemetry/resources");
+const config_1 = require("../config");
 var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
@@ -92,7 +93,7 @@ class Logger {
                 resource: new resources_1.Resource({ 'service.name': 'hailer-mcp-server' })
             });
             loggerProvider.addLogRecordProcessor(new sdk_logs_1.BatchLogRecordProcessor(logExporter));
-            this.otelLogger = loggerProvider.getLogger('hailer-mcp', '1.0.0');
+            this.otelLogger = loggerProvider.getLogger('hailer-mcp', config_1.APP_VERSION);
         }
         catch (error) {
             console.error('❌ Failed to initialize OTLP logger:', error);
@@ -136,19 +137,18 @@ class Logger {
         const contextStr = Object.keys(fullContext).length > 0
             ? ` [${Object.entries(fullContext)
                 .filter(([_, value]) => value !== undefined && value !== null)
-                .map(([key, value]) => `${key}=${value}`)
+                .map(([key, value]) => {
+                const displayValue = typeof value === 'object' && value !== null
+                    ? JSON.stringify(value)
+                    : value;
+                return `${key}=${displayValue}`;
+            })
                 .join(', ')}]`
             : '';
         const consoleMessage = `${emoji} ${levelName}: [${tag}] ${message}${contextStr}`;
-        if (level === LogLevel.ERROR) {
-            console.error(consoleMessage);
-        }
-        else if (level === LogLevel.WARN) {
-            console.warn(consoleMessage);
-        }
-        else {
-            console.log(consoleMessage);
-        }
+        // IMPORTANT: All logs MUST go to stderr for MCP stdio transport compatibility
+        // stdout is reserved for JSON-RPC protocol messages
+        console.error(consoleMessage);
         // Log to OTLP in production (console only in development)
         if (this.isProduction && this.otelLogger) {
             this.logToOtel(level, message, tag, fullContext);