@hailer/mcp 1.0.25 → 1.0.27

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,281 @@
 #!/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) {
+    return new Promise((resolve) => {
+        if (isPassword) {
+            // For password input, use raw mode to hide characters
+            process.stdout.write(question);
+            let password = '';
+            const stdin = process.stdin;
+            if (!stdin.isTTY) {
+                // Not a TTY, fall back to simple readline (won't hide password)
+                const rl = readline.createInterface({ input: stdin, output: process.stdout });
+                rl.question('', (answer) => {
+                    rl.close();
+                    resolve(answer.trim());
+                });
+                return;
+            }
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.setEncoding('utf8');
+            const onData = (key) => {
+                // Handle each character
+                for (const char of key) {
+                    const code = char.charCodeAt(0);
+                    if (code === 13 || code === 10) {
+                        // Enter - done
+                        stdin.setRawMode(false);
+                        stdin.pause();
+                        stdin.removeListener('data', onData);
+                        process.stdout.write('\n');
+                        resolve(password);
+                        return;
+                    }
+                    else if (code === 3) {
+                        // Ctrl+C - exit
+                        stdin.setRawMode(false);
+                        process.stdout.write('\n');
+                        process.exit(0);
+                    }
+                    else if (code === 127 || code === 8) {
+                        // Backspace
+                        if (password.length > 0) {
+                            password = password.slice(0, -1);
+                            process.stdout.write('\b \b');
+                        }
+                    }
+                    else if (code >= 32) {
+                        // Printable character
+                        password += char;
+                        process.stdout.write('*');
+                    }
+                }
+            };
+            stdin.on('data', onData);
+        }
+        else {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hailer/mcp",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "config": {
     "docker": {
       "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"