@mcp-z/mcp-gmail 1.0.0

package/dist/cjs/setup/runtime.js

@@ -0,0 +1,489 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get assertStorageConfig () {
+        return assertStorageConfig;
+    },
+    get createAuthLayer () {
+        return createAuthLayer;
+    },
+    get createDcrStore () {
+        return createDcrStore;
+    },
+    get createDefaultRuntime () {
+        return createDefaultRuntime;
+    },
+    get createLogger () {
+        return createLogger;
+    },
+    get createLoggingLayer () {
+        return createLoggingLayer;
+    },
+    get createStorageLayer () {
+        return createStorageLayer;
+    },
+    get createTokenStore () {
+        return createTokenStore;
+    }
+});
+var _oauth = require("@mcp-z/oauth");
+var _server = require("@mcp-z/server");
+var _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+var _pino = /*#__PURE__*/ _interop_require_default(require("pino"));
+var _createstore = /*#__PURE__*/ _interop_require_default(require("../lib/create-store.js"));
+var _index = /*#__PURE__*/ _interop_require_wildcard(require("../mcp/index.js"));
+var _oauthgoogle = require("./oauth-google.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function createLogger(config) {
+    var _config_logLevel;
+    var hasStdio = config.transport.type === 'stdio';
+    var logsPath = _path.join(config.baseDir, 'logs', "".concat(config.name, ".log"));
+    if (hasStdio) _fs.mkdirSync(_path.dirname(logsPath), {
+        recursive: true
+    });
+    return (0, _pino.default)({
+        level: (_config_logLevel = config.logLevel) !== null && _config_logLevel !== void 0 ? _config_logLevel : 'info',
+        formatters: (0, _oauth.sanitizeForLoggingFormatter)()
+    }, hasStdio ? _pino.default.destination({
+        dest: logsPath,
+        sync: false
+    }) : _pino.default.destination(1));
+}
+function createTokenStore(baseDir) {
+    return _async_to_generator(function() {
+        var storeUri;
+        return _ts_generator(this, function(_state) {
+            storeUri = process.env.STORE_URI || "file://".concat(_path.join(baseDir, 'tokens.json'));
+            return [
+                2,
+                (0, _createstore.default)(storeUri)
+            ];
+        });
+    })();
+}
+function createDcrStore(baseDir, required) {
+    return _async_to_generator(function() {
+        var dcrStoreUri;
+        return _ts_generator(this, function(_state) {
+            if (!required) return [
+                2,
+                undefined
+            ];
+            dcrStoreUri = process.env.DCR_STORE_URI || "file://".concat(_path.join(baseDir, 'dcr.json'));
+            return [
+                2,
+                (0, _createstore.default)(dcrStoreUri)
+            ];
+        });
+    })();
+}
+function createAuthLayer(authMiddleware) {
+    return {
+        withTool: authMiddleware.withToolAuth,
+        withResource: authMiddleware.withResourceAuth,
+        withPrompt: authMiddleware.withPromptAuth
+    };
+}
+function createLoggingLayer(logger) {
+    var logging = (0, _server.createLoggingMiddleware)({
+        logger: logger
+    });
+    return {
+        withTool: logging.withToolLogging,
+        withResource: logging.withResourceLogging,
+        withPrompt: logging.withPromptLogging
+    };
+}
+function createStorageLayer(storageContext) {
+    var wrapAtPosition = function(module, extraPosition) {
+        var originalHandler = module.handler;
+        var wrappedHandler = function() {
+            for(var _len = arguments.length, allArgs = new Array(_len), _key = 0; _key < _len; _key++){
+                allArgs[_key] = arguments[_key];
+            }
+            return _async_to_generator(function() {
+                var extra;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            extra = allArgs[extraPosition];
+                            extra.storageContext = storageContext;
+                            return [
+                                4,
+                                originalHandler.apply(void 0, _to_consumable_array(allArgs))
+                            ];
+                        case 1:
+                            return [
+                                2,
+                                _state.sent()
+                            ];
+                    }
+                });
+            })();
+        };
+        return _object_spread_props(_object_spread({}, module), {
+            handler: wrappedHandler
+        });
+    };
+    return {
+        withTool: function(module) {
+            return wrapAtPosition(module, 1);
+        }
+    };
+}
+function assertStorageConfig(config) {
+    if (!config.storageDir) {
+        throw new Error('gmail-messages-export-csv: Server configuration missing storageDir.');
+    }
+    if (config.transport.type === 'http' && !config.baseUrl && !config.transport.port) {
+        throw new Error('gmail-messages-export-csv: HTTP transport requires either baseUrl in server config or port in transport config. This is a server configuration error - please provide --base-url or --port.');
+    }
+}
+function createDefaultRuntime(config, overrides) {
+    return _async_to_generator(function() {
+        var _config_baseUrl, _ref, _ref1, logger, tokenStore, baseUrl, dcrStore, oauthAdapters, deps, createDomainModules, middlewareFactories;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (config.auth === 'dcr' && config.transport.type !== 'http') throw new Error('DCR mode requires an HTTP transport');
+                    assertStorageConfig(config);
+                    logger = createLogger(config);
+                    return [
+                        4,
+                        createTokenStore(config.baseDir)
+                    ];
+                case 1:
+                    tokenStore = _state.sent();
+                    baseUrl = (_config_baseUrl = config.baseUrl) !== null && _config_baseUrl !== void 0 ? _config_baseUrl : config.transport.type === 'http' && config.transport.port ? "http://localhost:".concat(config.transport.port) : undefined;
+                    return [
+                        4,
+                        createDcrStore(config.baseDir, config.auth === 'dcr')
+                    ];
+                case 2:
+                    dcrStore = _state.sent();
+                    return [
+                        4,
+                        (0, _oauthgoogle.createOAuthAdapters)(config, {
+                            logger: logger,
+                            tokenStore: tokenStore,
+                            dcrStore: dcrStore
+                        }, baseUrl)
+                    ];
+                case 3:
+                    oauthAdapters = _state.sent();
+                    deps = {
+                        config: config,
+                        logger: logger,
+                        tokenStore: tokenStore,
+                        oauthAdapters: oauthAdapters,
+                        baseUrl: baseUrl
+                    };
+                    createDomainModules = (_ref = overrides === null || overrides === void 0 ? void 0 : overrides.createDomainModules) !== null && _ref !== void 0 ? _ref : function() {
+                        return {
+                            tools: Object.values(_index.toolFactories).map(function(factory) {
+                                return factory();
+                            }),
+                            resources: Object.values(_index.resourceFactories).map(function(factory) {
+                                return factory();
+                            }),
+                            prompts: Object.values(_index.promptFactories).map(function(factory) {
+                                return factory();
+                            })
+                        };
+                    };
+                    middlewareFactories = (_ref1 = overrides === null || overrides === void 0 ? void 0 : overrides.middlewareFactories) !== null && _ref1 !== void 0 ? _ref1 : [
+                        function() {
+                            return createAuthLayer(oauthAdapters.middleware);
+                        },
+                        function() {
+                            return createLoggingLayer(logger);
+                        },
+                        function() {
+                            return createStorageLayer({
+                                storageDir: config.storageDir,
+                                baseUrl: config.baseUrl,
+                                transport: config.transport
+                            });
+                        }
+                    ];
+                    return [
+                        2,
+                        {
+                            deps: deps,
+                            middlewareFactories: middlewareFactories,
+                            createDomainModules: createDomainModules,
+                            close: function() {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        return [
+                                            2
+                                        ];
+                                    });
+                                })();
+                            }
+                        }
+                    ];
+            }
+        });
+    })();
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/setup/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-gmail/src/setup/runtime.ts"],"sourcesContent":["import { sanitizeForLoggingFormatter } from '@mcp-z/oauth';\nimport type { CachedToken } from '@mcp-z/oauth-google';\nimport type { Logger, MiddlewareLayer } from '@mcp-z/server';\nimport { createLoggingMiddleware } from '@mcp-z/server';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport pino from 'pino';\nimport createStore from '../lib/create-store.js';\nimport * as mcp from '../mcp/index.js';\nimport type { CommonRuntime, RuntimeDeps, RuntimeOverrides, ServerConfig, StorageContext } from '../types.js';\nimport { createOAuthAdapters, type OAuthAdapters } from './oauth-google.js';\n\nexport function createLogger(config: ServerConfig): Logger {\n  const hasStdio = config.transport.type === 'stdio';\n  const logsPath = path.join(config.baseDir, 'logs', `${config.name}.log`);\n  if (hasStdio) fs.mkdirSync(path.dirname(logsPath), { recursive: true });\n  return pino({ level: config.logLevel ?? 'info', formatters: sanitizeForLoggingFormatter() }, hasStdio ? pino.destination({ dest: logsPath, sync: false }) : pino.destination(1));\n}\n\nexport async function createTokenStore(baseDir: string) {\n  const storeUri = process.env.STORE_URI || `file://${path.join(baseDir, 'tokens.json')}`;\n  return createStore<CachedToken>(storeUri);\n}\n\nexport async function createDcrStore(baseDir: string, required: boolean) {\n  if (!required) return undefined;\n  const dcrStoreUri = process.env.DCR_STORE_URI || `file://${path.join(baseDir, 'dcr.json')}`;\n  return createStore<unknown>(dcrStoreUri);\n}\n\nexport function createAuthLayer(authMiddleware: OAuthAdapters['middleware']): MiddlewareLayer {\n  return {\n    withTool: authMiddleware.withToolAuth,\n    withResource: authMiddleware.withResourceAuth,\n    withPrompt: authMiddleware.withPromptAuth,\n  };\n}\n\nexport function createLoggingLayer(logger: Logger): MiddlewareLayer {\n  const logging = createLoggingMiddleware({ logger });\n  return {\n    withTool: logging.withToolLogging,\n    withResource: logging.withResourceLogging,\n    withPrompt: logging.withPromptLogging,\n  };\n}\n\nexport function createStorageLayer(storageContext: StorageContext): MiddlewareLayer {\n  const wrapAtPosition = <T extends { name: string; handler: unknown; [key: string]: unknown }>(module: T, extraPosition: number): T => {\n    const originalHandler = module.handler as (...args: unknown[]) => Promise<unknown>;\n\n    const wrappedHandler = async (...allArgs: unknown[]) => {\n      const extra = allArgs[extraPosition];\n      (extra as { storageContext?: StorageContext }).storageContext = storageContext;\n      return await originalHandler(...allArgs);\n    };\n\n    return {\n      ...module,\n      handler: wrappedHandler,\n    } as T;\n  };\n\n  return {\n    withTool: <T extends { name: string; config: unknown; handler: unknown }>(module: T): T => wrapAtPosition(module, 1) as T,\n  };\n}\n\nexport function assertStorageConfig(config: ServerConfig) {\n  if (!config.storageDir) {\n    throw new Error('gmail-messages-export-csv: Server configuration missing storageDir.');\n  }\n  if (config.transport.type === 'http' && !config.baseUrl && !config.transport.port) {\n    throw new Error('gmail-messages-export-csv: HTTP transport requires either baseUrl in server config or port in transport config. This is a server configuration error - please provide --base-url or --port.');\n  }\n}\n\nexport async function createDefaultRuntime(config: ServerConfig, overrides?: RuntimeOverrides): Promise<CommonRuntime> {\n  if (config.auth === 'dcr' && config.transport.type !== 'http') throw new Error('DCR mode requires an HTTP transport');\n\n  assertStorageConfig(config);\n  const logger = createLogger(config);\n  const tokenStore = await createTokenStore(config.baseDir);\n  const baseUrl = config.baseUrl ?? (config.transport.type === 'http' && config.transport.port ? `http://localhost:${config.transport.port}` : undefined);\n  const dcrStore = await createDcrStore(config.baseDir, config.auth === 'dcr');\n  const oauthAdapters = await createOAuthAdapters(config, { logger, tokenStore, dcrStore }, baseUrl);\n  const deps: RuntimeDeps = { config, logger, tokenStore, oauthAdapters, baseUrl };\n  const createDomainModules =\n    overrides?.createDomainModules ??\n    (() => ({\n      tools: Object.values(mcp.toolFactories).map((factory) => factory()),\n      resources: Object.values(mcp.resourceFactories).map((factory) => factory()),\n      prompts: Object.values(mcp.promptFactories).map((factory) => factory()),\n    }));\n  const middlewareFactories = overrides?.middlewareFactories ?? [() => createAuthLayer(oauthAdapters.middleware), () => createLoggingLayer(logger), () => createStorageLayer({ storageDir: config.storageDir, baseUrl: config.baseUrl, transport: config.transport })];\n\n  return {\n    deps,\n    middlewareFactories,\n    createDomainModules,\n    close: async () => {},\n  };\n}\n"],"names":["assertStorageConfig","createAuthLayer","createDcrStore","createDefaultRuntime","createLogger","createLoggingLayer","createStorageLayer","createTokenStore","config","hasStdio","transport","type","logsPath","path","join","baseDir","name","fs","mkdirSync","dirname","recursive","pino","level","logLevel","formatters","sanitizeForLoggingFormatter","destination","dest","sync","storeUri","process","env","STORE_URI","createStore","required","dcrStoreUri","undefined","DCR_STORE_URI","authMiddleware","withTool","withToolAuth","withResource","withResourceAuth","withPrompt","withPromptAuth","logger","logging","createLoggingMiddleware","withToolLogging","withResourceLogging","withPromptLogging","storageContext","wrapAtPosition","module","extraPosition","originalHandler","handler","wrappedHandler","allArgs","extra","storageDir","Error","baseUrl","port","overrides","tokenStore","dcrStore","oauthAdapters","deps","createDomainModules","middlewareFactories","auth","createOAuthAdapters","tools","Object","values","mcp","toolFactories","map","factory","resources","resourceFactories","prompts","promptFactories","middleware","close"],"mappings":";;;;;;;;;;;QAoEgBA;eAAAA;;QAtCAC;eAAAA;;QANMC;eAAAA;;QAqDAC;eAAAA;;QAjENC;eAAAA;;QA0BAC;eAAAA;;QASAC;eAAAA;;QA5BMC;eAAAA;;;qBAnBsB;sBAGJ;0DACpB;4DACE;2DACL;kEACO;6DACH;2BAEmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjD,SAASH,aAAaI,MAAoB;QAI1BA;IAHrB,IAAMC,WAAWD,OAAOE,SAAS,CAACC,IAAI,KAAK;IAC3C,IAAMC,WAAWC,MAAKC,IAAI,CAACN,OAAOO,OAAO,EAAE,QAAQ,AAAC,GAAc,OAAZP,OAAOQ,IAAI,EAAC;IAClE,IAAIP,UAAUQ,IAAGC,SAAS,CAACL,MAAKM,OAAO,CAACP,WAAW;QAAEQ,WAAW;IAAK;IACrE,OAAOC,IAAAA,aAAI,EAAC;QAAEC,KAAK,GAAEd,mBAAAA,OAAOe,QAAQ,cAAff,8BAAAA,mBAAmB;QAAQgB,YAAYC,IAAAA,kCAA2B;IAAG,GAAGhB,WAAWY,aAAI,CAACK,WAAW,CAAC;QAAEC,MAAMf;QAAUgB,MAAM;IAAM,KAAKP,aAAI,CAACK,WAAW,CAAC;AAC/K;AAEO,SAAenB,iBAAiBQ,OAAe;;YAC9Cc;;YAAAA,WAAWC,QAAQC,GAAG,CAACC,SAAS,IAAI,AAAC,UAA2C,OAAlCnB,MAAKC,IAAI,CAACC,SAAS;YACvE;;gBAAOkB,IAAAA,oBAAW,EAAcJ;;;IAClC;;AAEO,SAAe3B,eAAea,OAAe,EAAEmB,QAAiB;;YAE/DC;;YADN,IAAI,CAACD,UAAU;;gBAAOE;;YAChBD,cAAcL,QAAQC,GAAG,CAACM,aAAa,IAAI,AAAC,UAAwC,OAA/BxB,MAAKC,IAAI,CAACC,SAAS;YAC9E;;gBAAOkB,IAAAA,oBAAW,EAAUE;;;IAC9B;;AAEO,SAASlC,gBAAgBqC,cAA2C;IACzE,OAAO;QACLC,UAAUD,eAAeE,YAAY;QACrCC,cAAcH,eAAeI,gBAAgB;QAC7CC,YAAYL,eAAeM,cAAc;IAC3C;AACF;AAEO,SAASvC,mBAAmBwC,MAAc;IAC/C,IAAMC,UAAUC,IAAAA,+BAAuB,EAAC;QAAEF,QAAAA;IAAO;IACjD,OAAO;QACLN,UAAUO,QAAQE,eAAe;QACjCP,cAAcK,QAAQG,mBAAmB;QACzCN,YAAYG,QAAQI,iBAAiB;IACvC;AACF;AAEO,SAAS5C,mBAAmB6C,cAA8B;IAC/D,IAAMC,iBAAiB,SAAuEC,QAAWC;QACvG,IAAMC,kBAAkBF,OAAOG,OAAO;QAEtC,IAAMC,iBAAiB;6CAAUC;gBAAAA;;;oBACzBC;;;;4BAAAA,QAAQD,OAAO,CAACJ,cAAc;4BACnCK,MAA8CR,cAAc,GAAGA;4BACzD;;gCAAMI,sBAAAA,KAAAA,GAAgB,qBAAGG;;;4BAAhC;;gCAAO;;;;YACT;;QAEA,OAAO,wCACFL;YACHG,SAASC;;IAEb;IAEA,OAAO;QACLlB,UAAU,SAAgEc;mBAAiBD,eAAeC,QAAQ;;IACpH;AACF;AAEO,SAASrD,oBAAoBQ,MAAoB;IACtD,IAAI,CAACA,OAAOoD,UAAU,EAAE;QACtB,MAAM,IAAIC,MAAM;IAClB;IACA,IAAIrD,OAAOE,SAAS,CAACC,IAAI,KAAK,UAAU,CAACH,OAAOsD,OAAO,IAAI,CAACtD,OAAOE,SAAS,CAACqD,IAAI,EAAE;QACjF,MAAM,IAAIF,MAAM;IAClB;AACF;AAEO,SAAe1D,qBAAqBK,MAAoB,EAAEwD,SAA4B;;YAM3ExD,8BAFVqC,QACAoB,YACAH,SACAI,UACAC,eACAC,MACAC,qBAOAC;;;;oBAhBN,IAAI9D,OAAO+D,IAAI,KAAK,SAAS/D,OAAOE,SAAS,CAACC,IAAI,KAAK,QAAQ,MAAM,IAAIkD,MAAM;oBAE/E7D,oBAAoBQ;oBACdqC,SAASzC,aAAaI;oBACT;;wBAAMD,iBAAiBC,OAAOO,OAAO;;;oBAAlDkD,aAAa;oBACbH,WAAUtD,kBAAAA,OAAOsD,OAAO,cAAdtD,6BAAAA,kBAAmBA,OAAOE,SAAS,CAACC,IAAI,KAAK,UAAUH,OAAOE,SAAS,CAACqD,IAAI,GAAG,AAAC,oBAAyC,OAAtBvD,OAAOE,SAAS,CAACqD,IAAI,IAAK3B;oBAC5H;;wBAAMlC,eAAeM,OAAOO,OAAO,EAAEP,OAAO+D,IAAI,KAAK;;;oBAAhEL,WAAW;oBACK;;wBAAMM,IAAAA,gCAAmB,EAAChE,QAAQ;4BAAEqC,QAAAA;4BAAQoB,YAAAA;4BAAYC,UAAAA;wBAAS,GAAGJ;;;oBAApFK,gBAAgB;oBAChBC,OAAoB;wBAAE5D,QAAAA;wBAAQqC,QAAAA;wBAAQoB,YAAAA;wBAAYE,eAAAA;wBAAeL,SAAAA;oBAAQ;oBACzEO,8BACJL,sBAAAA,gCAAAA,UAAWK,mBAAmB,uCAC7B;+BAAO;4BACNI,OAAOC,OAAOC,MAAM,CAACC,OAAIC,aAAa,EAAEC,GAAG,CAAC,SAACC;uCAAYA;;4BACzDC,WAAWN,OAAOC,MAAM,CAACC,OAAIK,iBAAiB,EAAEH,GAAG,CAAC,SAACC;uCAAYA;;4BACjEG,SAASR,OAAOC,MAAM,CAACC,OAAIO,eAAe,EAAEL,GAAG,CAAC,SAACC;uCAAYA;;wBAC/D;;oBACIT,+BAAsBN,sBAAAA,gCAAAA,UAAWM,mBAAmB;wBAAK;mCAAMrE,gBAAgBkE,cAAciB,UAAU;;wBAAG;mCAAM/E,mBAAmBwC;;wBAAS;mCAAMvC,mBAAmB;gCAAEsD,YAAYpD,OAAOoD,UAAU;gCAAEE,SAAStD,OAAOsD,OAAO;gCAAEpD,WAAWF,OAAOE,SAAS;4BAAC;;;oBAEjQ;;wBAAO;4BACL0D,MAAAA;4BACAE,qBAAAA;4BACAD,qBAAAA;4BACAgB,OAAO;;;;;;;gCAAa;;wBACtB;;;;IACF"}

package/dist/cjs/setup/stdio.d.cts

@@ -0,0 +1,7 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { RuntimeOverrides, ServerConfig } from '../types.js';
+export declare function createStdioServer(config: ServerConfig, overrides?: RuntimeOverrides): Promise<{
+    mcpServer: McpServer;
+    logger: import("@mcp-z/server").Logger;
+    close: () => Promise<void>;
+}>;

package/dist/cjs/setup/stdio.d.ts

@@ -0,0 +1,7 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { RuntimeOverrides, ServerConfig } from '../types.js';
+export declare function createStdioServer(config: ServerConfig, overrides?: RuntimeOverrides): Promise<{
+    mcpServer: McpServer;
+    logger: import("@mcp-z/server").Logger;
+    close: () => Promise<void>;
+}>;