@cardor/heimdall-mcp 0.1.0

package/dist/chunk-VOBMDW4J.js

@@ -0,0 +1,660 @@
+// src/proxy/McpProxy.ts
+import { EventEmitter } from "events";
+
+// src/interceptor/ForwardInterceptor.ts
+var ForwardInterceptor = class {
+  constructor(outbound) {
+    this.outbound = outbound;
+  }
+  outbound;
+  name = "ForwardInterceptor";
+  async intercept(request, _context, _next) {
+    return this.outbound.sendAndWait(request);
+  }
+};
+
+// src/interceptor/InterceptorPipeline.ts
+import { randomBytes } from "crypto";
+var InterceptorPipeline = class {
+  interceptors = [];
+  use(interceptor) {
+    this.interceptors.push(interceptor);
+    return this;
+  }
+  async run(request) {
+    const context = {
+      startedAt: /* @__PURE__ */ new Date(),
+      traceId: randomBytes(16).toString("hex"),
+      spanId: randomBytes(8).toString("hex"),
+      metadata: {}
+    };
+    let index = 0;
+    const next = async () => {
+      const interceptor = this.interceptors[index++];
+      if (!interceptor) throw new Error("Pipeline ended without ForwardInterceptor");
+      return interceptor.intercept(request, context, next);
+    };
+    return next();
+  }
+};
+
+// src/interceptor/TelemetryInterceptor.ts
+var TelemetryInterceptor = class {
+  constructor(collector) {
+    this.collector = collector;
+  }
+  collector;
+  name = "TelemetryInterceptor";
+  async intercept(request, context, next) {
+    context.startedAt = /* @__PURE__ */ new Date();
+    let response;
+    let status = "ok";
+    try {
+      response = await next();
+      if (response.error) status = "error";
+    } catch (err) {
+      status = "error";
+      response = {
+        jsonrpc: "2.0",
+        id: request.id,
+        error: { code: -32603, message: String(err) }
+      };
+    }
+    const endedAt = /* @__PURE__ */ new Date();
+    const durationMs = endedAt.getTime() - context.startedAt.getTime();
+    await this.collector.record({
+      traceId: context.traceId,
+      spanId: context.spanId,
+      request,
+      response,
+      status,
+      startedAt: context.startedAt,
+      endedAt,
+      durationMs
+    });
+    return response;
+  }
+};
+
+// src/telemetry/LogEmitter.ts
+import pc from "picocolors";
+var LogEmitter = class {
+  enabled;
+  constructor(enabled = true) {
+    this.enabled = enabled;
+  }
+  info(message, meta) {
+    this.emit("info", message, meta);
+  }
+  warn(message, meta) {
+    this.emit("warn", message, meta);
+  }
+  error(message, meta) {
+    this.emit("error", message, meta);
+  }
+  debug(message, meta) {
+    this.emit("debug", message, meta);
+  }
+  emit(level, message, meta) {
+    if (!this.enabled) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = {
+      info: pc.blue("[info]"),
+      warn: pc.yellow("[warn]"),
+      error: pc.red("[error]"),
+      debug: pc.gray("[debug]")
+    }[level];
+    const metaStr = meta ? " " + JSON.stringify(meta) : "";
+    process.stderr.write(`${ts} ${prefix} ${message}${metaStr}
+`);
+  }
+};
+
+// src/telemetry/McpSpanBuilder.ts
+import { randomBytes as randomBytes2 } from "crypto";
+var METHOD_TO_SPAN_NAME = {
+  initialize: "mcp.initialize",
+  "tools/list": "mcp.tools.list",
+  "tools/call": "mcp.tool.call",
+  "resources/read": "mcp.resource.read",
+  "resources/list": "mcp.resources.list",
+  "prompts/get": "mcp.prompt.get",
+  "prompts/list": "mcp.prompts.list",
+  shutdown: "mcp.shutdown"
+};
+var McpSpanBuilder = class {
+  build(input) {
+    const method = input.request.method ?? "unknown";
+    const spanName = METHOD_TO_SPAN_NAME[method] ?? `mcp.${method}`;
+    const params = input.request.params;
+    const result = input.response.result;
+    const attributes = this.buildAttributes(method, params, result, input);
+    const events = this.buildEvents(method, params, result);
+    return {
+      id: `${input.traceId}-${input.spanId}`,
+      traceId: input.traceId,
+      spanId: input.spanId,
+      name: spanName,
+      status: input.status,
+      startedAt: input.startedAt,
+      endedAt: input.endedAt,
+      durationMs: input.durationMs,
+      attributes,
+      events
+    };
+  }
+  buildAttributes(method, params, result, input) {
+    const base = {
+      "gen_ai.operation.name": method,
+      "mcp.duration_ms": input.durationMs
+    };
+    if (method === "tools/call") {
+      const name = params?.name;
+      base["gen_ai.tool.name"] = name;
+      base["gen_ai.tool.call.id"] = randomBytes2(8).toString("hex");
+    }
+    if (method === "tools/list") {
+      const tools = result?.tools;
+      base["mcp.tools_count"] = Array.isArray(tools) ? tools.length : 0;
+    }
+    if (method === "resources/read") {
+      base["url.full"] = params?.uri;
+    }
+    if (method === "prompts/get") {
+      base["mcp.prompt_name"] = params?.name;
+    }
+    if (method === "initialize") {
+      const p = params;
+      const r = result;
+      base["mcp.client_version"] = p?.clientInfo?.version;
+      base["mcp.server_version"] = r?.serverInfo?.version;
+      base["mcp.client_capabilities"] = JSON.stringify(p?.capabilities ?? {});
+      base["mcp.server_capabilities"] = JSON.stringify(r?.capabilities ?? {});
+    }
+    return base;
+  }
+  buildEvents(method, params, result) {
+    const events = [];
+    if (method === "tools/call") {
+      events.push({ name: "tool.input", timestamp: /* @__PURE__ */ new Date(), attributes: { body: JSON.stringify(params) } });
+      if (result) events.push({ name: "tool.output", timestamp: /* @__PURE__ */ new Date(), attributes: { body: JSON.stringify(result) } });
+    }
+    if (method === "tools/list" && result) {
+      events.push({ name: "tools.list", timestamp: /* @__PURE__ */ new Date(), attributes: { tools: JSON.stringify(result.tools ?? []) } });
+    }
+    if (method === "prompts/get" && result) {
+      events.push({ name: "prompt.rendered", timestamp: /* @__PURE__ */ new Date(), attributes: { body: JSON.stringify(result) } });
+    }
+    return events;
+  }
+};
+
+// src/telemetry/MetricsRecorder.ts
+var MetricsRecorder = class {
+  metrics = /* @__PURE__ */ new Map();
+  record(toolName, status, durationMs) {
+    const existing = this.metrics.get(toolName) ?? { callCount: 0, errorCount: 0, totalDurationMs: 0 };
+    existing.callCount++;
+    if (status === "error") existing.errorCount++;
+    existing.totalDurationMs += durationMs;
+    this.metrics.set(toolName, existing);
+  }
+  getAll() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [name, m] of this.metrics) {
+      result.set(name, {
+        ...m,
+        avgDurationMs: m.callCount > 0 ? m.totalDurationMs / m.callCount : 0
+      });
+    }
+    return result;
+  }
+};
+
+// src/telemetry/TelemetryCollector.ts
+var TelemetryCollector = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  spanBuilder = new McpSpanBuilder();
+  metrics = new MetricsRecorder();
+  log = new LogEmitter();
+  async record(input) {
+    const span = this.spanBuilder.build(input);
+    const toolName = input.request.params?.name;
+    if (input.request.method === "tools/call" && toolName) {
+      this.metrics.record(toolName, input.status, input.durationMs);
+    }
+    this.log.debug(`${span.name} [${input.status}] ${input.durationMs}ms`, {
+      traceId: span.traceId,
+      spanId: span.spanId
+    });
+    try {
+      await this.store.save(span);
+    } catch (err) {
+      this.log.error("Failed to save span", { err: String(err) });
+    }
+  }
+  getMetrics() {
+    return this.metrics.getAll();
+  }
+};
+
+// src/proxy/McpProxy.ts
+var McpProxy = class extends EventEmitter {
+  constructor(inbound, outbound, store) {
+    super();
+    this.inbound = inbound;
+    this.outbound = outbound;
+    const collector = new TelemetryCollector(store);
+    this.pipeline = new InterceptorPipeline();
+    this.pipeline.use(new TelemetryInterceptor(collector));
+    this.pipeline.use(new ForwardInterceptor(outbound));
+  }
+  inbound;
+  outbound;
+  pipeline;
+  addInterceptor(interceptor) {
+    this.pipeline.use(interceptor);
+    return this;
+  }
+  async start() {
+    this.inbound.onMessage(async (msg) => {
+      try {
+        return await this.pipeline.run(msg);
+      } catch (err) {
+        this.emit("error", err);
+        return {
+          jsonrpc: "2.0",
+          id: msg.id,
+          error: { code: -32603, message: String(err) }
+        };
+      }
+    });
+  }
+  async stop() {
+    await this.inbound.close();
+    await this.outbound.close();
+  }
+};
+
+// src/proxy/ProxyBuilder.ts
+import * as v from "valibot";
+
+// src/store/StoreResolver.ts
+import { homedir } from "os";
+function toLibsqlUrl(connectionString) {
+  if (connectionString.startsWith("file:") || connectionString === ":memory:") {
+    return connectionString;
+  }
+  const raw = connectionString.replace(/^sqlite:\/\//, "");
+  const expanded = raw.startsWith("~/") ? homedir() + raw.slice(1) : raw;
+  return `file:${expanded}`;
+}
+var StoreResolver = class {
+  static async resolve(connectionString) {
+    let store;
+    if (connectionString.startsWith("sqlite://") || connectionString.startsWith("file:") || connectionString === ":memory:") {
+      const { SqliteStore } = await import("./SqliteStore-HMGNDB3O.js");
+      store = new SqliteStore(toLibsqlUrl(connectionString));
+    } else if (connectionString.startsWith("postgres://") || connectionString.startsWith("postgresql://")) {
+      const { PostgresStore } = await import("./PostgresStore-QUSLDMPH.js");
+      store = new PostgresStore(connectionString);
+    } else if (connectionString.startsWith("mysql://")) {
+      const { MySqlStore } = await import("./MySqlStore-VOXUWDAJ.js");
+      store = new MySqlStore(connectionString);
+    } else {
+      throw new Error(`Unsupported store connection string: "${connectionString}". Expected sqlite://, postgres://, or mysql://`);
+    }
+    await store.init();
+    return store;
+  }
+};
+
+// src/transport/HttpInbound.ts
+import { createServer } from "http";
+var HttpInbound = class {
+  constructor(port, host = "0.0.0.0") {
+    this.port = port;
+    this.host = host;
+    this.server = createServer(async (req, res) => {
+      if (req.method !== "POST") {
+        res.writeHead(405).end();
+        return;
+      }
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      const body = Buffer.concat(chunks).toString();
+      try {
+        const msg = JSON.parse(body);
+        const response = this.handler ? await this.handler(msg) : { jsonrpc: "2.0", id: msg.id, result: null };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(response));
+      } catch {
+        res.writeHead(400).end();
+      }
+    });
+  }
+  port;
+  host;
+  handler;
+  server;
+  async send(_message) {
+  }
+  onMessage(handler) {
+    this.handler = handler;
+    this.server.listen(this.port, this.host);
+  }
+  async close() {
+    await new Promise(
+      (resolve, reject) => this.server.close((err) => err ? reject(err) : resolve())
+    );
+  }
+};
+
+// src/transport/HttpOutbound.ts
+var HttpOutbound = class {
+  constructor(url) {
+    this.url = url;
+  }
+  url;
+  async send(message) {
+    await fetch(this.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+  }
+  async sendAndWait(message) {
+    const res = await fetch(this.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+    return res.json();
+  }
+  onMessage(_handler) {
+  }
+  async close() {
+  }
+};
+
+// src/transport/SseInbound.ts
+import { createServer as createServer2 } from "http";
+var SseInbound = class {
+  constructor(port, host = "0.0.0.0") {
+    this.port = port;
+    this.host = host;
+    this.server = createServer2(async (req, res) => {
+      if (req.url === "/sse" && req.method === "GET") {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        });
+        this.clients.add(res);
+        req.on("close", () => this.clients.delete(res));
+        return;
+      }
+      if (req.method === "POST") {
+        const chunks = [];
+        for await (const chunk of req) chunks.push(chunk);
+        try {
+          const msg = JSON.parse(Buffer.concat(chunks).toString());
+          const response = this.handler ? await this.handler(msg) : { jsonrpc: "2.0", id: msg.id, result: null };
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(response));
+        } catch {
+          res.writeHead(400).end();
+        }
+        return;
+      }
+      res.writeHead(404).end();
+    });
+  }
+  port;
+  host;
+  handler;
+  server;
+  clients = /* @__PURE__ */ new Set();
+  async send(message) {
+    const data = `data: ${JSON.stringify(message)}
+
+`;
+    for (const client of this.clients) client.write(data);
+  }
+  onMessage(handler) {
+    this.handler = handler;
+    this.server.listen(this.port, this.host);
+  }
+  async close() {
+    for (const client of this.clients) client.end();
+    await new Promise(
+      (resolve, reject) => this.server.close((err) => err ? reject(err) : resolve())
+    );
+  }
+};
+
+// src/transport/SseOutbound.ts
+var SseOutbound = class {
+  constructor(url) {
+    this.url = url;
+  }
+  url;
+  eventSource;
+  pending = /* @__PURE__ */ new Map();
+  ensureConnected() {
+    if (this.eventSource) return;
+    this.eventSource = new EventSource(`${this.url}/sse`);
+    this.eventSource.onmessage = (e) => {
+      try {
+        const msg = JSON.parse(e.data);
+        const id = msg.id;
+        if (id != null) {
+          const resolve = this.pending.get(id);
+          if (resolve) {
+            this.pending.delete(id);
+            resolve(msg);
+          }
+        }
+      } catch {
+      }
+    };
+  }
+  async send(message) {
+    await fetch(this.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+  }
+  async sendAndWait(message) {
+    this.ensureConnected();
+    return new Promise((resolve, reject) => {
+      const id = message.id;
+      if (id == null) {
+        this.send(message).catch(reject);
+        resolve({ jsonrpc: "2.0", id: null });
+        return;
+      }
+      this.pending.set(id, resolve);
+      this.send(message).catch((err) => {
+        this.pending.delete(id);
+        reject(err);
+      });
+    });
+  }
+  onMessage(_handler) {
+  }
+  async close() {
+    this.eventSource?.close();
+  }
+};
+
+// src/transport/StdioInbound.ts
+import { createInterface } from "readline";
+var StdioInbound = class {
+  handler;
+  async send(message) {
+    process.stdout.write(JSON.stringify(message) + "\n");
+  }
+  onMessage(handler) {
+    this.handler = handler;
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const msg = JSON.parse(trimmed);
+        if (this.handler) {
+          const response = await this.handler(msg);
+          await this.send(response);
+        }
+      } catch {
+      }
+    });
+  }
+  async close() {
+    process.stdin.destroy();
+  }
+};
+
+// src/transport/StdioOutbound.ts
+import { spawn } from "child_process";
+import { createInterface as createInterface2 } from "readline";
+var StdioOutbound = class {
+  proc;
+  pending = /* @__PURE__ */ new Map();
+  constructor(command, args = []) {
+    this.proc = spawn(command, args, {
+      stdio: ["pipe", "pipe", "inherit"]
+    });
+    const rl = createInterface2({ input: this.proc.stdout, terminal: false });
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const msg = JSON.parse(trimmed);
+        const id = msg.id;
+        if (id != null) {
+          const resolve = this.pending.get(id);
+          if (resolve) {
+            this.pending.delete(id);
+            resolve(msg);
+          }
+        }
+      } catch {
+      }
+    });
+  }
+  async send(message) {
+    return new Promise((resolve, reject) => {
+      this.proc.stdin.write(JSON.stringify(message) + "\n", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  async sendAndWait(message) {
+    return new Promise((resolve, reject) => {
+      const id = message.id;
+      if (id == null) {
+        this.send(message).catch(reject);
+        resolve({ jsonrpc: "2.0", id: null });
+        return;
+      }
+      this.pending.set(id, resolve);
+      this.send(message).catch((err) => {
+        this.pending.delete(id);
+        reject(err);
+      });
+    });
+  }
+  // McpTransport.onMessage is not used for outbound — responses come via sendAndWait
+  onMessage(_handler) {
+  }
+  async close() {
+    this.proc.stdin.end();
+    await new Promise((resolve) => this.proc.on("close", resolve));
+  }
+};
+
+// src/transport/TransportFactory.ts
+var TransportFactory = class {
+  static createInbound(config) {
+    switch (config.transport) {
+      case "stdio":
+        return new StdioInbound();
+      case "http":
+        return new HttpInbound(config.port ?? 3e3, config.host);
+      case "sse":
+        return new SseInbound(config.port ?? 3e3, config.host);
+    }
+  }
+  static createOutbound(config) {
+    switch (config.transport) {
+      case "stdio":
+        if (!config.command) throw new Error("outbound stdio requires a command");
+        return new StdioOutbound(config.command, config.args);
+      case "http":
+        if (!config.url) throw new Error("outbound http requires a url");
+        return new HttpOutbound(config.url);
+      case "sse":
+        if (!config.url) throw new Error("outbound sse requires a url");
+        return new SseOutbound(config.url);
+    }
+  }
+};
+
+// src/proxy/ProxyBuilder.ts
+var InboundSchema = v.object({
+  transport: v.picklist(["stdio", "http", "sse"]),
+  port: v.optional(v.number()),
+  host: v.optional(v.string())
+});
+var OutboundSchema = v.object({
+  transport: v.picklist(["stdio", "http", "sse"]),
+  url: v.optional(v.string()),
+  command: v.optional(v.string()),
+  args: v.optional(v.array(v.string()))
+});
+var ProxyBuilder = class _ProxyBuilder {
+  _inbound;
+  _outbound;
+  _store;
+  static create() {
+    return new _ProxyBuilder();
+  }
+  inbound(config) {
+    this._inbound = v.parse(InboundSchema, config);
+    return this;
+  }
+  outbound(config) {
+    this._outbound = v.parse(OutboundSchema, config);
+    return this;
+  }
+  store(connectionString) {
+    this._store = connectionString;
+    return this;
+  }
+  async build() {
+    if (!this._inbound) throw new Error("ProxyBuilder: inbound config is required");
+    if (!this._outbound) throw new Error("ProxyBuilder: outbound config is required");
+    if (!this._store) throw new Error("ProxyBuilder: store connection string is required");
+    const inbound = TransportFactory.createInbound(this._inbound);
+    const outbound = TransportFactory.createOutbound(this._outbound);
+    const store = await StoreResolver.resolve(this._store);
+    return new McpProxy(
+      inbound,
+      outbound,
+      store
+    );
+  }
+};
+
+export {
+  McpProxy,
+  ProxyBuilder
+};
+//# sourceMappingURL=chunk-VOBMDW4J.js.map