@hailer/mcp 1.1.10 → 1.1.11

package/dist/mcp/tools/investigate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Investigation Tool - Spawn Claude Code agents to investigate local repos
+ *
+ * Uses `claude -p` (headless mode, subscription-based) to autonomously
+ * explore codebases, search for bugs, and analyze code.
+ */
+import { Tool } from '../tool-registry';
+export declare const investigateRepoTool: Tool;
+//# sourceMappingURL=investigate.d.ts.map

package/dist/mcp/tools/investigate.js

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * Investigation Tool - Spawn Claude Code agents to investigate local repos
+ *
+ * Uses `claude -p` (headless mode, subscription-based) to autonomously
+ * explore codebases, search for bugs, and analyze code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.investigateRepoTool = void 0;
+const zod_1 = require("zod");
+const child_process_1 = require("child_process");
+const tool_registry_1 = require("../tool-registry");
+const logger_1 = require("../../lib/logger");
+const config_1 = require("../../config");
+const logger = (0, logger_1.createLogger)({ component: 'investigate-tool' });
+/**
+ * Resolve claude CLI path at module load
+ */
+const CLAUDE_BIN = (() => {
+    try {
+        return (0, child_process_1.execSync)('which claude', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'claude'; // fallback to PATH lookup
+    }
+})();
+/**
+ * Parse DEV_AI_REPOS env var into a name->path map.
+ * Format: "name1:/path/one,name2:/path/two"
+ */
+function parseRepoPaths() {
+    const raw = config_1.environment.DEV_AI_REPOS;
+    const map = new Map();
+    if (!raw)
+        return map;
+    for (const entry of raw.split(',')) {
+        const colonIdx = entry.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const name = entry.slice(0, colonIdx).trim();
+        const repoPath = entry.slice(colonIdx + 1).trim();
+        if (name && repoPath) {
+            map.set(name, repoPath);
+        }
+    }
+    return map;
+}
+/**
+ * Resolve a repo name to its local filesystem path.
+ */
+function resolveRepoPath(repoName) {
+    const repos = parseRepoPaths();
+    return repos.get(repoName) || null;
+}
+/**
+ * Spawn `claude -p` in a repo directory and return its output.
+ */
+async function spawnInvestigation(prompt, cwd, maxTurns, repoName) {
+    const timeout = config_1.environment.DEV_AI_INVESTIGATION_TIMEOUT;
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(CLAUDE_BIN, [
+            '-p', prompt,
+            '--output-format', 'stream-json',
+            '--verbose',
+            '--allowedTools', 'Read,Glob,Grep,Bash,Task',
+            '--max-turns', String(maxTurns),
+        ], {
+            cwd,
+            timeout,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                // Strip MCP vars so investigation agent doesn't connect to our MCP server
+                MCP_SERVER_URL: undefined,
+                MCP_CLIENT_API_KEY: undefined,
+                MCP_CLIENT_ENABLED: undefined,
+                CLIENT_CONFIGS: undefined,
+                BOT_EMAIL: undefined,
+                BOT_PASSWORD: undefined,
+                BOT_API_BASE_URL: undefined,
+                ANTHROPIC_API_KEY: undefined,
+            },
+        });
+        let lineBuffer = '';
+        let resultText = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+            lineBuffer += data.toString();
+            const lines = lineBuffer.split('\n');
+            lineBuffer = lines.pop() || ''; // Keep incomplete last line in buffer
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const event = JSON.parse(trimmed);
+                    if (event.type === 'system' && event.subtype === 'init') {
+                        logger.debug(`[investigation:${repoName}] Agent initialized | tools: ${(event.tools || []).length} | model: ${event.model || 'unknown'}`);
+                    }
+                    else if (event.type === 'assistant' && event.message?.content) {
+                        for (const block of event.message.content) {
+                            if (block.type === 'tool_use') {
+                                const inputStr = JSON.stringify(block.input || {});
+                                logger.debug(`[investigation:${repoName}] Tool: ${block.name} ${inputStr.length > 200 ? inputStr.slice(0, 200) + '...' : inputStr}`);
+                            }
+                            else if (block.type === 'text') {
+                                const text = (block.text || '').trim();
+                                if (text) {
+                                    logger.debug(`[investigation:${repoName}] ${text.length > 300 ? text.slice(0, 300) + '...' : text}`);
+                                }
+                            }
+                        }
+                    }
+                    else if (event.type === 'tool') {
+                        const content = typeof event.content === 'string' ? event.content : JSON.stringify(event.content || '');
+                        logger.debug(`[investigation:${repoName}] Tool result (${event.tool_name}): ${content.length > 300 ? content.slice(0, 300) + '...' : content}`);
+                    }
+                    else if (event.type === 'result') {
+                        resultText = event.result || '';
+                        const cost = event.total_cost_usd ? `$${event.total_cost_usd.toFixed(4)}` : 'unknown';
+                        const duration = event.duration_ms ? `${(event.duration_ms / 1000).toFixed(1)}s` : 'unknown';
+                        logger.info(`[investigation:${repoName}] Complete | ${resultText.length} chars | ${duration} | cost: ${cost}`);
+                    }
+                }
+                catch {
+                    // Non-JSON line
+                    if (trimmed.length > 0) {
+                        logger.debug(`[investigation:${repoName}] ${trimmed.length > 300 ? trimmed.slice(0, 300) + '...' : trimmed}`);
+                    }
+                }
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            const chunk = data.toString();
+            stderr += chunk;
+            const trimmed = chunk.trim();
+            if (trimmed) {
+                logger.warn(`[investigation:${repoName}] ${trimmed.length > 500 ? trimmed.slice(0, 500) + '...' : trimmed}`);
+            }
+        });
+        proc.on('error', (err) => {
+            reject(new Error(`Failed to spawn claude: ${err.message}`));
+        });
+        proc.on('close', (code) => {
+            // Process any remaining data in lineBuffer
+            if (lineBuffer.trim()) {
+                try {
+                    const event = JSON.parse(lineBuffer.trim());
+                    if (event.type === 'result') {
+                        resultText = event.result || '';
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (code === 0) {
+                resolve(resultText || 'Investigation completed but returned no structured result.');
+            }
+            else {
+                const errDetail = stderr.trim() || `exit code ${code}`;
+                reject(new Error(`Investigation failed: ${errDetail}`));
+            }
+        });
+    });
+}
+const investigateRepoSchema = zod_1.z.object({
+    repoName: zod_1.z.string().describe('Target repo name (must match a configured repo). Available repos depend on DEV_AI_REPOS config.'),
+    prompt: zod_1.z.string().describe('What to investigate - bug description, search query, code question, etc.'),
+    maxTurns: zod_1.z.number().optional().default(30).describe('Max investigation depth (number of agentic turns). Default: 30.'),
+});
+exports.investigateRepoTool = {
+    name: 'investigate_repo',
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: 'Spawn a Claude Code agent to investigate code in a local repo. ' +
+        'Uses claude -p (headless mode, subscription-based). ' +
+        'The agent can explore files, search code, analyze the codebase autonomously, ' +
+        'and spawn investigation teams for parallel exploration of complex issues. ' +
+        'Returns the investigation findings as text.',
+    schema: investigateRepoSchema,
+    async execute(args, _context) {
+        const repos = parseRepoPaths();
+        // If no repos configured, return helpful error
+        if (repos.size === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'No repos configured. Set DEV_AI_REPOS in .env.local (format: "name:/path,name2:/path2").',
+                    }],
+            };
+        }
+        const repoPath = resolveRepoPath(args.repoName);
+        if (!repoPath) {
+            const available = Array.from(repos.keys()).join(', ');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Unknown repo: "${args.repoName}". Available repos: ${available}`,
+                    }],
+            };
+        }
+        const enhancedPrompt = `You are a lead investigator. Use parallel agents to explore the codebase efficiently.
+
+HOW TO USE PARALLEL AGENTS:
+- Call multiple Task tools in a SINGLE response to run them in parallel
+- Each Task call blocks until that agent finishes and returns its findings directly to you
+- Use subagent_type: "Explore" with model: "haiku" — these are fast, read-only codebase search agents
+- Do NOT use TeamCreate, SendMessage, or TaskCreate — just call Task directly
+
+APPROACH:
+1. In your FIRST response, call 2-3 Task tools simultaneously, each with a focused search prompt
+2. You will receive all their findings in the next turn
+3. If needed, do additional targeted searches yourself with Grep/Read
+4. Write your FINAL REPORT
+
+REPORT FORMAT:
+- Root cause of the issue
+- Affected files with paths and line numbers
+- Suggested fix with specific code changes
+
+INVESTIGATION TASK:
+${args.prompt}`;
+        logger.info('Starting investigation', {
+            repo: args.repoName,
+            repoPath,
+            maxTurns: args.maxTurns,
+            promptLength: enhancedPrompt.length,
+        });
+        try {
+            const result = await spawnInvestigation(enhancedPrompt, repoPath, args.maxTurns, args.repoName);
+            logger.info('Investigation completed', {
+                repo: args.repoName,
+                resultLength: result.length,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: result || 'Investigation completed but returned no output.',
+                    }],
+            };
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            logger.error('Investigation failed', { repo: args.repoName, error: errMsg });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Investigation failed: ${errMsg}`,
+                    }],
+            };
+        }
+    },
+};
+//# sourceMappingURL=investigate.js.map

