@hailer/mcp 1.0.24 → 1.0.26

package/dist/cli.d.ts

@@ -1,3 +1,10 @@
 #!/usr/bin/env node
-import './app';
+/**
+ * Hailer MCP CLI
+ *
+ * Commands:
+ *   setup  - Interactive setup for Claude Desktop
+ *   (none) - Start MCP server (auto-detects stdio/http mode)
+ */
+export {};
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -1,5 +1,270 @@
 #!/usr/bin/env node
 "use strict";
+/**
+ * Hailer MCP CLI
+ *
+ * Commands:
+ *   setup  - Interactive setup for Claude Desktop
+ *   (none) - Start MCP server (auto-detects stdio/http mode)
+ */
+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 });
-require("./app");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const readline = __importStar(require("readline"));
+const CLAUDE_CONFIG_DIR = path.join(os.homedir(), 'Library', 'Application Support', 'Claude');
+const CLAUDE_CONFIG_FILE = path.join(CLAUDE_CONFIG_DIR, 'claude_desktop_config.json');
+/**
+ * Prompt user for input
+ */
+function prompt(question, isPassword = false) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        if (isPassword) {
+            // For password, we need to handle it differently
+            process.stdout.write(question);
+            let password = '';
+            const stdin = process.stdin;
+            const wasRaw = stdin.isRaw;
+            if (stdin.isTTY) {
+                stdin.setRawMode(true);
+            }
+            stdin.resume();
+            stdin.setEncoding('utf8');
+            const onData = (char) => {
+                const charCode = char.charCodeAt(0);
+                if (charCode === 13 || charCode === 10) {
+                    // Enter
+                    stdin.removeListener('data', onData);
+                    if (stdin.isTTY) {
+                        stdin.setRawMode(wasRaw ?? false);
+                    }
+                    process.stdout.write('\n');
+                    rl.close();
+                    resolve(password);
+                }
+                else if (charCode === 3) {
+                    // Ctrl+C
+                    process.exit();
+                }
+                else if (charCode === 127 || charCode === 8) {
+                    // Backspace
+                    if (password.length > 0) {
+                        password = password.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                }
+                else {
+                    password += char;
+                    process.stdout.write('*');
+                }
+            };
+            stdin.on('data', onData);
+        }
+        else {
+            rl.question(question, (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        }
+    });
+}
+/**
+ * Find Node.js executable path
+ */
+function findNodePath() {
+    // Use current Node.js path (the one running this script)
+    return process.execPath;
+}
+/**
+ * Find the hailer-mcp package location
+ */
+function findPackagePath() {
+    // When installed globally via npm, __dirname will be in the package
+    // When running from source, we're in src/
+    const distPath = path.resolve(__dirname, '..', 'dist', 'app.js');
+    const srcPath = path.resolve(__dirname, 'app.js');
+    if (fs.existsSync(distPath)) {
+        return distPath;
+    }
+    if (fs.existsSync(srcPath)) {
+        return srcPath;
+    }
+    // For global npm install, find in node_modules
+    try {
+        const globalPath = require.resolve('@hailer/mcp/dist/app.js');
+        return globalPath;
+    }
+    catch {
+        // Fallback to current directory
+        return path.resolve(process.cwd(), 'dist', 'app.js');
+    }
+}
+/**
+ * Setup command - configure Claude Desktop
+ */
+async function runSetup() {
+    console.log('\n🔧 Hailer MCP Setup for Claude Desktop\n');
+    console.log('This will configure Claude Desktop to use Hailer MCP tools.\n');
+    // Check if macOS
+    if (process.platform !== 'darwin') {
+        console.log('⚠️  This setup is designed for macOS. For other platforms, please configure manually.');
+        console.log('   See: https://github.com/hailer/hailer-mcp#claude-desktop-setup\n');
+    }
+    // Get credentials
+    const email = await prompt('Hailer email: ');
+    if (!email) {
+        console.log('❌ Email is required');
+        process.exit(1);
+    }
+    const password = await prompt('Hailer password: ', true);
+    if (!password) {
+        console.log('❌ Password is required');
+        process.exit(1);
+    }
+    // Get API URL (optional)
+    const apiUrlInput = await prompt('Hailer API URL (press Enter for default https://api.hailer.com): ');
+    const apiUrl = apiUrlInput || 'https://api.hailer.com';
+    // Find paths
+    const nodePath = findNodePath();
+    const appPath = findPackagePath();
+    console.log('\n📍 Detected paths:');
+    console.log(`   Node.js: ${nodePath}`);
+    console.log(`   Hailer MCP: ${appPath}`);
+    // Check if app.js exists
+    if (!fs.existsSync(appPath)) {
+        console.log(`\n❌ Could not find app.js at ${appPath}`);
+        console.log('   Please run "npm run build" first if using from source.');
+        process.exit(1);
+    }
+    // Create config
+    const hailerConfig = {
+        command: nodePath,
+        args: [appPath],
+        env: {
+            MCP_CLIENT_API_KEY: 'claude-desktop',
+            HAILER_EMAIL: email,
+            HAILER_PASSWORD: password,
+            HAILER_API_URL: apiUrl,
+        },
+    };
+    // Read existing config or create new
+    let config = { mcpServers: {} };
+    if (fs.existsSync(CLAUDE_CONFIG_FILE)) {
+        try {
+            const existingContent = fs.readFileSync(CLAUDE_CONFIG_FILE, 'utf-8');
+            config = JSON.parse(existingContent);
+            if (!config.mcpServers) {
+                config.mcpServers = {};
+            }
+            console.log('\n📄 Found existing Claude Desktop config');
+        }
+        catch (error) {
+            console.log('\n⚠️  Could not parse existing config, creating new one');
+        }
+    }
+    // Check if hailer already configured
+    if (config.mcpServers.hailer) {
+        const overwrite = await prompt('\n⚠️  Hailer MCP is already configured. Overwrite? (y/N): ');
+        if (overwrite.toLowerCase() !== 'y') {
+            console.log('Setup cancelled.');
+            process.exit(0);
+        }
+    }
+    // Add hailer config
+    config.mcpServers.hailer = hailerConfig;
+    // Ensure directory exists
+    if (!fs.existsSync(CLAUDE_CONFIG_DIR)) {
+        fs.mkdirSync(CLAUDE_CONFIG_DIR, { recursive: true });
+        console.log(`\n📁 Created directory: ${CLAUDE_CONFIG_DIR}`);
+    }
+    // Write config
+    fs.writeFileSync(CLAUDE_CONFIG_FILE, JSON.stringify(config, null, 2));
+    console.log('\n✅ Configuration saved!');
+    console.log(`   File: ${CLAUDE_CONFIG_FILE}`);
+    console.log('\n🚀 Next steps:');
+    console.log('   1. Quit Claude Desktop completely (Cmd+Q)');
+    console.log('   2. Reopen Claude Desktop');
+    console.log('   3. Look for "hailer" in the MCP tools list');
+    console.log('\n💡 Tip: Use a dedicated bot account, not your personal account.\n');
+}
+/**
+ * Main entry point
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    switch (command) {
+        case 'setup':
+            await runSetup();
+            break;
+        case 'help':
+        case '--help':
+        case '-h':
+            console.log(`
+Hailer MCP - Model Context Protocol server for Hailer
+
+Usage:
+  hailer-mcp              Start MCP server (auto-detects stdio/http mode)
+  hailer-mcp setup        Interactive setup for Claude Desktop
+  hailer-mcp help         Show this help message
+
+Environment variables:
+  MCP_CLIENT_API_KEY      Client identifier (required for stdio mode)
+  HAILER_EMAIL            Hailer account email
+  HAILER_PASSWORD         Hailer account password
+  HAILER_API_URL          API URL (default: https://api.hailer.com)
+  MCP_TRANSPORT           Force transport: 'stdio' or 'http'
+  ENABLE_NUCLEAR_TOOLS    Enable destructive operations (default: false)
+
+For more information, see:
+  https://github.com/hailer/hailer-mcp
+`);
+            break;
+        default:
+            // Start the server (default behavior)
+            await Promise.resolve().then(() => __importStar(require('./app')));
+            break;
+    }
+}
+main().catch((error) => {
+    console.error('Error:', error.message);
+    process.exit(1);
+});
 //# sourceMappingURL=cli.js.map

package/dist/mcp/tool-registry.d.ts

@@ -113,6 +113,21 @@ export declare class ToolRegistry {
      * Get tool metadata (for access control checks)
      */
     getTool(name: string): Tool | undefined;
