@johpaz/hive-mcp 0.1.1

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@johpaz/hive-mcp",
+  "version": "0.1.1",
+  "description": "Hive MCP Client — Model Context Protocol client layer",
+  "main": "./src/index.ts",
+  "license": "MIT",
+  "files": [
+    "src/"
+  ],
+  "scripts": {
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "typescript": "latest",
+    "@types/bun": "latest"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./transports": "./src/transports/index.ts"
+  }
+}

package/src/config.ts

@@ -0,0 +1,12 @@
+export interface MCPConfig {
+  servers?: Record<string, MCPServerConfig>;
+}
+
+export interface MCPServerConfig {
+  transport: "stdio" | "sse" | "websocket";
+  enabled?: boolean;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  url?: string;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./manager.ts";

package/src/logger.ts

@@ -0,0 +1,40 @@
+type LogLevel = "debug" | "info" | "warn" | "error";
+
+class Logger {
+  private context: string;
+  private level: LogLevel = "info";
+
+  constructor(context: string) {
+    this.context = context;
+  }
+
+  private log(level: LogLevel, message: string, data?: Record<string, unknown>): void {
+    const levels: LogLevel[] = ["debug", "info", "warn", "error"];
+    if (levels.indexOf(level) < levels.indexOf(this.level)) return;
+
+    const timestamp = new Date().toISOString();
+    const prefix = `[${timestamp}] [${level.toUpperCase().padEnd(5)}] [${this.context}]`;
+    
+    if (data) {
+      console.log(`${prefix} ${message}`, JSON.stringify(data));
+    } else {
+      console.log(`${prefix} ${message}`);
+    }
+  }
+
+  debug(message: string, data?: Record<string, unknown>): void { this.log("debug", message, data); }
+  info(message: string, data?: Record<string, unknown>): void { this.log("info", message, data); }
+  warn(message: string, data?: Record<string, unknown>): void { this.log("warn", message, data); }
+  error(message: string, data?: Record<string, unknown>): void { this.log("error", message, data); }
+
+  child(context: string): Logger {
+    return new Logger(`${this.context}:${context}`);
+  }
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+}
+
+export const logger = new Logger("mcp");
+export type { LogLevel };

package/src/manager.ts

@@ -0,0 +1,325 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { MCPConfig, MCPServerConfig } from "./config.ts";
+import { logger } from "./logger.ts";
+import * as path from "node:path";
+import { 
+  createTransport, 
+  type TransportType,
+} from "./transports/index.ts";
+
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export interface MCPResource {
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+}
+
+export interface MCPPrompt {
+  name: string;
+  description?: string;
+  arguments?: Array<{
+    name: string;
+    description?: string;
+    required?: boolean;
+  }>;
+}
+
+interface MCPServerState {
+  name: string;
+  config: MCPServerConfig;
+  client: Client | null;
+  transport: Transport | null;
+  status: "connected" | "disconnected" | "error" | "connecting";
+  tools: MCPTool[];
+  resources: MCPResource[];
+  prompts: MCPPrompt[];
+  reconnectAttempts: number;
+}
+
+export class MCPClientManager {
+  private servers: Map<string, MCPServerState> = new Map();
+  private config: MCPConfig;
+  private log = logger.child("mcp");
+
+  constructor(config: MCPConfig) {
+    this.config = config;
+  }
+
+  async initialize(): Promise<void> {
+    const servers = this.config.servers ?? {};
+    
+    for (const [name, serverConfig] of Object.entries(servers)) {
+      if (serverConfig.enabled !== false) {
+        this.servers.set(name, {
+          name,
+          config: serverConfig as MCPServerConfig,
+          client: null,
+          transport: null,
+          status: "disconnected",
+          tools: [],
+          resources: [],
+          prompts: [],
+          reconnectAttempts: 0,
+        });
+      }
+    }
+
+    this.log.info(`MCP Client initialized with ${this.servers.size} servers`);
+  }
+
+  private expandPath(p: string): string {
+    if (p.startsWith("~")) {
+      return path.join(process.env.HOME ?? "", p.slice(1));
+    }
+    return p;
+  }
+
+  private createTransportForServer(state: MCPServerState): Transport {
+    const transportType = state.config.transport as TransportType;
+
+    switch (transportType) {
+      case "stdio": {
+        const command = state.config.command ?? "npx";
+        const args = state.config.args ?? [];
+        
+        const env: Record<string, string> = {};
+        for (const [key, value] of Object.entries(process.env)) {
+          if (value !== undefined) {
+            env[key] = value;
+          }
+        }
+        if (state.config.env) {
+          for (const [key, value] of Object.entries(state.config.env)) {
+            env[key] = this.expandPath(value);
+          }
+        }
+
+        return createTransport({
+          type: "stdio",
+          stdio: { command, args, env },
+        });
+      }
+
+      case "sse": {
+        const url = state.config.url;
+        if (!url) {
+          throw new Error("SSE transport requires 'url' config");
+        }
+        return createTransport({
+          type: "sse",
+          sse: { url },
+        });
+      }
+
+      case "websocket": {
+        const url = state.config.url;
+        if (!url) {
+          throw new Error("WebSocket transport requires 'url' config");
+        }
+        return createTransport({
+          type: "websocket",
+          websocket: { url },
+        });
+      }
+
+      default:
+        throw new Error(`Unknown transport type: ${transportType}`);
+    }
+  }
+
+  async connectServer(name: string): Promise<void> {
+    const state = this.servers.get(name);
+    if (!state) {
+      throw new Error(`MCP server not found: ${name}`);
+    }
+
+    if (state.status === "connected") {
+      return;
+    }
+
+    state.status = "connecting";
+    this.log.info(`Connecting to MCP server: ${name}`);
+
+    try {
+      const transport = this.createTransportForServer(state);
+
+      const client = new Client(
+        { name: "hive", version: "0.1.0" },
+        { capabilities: {} }
+      );
+
+      await client.connect(transport);
+
+      state.client = client;
+      state.transport = transport;
+      state.status = "connected";
+      state.reconnectAttempts = 0;
+
+      await this.discoverCapabilities(name);
+
+      this.log.info(`Connected to MCP server: ${name}`, {
+        tools: state.tools.length,
+        resources: state.resources.length,
+      });
+    } catch (error) {
+      state.status = "error";
+      this.log.error(`Failed to connect to MCP server ${name}`, {
+        error: (error as Error).message,
+      });
+      throw error;
+    }
+  }
+
+  private async discoverCapabilities(name: string): Promise<void> {
+    const state = this.servers.get(name);
+    if (!state?.client) return;
+
+    try {
+      const toolsResult = await state.client.listTools();
+      state.tools = (toolsResult.tools ?? []).map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+        inputSchema: t.inputSchema as Record<string, unknown>,
+      }));
+    } catch {
+      this.log.debug(`No tools from MCP server: ${name}`);
+    }
+
+    try {
+      const resourcesResult = await state.client.listResources();
+      state.resources = (resourcesResult.resources ?? []).map((r) => ({
+        uri: r.uri,
+        name: r.name,
+        description: r.description,
+        mimeType: r.mimeType,
+      }));
+    } catch {
+      this.log.debug(`No resources from MCP server: ${name}`);
+    }
+
+    try {
+      const promptsResult = await state.client.listPrompts();
+      state.prompts = (promptsResult.prompts ?? []).map((p) => ({
+        name: p.name,
+        description: p.description,
+        arguments: p.arguments,
+      }));
+    } catch {
+      this.log.debug(`No prompts from MCP server: ${name}`);
+    }
+  }
+
+  async disconnectServer(name: string): Promise<void> {
+    const state = this.servers.get(name);
+    if (!state) return;
+
+    if (state.client) {
+      try {
+        await state.client.close();
+      } catch {
+        // Ignore close errors
+      }
+    }
+
+    state.client = null;
+    state.transport = null;
+    state.status = "disconnected";
+    
+    this.log.info(`Disconnected from MCP server: ${name}`);
+  }
+
+  async callTool(
+    serverName: string,
+    toolName: string,
+    args: Record<string, unknown>
+  ): Promise<unknown> {
+    const state = this.servers.get(serverName);
+    if (!state?.client) {
+      throw new Error(`MCP server not connected: ${serverName}`);
+    }
+
+    this.log.debug(`Calling MCP tool: ${serverName}/${toolName}`, { args });
+
+    const result = await state.client.callTool({
+      name: toolName,
+      arguments: args,
+    });
+
+    return result.content;
+  }
+
+  async readResource(serverName: string, uri: string): Promise<unknown> {
+    const state = this.servers.get(serverName);
+    if (!state?.client) {
+      throw new Error(`MCP server not connected: ${serverName}`);
+    }
+
+    const result = await state.client.readResource({ uri });
+    return result.contents;
+  }
+
+  getServerStatus(name: string): MCPServerState["status"] | undefined {
+    return this.servers.get(name)?.status;
+  }
+
+  getServerTools(name: string): MCPTool[] {
+    return this.servers.get(name)?.tools ?? [];
+  }
+
+  getServerResources(name: string): MCPResource[] {
+    return this.servers.get(name)?.resources ?? [];
+  }
+
+  getAllTools(): Map<string, MCPTool[]> {
+    const result = new Map<string, MCPTool[]>();
+    for (const [name, state] of this.servers) {
+      if (state.status === "connected") {
+        result.set(name, state.tools);
+      }
+    }
+    return result;
+  }
+
+  listServers(): Array<{ name: string; status: string; tools: number }> {
+    return Array.from(this.servers.values()).map((s) => ({
+      name: s.name,
+      status: s.status,
+      tools: s.tools.length,
+    }));
+  }
+
+  async connectAll(): Promise<void> {
+    const promises: Promise<void>[] = [];
+    
+    for (const name of this.servers.keys()) {
+      promises.push(
+        this.connectServer(name).catch((error) => {
+          this.log.error(`Failed to connect ${name}: ${error.message}`);
+        })
+      );
+    }
+
+    await Promise.allSettled(promises);
+  }
+
+  async disconnectAll(): Promise<void> {
+    const promises: Promise<void>[] = [];
+    
+    for (const name of this.servers.keys()) {
+      promises.push(this.disconnectServer(name));
+    }
+
+    await Promise.allSettled(promises);
+  }
+}
+
+export function createMCPManager(config: MCPConfig): MCPClientManager {
+  return new MCPClientManager(config);
+}