package/dist/mcp-server.js

@@ -495,22 +495,6 @@ class MCPServerService {
                 catch (err) {
                     this.logger.debug('Could not update .mcp.json', { error: err.message });
                 }
-                // Update .opencode/opencode.json with the actual port so OpenCode connects to the right server
-                const opencodeJsonPath = path.join(process.cwd(), '.opencode', 'opencode.json');
-                try {
-                    if (fs.existsSync(opencodeJsonPath)) {
-                        const opencodeJson = JSON.parse(fs.readFileSync(opencodeJsonPath, 'utf-8'));
-                        const hailerMcp = opencodeJson?.mcp?.hailer;
-                        if (hailerMcp?.url && typeof hailerMcp.url === 'string' && hailerMcp.url.includes('localhost:')) {
-                            hailerMcp.url = hailerMcp.url.replace(/localhost:\d+/, `localhost:${port}`);
-                            fs.writeFileSync(opencodeJsonPath, JSON.stringify(opencodeJson, null, 2) + '\n');
-                            this.logger.debug('.opencode/opencode.json updated with port', { port });
-                        }
-                    }
-                }
-                catch (err) {
-                    this.logger.debug('Could not update .opencode/opencode.json', { error: err.message });
-                }
                 resolve();
             });
             this.server.on('error', (error) => {

package/dist/stdio-server.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Stdio MCP Server for Claude Desktop
+ *
+ * Uses @modelcontextprotocol/sdk with StdioServerTransport for
+ * JSON-RPC communication via stdin/stdout.
+ *
+ * This is the entry point when running as Claude Desktop MCP connector.
+ */
+import { ToolRegistry } from './mcp/tool-registry';
+/**
+ * Start the stdio MCP server with all registered tools
+ */
+export declare function startStdioServer(toolRegistry: ToolRegistry): Promise<void>;
+//# sourceMappingURL=stdio-server.d.ts.map

package/dist/stdio-server.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Stdio MCP Server for Claude Desktop
+ *
+ * Uses @modelcontextprotocol/sdk with StdioServerTransport for
+ * JSON-RPC communication via stdin/stdout.
+ *
+ * This is the entry point when running as Claude Desktop MCP connector.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStdioServer = startStdioServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const logger_1 = require("./lib/logger");
+const tool_registry_1 = require("./mcp/tool-registry");
+const UserContextCache_1 = require("./mcp/UserContextCache");
+const config_1 = require("./config");
+const logger = (0, logger_1.createLogger)({ component: 'stdio-server' });
+/**
+ * Start the stdio MCP server with all registered tools
+ */
+async function startStdioServer(toolRegistry) {
+    logger.info('Starting stdio MCP server for Claude Desktop');
+    // Get API key from environment (set in Claude Desktop config)
+    const apiKey = process.env.MCP_CLIENT_API_KEY;
+    if (!apiKey) {
+        logger.error('MCP_CLIENT_API_KEY environment variable is required for stdio mode');
+        process.exit(1);
+    }
+    // Create MCP server
+    const server = new mcp_js_1.McpServer({
+        name: 'hailer-mcp-server',
+        version: '1.0.0',
+    });
+    // Get tool definitions (filtered by allowed groups, excluding NUCLEAR unless enabled)
+    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 });
+    logger.info('Registering tools for stdio server', {
+        toolCount: toolDefinitions.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) => {
+            const startTime = Date.now();
+            logger.debug('Tool call received', { toolName: toolDef.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 duration = Date.now() - startTime;
+                logger.info('Tool call completed', { toolName: toolDef.name, duration });
+                // Handle different result formats
+                if (result && typeof result === 'object' && 'content' in result) {
+                    // Result is already in MCP format { content: [...] }
+                    return result;
+                }
+                // Wrap result in MCP format
+                return {
+                    content: [{
+                            type: 'text',
+                            text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+                        }]
+                };
+            }
+            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 });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: ${errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+        });
+    }
+    // Create stdio transport
+    const transport = new stdio_js_1.StdioServerTransport();
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+        logger.info('Received SIGINT, shutting down stdio server');
+        await server.close();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        logger.info('Received SIGTERM, shutting down stdio server');
+        await server.close();
+        process.exit(0);
+    });
+    // Connect and start serving
+    logger.info('Connecting stdio transport');
+    await server.connect(transport);
+    logger.info('Stdio MCP server is running');
+}
+//# sourceMappingURL=stdio-server.js.map

