@inixiative/hivemind 0.1.7 → 0.1.8

package/dist/mcp/core.d.ts

@@ -0,0 +1,157 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export declare const HIVEMIND_TOOL_DEFS: ({
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            label: {
+                type: string;
+                description: string;
+            };
+            sessionId: {
+                type: string;
+                description: string;
+            };
+            contextSummary: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            agentId: {
+                type: string;
+                description: string;
+            };
+            sessionId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            useGit: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+} | {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            confirm: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            taskId: {
+                type: string;
+                description: string;
+            };
+            agentId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: "object";
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            dryRun: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+})[];
+export declare function executeToolByName(name: string, args: unknown): unknown;
+export declare function createMcpServer(): Server;

package/dist/mcp/core.js

@@ -0,0 +1,78 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { setupTool, executeSetup, registerTool, executeRegister, emitEventTool, executeEmitEvent, queryTool, executeQuery, statusTool, executeStatus, resetTool, executeReset, claimTaskTool, executeClaimTask, startTaskTool, executeStartTask, completeTaskTool, executeCompleteTask, eventsTool, executeEvents, worktreeCleanupTool, executeWorktreeCleanup, } from './tools/index';
+export const HIVEMIND_TOOL_DEFS = [
+    setupTool,
+    registerTool,
+    statusTool,
+    eventsTool,
+    emitEventTool,
+    queryTool,
+    claimTaskTool,
+    startTaskTool,
+    completeTaskTool,
+    worktreeCleanupTool,
+    resetTool,
+];
+const TOOL_EXECUTORS = {
+    hivemind_setup: (args) => executeSetup(args),
+    hivemind_register: (args) => executeRegister(args),
+    hivemind_emit: (args) => executeEmitEvent(args),
+    hivemind_query: (args) => executeQuery(args),
+    hivemind_status: (args) => executeStatus(args),
+    hivemind_reset: (args) => executeReset(args),
+    hivemind_claim_task: (args) => executeClaimTask(args),
+    hivemind_start_task: (args) => executeStartTask(args),
+    hivemind_complete_task: (args) => executeCompleteTask(args),
+    hivemind_events: (args) => executeEvents(args),
+    hivemind_worktree_cleanup: (args) => executeWorktreeCleanup(args),
+};
+export function executeToolByName(name, args) {
+    const executor = TOOL_EXECUTORS[name];
+    if (!executor) {
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    return executor(args);
+}
+export function createMcpServer() {
+    const server = new Server({
+        name: 'hivemind',
+        version: '0.1.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: HIVEMIND_TOOL_DEFS,
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            const result = executeToolByName(name, args);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ error: message }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}

package/dist/mcp/httpServer.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+export declare function startHttpMcpServer(config?: {
+    port?: number;
+    hostname?: string;
+}): Bun.Server<undefined>;

package/dist/mcp/httpServer.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+import { randomUUID } from 'crypto';
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { createMcpServer } from './core';
+const sessions = new Map();
+function unauthorized() {
+    return new Response(JSON.stringify({
+        error: 'Unauthorized',
+        message: 'Missing or invalid bearer token',
+    }), {
+        status: 401,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+function badRequest(message) {
+    return new Response(JSON.stringify({
+        error: 'Bad Request',
+        message,
+    }), {
+        status: 400,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+function requireBearerAuth(req, expectedToken) {
+    const authHeader = req.headers.get('authorization');
+    if (!authHeader?.startsWith('Bearer ')) {
+        return false;
+    }
+    const token = authHeader.slice('Bearer '.length).trim();
+    return token.length > 0 && token === expectedToken;
+}
+async function createSessionTransport() {
+    let transport;
+    transport = new WebStandardStreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        onsessioninitialized: (sessionId) => {
+            sessions.set(sessionId, { transport });
+        },
+        onsessionclosed: (sessionId) => {
+            sessions.delete(sessionId);
+        },
+    });
+    transport.onclose = () => {
+        if (transport.sessionId) {
+            sessions.delete(transport.sessionId);
+        }
+    };
+    const server = createMcpServer();
+    await server.connect(transport);
+    return transport;
+}
+async function handleMcpRequest(req) {
+    const apiToken = process.env.HIVEMIND_API_TOKEN;
+    if (!apiToken) {
+        return badRequest('HIVEMIND_API_TOKEN is not configured on the server');
+    }
+    if (!requireBearerAuth(req, apiToken)) {
+        return unauthorized();
+    }
+    const sessionId = req.headers.get('mcp-session-id');
+    const existing = sessionId ? sessions.get(sessionId) : undefined;
+    let transport = existing?.transport;
+    if (req.method === 'POST') {
+        let parsedBody;
+        try {
+            parsedBody = await req.json();
+        }
+        catch {
+            return badRequest('Invalid JSON request body');
+        }
+        if (!transport) {
+            if (!isInitializeRequest(parsedBody)) {
+                return badRequest('Missing or invalid mcp-session-id for non-initialize request');
+            }
+            transport = await createSessionTransport();
+        }
+        return transport.handleRequest(req, { parsedBody });
+    }
+    if (!transport) {
+        return badRequest('Missing or invalid mcp-session-id');
+    }
+    if (req.method === 'GET' || req.method === 'DELETE') {
+        return transport.handleRequest(req);
+    }
+    return new Response('Method Not Allowed', { status: 405 });
+}
+async function closeAllSessions() {
+    const transports = [...sessions.values()].map((state) => state.transport);
+    sessions.clear();
+    for (const transport of transports) {
+        try {
+            await transport.close();
+        }
+        catch {
+            // Ignore close errors on shutdown
+        }
+    }
+}
+export function startHttpMcpServer(config) {
+    // Network transport always uses lease-based liveness.
+    if (!process.env.HIVEMIND_NETWORK_MODE) {
+        process.env.HIVEMIND_NETWORK_MODE = '1';
+    }
+    const apiToken = process.env.HIVEMIND_API_TOKEN;
+    if (!apiToken) {
+        throw new Error('HIVEMIND_API_TOKEN is required for network mode');
+    }
+    const port = config?.port ?? Number(process.env.PORT || 8787);
+    const hostname = config?.hostname ?? '0.0.0.0';
+    const server = Bun.serve({
+        hostname,
+        port,
+        fetch: async (req) => {
+            const url = new URL(req.url);
+            if (url.pathname === '/health') {
+                return new Response(JSON.stringify({
+                    ok: true,
+                    mode: 'network',
+                    sessions: sessions.size,
+                }), {
+                    headers: { 'content-type': 'application/json' },
+                });
+            }
+            if (url.pathname !== '/mcp') {
+                return new Response('Not Found', { status: 404 });
+            }
+            return handleMcpRequest(req);
+        },
+    });
+    return server;
+}
+if (import.meta.main) {
+    const server = startHttpMcpServer();
+    console.log(`hivemind HTTP MCP listening on http://${server.hostname}:${server.port}/mcp`);
+    const shutdown = async () => {
+        await closeAllSessions();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}

package/dist/mcp/httpServer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mcp/httpServer.test.js

@@ -0,0 +1,164 @@
+import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { spawn } from 'child_process';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { mkdtempSync, rmSync } from 'fs';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+const API_TOKEN = 'hivemind-test-token';
+const PROJECT = 'network-mode-e2e';
+let serverProcess = null;
+let tempBaseDir = '';
+let mcpUrl = '';
+let healthUrl = '';
+async function getFreePort() {
+    const net = await import('net');
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                reject(new Error('Failed to allocate free port'));
+                return;
+            }
+            const { port } = address;
+            server.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(port);
+            });
+        });
+        server.on('error', reject);
+    });
+}
+async function waitForHealthy(url, timeoutMs = 10_000) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        try {
+            const response = await fetch(url);
+            if (response.ok) {
+                return;
+            }
+        }
+        catch {
+            // Retry while server starts
+        }
+        await Bun.sleep(100);
+    }
+    throw new Error(`Timed out waiting for server health at ${url}`);
+}
+function parseToolJson(result) {
+    if (!result || typeof result !== 'object') {
+        throw new Error('Tool result did not return an object');
+    }
+    const content = result.content;
+    const text = content?.find((item) => item.type === 'text')?.text;
+    if (!text) {
+        throw new Error('Tool result did not include text content');
+    }
+    return JSON.parse(text);
+}
+async function createClient(name) {
+    const client = new Client({
+        name,
+        version: '0.1.0',
+    }, { capabilities: {} });
+    const transport = new StreamableHTTPClientTransport(new URL(mcpUrl), {
+        requestInit: {
+            headers: {
+                Authorization: `Bearer ${API_TOKEN}`,
+            },
+        },
+    });
+    await client.connect(transport);
+    return client;
+}
+describe('HTTP MCP server (network mode)', () => {
+    beforeAll(async () => {
+        const port = await getFreePort();
+        mcpUrl = `http://127.0.0.1:${port}/mcp`;
+        healthUrl = `http://127.0.0.1:${port}/health`;
+        tempBaseDir = mkdtempSync(join(tmpdir(), 'hivemind-http-test-'));
+        serverProcess = spawn('bun', ['run', 'src/mcp/httpServer.ts'], {
+            cwd: process.cwd(),
+            env: {
+                ...process.env,
+                PORT: String(port),
+                HIVEMIND_API_TOKEN: API_TOKEN,
+                HIVEMIND_BASE: tempBaseDir,
+                HIVEMIND_NETWORK_MODE: '1',
+            },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        await waitForHealthy(healthUrl);
+    });
+    afterAll(() => {
+        if (serverProcess && !serverProcess.killed) {
+            serverProcess.kill('SIGTERM');
+        }
+        serverProcess = null;
+        if (tempBaseDir) {
+            rmSync(tempBaseDir, { recursive: true, force: true });
+            tempBaseDir = '';
+        }
+    });
+    it('rejects unauthorized MCP requests', async () => {
+        const response = await fetch(mcpUrl, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'initialize',
+                params: {
+                    protocolVersion: '2025-06-18',
+                    capabilities: {},
+                    clientInfo: { name: 'unauthorized-test', version: '0.1.0' },
+                },
+            }),
+        });
+        expect(response.status).toBe(401);
+    });
+    it('allows two separate clients to coordinate through one remote hivemind', async () => {
+        const clientA = await createClient('network-client-a');
+        const clientB = await createClient('network-client-b');
+        try {
+            const registerA = parseToolJson(await clientA.callTool({
+                name: 'hivemind_register',
+                arguments: { project: PROJECT, sessionId: 'session-a' },
+            }));
+            const registerB = parseToolJson(await clientB.callTool({
+                name: 'hivemind_register',
+                arguments: { project: PROJECT, sessionId: 'session-b' },
+            }));
+            const emitResult = parseToolJson(await clientA.callTool({
+                name: 'hivemind_emit',
+                arguments: {
+                    project: PROJECT,
+                    agentId: registerA.agentId,
+                    type: 'note',
+                    content: 'network-e2e-message',
+                },
+            }));
+            expect(emitResult.success).toBe(true);
+            expect(emitResult.agentId).toBe(registerA.agentId);
+            const events = parseToolJson(await clientB.callTool({
+                name: 'hivemind_events',
+                arguments: { project: PROJECT, limit: 20, agentId: registerB.agentId },
+            }));
+            expect(events.events.some((event) => event.content.includes('network-e2e-message'))).toBe(true);
+            const status = parseToolJson(await clientB.callTool({
+                name: 'hivemind_status',
+                arguments: { project: PROJECT, agentId: registerB.agentId },
+            }));
+            const activeAgentIds = status.activeAgents.map((agent) => agent.id);
+            expect(activeAgentIds.includes(registerA.agentId)).toBe(true);
+            expect(activeAgentIds.includes(registerB.agentId)).toBe(true);
+        }
+        finally {
+            await clientA.close();
+            await clientB.close();
+        }
+    });
+});