package/src/transports/index.ts

@@ -0,0 +1,51 @@
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { SSETransport, type SSETransportConfig } from "./sse.ts";
+import { WebSocketTransport, type WebSocketTransportConfig } from "./websocket.ts";
+
+export { SSETransport, type SSETransportConfig };
+export { WebSocketTransport, type WebSocketTransportConfig };
+
+export interface StdioTransportConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export type TransportType = "stdio" | "sse" | "websocket";
+
+export interface TransportOptions {
+  type: TransportType;
+  stdio?: StdioTransportConfig;
+  sse?: SSETransportConfig;
+  websocket?: WebSocketTransportConfig;
+}
+
+export function createTransport(options: TransportOptions): Transport {
+  switch (options.type) {
+    case "stdio":
+      if (!options.stdio) {
+        throw new Error("stdio config required for stdio transport");
+      }
+      return new StdioClientTransport({
+        command: options.stdio.command,
+        args: options.stdio.args ?? [],
+        env: options.stdio.env ?? (process.env as Record<string, string>),
+      });
+
+    case "sse":
+      if (!options.sse) {
+        throw new Error("sse config required for SSE transport");
+      }
+      return new SSETransport(options.sse) as unknown as Transport;
+
+    case "websocket":
+      if (!options.websocket) {
+        throw new Error("websocket config required for WebSocket transport");
+      }
+      return new WebSocketTransport(options.websocket) as unknown as Transport;
+
+    default:
+      throw new Error(`Unknown transport type: ${options.type}`);
+  }
+}