+    /**
+     * Get tools with their original Zod schemas for MCP SDK registration.
+     * MCP SDK requires Zod schemas, not JSON Schema objects.
+     *
+     * @param filter - Optional filter configuration
+     * @returns Array of tools with name, description, and Zod schema
+     */
+    getToolsWithZodSchemas(filter?: {
+        allowedGroups?: ToolGroup[];
+        allowedTools?: string[];
+    }): Array<{
+        name: string;
+        description: string;
+        schema: z.ZodType;
+    }>;
     /**
      * Get total tool count
      */

package/dist/mcp/tool-registry.js

@@ -324,6 +324,29 @@ Then retry \`${name}\` with the correct format from the skill examples.` : `💡
     getTool(name) {
         return this.tools.get(name);
     }
+    /**
+     * Get tools with their original Zod schemas for MCP SDK registration.
+     * MCP SDK requires Zod schemas, not JSON Schema objects.
+     *
+     * @param filter - Optional filter configuration
+     * @returns Array of tools with name, description, and Zod schema
+     */
+    getToolsWithZodSchemas(filter) {
+        let toolsToExpose = Array.from(this.tools.values());
+        if (filter) {
+            if (filter.allowedTools) {
+                toolsToExpose = toolsToExpose.filter(t => filter.allowedTools.includes(t.name));
+            }
+            else if (filter.allowedGroups) {
+                toolsToExpose = toolsToExpose.filter(t => filter.allowedGroups.includes(t.group));
+            }
+        }
+        return toolsToExpose.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            schema: tool.schema
+        }));
+    }
     /**
      * Get total tool count
      */

package/dist/stdio-server.js

@@ -36,23 +36,36 @@ async function startStdioServer(toolRegistry) {
     const allowedGroups = config_1.environment.ENABLE_NUCLEAR_TOOLS
         ? [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND, tool_registry_1.ToolGroup.NUCLEAR]
         : [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND];
-    const toolDefinitions = toolRegistry.getToolDefinitions({ allowedGroups });
+    // Get tools with their original Zod schemas - MCP SDK requires Zod, not JSON Schema
+    const tools = toolRegistry.getToolsWithZodSchemas({ allowedGroups });
     logger.info('Registering tools for stdio server', {
-        toolCount: toolDefinitions.length,
+        toolCount: tools.length,
         allowedGroups,
     });
-    // Register each tool with the MCP server
-    for (const toolDef of toolDefinitions) {
-        server.tool(toolDef.name, toolDef.description, toolDef.inputSchema.properties ? toolDef.inputSchema : { type: 'object', properties: {} }, async (args) => {
+    // Register each tool with the MCP server using Zod schemas
+    for (const tool of tools) {
+        // Extract shape from ZodObject for MCP SDK compatibility
+        // MCP SDK expects a "raw shape" (object with Zod types as values), not a ZodObject
+        const zodSchema = tool.schema;
+        const shape = zodSchema._def?.typeName === 'ZodObject'
+            ? zodSchema._def.shape()
+            : zodSchema;
+        logger.debug('Registering tool with Zod schema', {
+            name: tool.name,
+            schemaTypeName: zodSchema._def?.typeName || 'unknown',
+            shapeKeys: Object.keys(shape || {})
+        });
+        // Use tool() method with shape object - MCP SDK will recognize Zod types
+        server.tool(tool.name, tool.description, shape, async (args) => {
             const startTime = Date.now();
-            logger.debug('Tool call received', { toolName: toolDef.name, args });
+            logger.debug('Tool call received', { toolName: tool.name, args });
             try {
                 // Get user context (cached)
                 const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
                 // Execute the tool
-                const result = await toolRegistry.executeTool(toolDef.name, args, userContext);
+                const result = await toolRegistry.executeTool(tool.name, args, userContext);
                 const duration = Date.now() - startTime;
-                logger.info('Tool call completed', { toolName: toolDef.name, duration });
+                logger.info('Tool call completed', { toolName: tool.name, duration });
                 // Handle different result formats
                 if (result && typeof result === 'object' && 'content' in result) {
                     // Result is already in MCP format { content: [...] }
@@ -69,7 +82,7 @@ async function startStdioServer(toolRegistry) {
             catch (error) {
                 const duration = Date.now() - startTime;
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.error('Tool call failed', error, { toolName: toolDef.name, duration });
+                logger.error('Tool call failed', error, { toolName: tool.name, duration });
                 return {
                     content: [{
                             type: 'text',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hailer/mcp",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "config": {
     "docker": {
       "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"
@@ -28,6 +28,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.54.0",
     "@hailer/cli": "^1.1.10",
+    "@hailer/mcp": "^1.0.24",
     "@modelcontextprotocol/sdk": "^1.11.5",
     "@opentelemetry/api-logs": "^0.57.0",
     "@opentelemetry/exporter-logs-otlp-proto": "^0.57.0",