@noetaris/harness-mcp 0.1.0

package/README.md

@@ -0,0 +1,258 @@
+# @noetaris/harness-mcp
+
+MCP (Model Context Protocol) client integration for [@noetaris/harness](https://github.com/noetaris-lab/harness). Connect your agents to MCP servers over HTTP or stdio and expose their tools directly to the harness tool-calling pipeline.
+
+## Overview
+
+`@noetaris/harness-mcp` provides two main building blocks:
+
+- **`MCPClient`** — connects to a single MCP server (HTTP or stdio), discovers its tools, and exposes them as `Tool[]` compatible with the harness tool schema
+- **`MCPManager`** — manages a pool of `MCPClient` instances, merges their tool lists, and supports live config reload via file watching
+
+Config files (`.json`, `.ts`, `.js`, `.mjs`) can be loaded with `MCPManager.fromConfig()` or watched for changes with `MCPManager.watch()`.
+
+## Installation
+
+```bash
+pnpm add @noetaris/harness-mcp
+```
+
+Peer dependency:
+
+```bash
+pnpm add @noetaris/harness-types
+```
+
+## Quick Start
+
+```typescript
+import { MCPClient, MCPManager } from '@noetaris/harness-mcp'
+
+// single HTTP server
+const client = await MCPClient.fromHttp('http://localhost:3100/mcp')
+console.log(client.tools()) // Tool[]
+
+// multiple servers via manager
+const manager = new MCPManager([client])
+await manager.addServer({ command: 'npx', args: ['my-mcp-server'] })
+console.log(manager.tools()) // merged Tool[] — last-write-wins on duplicate names
+```
+
+## API Reference
+
+### `MCPClient`
+
+Wraps a single MCP server connection. Use the static factory methods to create instances; the constructor is private.
+
+#### `MCPClient.fromHttp(url, options?): Promise<MCPClient>`
+
+Connects to an MCP server over Streamable HTTP and discovers its tools.
+
+```typescript
+const client = await MCPClient.fromHttp('http://localhost:3100/mcp', {
+  prefix: 'search',     // optional: prefix all tool names with "search/"
+  rediscover: 'per-session', // optional: re-run tool discovery on each harness session start
+})
+```
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `prefix` | `string` | Prepended to all tool names as `{prefix}/{name}`. Useful to namespace tools from different servers. |
+| `rediscover` | `"per-session"` | Re-discovers tools at the start of each harness run (via `bindObserver`). Omit for static tool lists. |
+
+#### `MCPClient.fromStdio(params): Promise<MCPClient>`
+
+Launches a subprocess and connects to it over stdio.
+
+```typescript
+const client = await MCPClient.fromStdio({
+  command: 'npx',
+  args: ['@acme/mcp-server', '--port', '0'],
+  env: { API_KEY: process.env.API_KEY! },
+  prefix: 'acme',
+})
+```
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `command` | `string` | The executable to run. |
+| `args` | `string[]` | Arguments passed to the command. |
+| `env` | `Record<string, string>` | Environment variables for the subprocess. |
+| `prefix` | `string` | Tool name prefix (same as HTTP). |
+| `rediscover` | `"per-session"` | Per-session rediscovery (same as HTTP). |
+
+#### `client.tools(): Tool[]`
+
+Returns the cached tool list from the last `discover()` call.
+
+#### `client.discover(): Promise<void>`
+
+Re-queries the server for its tool list and updates the cache. Called automatically on construction; call manually to refresh.
+
+#### `client.disconnect(): Promise<void>`
+
+Closes the underlying transport. Always call this when the client is no longer needed to avoid resource leaks.
+
+---
+
+### `MCPManager`
+
+Manages a pool of `MCPClient` instances. Tool name conflicts are resolved last-write-wins (later clients in the pool overwrite earlier ones for the same tool name).
+
+#### `new MCPManager(clients, options?)`
+
+```typescript
+const manager = new MCPManager([clientA, clientB], {
+  rediscover: 'per-session', // applies to all clients that don't set their own rediscover option
+})
+```
+
+#### `manager.tools(): Tool[]`
+
+Returns the merged tool list across all connected servers.
+
+#### `manager.addServer(params): Promise<void>`
+
+Connects to a new server and adds it to the pool. Accepts the same parameters as `MCPClient.fromHttp` (pass `{ url: '...' }`) or `MCPClient.fromStdio` (pass `{ command: '...' }`).
+
+```typescript
+await manager.addServer({ url: 'http://localhost:3200/mcp', prefix: 'tools' })
+await manager.addServer({ command: 'my-mcp-server', prefix: 'local' })
+```
+
+#### `manager.removeServer(key): Promise<void>`
+
+Disconnects and removes a server by its URL (HTTP) or command (stdio). Throws `MCPServerNotFoundError` if no server matches the key.
+
+```typescript
+await manager.removeServer('http://localhost:3200/mcp')
+await manager.removeServer('my-mcp-server')
+```
+
+#### `manager.loadConfig(path): Promise<void>`
+
+Loads server definitions from a config file and adds each as a new server. See [Config File Format](#config-file-format) below.
+
+#### `manager.watch(path, options?): Promise<() => Promise<void>>`
+
+Watches a config file for changes and hot-reloads servers. Changes are debounced by 100ms. Returns a `dispose` function to stop watching.
+
+```typescript
+const stopWatching = await manager.watch('./mcp.config.json', {
+  onError: (err) => console.error('MCP reload error:', err),
+})
+
+// later
+await stopWatching()
+```
+
+If a reload fails to add a new server, previously added servers from that reload batch are rolled back before `onError` is called.
+
+#### `manager.bindObserver(observer): void`
+
+Binds the manager to a harness observer. Clients configured with `rediscover: 'per-session'` will call `discover()` at the start of each harness run. Pass the observer you register with `harness.addObserver()`.
+
+```typescript
+const manager = new MCPManager([client], { rediscover: 'per-session' })
+harness.addObserver(manager.bindObserver.bind(manager))
+```
+
+#### `MCPManager.fromConfig(path): Promise<MCPManager>`
+
+Static factory. Creates a new manager and loads servers from a config file in one step.
+
+```typescript
+const manager = await MCPManager.fromConfig('./mcp.config.json')
+```
+
+---
+
+### Config File Format
+
+Config files can be `.json`, `.ts`, `.js`, or `.mjs`. The schema is:
+
+```typescript
+interface MCPConfigSchema {
+  servers: MCPServerEntry[]
+}
+```
+
+**JSON example:**
+
+```json
+{
+  "servers": [
+    { "url": "http://localhost:3100/mcp", "prefix": "search" },
+    {
+      "transport": "stdio",
+      "command": "npx",
+      "args": ["@acme/mcp-server"],
+      "env": { "API_KEY": "secret" },
+      "prefix": "acme",
+      "rediscover": "per-session"
+    }
+  ]
+}
+```
+
+**TypeScript example (`mcp.config.ts`):**
+
+```typescript
+export default {
+  servers: [
+    { url: 'http://localhost:3100/mcp' },
+    { transport: 'stdio' as const, command: 'my-server' },
+  ],
+}
+```
+
+HTTP entries default to `transport: 'http'` and require a `url` field. Stdio entries require `transport: 'stdio'` and a `command` field. Both support optional `prefix` and `rediscover` fields.
+
+---
+
+### Error Classes
+
+#### `MCPServerNotFoundError`
+
+Thrown by `removeServer()` when no client matches the given key.
+
+```typescript
+import { MCPServerNotFoundError } from '@noetaris/harness-mcp'
+
+try {
+  await manager.removeServer('http://gone.invalid')
+} catch (err) {
+  if (err instanceof MCPServerNotFoundError) {
+    console.error(err.key) // 'http://gone.invalid'
+  }
+}
+```
+
+#### `MCPConfigParseError`
+
+Thrown by `loadConfig()` and `watch()` when the config file is structurally invalid.
+
+```typescript
+import { MCPConfigParseError } from '@noetaris/harness-mcp'
+
+try {
+  await manager.loadConfig('./bad-config.json')
+} catch (err) {
+  if (err instanceof MCPConfigParseError) {
+    console.error(err.path)   // file path
+    console.error(err.detail) // what was wrong
+  }
+}
+```
+
+#### `MCPConfigExtensionError`
+
+Thrown when the config file has an unsupported extension.
+
+```typescript
+import { MCPConfigExtensionError } from '@noetaris/harness-mcp'
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,109 @@
+import { Tool } from '@noetaris/harness-types';
+
+interface MCPClientOptions {
+    prefix?: string;
+    rediscover?: "per-session";
+}
+interface MCPStdioParams extends MCPClientOptions {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+type TransportKind = "http" | "stdio";
+type MCPCallToolResult = {
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    isError?: boolean;
+};
+declare class MCPNotConnectedError extends Error {
+    constructor();
+}
+declare class MCPClient {
+    readonly url: string | undefined;
+    readonly command: string | undefined;
+    readonly options: MCPClientOptions;
+    readonly transportKind: TransportKind;
+    private sdk;
+    private cachedTools;
+    private connected;
+    private constructor();
+    static fromHttp(url: string, options?: MCPClientOptions): Promise<MCPClient>;
+    static fromStdio(params: MCPStdioParams): Promise<MCPClient>;
+    discover(): Promise<void>;
+    tools(): Tool[];
+    callTool(params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }): Promise<MCPCallToolResult>;
+    disconnect(): Promise<void>;
+}
+
+interface MCPManagerOptions {
+    rediscover?: 'per-session';
+}
+interface MCPWatchOptions {
+    onError?: (err: Error) => void;
+}
+interface MCPHttpParams extends MCPClientOptions {
+    url: string;
+}
+type LocalObserver = {
+    onRunStart?: (...args: unknown[]) => void;
+    onRunEnd?: (...args: unknown[]) => void;
+    onStepStart?: (...args: unknown[]) => void;
+    onStepEnd?: (...args: unknown[]) => void;
+    onStepError?: (...args: unknown[]) => void;
+    onInterrupt?: (...args: unknown[]) => void;
+    onEvent?: (...args: unknown[]) => void;
+};
+declare class MCPServerNotFoundError extends Error {
+    readonly key: string;
+    constructor(key: string);
+}
+declare class MCPManager {
+    private clients;
+    private readonly options;
+    constructor(clients: MCPClient[], options?: MCPManagerOptions);
+    tools(): Tool[];
+    addServer(params: MCPHttpParams | MCPStdioParams): Promise<void>;
+    removeServer(key: string): Promise<void>;
+    bindObserver(_observer: LocalObserver): void;
+    loadConfig(path: string): Promise<void>;
+    watch(path: string, options?: MCPWatchOptions): Promise<() => Promise<void>>;
+    static fromConfig(path: string): Promise<MCPManager>;
+    private shouldRediscover;
+}
+
+interface MCPHttpEntry {
+    transport?: 'http';
+    url: string;
+    prefix?: string;
+    rediscover?: 'per-session';
+}
+interface MCPStdioEntry {
+    transport: 'stdio';
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    prefix?: string;
+    rediscover?: 'per-session';
+}
+type MCPServerEntry = MCPHttpEntry | MCPStdioEntry;
+interface MCPConfigSchema {
+    servers: MCPServerEntry[];
+}
+declare class MCPConfigParseError extends Error {
+    readonly path: string;
+    readonly detail: string;
+    constructor(path: string, detail: string);
+}
+declare class MCPConfigExtensionError extends Error {
+    readonly path: string;
+    readonly extension: string;
+    constructor(path: string, extension: string);
+}
+
+export { type MCPCallToolResult, MCPClient, type MCPClientOptions, MCPConfigExtensionError, MCPConfigParseError, type MCPConfigSchema, type MCPHttpEntry, type MCPHttpParams, MCPManager, type MCPManagerOptions, MCPNotConnectedError, type MCPServerEntry, MCPServerNotFoundError, type MCPStdioEntry, type MCPStdioParams, type MCPWatchOptions };

package/dist/index.js

@@ -0,0 +1,353 @@
+// src/mcp-client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+var MCPNotConnectedError = class extends Error {
+  constructor() {
+    super("not connected: client has been disconnected");
+    this.name = "MCPNotConnectedError";
+  }
+};
+var MCPClient = class _MCPClient {
+  url;
+  command;
+  options;
+  transportKind;
+  sdk;
+  cachedTools = [];
+  connected = true;
+  constructor(transportKind, options, url, command) {
+    this.transportKind = transportKind;
+    this.options = options;
+    this.url = url;
+    this.command = command;
+    this.sdk = new Client({ name: "@noetaris/harness-mcp", version: "0.1.0" });
+  }
+  static async fromHttp(url, options = {}) {
+    const client = new _MCPClient("http", options, url, void 0);
+    const transport = new StreamableHTTPClientTransport(new URL(url));
+    await client.sdk.connect(transport);
+    await client.discover();
+    return client;
+  }
+  static async fromStdio(params) {
+    const { command, args, env, ...options } = params;
+    const client = new _MCPClient("stdio", options, void 0, command);
+    const stdioParams = { command, ...args !== void 0 && { args }, ...env !== void 0 && { env } };
+    const transport = new StdioClientTransport(stdioParams);
+    await client.sdk.connect(transport);
+    await client.discover();
+    return client;
+  }
+  async discover() {
+    const result = await this.sdk.listTools();
+    const prefix = this.options.prefix;
+    this.cachedTools = result.tools.map((t) => ({
+      name: prefix !== void 0 ? `${prefix}/${t.name}` : t.name,
+      description: t.description ?? "",
+      inputSchema: t.inputSchema
+      // as: MCP SDK types inputSchema as a specific JSON Schema type; harness Tool uses the wider Record<string, unknown>
+    }));
+  }
+  tools() {
+    if (!this.connected) {
+      throw new MCPNotConnectedError();
+    }
+    return this.cachedTools;
+  }
+  async callTool(params) {
+    if (!this.connected) {
+      throw new MCPNotConnectedError();
+    }
+    const result = await this.sdk.callTool(params);
+    return result;
+  }
+  async disconnect() {
+    this.connected = false;
+    await this.sdk.close();
+  }
+};
+
+// src/mcp-manager.ts
+import { watch as fsWatch } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/mcp-config-loader.ts
+import { readFileSync } from "fs";
+import { resolve, extname } from "path";
+import { pathToFileURL } from "url";
+var MCPConfigParseError = class extends Error {
+  path;
+  detail;
+  constructor(path, detail) {
+    super(`invalid MCP config at ${path}: ${detail}`);
+    this.name = "MCPConfigParseError";
+    this.path = path;
+    this.detail = detail;
+  }
+};
+var MCPConfigExtensionError = class extends Error {
+  path;
+  extension;
+  constructor(path, extension) {
+    super(`unsupported config file extension "${extension}" at ${path}: expected .json, .ts, .js, or .mjs`);
+    this.name = "MCPConfigExtensionError";
+    this.path = path;
+    this.extension = extension;
+  }
+};
+function validateEntry(entry, index, configPath) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    throw new MCPConfigParseError(configPath, `servers[${index}]: entry must be an object`);
+  }
+  const raw = entry;
+  const transport = raw["transport"] === void 0 ? "http" : raw["transport"];
+  if (transport !== "http" && transport !== "stdio") {
+    throw new MCPConfigParseError(configPath, `servers[${index}]: unrecognized transport value "${String(transport)}"`);
+  }
+  if (raw["prefix"] !== void 0 && typeof raw["prefix"] !== "string") {
+    throw new MCPConfigParseError(configPath, `servers[${index}]: prefix must be a string`);
+  }
+  if (raw["rediscover"] !== void 0 && raw["rediscover"] !== "per-session") {
+    throw new MCPConfigParseError(configPath, `servers[${index}]: rediscover must be "per-session"`);
+  }
+  const prefix = raw["prefix"];
+  const rediscover = raw["rediscover"];
+  if (transport === "http") {
+    if (!("url" in raw) || raw["url"] === void 0) {
+      throw new MCPConfigParseError(configPath, `servers[${index}]: http entry missing required field: url`);
+    }
+    if (typeof raw["url"] !== "string") {
+      throw new MCPConfigParseError(configPath, `servers[${index}]: url must be a string`);
+    }
+    const result2 = { url: raw["url"] };
+    if (prefix !== void 0) result2.prefix = prefix;
+    if (rediscover !== void 0) result2.rediscover = rediscover;
+    return result2;
+  }
+  if (!("command" in raw) || raw["command"] === void 0) {
+    throw new MCPConfigParseError(configPath, `servers[${index}]: stdio entry missing required field: command`);
+  }
+  if (typeof raw["command"] !== "string") {
+    throw new MCPConfigParseError(configPath, `servers[${index}]: command must be a string`);
+  }
+  if (raw["args"] !== void 0) {
+    if (!Array.isArray(raw["args"])) {
+      throw new MCPConfigParseError(configPath, `servers[${index}]: args must be a string array`);
+    }
+    if (!raw["args"].every((a) => typeof a === "string")) {
+      throw new MCPConfigParseError(configPath, `servers[${index}]: args must be a string array`);
+    }
+  }
+  if (raw["env"] !== void 0) {
+    const env = raw["env"];
+    if (typeof env !== "object" || env === null || Array.isArray(env)) {
+      throw new MCPConfigParseError(configPath, `servers[${index}]: env must be a plain object with string values`);
+    }
+    if (!Object.values(env).every((v) => typeof v === "string")) {
+      throw new MCPConfigParseError(configPath, `servers[${index}]: env must be a plain object with string values`);
+    }
+  }
+  const result = { command: raw["command"] };
+  if (raw["args"] !== void 0) result.args = raw["args"];
+  if (raw["env"] !== void 0) result.env = raw["env"];
+  if (prefix !== void 0) result.prefix = prefix;
+  if (rediscover !== void 0) result.rediscover = rediscover;
+  return result;
+}
+function validateServers(data, configPath) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new MCPConfigParseError(configPath, "config must be a plain object");
+  }
+  const obj = data;
+  if (!Array.isArray(obj["servers"])) {
+    throw new MCPConfigParseError(configPath, "servers must be an array");
+  }
+  return obj["servers"].map((entry, i) => validateEntry(entry, i, configPath));
+}
+async function loadFromDynamicImport(resolvedPath, originalPath) {
+  const fileUrl = pathToFileURL(resolvedPath).href;
+  const mod = await import(fileUrl);
+  const defaultExport = mod.default;
+  if (typeof defaultExport !== "object" || defaultExport === null) {
+    throw new MCPConfigParseError(originalPath, "default export must be a non-null object (missing or invalid default export)");
+  }
+  return validateServers(defaultExport, originalPath);
+}
+function loadFromJson(resolvedPath, originalPath) {
+  let raw;
+  try {
+    raw = readFileSync(resolvedPath, "utf-8");
+  } catch (err) {
+    throw new MCPConfigParseError(originalPath, err.message);
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (err) {
+    throw new MCPConfigParseError(originalPath, err.message);
+  }
+  return validateServers(data, originalPath);
+}
+async function loadMCPConfig(configPath) {
+  const resolvedPath = resolve(configPath);
+  const ext = extname(configPath);
+  if (ext === ".json") {
+    return loadFromJson(resolvedPath, configPath);
+  }
+  if (ext === ".ts" || ext === ".js" || ext === ".mjs") {
+    return loadFromDynamicImport(resolvedPath, configPath);
+  }
+  throw new MCPConfigExtensionError(configPath, ext);
+}
+
+// src/mcp-manager.ts
+var MCPServerNotFoundError = class extends Error {
+  key;
+  constructor(key) {
+    super(`no MCP server registered with key: ${key}`);
+    this.name = "MCPServerNotFoundError";
+    this.key = key;
+  }
+};
+var MCPManager = class _MCPManager {
+  clients;
+  options;
+  constructor(clients, options = {}) {
+    this.clients = [...clients];
+    this.options = options;
+  }
+  tools() {
+    const map = /* @__PURE__ */ new Map();
+    for (const client of this.clients) {
+      for (const tool of client.tools()) {
+        map.set(tool.name, tool);
+      }
+    }
+    return [...map.values()];
+  }
+  async addServer(params) {
+    let client;
+    if ("url" in params) {
+      const { url, ...clientOptions } = params;
+      client = await MCPClient.fromHttp(url, clientOptions);
+    } else {
+      client = await MCPClient.fromStdio(params);
+    }
+    this.clients.push(client);
+  }
+  async removeServer(key) {
+    const index = this.clients.findIndex((c) => c.url === key || c.command === key);
+    if (index === -1) {
+      throw new MCPServerNotFoundError(key);
+    }
+    const client = this.clients[index];
+    await client.disconnect();
+    this.clients.splice(index, 1);
+  }
+  bindObserver(_observer) {
+    const applicable = this.clients.filter((c) => this.shouldRediscover(c));
+    if (applicable.length > 0) {
+      void Promise.all(applicable.map((c) => c.discover()));
+    }
+  }
+  async loadConfig(path) {
+    const entries = await loadMCPConfig(path);
+    for (const entry of entries) {
+      await this.addServer(entry);
+    }
+  }
+  async watch(path, options) {
+    const resolvedPath = resolve2(path);
+    const onError = options?.onError;
+    let disposed = false;
+    let debounceTimer;
+    const reload = async () => {
+      let entries;
+      try {
+        entries = await loadMCPConfig(resolvedPath);
+      } catch (err) {
+        onError?.(err);
+        return;
+      }
+      const currentKeys = new Set(this.clients.map((c) => c.url ?? c.command ?? ""));
+      const newKeys = new Set(entries.map((e) => ("url" in e ? e.url : e.command) ?? ""));
+      const toAdd = entries.filter((e) => {
+        const key = ("url" in e ? e.url : e.command) ?? "";
+        if (!currentKeys.has(key)) return true;
+        const existing = this.clients.find((c) => (c.url ?? c.command) === key);
+        if (existing === void 0) return true;
+        const existingPrefix = existing.options.prefix;
+        const newPrefix = e.prefix;
+        return existingPrefix !== newPrefix;
+      });
+      const toAddKeys = new Set(toAdd.map((e) => ("url" in e ? e.url : e.command) ?? ""));
+      const toRemoveKeys = [...currentKeys].filter((k) => !newKeys.has(k) || toAddKeys.has(k));
+      const addedKeys = [];
+      try {
+        for (const entry of toAdd) {
+          await this.addServer(entry);
+          addedKeys.push(("url" in entry ? entry.url : entry.command) ?? "");
+        }
+      } catch (err) {
+        for (let i = addedKeys.length - 1; i >= 0; i--) {
+          try {
+            await this.removeServer(addedKeys[i]);
+          } catch {
+          }
+        }
+        onError?.(err);
+        return;
+      }
+      for (const key of toRemoveKeys) {
+        try {
+          await this.removeServer(key);
+        } catch (err) {
+          onError?.(err);
+          return;
+        }
+      }
+    };
+    const watcher = fsWatch(resolvedPath);
+    watcher.on("change", () => {
+      if (disposed) return;
+      clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        void reload();
+      }, 100);
+    });
+    watcher.on("error", (err) => {
+      disposed = true;
+      clearTimeout(debounceTimer);
+      watcher.close();
+      onError?.(err);
+    });
+    return () => {
+      if (!disposed) {
+        disposed = true;
+        clearTimeout(debounceTimer);
+        watcher.close();
+      }
+      return Promise.resolve();
+    };
+  }
+  static async fromConfig(path) {
+    const manager = new _MCPManager([]);
+    await manager.loadConfig(path);
+    return manager;
+  }
+  shouldRediscover(client) {
+    if (client.options.rediscover === "per-session") return true;
+    if (client.options.rediscover === void 0 && this.options.rediscover === "per-session") return true;
+    return false;
+  }
+};
+export {
+  MCPClient,
+  MCPConfigExtensionError,
+  MCPConfigParseError,
+  MCPManager,
+  MCPNotConnectedError,
+  MCPServerNotFoundError
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mcp-client.ts","../src/mcp-manager.ts","../src/mcp-config-loader.ts"],"sourcesContent":["import { Client } from \"@modelcontextprotocol/sdk/client/index.js\"\nimport { StreamableHTTPClientTransport } from \"@modelcontextprotocol/sdk/client/streamableHttp.js\"\nimport { StdioClientTransport } from \"@modelcontextprotocol/sdk/client/stdio.js\"\nimport type { Transport } from \"@modelcontextprotocol/sdk/shared/transport.js\"\nimport type { Tool } from \"@noetaris/harness-types\"\n\nexport interface MCPClientOptions {\n  prefix?: string\n  rediscover?: \"per-session\"\n}\n\nexport interface MCPStdioParams extends MCPClientOptions {\n  command: string\n  args?: string[]\n  env?: Record<string, string>\n}\n\ntype TransportKind = \"http\" | \"stdio\"\n\nexport type MCPCallToolResult = {\n  content: Array<{ type: string; text?: string; [key: string]: unknown }>\n  isError?: boolean\n}\n\nexport class MCPNotConnectedError extends Error {\n  constructor() {\n    super(\"not connected: client has been disconnected\")\n    this.name = \"MCPNotConnectedError\"\n  }\n}\n\nexport class MCPClient {\n  readonly url: string | undefined\n  readonly command: string | undefined\n  readonly options: MCPClientOptions\n  readonly transportKind: TransportKind\n\n  private sdk: Client\n  private cachedTools: Tool[] = []\n  private connected = true\n\n  private constructor(\n    transportKind: TransportKind,\n    options: MCPClientOptions,\n    url?: string,\n    command?: string,\n  ) {\n    this.transportKind = transportKind\n    this.options = options\n    this.url = url\n    this.command = command\n    this.sdk = new Client({ name: \"@noetaris/harness-mcp\", version: \"0.1.0\" })\n  }\n\n  static async fromHttp(url: string, options: MCPClientOptions = {}): Promise<MCPClient> {\n    const client = new MCPClient(\"http\", options, url, undefined)\n    const transport = new StreamableHTTPClientTransport(new URL(url))\n    await client.sdk.connect(transport as Transport) // as: StreamableHTTPClientTransport implements Transport but the SDK typings don't extend the base interface directly\n    await client.discover()\n    return client\n  }\n\n  static async fromStdio(params: MCPStdioParams): Promise<MCPClient> {\n    const { command, args, env, ...options } = params\n    const client = new MCPClient(\"stdio\", options, undefined, command)\n    const stdioParams = { command, ...(args !== undefined && { args }), ...(env !== undefined && { env }) }\n    const transport = new StdioClientTransport(stdioParams)\n    await client.sdk.connect(transport as Transport) // as: StdioClientTransport implements Transport but the SDK typings don't extend the base interface directly\n    await client.discover()\n    return client\n  }\n\n  async discover(): Promise<void> {\n    const result = await this.sdk.listTools()\n    const prefix = this.options.prefix\n    this.cachedTools = result.tools.map(t => ({\n      name: prefix !== undefined ? `${prefix}/${t.name}` : t.name,\n      description: t.description ?? \"\",\n      inputSchema: t.inputSchema as Record<string, unknown>, // as: MCP SDK types inputSchema as a specific JSON Schema type; harness Tool uses the wider Record<string, unknown>\n    }))\n  }\n\n  tools(): Tool[] {\n    if (!this.connected) {\n      throw new MCPNotConnectedError()\n    }\n    return this.cachedTools\n  }\n\n  async callTool(params: { name: string; arguments?: Record<string, unknown> }): Promise<MCPCallToolResult> {\n    if (!this.connected) {\n      throw new MCPNotConnectedError()\n    }\n    const result = await this.sdk.callTool(params)\n    return result as MCPCallToolResult // as: SDK callTool returns a wider union type; MCPCallToolResult matches the content structure\n  }\n\n  async disconnect(): Promise<void> {\n    this.connected = false\n    await this.sdk.close()\n  }\n}\n","import { watch as fsWatch } from 'node:fs'\nimport { resolve } from 'node:path'\nimport type { Tool } from '@noetaris/harness-types'\nimport { MCPClient, type MCPClientOptions, type MCPStdioParams } from './mcp-client.js'\nimport { loadMCPConfig } from './mcp-config-loader.js'\n\nexport interface MCPManagerOptions {\n  rediscover?: 'per-session'\n}\n\nexport interface MCPWatchOptions {\n  onError?: (err: Error) => void\n}\n\nexport interface MCPHttpParams extends MCPClientOptions {\n  url: string\n}\n\ntype LocalObserver = {\n  onRunStart?:  (...args: unknown[]) => void\n  onRunEnd?:    (...args: unknown[]) => void\n  onStepStart?: (...args: unknown[]) => void\n  onStepEnd?:   (...args: unknown[]) => void\n  onStepError?: (...args: unknown[]) => void\n  onInterrupt?: (...args: unknown[]) => void\n  onEvent?:     (...args: unknown[]) => void\n}\n\nexport class MCPServerNotFoundError extends Error {\n  readonly key: string\n  constructor(key: string) {\n    super(`no MCP server registered with key: ${key}`)\n    this.name = 'MCPServerNotFoundError'\n    this.key = key\n  }\n}\n\nexport class MCPManager {\n  private clients: MCPClient[]\n  private readonly options: MCPManagerOptions\n\n  constructor(clients: MCPClient[], options: MCPManagerOptions = {}) {\n    this.clients = [...clients]\n    this.options = options\n  }\n\n  tools(): Tool[] {\n    const map = new Map<string, Tool>()\n    for (const client of this.clients) {\n      for (const tool of client.tools()) {\n        map.set(tool.name, tool)\n      }\n    }\n    return [...map.values()]\n  }\n\n  async addServer(params: MCPHttpParams | MCPStdioParams): Promise<void> {\n    let client: MCPClient\n    if ('url' in params) {\n      const { url, ...clientOptions } = params\n      client = await MCPClient.fromHttp(url, clientOptions)\n    } else {\n      client = await MCPClient.fromStdio(params)\n    }\n    this.clients.push(client)\n  }\n\n  async removeServer(key: string): Promise<void> {\n    const index = this.clients.findIndex(c => c.url === key || c.command === key)\n    if (index === -1) {\n      throw new MCPServerNotFoundError(key)\n    }\n    // noUncheckedIndexedAccess: index is validated above so the value is defined\n    const client = this.clients[index]!\n    await client.disconnect()\n    this.clients.splice(index, 1)\n  }\n\n  bindObserver(_observer: LocalObserver): void {\n    const applicable = this.clients.filter(c => this.shouldRediscover(c))\n    if (applicable.length > 0) {\n      void Promise.all(applicable.map(c => c.discover()))\n    }\n  }\n\n  async loadConfig(path: string): Promise<void> {\n    const entries = await loadMCPConfig(path)\n    for (const entry of entries) {\n      await this.addServer(entry)\n    }\n  }\n\n  async watch(path: string, options?: MCPWatchOptions): Promise<() => Promise<void>> {\n    const resolvedPath = resolve(path)\n    const onError = options?.onError\n    let disposed = false\n    let debounceTimer: ReturnType<typeof setTimeout> | undefined\n\n    const reload = async (): Promise<void> => {\n      let entries: Array<MCPHttpParams | MCPStdioParams>\n      try {\n        entries = await loadMCPConfig(resolvedPath)\n      } catch (err) {\n        onError?.(err as Error) // as: caught value is typed unknown; caller expects Error\n        return\n      }\n\n      const currentKeys = new Set(this.clients.map(c => c.url ?? c.command ?? ''))\n      const newKeys = new Set(entries.map(e => ('url' in e ? e.url : e.command) ?? ''))\n\n      // entries whose key is not in current set, OR whose key is present but options differ\n      const toAdd = entries.filter(e => {\n        const key = ('url' in e ? e.url : e.command) ?? ''\n        if (!currentKeys.has(key)) return true\n        const existing = this.clients.find(c => (c.url ?? c.command) === key)\n        if (existing === undefined) return true\n        // compare prefix option: if different, treat as replace\n        const existingPrefix = existing.options.prefix\n        const newPrefix = e.prefix\n        return existingPrefix !== newPrefix\n      })\n      // keys to remove: not in new set, OR same key but options differ (matched toAdd key)\n      const toAddKeys = new Set(toAdd.map(e => ('url' in e ? e.url : e.command) ?? ''))\n      const toRemoveKeys = [...currentKeys].filter(k => !newKeys.has(k) || toAddKeys.has(k))\n\n      const addedKeys: string[] = []\n      try {\n        for (const entry of toAdd) {\n          await this.addServer(entry)\n          addedKeys.push(('url' in entry ? entry.url : entry.command) ?? '')\n        }\n      } catch (err) {\n        // rollback successfully added servers in reverse order; swallow rollback errors to ensure onError is always called\n        for (let i = addedKeys.length - 1; i >= 0; i--) {\n          try { await this.removeServer(addedKeys[i]!) } catch { /* swallow: rollback best-effort; onError called below */ }\n        }\n        onError?.(err as Error) // as: caught value is typed unknown; caller expects Error\n        return\n      }\n\n      for (const key of toRemoveKeys) {\n        try {\n          await this.removeServer(key)\n        } catch (err) {\n          onError?.(err as Error) // as: caught value is typed unknown; caller expects Error\n          return\n        }\n      }\n    }\n\n    const watcher = fsWatch(resolvedPath)\n\n    watcher.on('change', () => {\n      if (disposed) return\n      clearTimeout(debounceTimer)\n      debounceTimer = setTimeout(() => {\n        void reload()\n      }, 100)\n    })\n\n    watcher.on('error', (err: Error) => {\n      disposed = true\n      clearTimeout(debounceTimer)\n      watcher.close()\n      onError?.(err)\n    })\n\n    return (): Promise<void> => {\n      if (!disposed) {\n        disposed = true\n        clearTimeout(debounceTimer)\n        watcher.close()\n      }\n      return Promise.resolve()\n    }\n  }\n\n  static async fromConfig(path: string): Promise<MCPManager> {\n    const manager = new MCPManager([])\n    await manager.loadConfig(path)\n    return manager\n  }\n\n  private shouldRediscover(client: MCPClient): boolean {\n    if (client.options.rediscover === 'per-session') return true\n    if (client.options.rediscover === undefined && this.options.rediscover === 'per-session') return true\n    return false\n  }\n}\n","import { readFileSync } from 'node:fs'\nimport { resolve, extname } from 'node:path'\nimport { pathToFileURL } from 'node:url'\nimport type { MCPHttpParams } from './mcp-manager.js'\nimport type { MCPStdioParams } from './mcp-client.js'\n\nexport interface MCPHttpEntry {\n  transport?: 'http'\n  url: string\n  prefix?: string\n  rediscover?: 'per-session'\n}\n\nexport interface MCPStdioEntry {\n  transport: 'stdio'\n  command: string\n  args?: string[]\n  env?: Record<string, string>\n  prefix?: string\n  rediscover?: 'per-session'\n}\n\nexport type MCPServerEntry = MCPHttpEntry | MCPStdioEntry\n\nexport interface MCPConfigSchema {\n  servers: MCPServerEntry[]\n}\n\nexport class MCPConfigParseError extends Error {\n  readonly path: string\n  readonly detail: string\n  constructor(path: string, detail: string) {\n    super(`invalid MCP config at ${path}: ${detail}`)\n    this.name = 'MCPConfigParseError'\n    this.path = path\n    this.detail = detail\n  }\n}\n\nexport class MCPConfigExtensionError extends Error {\n  readonly path: string\n  readonly extension: string\n  constructor(path: string, extension: string) {\n    super(`unsupported config file extension \"${extension}\" at ${path}: expected .json, .ts, .js, or .mjs`)\n    this.name = 'MCPConfigExtensionError'\n    this.path = path\n    this.extension = extension\n  }\n}\n\nfunction validateEntry(entry: unknown, index: number, configPath: string): MCPHttpParams | MCPStdioParams {\n  if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {\n    throw new MCPConfigParseError(configPath, `servers[${index}]: entry must be an object`)\n  }\n\n  const raw = entry as Record<string, unknown> // as: entry is not-null object (Array check above); Record<string,unknown> is the narrowest safe widening\n\n  // default transport to 'http' if absent\n  const transport = raw['transport'] === undefined ? 'http' : raw['transport']\n\n  if (transport !== 'http' && transport !== 'stdio') {\n    throw new MCPConfigParseError(configPath, `servers[${index}]: unrecognized transport value \"${String(transport)}\"`)\n  }\n\n  // validate shared optional fields\n  if (raw['prefix'] !== undefined && typeof raw['prefix'] !== 'string') {\n    throw new MCPConfigParseError(configPath, `servers[${index}]: prefix must be a string`)\n  }\n\n  if (raw['rediscover'] !== undefined && raw['rediscover'] !== 'per-session') {\n    throw new MCPConfigParseError(configPath, `servers[${index}]: rediscover must be \"per-session\"`)\n  }\n\n  const prefix = raw['prefix'] as string | undefined // as: validated typeof === 'string' in the guard above\n  const rediscover = raw['rediscover'] as 'per-session' | undefined // as: validated === 'per-session' in the guard above\n\n  if (transport === 'http') {\n    if (!('url' in raw) || raw['url'] === undefined) {\n      throw new MCPConfigParseError(configPath, `servers[${index}]: http entry missing required field: url`)\n    }\n    if (typeof raw['url'] !== 'string') {\n      throw new MCPConfigParseError(configPath, `servers[${index}]: url must be a string`)\n    }\n\n    const result: MCPHttpParams = { url: raw['url'] }\n    if (prefix !== undefined) result.prefix = prefix\n    if (rediscover !== undefined) result.rediscover = rediscover\n    return result\n  }\n\n  // stdio\n  if (!('command' in raw) || raw['command'] === undefined) {\n    throw new MCPConfigParseError(configPath, `servers[${index}]: stdio entry missing required field: command`)\n  }\n  if (typeof raw['command'] !== 'string') {\n    throw new MCPConfigParseError(configPath, `servers[${index}]: command must be a string`)\n  }\n\n  if (raw['args'] !== undefined) {\n    if (!Array.isArray(raw['args'])) {\n      throw new MCPConfigParseError(configPath, `servers[${index}]: args must be a string array`)\n    }\n    if (!(raw['args'] as unknown[]).every(a => typeof a === 'string')) { // as: Array.isArray confirmed above; unknown[] is safe for .every narrowing\n      throw new MCPConfigParseError(configPath, `servers[${index}]: args must be a string array`)\n    }\n  }\n\n  if (raw['env'] !== undefined) {\n    const env = raw['env']\n    if (typeof env !== 'object' || env === null || Array.isArray(env)) {\n      throw new MCPConfigParseError(configPath, `servers[${index}]: env must be a plain object with string values`)\n    }\n    if (!Object.values(env as Record<string, unknown>).every(v => typeof v === 'string')) { // as: object/non-null/non-array confirmed above; Record<string,unknown> for Object.values narrowing\n      throw new MCPConfigParseError(configPath, `servers[${index}]: env must be a plain object with string values`)\n    }\n  }\n\n  const result: MCPStdioParams = { command: raw['command'] }\n  if (raw['args'] !== undefined) result.args = raw['args'] as string[] // as: validated Array.isArray + every element is string above\n  if (raw['env'] !== undefined) result.env = raw['env'] as Record<string, string> // as: validated plain object with all-string values above\n  if (prefix !== undefined) result.prefix = prefix\n  if (rediscover !== undefined) result.rediscover = rediscover\n  return result\n}\n\nfunction validateServers(data: unknown, configPath: string): Array<MCPHttpParams | MCPStdioParams> {\n  if (typeof data !== 'object' || data === null || Array.isArray(data)) {\n    throw new MCPConfigParseError(configPath, 'config must be a plain object')\n  }\n\n  const obj = data as Record<string, unknown> // as: data is non-null non-array object (guards above); Record<string,unknown> is the narrowest safe widening\n\n  if (!Array.isArray(obj['servers'])) {\n    throw new MCPConfigParseError(configPath, 'servers must be an array')\n  }\n\n  return (obj['servers'] as unknown[]).map((entry, i) => validateEntry(entry, i, configPath)) // as: Array.isArray confirmed on line above; unknown[] is the safe element type for map\n}\n\nasync function loadFromDynamicImport(resolvedPath: string, originalPath: string): Promise<Array<MCPHttpParams | MCPStdioParams>> {\n  const fileUrl = pathToFileURL(resolvedPath).href\n  // dynamic import errors (missing file, syntax error) propagate as-is\n  const mod = await import(fileUrl)\n  const defaultExport: unknown = mod.default\n\n  if (typeof defaultExport !== 'object' || defaultExport === null) {\n    throw new MCPConfigParseError(originalPath, 'default export must be a non-null object (missing or invalid default export)')\n  }\n\n  return validateServers(defaultExport, originalPath)\n}\n\nfunction loadFromJson(resolvedPath: string, originalPath: string): Array<MCPHttpParams | MCPStdioParams> {\n  let raw: string\n  try {\n    raw = readFileSync(resolvedPath, 'utf-8')\n  } catch (err) {\n    throw new MCPConfigParseError(originalPath, (err as Error).message) // as: catch binds unknown; fs errors are always Error instances with .message\n  }\n\n  let data: unknown\n  try {\n    data = JSON.parse(raw)\n  } catch (err) {\n    throw new MCPConfigParseError(originalPath, (err as Error).message) // as: catch binds unknown; JSON.parse throws SyntaxError (an Error) with .message\n  }\n\n  return validateServers(data, originalPath)\n}\n\nexport async function loadMCPConfig(configPath: string): Promise<Array<MCPHttpParams | MCPStdioParams>> {\n  const resolvedPath = resolve(configPath)\n  const ext = extname(configPath)\n\n  if (ext === '.json') {\n    return loadFromJson(resolvedPath, configPath)\n  }\n\n  if (ext === '.ts' || ext === '.js' || ext === '.mjs') {\n    return loadFromDynamicImport(resolvedPath, configPath)\n  }\n\n  throw new MCPConfigExtensionError(configPath, ext)\n}\n"],"mappings":"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","names":["resolve","result","resolve"]}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@noetaris/harness-mcp",
+  "version": "0.1.0",
+  "description": "MCP server integration for @noetaris/harness",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/noetaris-lab/harness-mcp.git"
+  },
+  "homepage": "https://github.com/noetaris-lab/harness-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/noetaris-lab/harness-mcp/issues"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "pnpm build && pnpm test",
+    "publish:npm": "pnpm publish --access public --no-git-checks"
+  },
+  "files": [
+    "dist"
+  ],
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  },
+  "devDependencies": {
+    "@noetaris/harness-types": "^0.2.0",
+    "@types/node": "^25.9.1",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "peerDependencies": null
+}