@band-ai/sdk 0.1.2

package/dist/chunk-NIAQBANR.js

@@ -0,0 +1,577 @@
+import {
+  buildRoomScopedRegistrations,
+  buildSingleContextRegistrations,
+  buildZodShape
+} from "./chunk-EDPKUUJL.js";
+import {
+  mcpToolNames
+} from "./chunk-GVEQ3RAH.js";
+
+// src/mcp/stdio.ts
+var ThenvoiMcpStdioServer = class {
+  options;
+  registrations;
+  mcpServer = null;
+  transport = null;
+  constructor(options) {
+    this.options = options;
+    const regOptions = {
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: options.enableContactTools,
+      additionalTools: options.additionalTools
+    };
+    if (typeof options.tools === "function") {
+      this.registrations = buildRoomScopedRegistrations(options.tools, regOptions);
+    } else {
+      this.registrations = buildSingleContextRegistrations(options.tools, regOptions);
+    }
+  }
+  get toolNames() {
+    return this.registrations.map((r) => r.name);
+  }
+  async start() {
+    if (this.transport) {
+      return;
+    }
+    const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+    const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+    const { z } = await import("zod");
+    const mcpServer = new McpServer({
+      name: this.options.name ?? "thenvoi",
+      version: "1.0.0"
+    });
+    registerTools(mcpServer, z, this.registrations);
+    const transport = new StdioServerTransport(this.options.stdin, this.options.stdout);
+    await mcpServer.connect(transport);
+    this.mcpServer = mcpServer;
+    this.transport = transport;
+  }
+  async stop() {
+    await this.transport?.close();
+    this.transport = null;
+    this.mcpServer = null;
+  }
+};
+function registerTools(mcpServer, z, registrations) {
+  for (const reg of registrations) {
+    const zodShape = buildZodShape(z, reg.inputSchema.properties, new Set(reg.inputSchema.required));
+    mcpServer.registerTool(
+      reg.name,
+      {
+        description: reg.description,
+        inputSchema: z.object(zodShape)
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK handler signature is complex; our McpToolResult is compatible
+      async (args) => reg.execute(args)
+    );
+  }
+}
+
+// src/mcp/server.ts
+var PORT_RANGE_START = 5e4;
+var PORT_RANGE_END = 6e4;
+var MCP_SERVER_VERSION = "1.0.0";
+var SESSION_IDLE_TTL_MS = 15 * 60 * 1e3;
+var SESSION_SWEEP_INTERVAL_MS = 60 * 1e3;
+var ThenvoiMcpServer = class {
+  options;
+  registrations;
+  httpServer = null;
+  actualPort = null;
+  sessions = /* @__PURE__ */ new Map();
+  sessionSweepTimer = null;
+  constructor(options) {
+    this.options = options;
+    const regOptions = {
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: options.enableContactTools,
+      additionalTools: options.additionalTools
+    };
+    if (typeof options.tools === "function") {
+      this.registrations = buildRoomScopedRegistrations(options.tools, regOptions);
+    } else {
+      this.registrations = buildSingleContextRegistrations(options.tools, regOptions);
+    }
+  }
+  /** Port the server is listening on. Null if not started. */
+  get port() {
+    return this.actualPort;
+  }
+  /** MCP endpoint URL. Null if not started. */
+  get url() {
+    if (this.actualPort === null) {
+      return null;
+    }
+    return `http://127.0.0.1:${this.actualPort}/mcp`;
+  }
+  /** Tool names registered on this server. */
+  get toolNames() {
+    return this.registrations.map((r) => r.name);
+  }
+  async start() {
+    const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    const { isInitializeRequest } = await import("@modelcontextprotocol/sdk/types.js");
+    const expressModule = await import("express");
+    const express = expressModule.default ?? expressModule;
+    const http = await import("http");
+    const { randomUUID } = await import("crypto");
+    const { z } = await import("zod");
+    const serverName = this.options.name ?? "thenvoi";
+    const app = express();
+    app.use(express.json());
+    app.get("/healthz", (_req, res) => {
+      res.json({ status: "ok" });
+    });
+    const handleMcpRequest = async (req, res) => {
+      try {
+        const sessionId = getSessionIdHeader(req.headers["mcp-session-id"]);
+        let session = sessionId ? this.sessions.get(sessionId) : void 0;
+        if (!session) {
+          if (req.method !== "POST" || sessionId || !isInitializeRequest(req.body)) {
+            sendMcpError(res, sessionId ? 404 : 400, sessionId ? "Session not found" : "Bad Request: No valid session ID provided");
+            return;
+          }
+          session = await this.createSession({
+            McpServer,
+            StreamableHTTPServerTransport,
+            serverName,
+            sessionIdGenerator: randomUUID,
+            z
+          });
+        }
+        session.lastSeenAt = Date.now();
+        await session.transport.handleRequest(req, res, req.body);
+      } catch (error) {
+        if (!res.headersSent) {
+          sendMcpError(res, 500, "Internal server error");
+        }
+      }
+    };
+    app.post("/mcp", async (req, res) => {
+      await handleMcpRequest(req, res);
+    });
+    app.get("/mcp", async (req, res) => {
+      await handleMcpRequest(req, res);
+    });
+    app.delete("/mcp", async (req, res) => {
+      await handleMcpRequest(req, res);
+    });
+    const port = this.options.port ?? await findAvailablePort(http);
+    return new Promise((resolve, reject) => {
+      const server = http.createServer(app);
+      server.on("error", reject);
+      server.listen(port, "127.0.0.1", () => {
+        this.httpServer = server;
+        this.actualPort = port;
+        this.startSessionSweep();
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    this.stopSessionSweep();
+    const activeSessions = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.all(activeSessions.map(async (session) => {
+      await session.transport.close();
+    }));
+    if (!this.httpServer) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.httpServer.close((error) => {
+        this.httpServer = null;
+        this.actualPort = null;
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  async createSession(input) {
+    const createdAt = Date.now();
+    const mcpServer = new input.McpServer({ name: input.serverName, version: MCP_SERVER_VERSION });
+    registerTools2(mcpServer, input.z, this.registrations);
+    let record = null;
+    const transport = new input.StreamableHTTPServerTransport({
+      sessionIdGenerator: input.sessionIdGenerator,
+      onsessioninitialized: (sessionId) => {
+        if (!record) {
+          return;
+        }
+        this.sessions.set(sessionId, record);
+      },
+      onsessionclosed: (sessionId) => {
+        this.sessions.delete(sessionId);
+      }
+    });
+    transport.onclose = () => {
+      const sessionId = transport.sessionId;
+      if (sessionId) {
+        this.sessions.delete(sessionId);
+      }
+    };
+    await mcpServer.connect(transport);
+    record = {
+      mcpServer,
+      transport,
+      createdAt,
+      lastSeenAt: createdAt
+    };
+    return record;
+  }
+  startSessionSweep() {
+    if (this.sessionSweepTimer) {
+      return;
+    }
+    this.sessionSweepTimer = setInterval(() => {
+      void this.closeIdleSessions();
+    }, SESSION_SWEEP_INTERVAL_MS);
+    this.sessionSweepTimer.unref?.();
+  }
+  stopSessionSweep() {
+    if (!this.sessionSweepTimer) {
+      return;
+    }
+    clearInterval(this.sessionSweepTimer);
+    this.sessionSweepTimer = null;
+  }
+  async closeIdleSessions() {
+    const cutoff = Date.now() - SESSION_IDLE_TTL_MS;
+    const idleSessions = [...this.sessions.values()].filter((session) => session.lastSeenAt < cutoff);
+    await Promise.all(idleSessions.map(async (session) => {
+      await session.transport.close();
+    }));
+  }
+};
+function getSessionIdHeader(headerValue) {
+  if (typeof headerValue === "string" && headerValue.length > 0) {
+    return headerValue;
+  }
+  return null;
+}
+function sendMcpError(res, status, message) {
+  res.status(status).json({
+    jsonrpc: "2.0",
+    error: {
+      code: -32e3,
+      message
+    },
+    id: null
+  });
+}
+function registerTools2(mcpServer, z, registrations) {
+  for (const reg of registrations) {
+    const zodShape = buildZodShape(z, reg.inputSchema.properties, new Set(reg.inputSchema.required));
+    mcpServer.registerTool(
+      reg.name,
+      {
+        description: reg.description,
+        inputSchema: z.object(zodShape)
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK handler signature is complex; our McpToolResult is compatible
+      async (args) => reg.execute(args)
+    );
+  }
+}
+async function findAvailablePort(http) {
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const port = PORT_RANGE_START + Math.floor(Math.random() * (PORT_RANGE_END - PORT_RANGE_START));
+    const available = await checkPort(http, port);
+    if (available) {
+      return port;
+    }
+  }
+  return 0;
+}
+function checkPort(http, port) {
+  return new Promise((resolve) => {
+    const server = http.createServer();
+    server.once("error", () => resolve(false));
+    server.listen(port, "127.0.0.1", () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+// src/mcp/sse.ts
+var PORT_RANGE_START2 = 5e4;
+var PORT_RANGE_END2 = 6e4;
+var SESSION_IDLE_TTL_MS2 = 15 * 60 * 1e3;
+var SESSION_SWEEP_INTERVAL_MS2 = 60 * 1e3;
+var ThenvoiMcpSseServer = class {
+  options;
+  registrations;
+  httpServer = null;
+  actualPort = null;
+  sessions = /* @__PURE__ */ new Map();
+  sweepTimer = null;
+  constructor(options) {
+    this.options = options;
+    const regOptions = {
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: options.enableContactTools,
+      additionalTools: options.additionalTools
+    };
+    if (typeof options.tools === "function") {
+      this.registrations = buildRoomScopedRegistrations(options.tools, regOptions);
+    } else {
+      this.registrations = buildSingleContextRegistrations(options.tools, regOptions);
+    }
+  }
+  get port() {
+    return this.actualPort;
+  }
+  get sseUrl() {
+    if (this.actualPort === null) {
+      return null;
+    }
+    return `http://127.0.0.1:${this.actualPort}/sse`;
+  }
+  get toolNames() {
+    return this.registrations.map((registration) => registration.name);
+  }
+  async start() {
+    if (this.httpServer) {
+      return;
+    }
+    const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+    const { SSEServerTransport } = await import("@modelcontextprotocol/sdk/server/sse.js");
+    const expressModule = await import("express");
+    const express = expressModule.default ?? expressModule;
+    const http = await import("http");
+    const { z } = await import("zod");
+    const app = express();
+    app.use(express.json());
+    app.get("/healthz", (_req, res) => {
+      res.json({ status: "ok" });
+    });
+    app.get("/sse", async (_req, res) => {
+      const transport = new SSEServerTransport("/messages", res);
+      const mcpServer = new McpServer({
+        name: this.options.name ?? "thenvoi",
+        version: "1.0.0"
+      });
+      registerTools3(mcpServer, z, this.registrations);
+      await mcpServer.connect(transport);
+      const sessionId = transport.sessionId;
+      this.sessions.set(sessionId, {
+        mcpServer,
+        transport,
+        lastSeenAt: Date.now()
+      });
+      transport.onclose = () => {
+        this.sessions.delete(sessionId);
+      };
+      transport.onerror = () => {
+        this.sessions.delete(sessionId);
+      };
+      res.on("close", () => {
+        this.sessions.delete(sessionId);
+      });
+    });
+    app.post("/messages", async (req, res) => {
+      const sessionId = typeof req.query.sessionId === "string" ? req.query.sessionId : null;
+      if (!sessionId) {
+        res.status(400).send("Missing sessionId");
+        return;
+      }
+      const session = this.sessions.get(sessionId);
+      if (!session) {
+        res.status(404).send("Session not found");
+        return;
+      }
+      session.lastSeenAt = Date.now();
+      await session.transport.handlePostMessage(req, res, req.body);
+    });
+    const port = this.options.port ?? await findAvailablePort2(http);
+    await new Promise((resolve, reject) => {
+      const server = http.createServer(app);
+      server.on("error", reject);
+      server.listen(port, "127.0.0.1", () => {
+        this.httpServer = server;
+        this.actualPort = port;
+        this.startSessionSweep();
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    this.stopSessionSweep();
+    const sessions = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.all(sessions.map(async (session) => {
+      await session.transport.close();
+    }));
+    if (!this.httpServer) {
+      return;
+    }
+    const server = this.httpServer;
+    this.httpServer = null;
+    this.actualPort = null;
+    await new Promise((resolve, reject) => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  startSessionSweep() {
+    if (this.sweepTimer) {
+      return;
+    }
+    this.sweepTimer = setInterval(() => {
+      this.closeIdleSessions();
+    }, SESSION_SWEEP_INTERVAL_MS2);
+    this.sweepTimer.unref?.();
+  }
+  stopSessionSweep() {
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+  }
+  closeIdleSessions() {
+    const cutoff = Date.now() - SESSION_IDLE_TTL_MS2;
+    for (const [sessionId, session] of this.sessions) {
+      if (session.lastSeenAt < cutoff) {
+        this.sessions.delete(sessionId);
+        void session.transport.close();
+      }
+    }
+  }
+};
+function registerTools3(mcpServer, z, registrations) {
+  for (const registration of registrations) {
+    const zodShape = buildZodShape(
+      z,
+      registration.inputSchema.properties,
+      new Set(registration.inputSchema.required)
+    );
+    mcpServer.registerTool(
+      registration.name,
+      {
+        description: registration.description,
+        inputSchema: z.object(zodShape)
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK handler signature is complex; our McpToolResult is compatible
+      async (args) => registration.execute(args)
+    );
+  }
+}
+async function findAvailablePort2(http) {
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const port = PORT_RANGE_START2 + Math.floor(Math.random() * (PORT_RANGE_END2 - PORT_RANGE_START2));
+    if (await checkPort2(http, port)) {
+      return port;
+    }
+  }
+  return 0;
+}
+function checkPort2(http, port) {
+  return new Promise((resolve) => {
+    const server = http.createServer();
+    server.once("error", () => {
+      resolve(false);
+    });
+    server.listen(port, "127.0.0.1", () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+// src/mcp/backends.ts
+async function createThenvoiMcpBackend(options) {
+  const registrations = buildRoomScopedRegistrations(
+    options.getToolsForRoom,
+    {
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: true,
+      additionalTools: options.additionalTools
+    }
+  );
+  const allowedTools = mcpToolNames(new Set(registrations.map((registration) => registration.name)));
+  if (options.kind === "sdk") {
+    const { createThenvoiSdkMcpServer } = await import("./sdk-HJUVSSWA.js");
+    const server2 = createThenvoiSdkMcpServer({
+      enableMemoryTools: options.enableMemoryTools,
+      getToolsForRoom: options.getToolsForRoom,
+      additionalTools: options.additionalTools
+    });
+    return {
+      kind: "sdk",
+      server: server2,
+      allowedTools: server2.allowedTools,
+      stop: async () => void 0
+    };
+  }
+  if (options.kind === "stdio") {
+    const server2 = new ThenvoiMcpStdioServer({
+      tools: options.getToolsForRoom,
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: true,
+      additionalTools: options.additionalTools
+    });
+    await server2.start();
+    return {
+      kind: "stdio",
+      server: server2,
+      allowedTools,
+      stop: async () => {
+        await server2.stop();
+      }
+    };
+  }
+  if (options.kind === "sse") {
+    const server2 = new ThenvoiMcpSseServer({
+      tools: options.getToolsForRoom,
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: true,
+      additionalTools: options.additionalTools
+    });
+    await server2.start();
+    return {
+      kind: "sse",
+      server: server2,
+      allowedTools,
+      stop: async () => {
+        await server2.stop();
+      }
+    };
+  }
+  const server = new ThenvoiMcpServer({
+    tools: options.getToolsForRoom,
+    enableMemoryTools: options.enableMemoryTools,
+    enableContactTools: true,
+    additionalTools: options.additionalTools
+  });
+  await server.start();
+  return {
+    kind: "http",
+    server,
+    allowedTools,
+    stop: async () => {
+      await server.stop();
+    }
+  };
+}
+function getThenvoiSdkMcpServerConfig(backend) {
+  if (backend.kind !== "sdk") {
+    throw new Error(`Expected sdk MCP backend, received ${backend.kind}`);
+  }
+  return backend.server.serverConfig;
+}
+
+export {
+  ThenvoiMcpStdioServer,
+  ThenvoiMcpServer,
+  ThenvoiMcpSseServer,
+  createThenvoiMcpBackend,
+  getThenvoiSdkMcpServerConfig
+};

package/dist/chunk-OD2G5LFQ.js

@@ -0,0 +1,78 @@
+// src/core/logger.ts
+var noop = () => void 0;
+var REDACTED_VALUE = "[REDACTED]";
+var CIRCULAR_VALUE = "[Circular]";
+var SENSITIVE_KEY_PATTERN = /(authorization|api[-_]?key|token|secret|password|cookie)/i;
+var NoopLogger = class {
+  debug = noop;
+  info = noop;
+  warn = noop;
+  error = noop;
+};
+var ConsoleLogger = class {
+  debug(message, context) {
+    this.emit("debug", message, context);
+  }
+  info(message, context) {
+    this.emit("info", message, context);
+  }
+  warn(message, context) {
+    this.emit("warn", message, context);
+  }
+  error(message, context) {
+    const payload = context ? ` ${safeSerializeContext(context)}` : "";
+    process.stderr.write(`${message}${payload}
+`);
+  }
+  emit(level, message, context) {
+    const fn = console[level];
+    if (context === void 0) {
+      fn(message);
+      return;
+    }
+    fn(message, sanitizeValue(context));
+  }
+};
+function safeSerializeContext(context) {
+  try {
+    return JSON.stringify(sanitizeValue(context));
+  } catch {
+    return JSON.stringify({ context: "[Unserializable]" });
+  }
+}
+function sanitizeValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return sanitizeValue(
+      {
+        name: value.name,
+        message: value.message,
+        stack: value.stack,
+        ...value.cause !== void 0 ? { cause: value.cause } : {}
+      },
+      seen
+    );
+  }
+  if (seen.has(value)) {
+    return CIRCULAR_VALUE;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeValue(entry, seen));
+  }
+  const sanitized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    sanitized[key] = SENSITIVE_KEY_PATTERN.test(key) ? REDACTED_VALUE : sanitizeValue(entry, seen);
+  }
+  return sanitized;
+}
+
+export {
+  NoopLogger,
+  ConsoleLogger
+};