package/dist/mcp/server.js

@@ -1,99 +1,8 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { setupTool, executeSetup, registerTool, executeRegister, emitEventTool, executeEmitEvent, queryTool, executeQuery, statusTool, executeStatus, resetTool, executeReset, claimTaskTool, executeClaimTask, startTaskTool, executeStartTask, completeTaskTool, executeCompleteTask, eventsTool, executeEvents, worktreeCleanupTool, executeWorktreeCleanup, } from './tools/index';
-const server = new Server({
-    name: 'hivemind',
-    version: '0.1.0',
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-// List available tools
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            setupTool,
-            registerTool,
-            statusTool,
-            eventsTool,
-            emitEventTool,
-            queryTool,
-            claimTaskTool,
-            startTaskTool,
-            completeTaskTool,
-            worktreeCleanupTool,
-            resetTool,
-        ],
-    };
-});
-// Handle tool calls
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-        let result;
-        switch (name) {
-            case 'hivemind_setup':
-                result = executeSetup(args);
-                break;
-            case 'hivemind_register':
-                result = executeRegister(args);
-                break;
-            case 'hivemind_emit':
-                result = executeEmitEvent(args);
-                break;
-            case 'hivemind_query':
-                result = executeQuery(args);
-                break;
-            case 'hivemind_status':
-                result = executeStatus(args);
-                break;
-            case 'hivemind_reset':
-                result = executeReset(args);
-                break;
-            case 'hivemind_claim_task':
-                result = executeClaimTask(args);
-                break;
-            case 'hivemind_start_task':
-                result = executeStartTask(args);
-                break;
-            case 'hivemind_complete_task':
-                result = executeCompleteTask(args);
-                break;
-            case 'hivemind_events':
-                result = executeEvents(args);
-                break;
-            case 'hivemind_worktree_cleanup':
-                result = executeWorktreeCleanup(args);
-                break;
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({ error: message }),
-                },
-            ],
-            isError: true,
-        };
-    }
-});
+import { createMcpServer } from './core';
 async function main() {
+    const server = createMcpServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

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

@@ -51,6 +51,7 @@ export type EmitEventInput = {
     content: string;
     planId?: string;
     taskId?: string;
+    cwd?: string;
 };
 export type EmitEventResult = {
     success: boolean;