@metorial/mcp-server 1.0.0-rc.1

package/dist/index.cjs

@@ -0,0 +1,397 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  auth: () => auth,
+  clientAdapter: () => clientAdapter,
+  config: () => config,
+  createAuth: () => createAuth,
+  createConfig: () => createConfig,
+  createMcpServer: () => createMcpServer,
+  serverAdapter: () => serverAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/instance.ts
+var import_mcp = require("@metorial/mcp");
+
+// src/auth.ts
+var import_zod = __toESM(require("zod"), 1);
+var McpServerAuthConfig = class _McpServerAuthConfig {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  #value = null;
+  #getAuthUrlHandler;
+  #callbackHandler;
+  #tokenRefreshHandler;
+  static create(schema) {
+    return new _McpServerAuthConfig(schema ?? import_zod.default.object({}));
+  }
+  static getImplementation(config2) {
+    if (!config2.#getAuthUrlHandler || !config2.#callbackHandler) {
+      throw new Error("MCP Server auth config is missing required handlers");
+    }
+    return {
+      getAuthUrlHandler: config2.#getAuthUrlHandler,
+      callbackHandler: config2.#callbackHandler,
+      tokenRefreshHandler: config2.#tokenRefreshHandler
+    };
+  }
+  setValue(value) {
+    this.#value = value;
+  }
+  getAuthorizationUrl(cb) {
+    this.#getAuthUrlHandler = async (d) => {
+      let res = await cb(d);
+      if (typeof res == "string") {
+        return { authorizationUrl: res };
+      }
+      return res;
+    };
+    return this;
+  }
+  handleCallback(cb) {
+    this.#callbackHandler = cb;
+    return this;
+  }
+  refreshToken(cb) {
+    this.#tokenRefreshHandler = cb;
+    return this;
+  }
+  build() {
+    if (!this.#getAuthUrlHandler || !this.#callbackHandler) {
+      throw new Error("MCP Server auth config is missing required handlers");
+    }
+    let self = this;
+    return new Proxy(
+      {},
+      {
+        get: (target, prop, receiver) => {
+          if (prop == "__config__") {
+            return self;
+          }
+          if (self.#value === null) {
+            throw new Error("MCP Server auth config value not set");
+          }
+          return self.#value[prop];
+        }
+      }
+    );
+  }
+};
+var createAuth = (schema) => {
+  return McpServerAuthConfig.create(schema);
+};
+var auth = (schema) => createAuth(schema);
+var getAuthConfigImplementation = (configValue) => {
+  let self = configValue["__config__"];
+  return McpServerAuthConfig.getImplementation(self);
+};
+
+// src/client.ts
+var import_mcp_transport_memory = require("@metorial/mcp-transport-memory");
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_zod2 = __toESM(require("zod"), 1);
+var getClient = async (server, notificationListener, opts) => {
+  let transport = (0, import_mcp_transport_memory.createInMemoryTransport)();
+  await server.connect(transport.server);
+  let client = new import_client.Client(opts.client);
+  client.registerCapabilities(opts.capabilities);
+  client.fallbackNotificationHandler = notificationListener;
+  await client.connect(transport.client);
+  return client;
+};
+var handleMcpMessages = async (server, opts, messages) => {
+  let responses = [];
+  let client = await getClient(
+    server,
+    async (notification) => {
+      responses.push(notification);
+    },
+    opts
+  );
+  let error = null;
+  for (let message of messages) {
+    try {
+      if ("id" in message) {
+        let res = await client.request(message, import_zod2.default.any());
+        responses.push(res);
+      } else {
+        await client.notification(message);
+      }
+    } catch (err) {
+      error = err;
+      break;
+    }
+  }
+  return { messages: responses, error };
+};
+
+// src/config.ts
+var McpServerConfig = class _McpServerConfig {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  #value = null;
+  static create(schema) {
+    return new _McpServerConfig(schema);
+  }
+  setValue(value) {
+    let parsed = this.schema.parse(value);
+    this.#value = parsed;
+  }
+  value() {
+    let self = this;
+    return new Proxy(
+      {},
+      {
+        get: (target, prop, receiver) => {
+          if (prop == "__config__") {
+            return self;
+          }
+          if (self.#value === null) {
+            throw new Error("MCP Server config value not set");
+          }
+          return self.#value[prop];
+        }
+      }
+    );
+  }
+};
+var createConfig = (schema) => {
+  return McpServerConfig.create(schema).value();
+};
+var config = (schema) => createConfig(schema);
+var setConfigValue = (configValue, value) => {
+  let self = configValue["__config__"];
+  self.setValue(value);
+};
+var getConfigSchema = (configValue) => {
+  let self = configValue["__config__"];
+  return self.schema.toJSONSchema({
+    unrepresentable: "any",
+    override: (ctx) => {
+      let def = ctx.zodSchema._zod.def;
+      if (def.type === "date") {
+        ctx.jsonSchema.type = "string";
+        ctx.jsonSchema.format = "date-time";
+      }
+      if (def.type === "bigint") {
+        ctx.jsonSchema.type = "number";
+      }
+    }
+  });
+};
+
+// src/instance.ts
+var getServer = (instance) => {
+  if ("server" in instance) {
+    return instance.server;
+  } else {
+    return (0, import_mcp.createMcpServer)(instance);
+  }
+};
+var McpServerInstance = class _McpServerInstance {
+  constructor(instance) {
+    this.instance = instance;
+    this.#server = getServer(instance);
+  }
+  #server;
+  static create(instance) {
+    return new _McpServerInstance(instance);
+  }
+  discover() {
+    return {
+      configSchema: this.instance.config ? getConfigSchema(this.instance.config) : null,
+      oauth: this.instance.authConfig ? {
+        status: "enabled",
+        hasTokenRefresh: !!getAuthConfigImplementation(this.instance.authConfig).tokenRefreshHandler
+      } : {
+        status: "disabled"
+      }
+    };
+  }
+  handleMcpMessages(opts) {
+    setConfigValue(this.instance.config, opts.config);
+    return handleMcpMessages(this.#server, opts.client, opts.message);
+  }
+  getOauthAuthorizationUrl(d) {
+    if (!this.instance.authConfig) return null;
+    let impl = getAuthConfigImplementation(this.instance.authConfig);
+    return impl.getAuthUrlHandler(d);
+  }
+  handleOauthCallback(d) {
+    if (!this.instance.authConfig) return null;
+    let impl = getAuthConfigImplementation(this.instance.authConfig);
+    return impl.callbackHandler(d);
+  }
+  handleOauthTokenRefresh(d) {
+    if (!this.instance.authConfig) return null;
+    let impl = getAuthConfigImplementation(this.instance.authConfig);
+    if (!impl.tokenRefreshHandler) {
+      return null;
+    }
+    return impl.tokenRefreshHandler(d);
+  }
+};
+var createMcpServer = (instance) => {
+  return McpServerInstance.create(instance);
+};
+
+// src/adapter.ts
+var import_zod3 = __toESM(require("zod"), 1);
+var discoverMessage = import_zod3.default.object({
+  type: import_zod3.default.literal("metorial-mcp.discover")
+});
+var authUrlMessage = import_zod3.default.object({
+  type: import_zod3.default.literal("metorial-mcp.get-oauth-authorization-url"),
+  params: import_zod3.default.object({
+    authConfig: import_zod3.default.record(import_zod3.default.string(), import_zod3.default.any()),
+    clientId: import_zod3.default.string(),
+    clientSecret: import_zod3.default.string(),
+    state: import_zod3.default.string(),
+    redirectUri: import_zod3.default.string()
+  })
+});
+var oauthCallbackMessage = import_zod3.default.object({
+  type: import_zod3.default.literal("metorial-mcp.handle-oauth-callback"),
+  params: import_zod3.default.object({
+    authConfig: import_zod3.default.record(import_zod3.default.string(), import_zod3.default.any()),
+    authState: import_zod3.default.record(import_zod3.default.string(), import_zod3.default.string()),
+    clientId: import_zod3.default.string(),
+    clientSecret: import_zod3.default.string(),
+    code: import_zod3.default.string(),
+    state: import_zod3.default.string(),
+    redirectUri: import_zod3.default.string(),
+    callbackUrl: import_zod3.default.string(),
+    authorizationUrl: import_zod3.default.string()
+  })
+});
+var oauthTokenRefreshMessage = import_zod3.default.object({
+  type: import_zod3.default.literal("metorial-mcp.handle-oauth-token-refresh"),
+  params: import_zod3.default.object({
+    authConfig: import_zod3.default.record(import_zod3.default.string(), import_zod3.default.any()),
+    authState: import_zod3.default.record(import_zod3.default.string(), import_zod3.default.string()),
+    refreshToken: import_zod3.default.string(),
+    clientId: import_zod3.default.string(),
+    clientSecret: import_zod3.default.string()
+  })
+});
+var allMessages = import_zod3.default.union([
+  discoverMessage,
+  authUrlMessage,
+  oauthCallbackMessage,
+  oauthTokenRefreshMessage
+]);
+var serverAdapter = async (instance, messages) => Promise.all(
+  messages.map(async (message) => {
+    let parsed = allMessages.parse(message);
+    switch (parsed.type) {
+      case "metorial-mcp.discover": {
+        return instance.discover();
+      }
+      case "metorial-mcp.get-oauth-authorization-url": {
+        return instance.getOauthAuthorizationUrl(parsed.params);
+      }
+      case "metorial-mcp.handle-oauth-callback": {
+        return instance.handleOauthCallback(parsed.params);
+      }
+      case "metorial-mcp.handle-oauth-token-refresh": {
+        return instance.handleOauthTokenRefresh(parsed.params);
+      }
+    }
+    throw new Error(`Unknown message type: ${message.type}`);
+  })
+);
+var clientAdapter = (transport) => {
+  let queue = [];
+  let isSent = { current: false };
+  let isSending = { current: false };
+  let send = async (message) => {
+    let promise = new Promise((resolve, reject) => {
+      queue.push({ msg: message, resolve, reject });
+    });
+    if (!isSending.current) {
+      isSending.current = true;
+      setTimeout(async () => {
+        isSent.current = true;
+        try {
+          let res = await transport(queue.map((q) => q.msg));
+          res.forEach((r, i) => {
+            queue[i].resolve(r);
+          });
+        } catch (err) {
+          queue.forEach((q) => {
+            q.reject(err);
+          });
+        } finally {
+          queue = [];
+        }
+      }, 2);
+    }
+    return promise;
+  };
+  return {
+    discover: async () => {
+      return send({ type: "metorial-mcp.discover" });
+    },
+    getOauthAuthorizationUrl: async (d) => {
+      return send({
+        type: "metorial-mcp.get-oauth-authorization-url",
+        params: d
+      });
+    },
+    handleOauthCallback: async (d) => {
+      return send({
+        type: "metorial-mcp.handle-oauth-callback",
+        params: d
+      });
+    },
+    handleOauthTokenRefresh: async (d) => {
+      return send({
+        type: "metorial-mcp.handle-oauth-token-refresh",
+        params: d
+      });
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  auth,
+  clientAdapter,
+  config,
+  createAuth,
+  createConfig,
+  createMcpServer,
+  serverAdapter
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/instance.ts","../src/auth.ts","../src/client.ts","../src/config.ts","../src/adapter.ts"],"sourcesContent":["export {\n  createMcpServer,\n  type McpServerInstance,\n  type McpServerInstanceOpts,\n  type McpServerInstanceServer\n} from './instance';\n\nexport {\n  clientAdapter,\n  serverAdapter,\n  type McpServerInstanceAdapterResponses,\n  type McpServerInstanceMessage\n} from './adapter';\n\nexport {\n  auth,\n  createAuth,\n  type McpServerAuthCallbackHandler,\n  type McpServerAuthCallbackHandlerParams,\n  type McpServerAuthCallbackHandlerResult,\n  type McpServerAuthConfig,\n  type McpServerAuthTokenRefreshHandler,\n  type McpServerAuthTokenRefreshHandlerParams,\n  type McpServerAuthTokenRefreshHandlerResult,\n  type McpServerAuthUrlHandler,\n  type McpServerAuthUrlHandlerInternal,\n  type McpServerAuthUrlHandlerParams,\n  type McpServerAuthUrlHandlerResult,\n  type McpServerAuthValue\n} from './auth';\n\nexport { config, createConfig, type McpServerConfig } from './config';\n","import {\n  createMcpServer as createMcpServerInternal,\n  CreateMcpServerOpts\n} from '@metorial/mcp';\nimport { McpServer } from '@modelcontextprotocol/sdk/server/mcp';\nimport { JSONRPCMessage } from '@modelcontextprotocol/sdk/types';\nimport {\n  getAuthConfigImplementation,\n  McpServerAuthCallbackHandlerParams,\n  McpServerAuthTokenRefreshHandlerParams,\n  McpServerAuthUrlHandlerParams\n} from './auth';\nimport { ClientOpts, handleMcpMessages } from './client';\nimport { getConfigSchema, setConfigValue } from './config';\n\nexport type McpServerInstanceServer = CreateMcpServerOpts | { server: McpServer };\nlet getServer = (instance: McpServerInstanceServer) => {\n  if ('server' in instance) {\n    return instance.server;\n  } else {\n    return createMcpServerInternal(instance);\n  }\n};\n\nexport type McpServerInstanceOpts = McpServerInstanceServer & {\n  config?: any;\n  authConfig?: any;\n};\n\nexport class McpServerInstance {\n  #server: McpServer;\n\n  private constructor(private instance: McpServerInstanceOpts) {\n    this.#server = getServer(instance);\n  }\n\n  static create(instance: McpServerInstanceOpts) {\n    return new McpServerInstance(instance);\n  }\n\n  discover() {\n    return {\n      configSchema: this.instance.config ? getConfigSchema(this.instance.config) : null,\n      oauth: this.instance.authConfig\n        ? {\n            status: 'enabled' as const,\n            hasTokenRefresh: !!getAuthConfigImplementation(this.instance.authConfig)\n              .tokenRefreshHandler\n          }\n        : {\n            status: 'disabled' as const\n          }\n    };\n  }\n\n  handleMcpMessages(opts: { config: any; client: ClientOpts; message: JSONRPCMessage[] }) {\n    setConfigValue(this.instance.config, opts.config);\n\n    return handleMcpMessages(this.#server, opts.client, opts.message);\n  }\n\n  getOauthAuthorizationUrl(d: McpServerAuthUrlHandlerParams<any>) {\n    if (!this.instance.authConfig) return null;\n    let impl = getAuthConfigImplementation(this.instance.authConfig);\n\n    return impl.getAuthUrlHandler(d);\n  }\n\n  handleOauthCallback(d: McpServerAuthCallbackHandlerParams<any>) {\n    if (!this.instance.authConfig) return null;\n    let impl = getAuthConfigImplementation(this.instance.authConfig);\n\n    return impl.callbackHandler(d);\n  }\n\n  handleOauthTokenRefresh(d: McpServerAuthTokenRefreshHandlerParams<any>) {\n    if (!this.instance.authConfig) return null;\n    let impl = getAuthConfigImplementation(this.instance.authConfig);\n\n    if (!impl.tokenRefreshHandler) {\n      return null;\n    }\n\n    return impl.tokenRefreshHandler(d);\n  }\n}\n\nexport let createMcpServer = (instance: McpServerInstanceOpts) => {\n  return McpServerInstance.create(instance);\n};\n","import z from 'zod';\n\nexport type McpServerAuthUrlHandlerParams<AuthConfig extends {}> = {\n  authConfig: AuthConfig;\n  clientId: string;\n  clientSecret: string;\n  state: string;\n  redirectUri: string;\n};\n\nexport type McpServerAuthUrlHandlerResult = {\n  authorizationUrl: string;\n  authState?: Record<string, string> | null;\n};\n\nexport type McpServerAuthUrlHandlerInternal = <AuthConfig extends {}>(\n  d: McpServerAuthUrlHandlerParams<AuthConfig>\n) => Promise<McpServerAuthUrlHandlerResult>;\n\nexport type McpServerAuthUrlHandler = <AuthConfig extends {}>(\n  d: McpServerAuthUrlHandlerParams<AuthConfig>\n) => Promise<string | McpServerAuthUrlHandlerResult>;\n\nexport type McpServerAuthCallbackHandlerParams<AuthConfig extends {}> = {\n  authConfig: AuthConfig;\n  authState: Record<string, string>;\n  clientId: string;\n  clientSecret: string;\n  code: string;\n  state: string;\n  redirectUri: string;\n  callbackUrl: string;\n  authorizationUrl: string;\n};\n\nexport type McpServerAuthCallbackHandlerResult = {\n  accessToken: string;\n  refreshToken?: string;\n  expiresIn?: number;\n  scope?: string;\n  tokenType?: string;\n  [key: string]: any;\n};\n\nexport type McpServerAuthCallbackHandler = <AuthConfig extends {}>(\n  d: McpServerAuthCallbackHandlerParams<AuthConfig>\n) => Promise<McpServerAuthCallbackHandlerResult>;\n\nexport type McpServerAuthTokenRefreshHandlerParams<AuthConfig extends {}> = {\n  authConfig: AuthConfig;\n  authState: Record<string, string>;\n  refreshToken: string;\n  clientId: string;\n  clientSecret: string;\n};\n\nexport type McpServerAuthTokenRefreshHandlerResult = {\n  accessToken: string;\n  refreshToken?: string;\n  expiresIn?: number;\n  scope?: string;\n  tokenType?: string;\n  [key: string]: any;\n};\n\nexport type McpServerAuthTokenRefreshHandler = <AuthConfig extends {}>(\n  d: McpServerAuthTokenRefreshHandlerParams<AuthConfig>\n) => Promise<McpServerAuthTokenRefreshHandlerResult>;\n\nexport type McpServerAuthValue = {\n  accessToken: string;\n  expiresIn?: number;\n  scope?: string;\n  tokenType?: string;\n  [key: string]: any;\n};\n\nexport class McpServerAuthConfig<AuthConfig extends {}> {\n  #value: McpServerAuthValue | null = null;\n\n  #getAuthUrlHandler?: McpServerAuthUrlHandlerInternal;\n  #callbackHandler?: McpServerAuthCallbackHandler;\n  #tokenRefreshHandler?: McpServerAuthTokenRefreshHandler;\n\n  private constructor(private readonly schema: z.ZodType<AuthConfig>) {}\n\n  static create<AuthConfig extends {}>(schema?: z.ZodType<AuthConfig>) {\n    return new McpServerAuthConfig(schema ?? (z.object({}) as z.ZodType<AuthConfig>));\n  }\n\n  static getImplementation(config: McpServerAuthConfig<any>) {\n    if (!config.#getAuthUrlHandler || !config.#callbackHandler) {\n      throw new Error('MCP Server auth config is missing required handlers');\n    }\n\n    return {\n      getAuthUrlHandler: config.#getAuthUrlHandler,\n      callbackHandler: config.#callbackHandler,\n      tokenRefreshHandler: config.#tokenRefreshHandler\n    };\n  }\n\n  setValue(value: McpServerAuthValue) {\n    this.#value = value;\n  }\n\n  getAuthorizationUrl(cb: McpServerAuthUrlHandler) {\n    this.#getAuthUrlHandler = async d => {\n      let res = await cb(d);\n      if (typeof res == 'string') {\n        return { authorizationUrl: res };\n      }\n      return res;\n    };\n    return this;\n  }\n\n  handleCallback(cb: McpServerAuthCallbackHandler) {\n    this.#callbackHandler = cb;\n    return this;\n  }\n\n  refreshToken(cb: McpServerAuthTokenRefreshHandler) {\n    this.#tokenRefreshHandler = cb;\n    return this;\n  }\n\n  build(): AuthConfig {\n    if (!this.#getAuthUrlHandler || !this.#callbackHandler) {\n      throw new Error('MCP Server auth config is missing required handlers');\n    }\n\n    let self = this;\n\n    // Proxy for getting the config values\n    // or throwing an error if not set\n    return new Proxy(\n      {},\n      {\n        get: (target, prop, receiver) => {\n          if (prop == '__config__') {\n            return self;\n          }\n\n          if (self.#value === null) {\n            throw new Error('MCP Server auth config value not set');\n          }\n\n          return (self.#value as any)[prop];\n        }\n      }\n    ) as any as AuthConfig;\n  }\n}\n\nexport let createAuth = <Config extends {}>(schema?: z.ZodType<Config>) => {\n  return McpServerAuthConfig.create(schema);\n};\n\nexport let auth = <Config extends {}>(schema?: z.ZodType<Config>) => createAuth(schema);\n\nexport let getAuthConfigImplementation = <Config extends {}>(configValue: any) => {\n  let self = configValue['__config__'] as McpServerAuthConfig<Config>;\n  return McpServerAuthConfig.getImplementation(self);\n};\n","import { createInMemoryTransport } from '@metorial/mcp-transport-memory';\nimport { Client } from '@modelcontextprotocol/sdk/client/index.js';\nimport { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';\nimport {\n  ClientCapabilities,\n  JSONRPCMessage,\n  Notification\n} from '@modelcontextprotocol/sdk/types.js';\nimport z from 'zod';\n\nexport interface ClientOpts {\n  client: {\n    name: string;\n    version: string;\n  };\n  capabilities: ClientCapabilities;\n}\n\nexport let getClient = async (\n  server: McpServer,\n  notificationListener: (notification: Notification) => Promise<void>,\n  opts: ClientOpts\n) => {\n  let transport = createInMemoryTransport();\n  await server.connect(transport.server);\n\n  let client = new Client(opts.client);\n\n  client.registerCapabilities(opts.capabilities);\n  client.fallbackNotificationHandler = notificationListener;\n\n  await client.connect(transport.client);\n\n  return client;\n};\n\nexport let handleMcpMessages = async (\n  server: McpServer,\n  opts: ClientOpts,\n  messages: JSONRPCMessage[]\n) => {\n  let responses: JSONRPCMessage[] = [];\n\n  let client = await getClient(\n    server,\n    async notification => {\n      responses.push(notification as JSONRPCMessage);\n    },\n    opts\n  );\n\n  let error: Error | null = null;\n\n  for (let message of messages) {\n    try {\n      if ('id' in message) {\n        let res = await client.request(message as any, z.any());\n        responses.push(res);\n      } else {\n        await client.notification(message as any);\n      }\n    } catch (err) {\n      error = err as Error;\n      break;\n    }\n  }\n\n  return { messages: responses, error };\n};\n","import z from 'zod';\n\nexport class McpServerConfig<Config extends {}> {\n  #value: Config | null = null;\n\n  private constructor(public readonly schema: z.ZodType<Config>) {}\n\n  static create<Config extends {}>(schema: z.ZodType<Config>) {\n    return new McpServerConfig(schema);\n  }\n\n  setValue(value: unknown) {\n    let parsed = this.schema.parse(value);\n    this.#value = parsed;\n  }\n\n  value(): Config {\n    let self = this;\n\n    // Proxy for getting the config values\n    // or throwing an error if not set\n    return new Proxy(\n      {},\n      {\n        get: (target, prop, receiver) => {\n          if (prop == '__config__') {\n            return self;\n          }\n\n          if (self.#value === null) {\n            throw new Error('MCP Server config value not set');\n          }\n\n          return (self.#value as any)[prop];\n        }\n      }\n    ) as any as Config;\n  }\n}\n\nexport let createConfig = <Config extends {}>(schema: z.ZodType<Config>) => {\n  return McpServerConfig.create(schema).value();\n};\n\nexport let config = <Config extends {}>(schema: z.ZodType<Config>) => createConfig(schema);\n\nexport let setConfigValue = <Config extends {}>(configValue: any, value: Config) => {\n  let self = configValue['__config__'] as McpServerConfig<Config>;\n  self.setValue(value);\n};\n\nexport let getConfigSchema = <Config extends {}>(configValue: any) => {\n  let self = configValue['__config__'] as McpServerConfig<Config>;\n  return self.schema.toJSONSchema({\n    unrepresentable: 'any',\n    override: ctx => {\n      let def = ctx.zodSchema._zod.def;\n\n      if (def.type === 'date') {\n        ctx.jsonSchema.type = 'string';\n        ctx.jsonSchema.format = 'date-time';\n      }\n      if (def.type === 'bigint') {\n        ctx.jsonSchema.type = 'number';\n      }\n    }\n  });\n};\n","import z from 'zod';\nimport { McpServerInstance } from './instance';\n\nlet discoverMessage = z.object({\n  type: z.literal('metorial-mcp.discover')\n});\ntype DiscoverMessage = z.infer<typeof discoverMessage>;\n\nlet authUrlMessage = z.object({\n  type: z.literal('metorial-mcp.get-oauth-authorization-url'),\n  params: z.object({\n    authConfig: z.record(z.string(), z.any()),\n    clientId: z.string(),\n    clientSecret: z.string(),\n    state: z.string(),\n    redirectUri: z.string()\n  })\n});\ntype AuthUrlMessage = z.infer<typeof authUrlMessage>;\n\nlet oauthCallbackMessage = z.object({\n  type: z.literal('metorial-mcp.handle-oauth-callback'),\n  params: z.object({\n    authConfig: z.record(z.string(), z.any()),\n    authState: z.record(z.string(), z.string()),\n    clientId: z.string(),\n    clientSecret: z.string(),\n    code: z.string(),\n    state: z.string(),\n    redirectUri: z.string(),\n    callbackUrl: z.string(),\n    authorizationUrl: z.string()\n  })\n});\ntype OauthCallbackMessage = z.infer<typeof oauthCallbackMessage>;\n\nlet oauthTokenRefreshMessage = z.object({\n  type: z.literal('metorial-mcp.handle-oauth-token-refresh'),\n  params: z.object({\n    authConfig: z.record(z.string(), z.any()),\n    authState: z.record(z.string(), z.string()),\n    refreshToken: z.string(),\n    clientId: z.string(),\n    clientSecret: z.string()\n  })\n});\ntype OauthTokenRefreshMessage = z.infer<typeof oauthTokenRefreshMessage>;\n\nlet allMessages = z.union([\n  discoverMessage,\n  authUrlMessage,\n  oauthCallbackMessage,\n  oauthTokenRefreshMessage\n]);\n\nexport type McpServerInstanceMessage =\n  | DiscoverMessage\n  | AuthUrlMessage\n  | OauthCallbackMessage\n  | OauthTokenRefreshMessage;\n\nexport let serverAdapter = async (\n  instance: McpServerInstance,\n  messages: McpServerInstanceMessage[]\n) =>\n  Promise.all(\n    messages.map(async message => {\n      let parsed = allMessages.parse(message);\n\n      switch (parsed.type) {\n        case 'metorial-mcp.discover': {\n          return instance.discover();\n        }\n        case 'metorial-mcp.get-oauth-authorization-url': {\n          return instance.getOauthAuthorizationUrl(parsed.params);\n        }\n        case 'metorial-mcp.handle-oauth-callback': {\n          return instance.handleOauthCallback(parsed.params);\n        }\n        case 'metorial-mcp.handle-oauth-token-refresh': {\n          return instance.handleOauthTokenRefresh(parsed.params);\n        }\n      }\n\n      throw new Error(`Unknown message type: ${(message as any).type}`);\n    })\n  );\n\nexport type McpServerInstanceAdapterResponses = Awaited<ReturnType<typeof serverAdapter>>;\n\nexport let clientAdapter = (\n  transport: (\n    messages: McpServerInstanceMessage[]\n  ) => Promise<McpServerInstanceAdapterResponses>\n) => {\n  let queue: {\n    msg: McpServerInstanceMessage;\n    resolve: (res: any) => void;\n    reject: (err: any) => void;\n  }[] = [];\n  let isSent = { current: false };\n  let isSending = { current: false };\n\n  let send = async (message: McpServerInstanceMessage) => {\n    let promise = new Promise<any>((resolve, reject) => {\n      queue.push({ msg: message, resolve, reject });\n    });\n\n    if (!isSending.current) {\n      isSending.current = true;\n\n      setTimeout(async () => {\n        isSent.current = true;\n\n        try {\n          let res = await transport(queue.map(q => q.msg));\n          res.forEach((r, i) => {\n            queue[i].resolve(r);\n          });\n        } catch (err) {\n          queue.forEach(q => {\n            q.reject(err);\n          });\n        } finally {\n          queue = [];\n        }\n      }, 2);\n    }\n\n    return promise;\n  };\n\n  return {\n    discover: async () => {\n      return send({ type: 'metorial-mcp.discover' }) as Promise<\n        Awaited<ReturnType<McpServerInstance['discover']>>\n      >;\n    },\n\n    getOauthAuthorizationUrl: async (\n      d: Parameters<McpServerInstance['getOauthAuthorizationUrl']>[0]\n    ) => {\n      return send({\n        type: 'metorial-mcp.get-oauth-authorization-url',\n        params: d\n      }) as Promise<Awaited<ReturnType<McpServerInstance['getOauthAuthorizationUrl']>>>;\n    },\n\n    handleOauthCallback: async (\n      d: Parameters<McpServerInstance['handleOauthCallback']>[0]\n    ) => {\n      return send({\n        type: 'metorial-mcp.handle-oauth-callback',\n        params: d\n      }) as Promise<Awaited<ReturnType<McpServerInstance['handleOauthCallback']>>>;\n    },\n\n    handleOauthTokenRefresh: async (\n      d: Parameters<McpServerInstance['handleOauthTokenRefresh']>[0]\n    ) => {\n      return send({\n        type: 'metorial-mcp.handle-oauth-token-refresh',\n        params: d\n      }) as Promise<Awaited<ReturnType<McpServerInstance['handleOauthTokenRefresh']>>>;\n    }\n  };\n};\n"],"mappings":"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","names":["z","config","import_zod","z","createMcpServerInternal","import_zod","z"]}

package/dist/index.d.cts

@@ -0,0 +1,208 @@
+import * as z from 'zod';
+import z__default from 'zod';
+import * as zod_v4_core from 'zod/v4/core';
+import { CreateMcpServerOpts } from '@metorial/mcp';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types';
+import { ClientCapabilities } from '@modelcontextprotocol/sdk/types.js';
+
+type McpServerAuthUrlHandlerParams<AuthConfig extends {}> = {
+    authConfig: AuthConfig;
+    clientId: string;
+    clientSecret: string;
+    state: string;
+    redirectUri: string;
+};
+type McpServerAuthUrlHandlerResult = {
+    authorizationUrl: string;
+    authState?: Record<string, string> | null;
+};
+type McpServerAuthUrlHandlerInternal = <AuthConfig extends {}>(d: McpServerAuthUrlHandlerParams<AuthConfig>) => Promise<McpServerAuthUrlHandlerResult>;
+type McpServerAuthUrlHandler = <AuthConfig extends {}>(d: McpServerAuthUrlHandlerParams<AuthConfig>) => Promise<string | McpServerAuthUrlHandlerResult>;
+type McpServerAuthCallbackHandlerParams<AuthConfig extends {}> = {
+    authConfig: AuthConfig;
+    authState: Record<string, string>;
+    clientId: string;
+    clientSecret: string;
+    code: string;
+    state: string;
+    redirectUri: string;
+    callbackUrl: string;
+    authorizationUrl: string;
+};
+type McpServerAuthCallbackHandlerResult = {
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn?: number;
+    scope?: string;
+    tokenType?: string;
+    [key: string]: any;
+};
+type McpServerAuthCallbackHandler = <AuthConfig extends {}>(d: McpServerAuthCallbackHandlerParams<AuthConfig>) => Promise<McpServerAuthCallbackHandlerResult>;
+type McpServerAuthTokenRefreshHandlerParams<AuthConfig extends {}> = {
+    authConfig: AuthConfig;
+    authState: Record<string, string>;
+    refreshToken: string;
+    clientId: string;
+    clientSecret: string;
+};
+type McpServerAuthTokenRefreshHandlerResult = {
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn?: number;
+    scope?: string;
+    tokenType?: string;
+    [key: string]: any;
+};
+type McpServerAuthTokenRefreshHandler = <AuthConfig extends {}>(d: McpServerAuthTokenRefreshHandlerParams<AuthConfig>) => Promise<McpServerAuthTokenRefreshHandlerResult>;
+type McpServerAuthValue = {
+    accessToken: string;
+    expiresIn?: number;
+    scope?: string;
+    tokenType?: string;
+    [key: string]: any;
+};
+declare class McpServerAuthConfig<AuthConfig extends {}> {
+    #private;
+    private readonly schema;
+    private constructor();
+    static create<AuthConfig extends {}>(schema?: z__default.ZodType<AuthConfig>): McpServerAuthConfig<AuthConfig>;
+    static getImplementation(config: McpServerAuthConfig<any>): {
+        getAuthUrlHandler: McpServerAuthUrlHandlerInternal;
+        callbackHandler: McpServerAuthCallbackHandler;
+        tokenRefreshHandler: McpServerAuthTokenRefreshHandler | undefined;
+    };
+    setValue(value: McpServerAuthValue): void;
+    getAuthorizationUrl(cb: McpServerAuthUrlHandler): this;
+    handleCallback(cb: McpServerAuthCallbackHandler): this;
+    refreshToken(cb: McpServerAuthTokenRefreshHandler): this;
+    build(): AuthConfig;
+}
+declare let createAuth: <Config extends {}>(schema?: z__default.ZodType<Config>) => McpServerAuthConfig<Config>;
+declare let auth: <Config extends {}>(schema?: z__default.ZodType<Config>) => McpServerAuthConfig<Config>;
+
+interface ClientOpts {
+    client: {
+        name: string;
+        version: string;
+    };
+    capabilities: ClientCapabilities;
+}
+
+type McpServerInstanceServer = CreateMcpServerOpts | {
+    server: McpServer;
+};
+type McpServerInstanceOpts = McpServerInstanceServer & {
+    config?: any;
+    authConfig?: any;
+};
+declare class McpServerInstance {
+    #private;
+    private instance;
+    private constructor();
+    static create(instance: McpServerInstanceOpts): McpServerInstance;
+    discover(): {
+        configSchema: zod_v4_core.ZodStandardJSONSchemaPayload<z.ZodType<{}, unknown, zod_v4_core.$ZodTypeInternals<{}, unknown>>> | null;
+        oauth: {
+            status: "enabled";
+            hasTokenRefresh: boolean;
+        } | {
+            status: "disabled";
+            hasTokenRefresh?: undefined;
+        };
+    };
+    handleMcpMessages(opts: {
+        config: any;
+        client: ClientOpts;
+        message: JSONRPCMessage[];
+    }): Promise<{
+        messages: JSONRPCMessage[];
+        error: Error | null;
+    }>;
+    getOauthAuthorizationUrl(d: McpServerAuthUrlHandlerParams<any>): Promise<McpServerAuthUrlHandlerResult> | null;
+    handleOauthCallback(d: McpServerAuthCallbackHandlerParams<any>): Promise<McpServerAuthCallbackHandlerResult> | null;
+    handleOauthTokenRefresh(d: McpServerAuthTokenRefreshHandlerParams<any>): Promise<McpServerAuthTokenRefreshHandlerResult> | null;
+}
+declare let createMcpServer: (instance: McpServerInstanceOpts) => McpServerInstance;
+
+declare let discoverMessage: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"metorial-mcp.discover">;
+}, z__default.core.$strip>;
+type DiscoverMessage = z__default.infer<typeof discoverMessage>;
+declare let authUrlMessage: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"metorial-mcp.get-oauth-authorization-url">;
+    params: z__default.ZodObject<{
+        authConfig: z__default.ZodRecord<z__default.ZodString, z__default.ZodAny>;
+        clientId: z__default.ZodString;
+        clientSecret: z__default.ZodString;
+        state: z__default.ZodString;
+        redirectUri: z__default.ZodString;
+    }, z__default.core.$strip>;
+}, z__default.core.$strip>;
+type AuthUrlMessage = z__default.infer<typeof authUrlMessage>;
+declare let oauthCallbackMessage: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"metorial-mcp.handle-oauth-callback">;
+    params: z__default.ZodObject<{
+        authConfig: z__default.ZodRecord<z__default.ZodString, z__default.ZodAny>;
+        authState: z__default.ZodRecord<z__default.ZodString, z__default.ZodString>;
+        clientId: z__default.ZodString;
+        clientSecret: z__default.ZodString;
+        code: z__default.ZodString;
+        state: z__default.ZodString;
+        redirectUri: z__default.ZodString;
+        callbackUrl: z__default.ZodString;
+        authorizationUrl: z__default.ZodString;
+    }, z__default.core.$strip>;
+}, z__default.core.$strip>;
+type OauthCallbackMessage = z__default.infer<typeof oauthCallbackMessage>;
+declare let oauthTokenRefreshMessage: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"metorial-mcp.handle-oauth-token-refresh">;
+    params: z__default.ZodObject<{
+        authConfig: z__default.ZodRecord<z__default.ZodString, z__default.ZodAny>;
+        authState: z__default.ZodRecord<z__default.ZodString, z__default.ZodString>;
+        refreshToken: z__default.ZodString;
+        clientId: z__default.ZodString;
+        clientSecret: z__default.ZodString;
+    }, z__default.core.$strip>;
+}, z__default.core.$strip>;
+type OauthTokenRefreshMessage = z__default.infer<typeof oauthTokenRefreshMessage>;
+type McpServerInstanceMessage = DiscoverMessage | AuthUrlMessage | OauthCallbackMessage | OauthTokenRefreshMessage;
+declare let serverAdapter: (instance: McpServerInstance, messages: McpServerInstanceMessage[]) => Promise<(McpServerAuthUrlHandlerResult | McpServerAuthCallbackHandlerResult | {
+    configSchema: z__default.core.ZodStandardJSONSchemaPayload<z__default.ZodType<{}, unknown, z__default.core.$ZodTypeInternals<{}, unknown>>> | null;
+    oauth: {
+        status: "enabled";
+        hasTokenRefresh: boolean;
+    } | {
+        status: "disabled";
+        hasTokenRefresh?: undefined;
+    };
+} | null)[]>;
+type McpServerInstanceAdapterResponses = Awaited<ReturnType<typeof serverAdapter>>;
+declare let clientAdapter: (transport: (messages: McpServerInstanceMessage[]) => Promise<McpServerInstanceAdapterResponses>) => {
+    discover: () => Promise<{
+        configSchema: z__default.core.ZodStandardJSONSchemaPayload<z__default.ZodType<{}, unknown, z__default.core.$ZodTypeInternals<{}, unknown>>> | null;
+        oauth: {
+            status: "enabled";
+            hasTokenRefresh: boolean;
+        } | {
+            status: "disabled";
+            hasTokenRefresh?: undefined;
+        };
+    }>;
+    getOauthAuthorizationUrl: (d: Parameters<McpServerInstance["getOauthAuthorizationUrl"]>[0]) => Promise<McpServerAuthUrlHandlerResult | null>;
+    handleOauthCallback: (d: Parameters<McpServerInstance["handleOauthCallback"]>[0]) => Promise<McpServerAuthCallbackHandlerResult | null>;
+    handleOauthTokenRefresh: (d: Parameters<McpServerInstance["handleOauthTokenRefresh"]>[0]) => Promise<McpServerAuthTokenRefreshHandlerResult | null>;
+};
+
+declare class McpServerConfig<Config extends {}> {
+    #private;
+    readonly schema: z__default.ZodType<Config>;
+    private constructor();
+    static create<Config extends {}>(schema: z__default.ZodType<Config>): McpServerConfig<Config>;
+    setValue(value: unknown): void;
+    value(): Config;
+}
+declare let createConfig: <Config extends {}>(schema: z__default.ZodType<Config>) => Config;
+declare let config: <Config extends {}>(schema: z__default.ZodType<Config>) => Config;
+
+export { type McpServerAuthCallbackHandler, type McpServerAuthCallbackHandlerParams, type McpServerAuthCallbackHandlerResult, McpServerAuthConfig, type McpServerAuthTokenRefreshHandler, type McpServerAuthTokenRefreshHandlerParams, type McpServerAuthTokenRefreshHandlerResult, type McpServerAuthUrlHandler, type McpServerAuthUrlHandlerInternal, type McpServerAuthUrlHandlerParams, type McpServerAuthUrlHandlerResult, type McpServerAuthValue, McpServerConfig, McpServerInstance, type McpServerInstanceAdapterResponses, type McpServerInstanceMessage, type McpServerInstanceOpts, type McpServerInstanceServer, auth, clientAdapter, config, createAuth, createConfig, createMcpServer, serverAdapter };