@hailer/mcp 1.0.21 → 1.0.23

package/dist/commands/setup.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Setup wizard for Claude Desktop integration
+ *
+ * Automatically configures Claude Desktop to use Hailer MCP server
+ * by generating the correct config with detected paths.
+ */
+/**
+ * Main setup function
+ */
+export declare function runSetup(): Promise<void>;
+//# sourceMappingURL=setup.d.ts.map

package/dist/commands/setup.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * Setup wizard for Claude Desktop integration
+ *
+ * Automatically configures Claude Desktop to use Hailer MCP server
+ * by generating the correct config with detected paths.
+ */
+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.runSetup = runSetup;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const readline = __importStar(require("readline"));
+// ANSI colors for terminal output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+};
+function log(message) {
+    console.log(message);
+}
+function success(message) {
+    console.log(`${colors.green}✓${colors.reset} ${message}`);
+}
+function warn(message) {
+    console.log(`${colors.yellow}⚠${colors.reset} ${message}`);
+}
+function error(message) {
+    console.log(`${colors.red}✗${colors.reset} ${message}`);
+}
+function header(message) {
+    console.log(`\n${colors.bright}${colors.cyan}${message}${colors.reset}\n`);
+}
+/**
+ * Get Claude Desktop config path based on OS
+ */
+function getClaudeConfigPath() {
+    const platform = os.platform();
+    const home = os.homedir();
+    switch (platform) {
+        case 'darwin': // macOS
+            return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        case 'win32': // Windows
+            return path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+        case 'linux':
+            return path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+        default:
+            throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+/**
+ * Get the path to the installed @hailer/mcp app.js
+ */
+function getAppJsPath() {
+    // __dirname in compiled JS will be dist/commands
+    // app.js is at dist/app.js
+    const distDir = path.dirname(__dirname);
+    const appJsPath = path.join(distDir, 'app.js');
+    if (!fs.existsSync(appJsPath)) {
+        throw new Error(`app.js not found at ${appJsPath}. ` +
+            `Make sure @hailer/mcp is installed globally: npm install -g @hailer/mcp`);
+    }
+    return appJsPath;
+}
+/**
+ * Get the path to Node.js executable
+ */
+function getNodePath() {
+    // process.execPath gives us the actual node binary path
+    // This works correctly with nvm, fnm, volta, etc.
+    const nodePath = process.execPath;
+    // Verify it's actually node (not npm or npx)
+    const basename = path.basename(nodePath).toLowerCase();
+    if (!basename.startsWith('node')) {
+        throw new Error(`Unexpected executable: ${nodePath}. ` +
+            `Expected node binary. Please run this script with node directly.`);
+    }
+    return nodePath;
+}
+/**
+ * Prompt for user input with optional default value
+ */
+async function prompt(rl, question, defaultValue) {
+    const defaultText = defaultValue ? ` [${defaultValue}]` : '';
+    return new Promise((resolve) => {
+        rl.question(`${question}${defaultText}: `, (answer) => {
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}
+/**
+ * Prompt for password (hidden input)
+ */
+async function promptPassword(question) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        stdout.write(`${question}: `);
+        // Pause stdin first to clear any buffered input
+        stdin.pause();
+        // Enable raw mode to capture keystrokes without echo
+        if (stdin.isTTY) {
+            stdin.setRawMode(true);
+        }
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        let password = '';
+        const onData = (key) => {
+            switch (key) {
+                case '\n':
+                case '\r':
+                case '\u0004': // Ctrl+D
+                    // Restore terminal state
+                    stdin.removeListener('data', onData);
+                    stdin.setRawMode(false);
+                    stdin.pause();
+                    stdout.write('\n');
+                    resolve(password);
+                    break;
+                case '\u0003': // Ctrl+C
+                    // Restore terminal state and exit
+                    stdin.setRawMode(false);
+                    stdout.write('\n');
+                    process.exit(1);
+                    break;
+                case '\u007F': // Backspace
+                case '\b': // Backspace (alternative)
+                    if (password.length > 0) {
+                        password = password.slice(0, -1);
+                        stdout.write('\b \b'); // Erase last asterisk
+                    }
+                    break;
+                default:
+                    // Only add printable characters
+                    if (key.length === 1 && key.charCodeAt(0) >= 32) {
+                        password += key;
+                        stdout.write('*');
+                    }
+                    break;
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
+/**
+ * Read existing Claude Desktop config
+ */
+function readExistingConfig(configPath) {
+    try {
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, 'utf8');
+            return JSON.parse(content);
+        }
+    }
+    catch (err) {
+        warn(`Could not read existing config: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return {};
+}
+/**
+ * Write config to file, creating directories if needed
+ */
+function writeConfig(configPath, config) {
+    const configDir = path.dirname(configPath);
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+        success(`Created directory: ${configDir}`);
+    }
+    // Write config with nice formatting
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+/**
+ * Main setup function
+ */
+async function runSetup() {
+    header('Hailer MCP Setup for Claude Desktop');
+    // Detect environment
+    log('Detecting environment...\n');
+    let nodePath;
+    let appJsPath;
+    let configPath;
+    try {
+        nodePath = getNodePath();
+        success(`Node.js: ${nodePath}`);
+    }
+    catch (err) {
+        error(`Failed to detect Node.js: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    try {
+        appJsPath = getAppJsPath();
+        success(`MCP Server: ${appJsPath}`);
+    }
+    catch (err) {
+        error(`${err instanceof Error ? err.message : String(err)}`);
+        log('\nTo install globally, run:');
+        log(`  ${colors.cyan}npm install -g @hailer/mcp${colors.reset}`);
+        log('\nThen run setup again:');
+        log(`  ${colors.cyan}hailer-mcp setup${colors.reset}`);
+        process.exit(1);
+    }
+    try {
+        configPath = getClaudeConfigPath();
+        success(`Config path: ${configPath}`);
+    }
+    catch (err) {
+        error(`${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    // Create readline interface
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        header('Hailer Credentials');
+        log('Enter your Hailer account credentials.');
+        log('(Recommended: use a dedicated bot account with access to one workspace)\n');
+        const email = await prompt(rl, 'Hailer email');
+        if (!email) {
+            error('Email is required');
+            process.exit(1);
+        }
+        // Close readline temporarily for password input
+        rl.close();
+        const password = await promptPassword('Hailer password');
+        if (!password) {
+            error('Password is required');
+            process.exit(1);
+        }
+        // Reopen readline for remaining prompts
+        const rl2 = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const apiUrl = await prompt(rl2, 'API URL', 'https://api.hailer.com');
+        rl2.close();
+        // Generate config
+        header('Generating Configuration');
+        const existingConfig = readExistingConfig(configPath);
+        const existingServers = existingConfig.mcpServers || {};
+        // Check if hailer config already exists
+        if (existingServers.hailer) {
+            warn('Existing "hailer" MCP server configuration found - will be updated');
+        }
+        const newConfig = {
+            ...existingConfig,
+            mcpServers: {
+                ...existingServers,
+                hailer: {
+                    command: nodePath,
+                    args: [appJsPath],
+                    env: {
+                        MCP_CLIENT_API_KEY: 'claude-desktop',
+                        HAILER_EMAIL: email,
+                        HAILER_PASSWORD: password,
+                        HAILER_API_URL: apiUrl,
+                    },
+                },
+            },
+        };
+        // Write config
+        writeConfig(configPath, newConfig);
+        success(`Config written to ${configPath}`);
+        // Success message
+        header('Setup Complete!');
+        log('Claude Desktop is now configured to use Hailer MCP.');
+        log('');
+        log(`${colors.bright}Next steps:${colors.reset}`);
+        log('  1. Restart Claude Desktop (quit and reopen)');
+        log('  2. Look for "hailer" in the MCP tools list');
+        log('  3. Try asking Claude to list your Hailer workflows');
+        log('');
+        warn('Security note: Your password is stored in plain text in the config file.');
+        log('Consider using a dedicated bot account with limited permissions.');
+    }
+    catch (err) {
+        error(`Setup failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=setup.js.map

package/package.json

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