package/inbox/failures.log

@@ -0,0 +1 @@
+[2026-02-16T05:32:29.204Z] agent-giuseppe-app-builder | skill | hailer-mcp | \"Field '{fieldLabel}' expects Unix ms timestamp (number), got: '{value}'. Convert the date to milliseconds first.\"\n```\n\n**Important:**\n- Read th

package/inbox/usage.jsonl

@@ -0,0 +1,4 @@
+{"ts":"2026-02-13T08:23:26.264Z","agent":"general-purpose","status":"unknown","project":"hailer-mcp","description":"Convert new agents to OpenCode"}
+{"ts":"2026-02-16T05:26:20.980Z","agent":"agent-svetlana-code-review","status":"unknown","project":"hailer-mcp","description":"Check bot date handling code"}
+{"ts":"2026-02-16T05:32:29.203Z","agent":"agent-giuseppe-app-builder","status":"error","project":"hailer-mcp","description":"Add date validation to bot+tools"}
+{"ts":"2026-02-24T12:50:03.634Z","agent":"agent-gunther-mcp-tools","status":"unknown","project":"hailer-mcp","description":"Find removed MCP tools"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hailer/mcp",
-  "version": "1.1.10",
+  "version": "1.1.11",
   "config": {
     "docker": {
       "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"
@@ -25,7 +25,8 @@
     "release:patch": "npm version patch -m 'chore: release v%s' && git push && git push --tags && npm run build && npm publish --access public",
     "release:minor": "npm version minor -m 'chore: release v%s' && git push && git push --tags && npm run build && npm publish --access public",
     "release:major": "npm version major -m 'chore: release v%s' && git push && git push --tags && npm run build && npm publish --access public",
-    "seed-config": "tsx src/commands/seed-config.ts"
+    "seed-config": "tsx src/commands/seed-config.ts",
+    "postinstall": "node scripts/postinstall.cjs"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.54.0",

package/scripts/postinstall.cjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * postinstall: Copies .claude/ (agents, skills, hooks) to the project root.
+ * Runs automatically after `npm install @hailer/mcp`.
+ * Skips when installing in the hailer-mcp repo itself (development).
+ */
+const fs = require('fs');
+const path = require('path');
+
+// Find the project root by walking up from node_modules/@hailer/mcp/
+function findProjectRoot() {
+  let dir = __dirname;
+  // Walk up until we find a package.json that isn't ours
+  for (let i = 0; i < 10; i++) {
+    dir = path.dirname(dir);
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        // Skip if this is our own package.json
+        if (pkg.name === '@hailer/mcp') continue;
+        return dir;
+      } catch { continue; }
+    }
+  }
+  return null;
+}
+
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) return;
+  fs.mkdirSync(dest, { recursive: true });
+
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      // Don't overwrite user's local settings
+      if (entry.name === 'settings.local.json' && fs.existsSync(destPath)) continue;
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+const projectRoot = findProjectRoot();
+
+// Skip if we can't find a project root or if running in dev (our own repo)
+if (!projectRoot) {
+  console.log('@hailer/mcp: skipping agent install (no project root found)');
+  process.exit(0);
+}
+
+const src = path.join(__dirname, '..', '.claude');
+const dest = path.join(projectRoot, '.claude');
+
+if (!fs.existsSync(src)) {
+  console.log('@hailer/mcp: no .claude/ directory in package, skipping');
+  process.exit(0);
+}
+
+copyDir(src, dest);
+console.log(`@hailer/mcp: agents installed to ${dest}`);