package/src/transports/sse.ts

@@ -0,0 +1,59 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+export interface SSETransportConfig {
+  url: string;
+  headers?: Record<string, string>;
+}
+
+export class SSETransport {
+  private url: string;
+  private headers: Record<string, string>;
+  private abortController: AbortController | null = null;
+  
+  onmessage: ((message: unknown) => void) | undefined;
+  onerror: ((error: Error) => void) | undefined;
+  onclose: (() => void) | undefined;
+
+  constructor(config: SSETransportConfig) {
+    this.url = config.url;
+    this.headers = config.headers ?? {};
+  }
+
+  async start(): Promise<void> {
+    this.abortController = new AbortController();
+  }
+
+  async close(): Promise<void> {
+    this.abortController?.abort();
+    this.abortController = null;
+    
+    if (this.onclose) {
+      this.onclose();
+    }
+  }
+
+  async send(message: unknown): Promise<void> {
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers,
+      },
+      body: JSON.stringify(message),
+      signal: this.abortController?.signal,
+    });
+
+    if (!response.ok) {
+      throw new Error(`SSE request failed: ${response.status}`);
+    }
+
+    const data = await response.json();
+    if (this.onmessage && data) {
+      this.onmessage(data);
+    }
+  }
+}
+
+export function createSSETransport(config: SSETransportConfig): Transport {
+  return new SSETransport(config) as unknown as Transport;
+}

package/src/transports/websocket.ts

@@ -0,0 +1,70 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+export interface WebSocketTransportConfig {
+  url: string;
+  headers?: Record<string, string>;
+}
+
+export class WebSocketTransport {
+  private url: string;
+  private ws: WebSocket | null = null;
+  
+  onmessage: ((message: unknown) => void) | undefined;
+  onerror: ((error: Error) => void) | undefined;
+  onclose: (() => void) | undefined;
+
+  constructor(config: WebSocketTransportConfig) {
+    this.url = config.url;
+  }
+
+  async start(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.url);
+
+      this.ws.onopen = () => resolve();
+
+      this.ws.onmessage = (event) => {
+        if (this.onmessage) {
+          try {
+            const data = JSON.parse(event.data as string);
+            this.onmessage(data);
+          } catch {
+            // Ignore parse errors
+          }
+        }
+      };
+
+      this.ws.onerror = () => {
+        const error = new Error("WebSocket connection failed");
+        if (this.onerror) {
+          this.onerror(error);
+        }
+        reject(error);
+      };
+
+      this.ws.onclose = () => {
+        if (this.onclose) {
+          this.onclose();
+        }
+      };
+    });
+  }
+
+  async close(): Promise<void> {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  async send(message: unknown): Promise<void> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket not connected");
+    }
+    this.ws.send(JSON.stringify(message));
+  }
+}
+
+export function createWebSocketTransport(config: WebSocketTransportConfig): Transport {
+  return new WebSocketTransport(config) as unknown as Transport;
+}