@mcp-weave/webui 0.1.1

package/dist/index.mjs

@@ -0,0 +1,2189 @@
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+// ../../node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js
+var require_Reflect = __commonJS({
+  "../../node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js"() {
+    "use strict";
+    var Reflect2;
+    (function(Reflect3) {
+      (function(factory) {
+        var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+        var exporter = makeExporter(Reflect3);
+        if (typeof root.Reflect !== "undefined") {
+          exporter = makeExporter(root.Reflect, exporter);
+        }
+        factory(exporter, root);
+        if (typeof root.Reflect === "undefined") {
+          root.Reflect = Reflect3;
+        }
+        function makeExporter(target, previous) {
+          return function(key, value) {
+            Object.defineProperty(target, key, { configurable: true, writable: true, value });
+            if (previous)
+              previous(key, value);
+          };
+        }
+        function functionThis() {
+          try {
+            return Function("return this;")();
+          } catch (_) {
+          }
+        }
+        function indirectEvalThis() {
+          try {
+            return (void 0, eval)("(function() { return this; })()");
+          } catch (_) {
+          }
+        }
+        function sloppyModeThis() {
+          return functionThis() || indirectEvalThis();
+        }
+      })(function(exporter, root) {
+        var hasOwn = Object.prototype.hasOwnProperty;
+        var supportsSymbol = typeof Symbol === "function";
+        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+        var supportsCreate = typeof Object.create === "function";
+        var supportsProto = { __proto__: [] } instanceof Array;
+        var downLevel = !supportsCreate && !supportsProto;
+        var HashMap = {
+          // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+          create: supportsCreate ? function() {
+            return MakeDictionary(/* @__PURE__ */ Object.create(null));
+          } : supportsProto ? function() {
+            return MakeDictionary({ __proto__: null });
+          } : function() {
+            return MakeDictionary({});
+          },
+          has: downLevel ? function(map, key) {
+            return hasOwn.call(map, key);
+          } : function(map, key) {
+            return key in map;
+          },
+          get: downLevel ? function(map, key) {
+            return hasOwn.call(map, key) ? map[key] : void 0;
+          } : function(map, key) {
+            return map[key];
+          }
+        };
+        var functionPrototype = Object.getPrototypeOf(Function);
+        var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+        var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+        var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+        var registrySymbol = supportsSymbol ? /* @__PURE__ */ Symbol.for("@reflect-metadata:registry") : void 0;
+        var metadataRegistry = GetOrCreateMetadataRegistry();
+        var metadataProvider = CreateMetadataProvider(metadataRegistry);
+        function decorate(decorators, target, propertyKey, attributes) {
+          if (!IsUndefined(propertyKey)) {
+            if (!IsArray(decorators))
+              throw new TypeError();
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
+              throw new TypeError();
+            if (IsNull(attributes))
+              attributes = void 0;
+            propertyKey = ToPropertyKey(propertyKey);
+            return DecorateProperty(decorators, target, propertyKey, attributes);
+          } else {
+            if (!IsArray(decorators))
+              throw new TypeError();
+            if (!IsConstructor(target))
+              throw new TypeError();
+            return DecorateConstructor(decorators, target);
+          }
+        }
+        exporter("decorate", decorate);
+        function metadata(metadataKey, metadataValue) {
+          function decorator(target, propertyKey) {
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+              throw new TypeError();
+            OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+          }
+          return decorator;
+        }
+        exporter("metadata", metadata);
+        function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+        }
+        exporter("defineMetadata", defineMetadata);
+        function hasMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+        }
+        exporter("hasMetadata", hasMetadata);
+        function hasOwnMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+        }
+        exporter("hasOwnMetadata", hasOwnMetadata);
+        function getMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+        }
+        exporter("getMetadata", getMetadata);
+        function getOwnMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+        }
+        exporter("getOwnMetadata", getOwnMetadata);
+        function getMetadataKeys(target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryMetadataKeys(target, propertyKey);
+        }
+        exporter("getMetadataKeys", getMetadataKeys);
+        function getOwnMetadataKeys(target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryOwnMetadataKeys(target, propertyKey);
+        }
+        exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+        function deleteMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          var provider = GetMetadataProvider(
+            target,
+            propertyKey,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider))
+            return false;
+          return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+        }
+        exporter("deleteMetadata", deleteMetadata);
+        function DecorateConstructor(decorators, target) {
+          for (var i = decorators.length - 1; i >= 0; --i) {
+            var decorator = decorators[i];
+            var decorated = decorator(target);
+            if (!IsUndefined(decorated) && !IsNull(decorated)) {
+              if (!IsConstructor(decorated))
+                throw new TypeError();
+              target = decorated;
+            }
+          }
+          return target;
+        }
+        function DecorateProperty(decorators, target, propertyKey, descriptor) {
+          for (var i = decorators.length - 1; i >= 0; --i) {
+            var decorator = decorators[i];
+            var decorated = decorator(target, propertyKey, descriptor);
+            if (!IsUndefined(decorated) && !IsNull(decorated)) {
+              if (!IsObject(decorated))
+                throw new TypeError();
+              descriptor = decorated;
+            }
+          }
+          return descriptor;
+        }
+        function OrdinaryHasMetadata(MetadataKey, O, P) {
+          var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+          if (hasOwn2)
+            return true;
+          var parent = OrdinaryGetPrototypeOf(O);
+          if (!IsNull(parent))
+            return OrdinaryHasMetadata(MetadataKey, parent, P);
+          return false;
+        }
+        function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider))
+            return false;
+          return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+        }
+        function OrdinaryGetMetadata(MetadataKey, O, P) {
+          var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+          if (hasOwn2)
+            return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+          var parent = OrdinaryGetPrototypeOf(O);
+          if (!IsNull(parent))
+            return OrdinaryGetMetadata(MetadataKey, parent, P);
+          return void 0;
+        }
+        function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider))
+            return;
+          return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+        }
+        function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            true
+          );
+          provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+        }
+        function OrdinaryMetadataKeys(O, P) {
+          var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+          var parent = OrdinaryGetPrototypeOf(O);
+          if (parent === null)
+            return ownKeys;
+          var parentKeys = OrdinaryMetadataKeys(parent, P);
+          if (parentKeys.length <= 0)
+            return ownKeys;
+          if (ownKeys.length <= 0)
+            return parentKeys;
+          var set = new _Set();
+          var keys = [];
+          for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
+            var key = ownKeys_1[_i];
+            var hasKey = set.has(key);
+            if (!hasKey) {
+              set.add(key);
+              keys.push(key);
+            }
+          }
+          for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
+            var key = parentKeys_1[_a];
+            var hasKey = set.has(key);
+            if (!hasKey) {
+              set.add(key);
+              keys.push(key);
+            }
+          }
+          return keys;
+        }
+        function OrdinaryOwnMetadataKeys(O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*create*/
+            false
+          );
+          if (!provider) {
+            return [];
+          }
+          return provider.OrdinaryOwnMetadataKeys(O, P);
+        }
+        function Type(x) {
+          if (x === null)
+            return 1;
+          switch (typeof x) {
+            case "undefined":
+              return 0;
+            case "boolean":
+              return 2;
+            case "string":
+              return 3;
+            case "symbol":
+              return 4;
+            case "number":
+              return 5;
+            case "object":
+              return x === null ? 1 : 6;
+            default:
+              return 6;
+          }
+        }
+        function IsUndefined(x) {
+          return x === void 0;
+        }
+        function IsNull(x) {
+          return x === null;
+        }
+        function IsSymbol(x) {
+          return typeof x === "symbol";
+        }
+        function IsObject(x) {
+          return typeof x === "object" ? x !== null : typeof x === "function";
+        }
+        function ToPrimitive(input, PreferredType) {
+          switch (Type(input)) {
+            case 0:
+              return input;
+            case 1:
+              return input;
+            case 2:
+              return input;
+            case 3:
+              return input;
+            case 4:
+              return input;
+            case 5:
+              return input;
+          }
+          var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
+          var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+          if (exoticToPrim !== void 0) {
+            var result = exoticToPrim.call(input, hint);
+            if (IsObject(result))
+              throw new TypeError();
+            return result;
+          }
+          return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+        }
+        function OrdinaryToPrimitive(O, hint) {
+          if (hint === "string") {
+            var toString_1 = O.toString;
+            if (IsCallable(toString_1)) {
+              var result = toString_1.call(O);
+              if (!IsObject(result))
+                return result;
+            }
+            var valueOf = O.valueOf;
+            if (IsCallable(valueOf)) {
+              var result = valueOf.call(O);
+              if (!IsObject(result))
+                return result;
+            }
+          } else {
+            var valueOf = O.valueOf;
+            if (IsCallable(valueOf)) {
+              var result = valueOf.call(O);
+              if (!IsObject(result))
+                return result;
+            }
+            var toString_2 = O.toString;
+            if (IsCallable(toString_2)) {
+              var result = toString_2.call(O);
+              if (!IsObject(result))
+                return result;
+            }
+          }
+          throw new TypeError();
+        }
+        function ToBoolean(argument) {
+          return !!argument;
+        }
+        function ToString(argument) {
+          return "" + argument;
+        }
+        function ToPropertyKey(argument) {
+          var key = ToPrimitive(
+            argument,
+            3
+            /* String */
+          );
+          if (IsSymbol(key))
+            return key;
+          return ToString(key);
+        }
+        function IsArray(argument) {
+          return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+        }
+        function IsCallable(argument) {
+          return typeof argument === "function";
+        }
+        function IsConstructor(argument) {
+          return typeof argument === "function";
+        }
+        function IsPropertyKey(argument) {
+          switch (Type(argument)) {
+            case 3:
+              return true;
+            case 4:
+              return true;
+            default:
+              return false;
+          }
+        }
+        function SameValueZero(x, y) {
+          return x === y || x !== x && y !== y;
+        }
+        function GetMethod(V, P) {
+          var func = V[P];
+          if (func === void 0 || func === null)
+            return void 0;
+          if (!IsCallable(func))
+            throw new TypeError();
+          return func;
+        }
+        function GetIterator(obj) {
+          var method = GetMethod(obj, iteratorSymbol);
+          if (!IsCallable(method))
+            throw new TypeError();
+          var iterator = method.call(obj);
+          if (!IsObject(iterator))
+            throw new TypeError();
+          return iterator;
+        }
+        function IteratorValue(iterResult) {
+          return iterResult.value;
+        }
+        function IteratorStep(iterator) {
+          var result = iterator.next();
+          return result.done ? false : result;
+        }
+        function IteratorClose(iterator) {
+          var f = iterator["return"];
+          if (f)
+            f.call(iterator);
+        }
+        function OrdinaryGetPrototypeOf(O) {
+          var proto = Object.getPrototypeOf(O);
+          if (typeof O !== "function" || O === functionPrototype)
+            return proto;
+          if (proto !== functionPrototype)
+            return proto;
+          var prototype = O.prototype;
+          var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+          if (prototypeProto == null || prototypeProto === Object.prototype)
+            return proto;
+          var constructor = prototypeProto.constructor;
+          if (typeof constructor !== "function")
+            return proto;
+          if (constructor === O)
+            return proto;
+          return constructor;
+        }
+        function CreateMetadataRegistry() {
+          var fallback;
+          if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+            fallback = CreateFallbackProvider(root.Reflect);
+          }
+          var first;
+          var second;
+          var rest;
+          var targetProviderMap = new _WeakMap();
+          var registry = {
+            registerProvider,
+            getProvider,
+            setProvider
+          };
+          return registry;
+          function registerProvider(provider) {
+            if (!Object.isExtensible(registry)) {
+              throw new Error("Cannot add provider to a frozen registry.");
+            }
+            switch (true) {
+              case fallback === provider:
+                break;
+              case IsUndefined(first):
+                first = provider;
+                break;
+              case first === provider:
+                break;
+              case IsUndefined(second):
+                second = provider;
+                break;
+              case second === provider:
+                break;
+              default:
+                if (rest === void 0)
+                  rest = new _Set();
+                rest.add(provider);
+                break;
+            }
+          }
+          function getProviderNoCache(O, P) {
+            if (!IsUndefined(first)) {
+              if (first.isProviderFor(O, P))
+                return first;
+              if (!IsUndefined(second)) {
+                if (second.isProviderFor(O, P))
+                  return first;
+                if (!IsUndefined(rest)) {
+                  var iterator = GetIterator(rest);
+                  while (true) {
+                    var next = IteratorStep(iterator);
+                    if (!next) {
+                      return void 0;
+                    }
+                    var provider = IteratorValue(next);
+                    if (provider.isProviderFor(O, P)) {
+                      IteratorClose(iterator);
+                      return provider;
+                    }
+                  }
+                }
+              }
+            }
+            if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+              return fallback;
+            }
+            return void 0;
+          }
+          function getProvider(O, P) {
+            var providerMap = targetProviderMap.get(O);
+            var provider;
+            if (!IsUndefined(providerMap)) {
+              provider = providerMap.get(P);
+            }
+            if (!IsUndefined(provider)) {
+              return provider;
+            }
+            provider = getProviderNoCache(O, P);
+            if (!IsUndefined(provider)) {
+              if (IsUndefined(providerMap)) {
+                providerMap = new _Map();
+                targetProviderMap.set(O, providerMap);
+              }
+              providerMap.set(P, provider);
+            }
+            return provider;
+          }
+          function hasProvider(provider) {
+            if (IsUndefined(provider))
+              throw new TypeError();
+            return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+          }
+          function setProvider(O, P, provider) {
+            if (!hasProvider(provider)) {
+              throw new Error("Metadata provider not registered.");
+            }
+            var existingProvider = getProvider(O, P);
+            if (existingProvider !== provider) {
+              if (!IsUndefined(existingProvider)) {
+                return false;
+              }
+              var providerMap = targetProviderMap.get(O);
+              if (IsUndefined(providerMap)) {
+                providerMap = new _Map();
+                targetProviderMap.set(O, providerMap);
+              }
+              providerMap.set(P, provider);
+            }
+            return true;
+          }
+        }
+        function GetOrCreateMetadataRegistry() {
+          var metadataRegistry2;
+          if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+            metadataRegistry2 = root.Reflect[registrySymbol];
+          }
+          if (IsUndefined(metadataRegistry2)) {
+            metadataRegistry2 = CreateMetadataRegistry();
+          }
+          if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+            Object.defineProperty(root.Reflect, registrySymbol, {
+              enumerable: false,
+              configurable: false,
+              writable: false,
+              value: metadataRegistry2
+            });
+          }
+          return metadataRegistry2;
+        }
+        function CreateMetadataProvider(registry) {
+          var metadata2 = new _WeakMap();
+          var provider = {
+            isProviderFor: function(O, P) {
+              var targetMetadata = metadata2.get(O);
+              if (IsUndefined(targetMetadata))
+                return false;
+              return targetMetadata.has(P);
+            },
+            OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+            OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+            OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+            OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+            OrdinaryDeleteMetadata
+          };
+          metadataRegistry.registerProvider(provider);
+          return provider;
+          function GetOrCreateMetadataMap(O, P, Create) {
+            var targetMetadata = metadata2.get(O);
+            var createdTargetMetadata = false;
+            if (IsUndefined(targetMetadata)) {
+              if (!Create)
+                return void 0;
+              targetMetadata = new _Map();
+              metadata2.set(O, targetMetadata);
+              createdTargetMetadata = true;
+            }
+            var metadataMap = targetMetadata.get(P);
+            if (IsUndefined(metadataMap)) {
+              if (!Create)
+                return void 0;
+              metadataMap = new _Map();
+              targetMetadata.set(P, metadataMap);
+              if (!registry.setProvider(O, P, provider)) {
+                targetMetadata.delete(P);
+                if (createdTargetMetadata) {
+                  metadata2.delete(O);
+                }
+                throw new Error("Wrong provider for target.");
+              }
+            }
+            return metadataMap;
+          }
+          function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return false;
+            return ToBoolean(metadataMap.has(MetadataKey));
+          }
+          function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return void 0;
+            return metadataMap.get(MetadataKey);
+          }
+          function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              true
+            );
+            metadataMap.set(MetadataKey, MetadataValue);
+          }
+          function OrdinaryOwnMetadataKeys2(O, P) {
+            var keys = [];
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return keys;
+            var keysObj = metadataMap.keys();
+            var iterator = GetIterator(keysObj);
+            var k = 0;
+            while (true) {
+              var next = IteratorStep(iterator);
+              if (!next) {
+                keys.length = k;
+                return keys;
+              }
+              var nextValue = IteratorValue(next);
+              try {
+                keys[k] = nextValue;
+              } catch (e) {
+                try {
+                  IteratorClose(iterator);
+                } finally {
+                  throw e;
+                }
+              }
+              k++;
+            }
+          }
+          function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return false;
+            if (!metadataMap.delete(MetadataKey))
+              return false;
+            if (metadataMap.size === 0) {
+              var targetMetadata = metadata2.get(O);
+              if (!IsUndefined(targetMetadata)) {
+                targetMetadata.delete(P);
+                if (targetMetadata.size === 0) {
+                  metadata2.delete(targetMetadata);
+                }
+              }
+            }
+            return true;
+          }
+        }
+        function CreateFallbackProvider(reflect) {
+          var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata;
+          var metadataOwner = new _WeakMap();
+          var provider = {
+            isProviderFor: function(O, P) {
+              var metadataPropertySet = metadataOwner.get(O);
+              if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+                return true;
+              }
+              if (getOwnMetadataKeys2(O, P).length) {
+                if (IsUndefined(metadataPropertySet)) {
+                  metadataPropertySet = new _Set();
+                  metadataOwner.set(O, metadataPropertySet);
+                }
+                metadataPropertySet.add(P);
+                return true;
+              }
+              return false;
+            },
+            OrdinaryDefineOwnMetadata: defineMetadata2,
+            OrdinaryHasOwnMetadata: hasOwnMetadata2,
+            OrdinaryGetOwnMetadata: getOwnMetadata2,
+            OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+            OrdinaryDeleteMetadata: deleteMetadata2
+          };
+          return provider;
+        }
+        function GetMetadataProvider(O, P, Create) {
+          var registeredProvider = metadataRegistry.getProvider(O, P);
+          if (!IsUndefined(registeredProvider)) {
+            return registeredProvider;
+          }
+          if (Create) {
+            if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+              return metadataProvider;
+            }
+            throw new Error("Illegal state.");
+          }
+          return void 0;
+        }
+        function CreateMapPolyfill() {
+          var cacheSentinel = {};
+          var arraySentinel = [];
+          var MapIterator = (
+            /** @class */
+            (function() {
+              function MapIterator2(keys, values, selector) {
+                this._index = 0;
+                this._keys = keys;
+                this._values = values;
+                this._selector = selector;
+              }
+              MapIterator2.prototype["@@iterator"] = function() {
+                return this;
+              };
+              MapIterator2.prototype[iteratorSymbol] = function() {
+                return this;
+              };
+              MapIterator2.prototype.next = function() {
+                var index = this._index;
+                if (index >= 0 && index < this._keys.length) {
+                  var result = this._selector(this._keys[index], this._values[index]);
+                  if (index + 1 >= this._keys.length) {
+                    this._index = -1;
+                    this._keys = arraySentinel;
+                    this._values = arraySentinel;
+                  } else {
+                    this._index++;
+                  }
+                  return { value: result, done: false };
+                }
+                return { value: void 0, done: true };
+              };
+              MapIterator2.prototype.throw = function(error) {
+                if (this._index >= 0) {
+                  this._index = -1;
+                  this._keys = arraySentinel;
+                  this._values = arraySentinel;
+                }
+                throw error;
+              };
+              MapIterator2.prototype.return = function(value) {
+                if (this._index >= 0) {
+                  this._index = -1;
+                  this._keys = arraySentinel;
+                  this._values = arraySentinel;
+                }
+                return { value, done: true };
+              };
+              return MapIterator2;
+            })()
+          );
+          var Map2 = (
+            /** @class */
+            (function() {
+              function Map3() {
+                this._keys = [];
+                this._values = [];
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              }
+              Object.defineProperty(Map3.prototype, "size", {
+                get: function() {
+                  return this._keys.length;
+                },
+                enumerable: true,
+                configurable: true
+              });
+              Map3.prototype.has = function(key) {
+                return this._find(
+                  key,
+                  /*insert*/
+                  false
+                ) >= 0;
+              };
+              Map3.prototype.get = function(key) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  false
+                );
+                return index >= 0 ? this._values[index] : void 0;
+              };
+              Map3.prototype.set = function(key, value) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  true
+                );
+                this._values[index] = value;
+                return this;
+              };
+              Map3.prototype.delete = function(key) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  false
+                );
+                if (index >= 0) {
+                  var size = this._keys.length;
+                  for (var i = index + 1; i < size; i++) {
+                    this._keys[i - 1] = this._keys[i];
+                    this._values[i - 1] = this._values[i];
+                  }
+                  this._keys.length--;
+                  this._values.length--;
+                  if (SameValueZero(key, this._cacheKey)) {
+                    this._cacheKey = cacheSentinel;
+                    this._cacheIndex = -2;
+                  }
+                  return true;
+                }
+                return false;
+              };
+              Map3.prototype.clear = function() {
+                this._keys.length = 0;
+                this._values.length = 0;
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              };
+              Map3.prototype.keys = function() {
+                return new MapIterator(this._keys, this._values, getKey);
+              };
+              Map3.prototype.values = function() {
+                return new MapIterator(this._keys, this._values, getValue);
+              };
+              Map3.prototype.entries = function() {
+                return new MapIterator(this._keys, this._values, getEntry);
+              };
+              Map3.prototype["@@iterator"] = function() {
+                return this.entries();
+              };
+              Map3.prototype[iteratorSymbol] = function() {
+                return this.entries();
+              };
+              Map3.prototype._find = function(key, insert) {
+                if (!SameValueZero(this._cacheKey, key)) {
+                  this._cacheIndex = -1;
+                  for (var i = 0; i < this._keys.length; i++) {
+                    if (SameValueZero(this._keys[i], key)) {
+                      this._cacheIndex = i;
+                      break;
+                    }
+                  }
+                }
+                if (this._cacheIndex < 0 && insert) {
+                  this._cacheIndex = this._keys.length;
+                  this._keys.push(key);
+                  this._values.push(void 0);
+                }
+                return this._cacheIndex;
+              };
+              return Map3;
+            })()
+          );
+          return Map2;
+          function getKey(key, _) {
+            return key;
+          }
+          function getValue(_, value) {
+            return value;
+          }
+          function getEntry(key, value) {
+            return [key, value];
+          }
+        }
+        function CreateSetPolyfill() {
+          var Set2 = (
+            /** @class */
+            (function() {
+              function Set3() {
+                this._map = new _Map();
+              }
+              Object.defineProperty(Set3.prototype, "size", {
+                get: function() {
+                  return this._map.size;
+                },
+                enumerable: true,
+                configurable: true
+              });
+              Set3.prototype.has = function(value) {
+                return this._map.has(value);
+              };
+              Set3.prototype.add = function(value) {
+                return this._map.set(value, value), this;
+              };
+              Set3.prototype.delete = function(value) {
+                return this._map.delete(value);
+              };
+              Set3.prototype.clear = function() {
+                this._map.clear();
+              };
+              Set3.prototype.keys = function() {
+                return this._map.keys();
+              };
+              Set3.prototype.values = function() {
+                return this._map.keys();
+              };
+              Set3.prototype.entries = function() {
+                return this._map.entries();
+              };
+              Set3.prototype["@@iterator"] = function() {
+                return this.keys();
+              };
+              Set3.prototype[iteratorSymbol] = function() {
+                return this.keys();
+              };
+              return Set3;
+            })()
+          );
+          return Set2;
+        }
+        function CreateWeakMapPolyfill() {
+          var UUID_SIZE = 16;
+          var keys = HashMap.create();
+          var rootKey = CreateUniqueKey();
+          return (
+            /** @class */
+            (function() {
+              function WeakMap2() {
+                this._key = CreateUniqueKey();
+              }
+              WeakMap2.prototype.has = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? HashMap.has(table, this._key) : false;
+              };
+              WeakMap2.prototype.get = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? HashMap.get(table, this._key) : void 0;
+              };
+              WeakMap2.prototype.set = function(target, value) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  true
+                );
+                table[this._key] = value;
+                return this;
+              };
+              WeakMap2.prototype.delete = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? delete table[this._key] : false;
+              };
+              WeakMap2.prototype.clear = function() {
+                this._key = CreateUniqueKey();
+              };
+              return WeakMap2;
+            })()
+          );
+          function CreateUniqueKey() {
+            var key;
+            do
+              key = "@@WeakMap@@" + CreateUUID();
+            while (HashMap.has(keys, key));
+            keys[key] = true;
+            return key;
+          }
+          function GetOrCreateWeakMapTable(target, create) {
+            if (!hasOwn.call(target, rootKey)) {
+              if (!create)
+                return void 0;
+              Object.defineProperty(target, rootKey, { value: HashMap.create() });
+            }
+            return target[rootKey];
+          }
+          function FillRandomBytes(buffer, size) {
+            for (var i = 0; i < size; ++i)
+              buffer[i] = Math.random() * 255 | 0;
+            return buffer;
+          }
+          function GenRandomBytes(size) {
+            if (typeof Uint8Array === "function") {
+              var array = new Uint8Array(size);
+              if (typeof crypto !== "undefined") {
+                crypto.getRandomValues(array);
+              } else if (typeof msCrypto !== "undefined") {
+                msCrypto.getRandomValues(array);
+              } else {
+                FillRandomBytes(array, size);
+              }
+              return array;
+            }
+            return FillRandomBytes(new Array(size), size);
+          }
+          function CreateUUID() {
+            var data = GenRandomBytes(UUID_SIZE);
+            data[6] = data[6] & 79 | 64;
+            data[8] = data[8] & 191 | 128;
+            var result = "";
+            for (var offset = 0; offset < UUID_SIZE; ++offset) {
+              var byte = data[offset];
+              if (offset === 4 || offset === 6 || offset === 8)
+                result += "-";
+              if (byte < 16)
+                result += "0";
+              result += byte.toString(16).toLowerCase();
+            }
+            return result;
+          }
+        }
+        function MakeDictionary(obj) {
+          obj.__ = void 0;
+          delete obj.__;
+          return obj;
+        }
+      });
+    })(Reflect2 || (Reflect2 = {}));
+  }
+});
+
+// src/index.ts
+var import_reflect_metadata2 = __toESM(require_Reflect());
+
+// src/server.ts
+var import_reflect_metadata = __toESM(require_Reflect());
+import { EventEmitter } from "events";
+import * as http from "http";
+import * as url from "url";
+import {
+  isMcpServer,
+  getServerMetadata,
+  getToolsMetadata,
+  getResourcesMetadata,
+  getPromptsMetadata
+} from "@mcp-weave/nestjs";
+var McpWebUI = class extends EventEmitter {
+  serverClass;
+  serverInstance;
+  options;
+  httpServer = null;
+  serverInfo = null;
+  callHistory = [];
+  logs = [];
+  constructor(serverClass, options = {}) {
+    super();
+    if (!isMcpServer(serverClass)) {
+      throw new Error(`Class ${serverClass.name} is not decorated with @McpServer`);
+    }
+    this.serverClass = serverClass;
+    this.options = {
+      port: options.port ?? 3e3,
+      host: options.host ?? "localhost",
+      title: options.title ?? "MCP Server Dashboard",
+      theme: options.theme ?? "dark",
+      enableLogs: options.enableLogs ?? true
+    };
+  }
+  /**
+   * Initialize server instance and extract metadata
+   */
+  initialize() {
+    this.serverInstance = new this.serverClass();
+    const serverMeta = getServerMetadata(this.serverClass);
+    const toolsMeta = getToolsMetadata(this.serverClass);
+    const resourcesMeta = getResourcesMetadata(this.serverClass);
+    const promptsMeta = getPromptsMetadata(this.serverClass);
+    this.serverInfo = {
+      name: serverMeta?.name ?? "Unknown Server",
+      version: serverMeta?.version ?? "1.0.0",
+      description: serverMeta?.description,
+      tools: toolsMeta.map((t) => ({
+        name: t.name,
+        description: t.description,
+        method: String(t.propertyKey),
+        inputSchema: t.inputSchema
+      })),
+      resources: resourcesMeta.map((r) => ({
+        uri: r.uri,
+        name: r.name,
+        description: r.description,
+        mimeType: r.mimeType,
+        method: String(r.propertyKey)
+      })),
+      prompts: promptsMeta.map((p) => ({
+        name: p.name,
+        description: p.description,
+        method: String(p.propertyKey),
+        arguments: p.arguments
+      }))
+    };
+  }
+  /**
+   * Start the Web UI server
+   */
+  async start() {
+    this.initialize();
+    return new Promise((resolve, reject) => {
+      this.httpServer = http.createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+      this.httpServer.on("error", reject);
+      this.httpServer.listen(this.options.port, this.options.host, () => {
+        const address = this.httpServer.address();
+        if (address && typeof address === "object") {
+          this.options.port = address.port;
+        }
+        this.log(`\u{1F3A8} MCP Web UI started at ${this.getUrl()}`);
+        resolve();
+      });
+    });
+  }
+  /**
+   * Stop the Web UI server
+   */
+  async stop() {
+    return new Promise((resolve, reject) => {
+      if (!this.httpServer) {
+        resolve();
+        return;
+      }
+      this.httpServer.close((err) => {
+        this.httpServer = null;
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  /**
+   * Get the URL of the dashboard
+   */
+  getUrl() {
+    return `http://${this.options.host}:${this.options.port}`;
+  }
+  /**
+   * Get server information
+   */
+  getServerInfo() {
+    return this.serverInfo;
+  }
+  /**
+   * Get call history
+   */
+  getCallHistory() {
+    return this.callHistory;
+  }
+  /**
+   * Log a message
+   */
+  log(message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logEntry = `[${timestamp}] ${message}`;
+    this.logs.push(logEntry);
+    if (this.logs.length > 1e3) {
+      this.logs.shift();
+    }
+    this.emit("log", logEntry);
+  }
+  /**
+   * Handle HTTP requests
+   */
+  handleRequest(req, res) {
+    const parsedUrl = url.parse(req.url ?? "/", true);
+    const pathname = parsedUrl.pathname ?? "/";
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    if (pathname === "/" && req.method === "GET") {
+      this.serveDashboard(res);
+    } else if (pathname === "/api/info" && req.method === "GET") {
+      this.serveServerInfo(res);
+    } else if (pathname === "/api/tools" && req.method === "GET") {
+      this.serveTools(res);
+    } else if (pathname === "/api/resources" && req.method === "GET") {
+      this.serveResources(res);
+    } else if (pathname === "/api/prompts" && req.method === "GET") {
+      this.servePrompts(res);
+    } else if (pathname === "/api/call-tool" && req.method === "POST") {
+      this.handleCallTool(req, res);
+    } else if (pathname === "/api/read-resource" && req.method === "POST") {
+      this.handleReadResource(req, res);
+    } else if (pathname === "/api/get-prompt" && req.method === "POST") {
+      this.handleGetPrompt(req, res);
+    } else if (pathname === "/api/history" && req.method === "GET") {
+      this.serveHistory(res);
+    } else if (pathname === "/api/logs" && req.method === "GET") {
+      this.serveLogs(res);
+    } else {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not Found" }));
+    }
+  }
+  /**
+   * Serve the main dashboard HTML
+   */
+  serveDashboard(res) {
+    const html = this.generateDashboardHTML();
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(html);
+  }
+  /**
+   * Serve server info as JSON
+   */
+  serveServerInfo(res) {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(this.serverInfo));
+  }
+  /**
+   * Serve tools list
+   */
+  serveTools(res) {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(this.serverInfo?.tools ?? []));
+  }
+  /**
+   * Serve resources list
+   */
+  serveResources(res) {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(this.serverInfo?.resources ?? []));
+  }
+  /**
+   * Serve prompts list
+   */
+  servePrompts(res) {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(this.serverInfo?.prompts ?? []));
+  }
+  /**
+   * Serve call history
+   */
+  serveHistory(res) {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(this.callHistory));
+  }
+  /**
+   * Serve server logs
+   */
+  serveLogs(res) {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(this.logs));
+  }
+  /**
+   * Handle tool call request
+   */
+  async handleCallTool(req, res) {
+    try {
+      const body = await this.readBody(req);
+      const { name, input } = JSON.parse(body);
+      const tool = this.serverInfo?.tools.find((t) => t.name === name);
+      if (!tool) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: `Tool '${name}' not found` }));
+        return;
+      }
+      const startTime = Date.now();
+      const historyEntry = {
+        id: this.generateId(),
+        type: "tool",
+        name,
+        input,
+        timestamp: /* @__PURE__ */ new Date(),
+        duration: 0
+      };
+      try {
+        this.log(`Calling tool: ${name}`);
+        this.emit("tool:call", name, input);
+        const method = this.serverInstance[tool.method];
+        const result = await method.call(this.serverInstance, input);
+        historyEntry.output = result;
+        historyEntry.duration = Date.now() - startTime;
+        this.callHistory.unshift(historyEntry);
+        this.log(`Tool ${name} completed in ${historyEntry.duration}ms`);
+        this.emit("tool:result", name, result);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: true, result }));
+      } catch (error) {
+        historyEntry.error = error instanceof Error ? error.message : String(error);
+        historyEntry.duration = Date.now() - startTime;
+        this.callHistory.unshift(historyEntry);
+        this.log(`Tool ${name} failed: ${historyEntry.error}`);
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: historyEntry.error }));
+      }
+    } catch (error) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid request body" }));
+    }
+  }
+  /**
+   * Handle resource read request
+   */
+  async handleReadResource(req, res) {
+    try {
+      const body = await this.readBody(req);
+      const { uri } = JSON.parse(body);
+      const resource = this.serverInfo?.resources.find((r) => {
+        const pattern = r.uri.replace(/{[^}]+}/g, "[^/]+");
+        const regex = new RegExp(`^${pattern}$`);
+        return regex.test(uri);
+      });
+      if (!resource) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: `Resource matching '${uri}' not found` }));
+        return;
+      }
+      const startTime = Date.now();
+      const historyEntry = {
+        id: this.generateId(),
+        type: "resource",
+        name: uri,
+        timestamp: /* @__PURE__ */ new Date(),
+        duration: 0
+      };
+      try {
+        this.log(`Reading resource: ${uri}`);
+        this.emit("resource:read", uri);
+        const params = this.extractUriParams(resource.uri, uri);
+        const method = this.serverInstance[resource.method];
+        const result = await method.call(this.serverInstance, params);
+        historyEntry.output = result;
+        historyEntry.duration = Date.now() - startTime;
+        this.callHistory.unshift(historyEntry);
+        this.log(`Resource ${uri} read in ${historyEntry.duration}ms`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: true, result }));
+      } catch (error) {
+        historyEntry.error = error instanceof Error ? error.message : String(error);
+        historyEntry.duration = Date.now() - startTime;
+        this.callHistory.unshift(historyEntry);
+        this.log(`Resource ${uri} failed: ${historyEntry.error}`);
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: historyEntry.error }));
+      }
+    } catch (error) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid request body" }));
+    }
+  }
+  /**
+   * Handle prompt get request
+   */
+  async handleGetPrompt(req, res) {
+    try {
+      const body = await this.readBody(req);
+      const { name, args } = JSON.parse(body);
+      const prompt = this.serverInfo?.prompts.find((p) => p.name === name);
+      if (!prompt) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: `Prompt '${name}' not found` }));
+        return;
+      }
+      const startTime = Date.now();
+      const historyEntry = {
+        id: this.generateId(),
+        type: "prompt",
+        name,
+        input: args,
+        timestamp: /* @__PURE__ */ new Date(),
+        duration: 0
+      };
+      try {
+        this.log(`Getting prompt: ${name}`);
+        this.emit("prompt:get", name, args);
+        const method = this.serverInstance[prompt.method];
+        const result = await method.call(this.serverInstance, args);
+        historyEntry.output = result;
+        historyEntry.duration = Date.now() - startTime;
+        this.callHistory.unshift(historyEntry);
+        this.log(`Prompt ${name} completed in ${historyEntry.duration}ms`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: true, result }));
+      } catch (error) {
+        historyEntry.error = error instanceof Error ? error.message : String(error);
+        historyEntry.duration = Date.now() - startTime;
+        this.callHistory.unshift(historyEntry);
+        this.log(`Prompt ${name} failed: ${historyEntry.error}`);
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: historyEntry.error }));
+      }
+    } catch (error) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid request body" }));
+    }
+  }
+  /**
+   * Read request body
+   */
+  readBody(req) {
+    return new Promise((resolve, reject) => {
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      req.on("end", () => resolve(body));
+      req.on("error", reject);
+    });
+  }
+  /**
+   * Extract parameters from URI template
+   */
+  extractUriParams(template, uri) {
+    const params = {};
+    const templateParts = template.split("/");
+    const uriParts = uri.split("/");
+    templateParts.forEach((part, index) => {
+      const match = part.match(/^{([^}]+)}$/);
+      const uriPart = uriParts[index];
+      if (match && match[1] && uriPart) {
+        params[match[1]] = uriPart;
+      }
+    });
+    return params;
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Generate the dashboard HTML
+   */
+  generateDashboardHTML() {
+    const isDark = this.options.theme === "dark";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${this.options.title}</title>
+  <style>
+    :root {
+      --bg-primary: ${isDark ? "#1a1a2e" : "#ffffff"};
+      --bg-secondary: ${isDark ? "#16213e" : "#f5f5f5"};
+      --bg-card: ${isDark ? "#0f3460" : "#ffffff"};
+      --text-primary: ${isDark ? "#ffffff" : "#1a1a2e"};
+      --text-secondary: ${isDark ? "#a0a0a0" : "#666666"};
+      --accent: #e94560;
+      --accent-hover: #ff6b6b;
+      --success: #4caf50;
+      --error: #f44336;
+      --border: ${isDark ? "#2a2a4a" : "#e0e0e0"};
+      --code-bg: ${isDark ? "#0d1117" : "#f6f8fa"};
+    }
+    
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      background: var(--bg-primary);
+      color: var(--text-primary);
+      line-height: 1.6;
+    }
+    
+    .container {
+      max-width: 1400px;
+      margin: 0 auto;
+      padding: 20px;
+    }
+    
+    header {
+      background: var(--bg-secondary);
+      padding: 20px;
+      border-bottom: 1px solid var(--border);
+      margin-bottom: 20px;
+    }
+    
+    header h1 {
+      color: var(--accent);
+      font-size: 24px;
+      display: flex;
+      align-items: center;
+      gap: 10px;
+    }
+    
+    .server-info {
+      display: flex;
+      gap: 20px;
+      margin-top: 10px;
+      color: var(--text-secondary);
+      font-size: 14px;
+    }
+    
+    .badge {
+      background: var(--accent);
+      color: white;
+      padding: 2px 8px;
+      border-radius: 12px;
+      font-size: 12px;
+    }
+    
+    .grid {
+      display: grid;
+      grid-template-columns: 300px 1fr 350px;
+      gap: 20px;
+      height: calc(100vh - 150px);
+    }
+    
+    .panel {
+      background: var(--bg-card);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      overflow: hidden;
+      display: flex;
+      flex-direction: column;
+    }
+    
+    .panel-header {
+      background: var(--bg-secondary);
+      padding: 12px 16px;
+      font-weight: 600;
+      border-bottom: 1px solid var(--border);
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    
+    .panel-content {
+      padding: 16px;
+      overflow-y: auto;
+      flex: 1;
+    }
+    
+    .tabs {
+      display: flex;
+      gap: 0;
+      background: var(--bg-secondary);
+      border-bottom: 1px solid var(--border);
+    }
+    
+    .tab {
+      padding: 10px 16px;
+      cursor: pointer;
+      border: none;
+      background: transparent;
+      color: var(--text-secondary);
+      font-size: 14px;
+      border-bottom: 2px solid transparent;
+      transition: all 0.2s;
+    }
+    
+    .tab:hover { color: var(--text-primary); }
+    .tab.active {
+      color: var(--accent);
+      border-bottom-color: var(--accent);
+    }
+    
+    .item {
+      padding: 12px;
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      margin-bottom: 8px;
+      cursor: pointer;
+      transition: all 0.2s;
+    }
+    
+    .item:hover {
+      border-color: var(--accent);
+      background: var(--bg-secondary);
+    }
+    
+    .item.selected {
+      border-color: var(--accent);
+      background: var(--bg-secondary);
+    }
+    
+    .item-name {
+      font-weight: 600;
+      color: var(--accent);
+    }
+    
+    .item-desc {
+      color: var(--text-secondary);
+      font-size: 13px;
+      margin-top: 4px;
+    }
+    
+    .form-group {
+      margin-bottom: 16px;
+    }
+    
+    .form-group label {
+      display: block;
+      margin-bottom: 6px;
+      font-weight: 500;
+      font-size: 14px;
+    }
+    
+    .form-group input,
+    .form-group textarea {
+      width: 100%;
+      padding: 10px 12px;
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      background: var(--bg-primary);
+      color: var(--text-primary);
+      font-family: inherit;
+      font-size: 14px;
+    }
+    
+    .form-group textarea {
+      min-height: 150px;
+      font-family: 'Monaco', 'Menlo', monospace;
+      font-size: 13px;
+    }
+    
+    .form-group input:focus,
+    .form-group textarea:focus {
+      outline: none;
+      border-color: var(--accent);
+    }
+    
+    .btn {
+      padding: 10px 20px;
+      border: none;
+      border-radius: 6px;
+      font-weight: 600;
+      cursor: pointer;
+      transition: all 0.2s;
+      font-size: 14px;
+    }
+    
+    .btn-primary {
+      background: var(--accent);
+      color: white;
+    }
+    
+    .btn-primary:hover { background: var(--accent-hover); }
+    .btn-primary:disabled { opacity: 0.5; cursor: not-allowed; }
+    
+    .result {
+      background: var(--code-bg);
+      border-radius: 6px;
+      padding: 16px;
+      font-family: 'Monaco', 'Menlo', monospace;
+      font-size: 13px;
+      white-space: pre-wrap;
+      word-break: break-all;
+      max-height: 300px;
+      overflow-y: auto;
+    }
+    
+    .result.success { border-left: 3px solid var(--success); }
+    .result.error { border-left: 3px solid var(--error); }
+    
+    .history-item {
+      padding: 10px 12px;
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      margin-bottom: 8px;
+      font-size: 13px;
+    }
+    
+    .history-item .type {
+      display: inline-block;
+      padding: 2px 6px;
+      border-radius: 4px;
+      font-size: 11px;
+      text-transform: uppercase;
+      font-weight: 600;
+    }
+    
+    .history-item .type.tool { background: #2196f3; color: white; }
+    .history-item .type.resource { background: #9c27b0; color: white; }
+    .history-item .type.prompt { background: #ff9800; color: white; }
+    
+    .history-item .name {
+      font-weight: 600;
+      margin-left: 8px;
+    }
+    
+    .history-item .time {
+      color: var(--text-secondary);
+      font-size: 12px;
+      margin-top: 4px;
+    }
+    
+    .history-item .duration {
+      color: var(--success);
+    }
+    
+    .history-item.error .duration { color: var(--error); }
+    
+    .empty-state {
+      text-align: center;
+      padding: 40px 20px;
+      color: var(--text-secondary);
+    }
+    
+    .spinner {
+      border: 3px solid var(--border);
+      border-top: 3px solid var(--accent);
+      border-radius: 50%;
+      width: 24px;
+      height: 24px;
+      animation: spin 1s linear infinite;
+      margin: 20px auto;
+    }
+    
+    @keyframes spin {
+      0% { transform: rotate(0deg); }
+      100% { transform: rotate(360deg); }
+    }
+    
+    .logs {
+      font-family: 'Monaco', 'Menlo', monospace;
+      font-size: 12px;
+      background: var(--code-bg);
+      padding: 12px;
+      border-radius: 6px;
+      max-height: 200px;
+      overflow-y: auto;
+    }
+    
+    .log-entry {
+      color: var(--text-secondary);
+      margin-bottom: 4px;
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <div class="container">
+      <h1>\u{1F527} ${this.options.title}</h1>
+      <div class="server-info" id="server-info">Loading...</div>
+    </div>
+  </header>
+  
+  <div class="container">
+    <div class="grid">
+      <!-- Left Panel: Items List -->
+      <div class="panel">
+        <div class="tabs">
+          <button class="tab active" data-tab="tools">Tools</button>
+          <button class="tab" data-tab="resources">Resources</button>
+          <button class="tab" data-tab="prompts">Prompts</button>
+        </div>
+        <div class="panel-content" id="items-list">
+          <div class="empty-state">Loading...</div>
+        </div>
+      </div>
+      
+      <!-- Center Panel: Tester -->
+      <div class="panel">
+        <div class="panel-header">
+          <span id="tester-title">Select an item to test</span>
+        </div>
+        <div class="panel-content" id="tester">
+          <div class="empty-state">
+            <p>Select a tool, resource, or prompt from the left panel to test it.</p>
+          </div>
+        </div>
+      </div>
+      
+      <!-- Right Panel: History -->
+      <div class="panel">
+        <div class="panel-header">
+          <span>Call History</span>
+          <button class="btn" onclick="clearHistory()" style="padding: 4px 8px; font-size: 12px;">Clear</button>
+        </div>
+        <div class="panel-content" id="history">
+          <div class="empty-state">No calls yet</div>
+        </div>
+      </div>
+    </div>
+  </div>
+  
+  <script>
+    // State
+    let serverInfo = null;
+    let currentTab = 'tools';
+    let selectedItem = null;
+    let isLoading = false;
+    let history = [];
+    
+    // Initialize
+    async function init() {
+      await loadServerInfo();
+      await loadItems();
+      setupTabs();
+      pollHistory();
+    }
+    
+    // Load server info
+    async function loadServerInfo() {
+      try {
+        const res = await fetch('/api/info');
+        serverInfo = await res.json();
+        document.getElementById('server-info').innerHTML = \`
+          <span><strong>Name:</strong> \${serverInfo.name}</span>
+          <span><strong>Version:</strong> \${serverInfo.version}</span>
+          <span class="badge">\${serverInfo.tools.length} Tools</span>
+          <span class="badge">\${serverInfo.resources.length} Resources</span>
+          <span class="badge">\${serverInfo.prompts.length} Prompts</span>
+        \`;
+      } catch (err) {
+        console.error('Failed to load server info:', err);
+      }
+    }
+    
+    // Load items based on current tab
+    async function loadItems() {
+      const container = document.getElementById('items-list');
+      let items = [];
+      
+      if (currentTab === 'tools') {
+        items = serverInfo?.tools || [];
+      } else if (currentTab === 'resources') {
+        items = serverInfo?.resources || [];
+      } else if (currentTab === 'prompts') {
+        items = serverInfo?.prompts || [];
+      }
+      
+      if (items.length === 0) {
+        container.innerHTML = '<div class="empty-state">No ' + currentTab + ' available</div>';
+        return;
+      }
+      
+      container.innerHTML = items.map((item, index) => \`
+        <div class="item" onclick="selectItem('\${currentTab}', \${index})">
+          <div class="item-name">\${item.name || item.uri}</div>
+          <div class="item-desc">\${item.description || ''}</div>
+        </div>
+      \`).join('');
+    }
+    
+    // Setup tabs
+    function setupTabs() {
+      document.querySelectorAll('.tab').forEach(tab => {
+        tab.addEventListener('click', () => {
+          document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+          tab.classList.add('active');
+          currentTab = tab.dataset.tab;
+          loadItems();
+          clearTester();
+        });
+      });
+    }
+    
+    // Select an item
+    function selectItem(type, index) {
+      let items = type === 'tools' ? serverInfo.tools : 
+                  type === 'resources' ? serverInfo.resources : 
+                  serverInfo.prompts;
+      selectedItem = { type, item: items[index] };
+      renderTester();
+    }
+    
+    // Clear tester
+    function clearTester() {
+      selectedItem = null;
+      document.getElementById('tester-title').textContent = 'Select an item to test';
+      document.getElementById('tester').innerHTML = \`
+        <div class="empty-state">
+          <p>Select a tool, resource, or prompt from the left panel to test it.</p>
+        </div>
+      \`;
+    }
+    
+    // Render tester for selected item
+    function renderTester() {
+      if (!selectedItem) return;
+      
+      const { type, item } = selectedItem;
+      document.getElementById('tester-title').textContent = item.name || item.uri;
+      
+      let html = '';
+      
+      if (type === 'tools') {
+        html = \`
+          <div class="form-group">
+            <label>Description</label>
+            <p style="color: var(--text-secondary); font-size: 14px;">\${item.description || 'No description'}</p>
+          </div>
+          <div class="form-group">
+            <label>Input (JSON)</label>
+            <textarea id="tool-input" placeholder='{"key": "value"}'>{}</textarea>
+          </div>
+          <button class="btn btn-primary" onclick="callTool()" id="call-btn">Call Tool</button>
+          <div id="result-container" style="margin-top: 16px;"></div>
+        \`;
+      } else if (type === 'resources') {
+        html = \`
+          <div class="form-group">
+            <label>URI Template</label>
+            <p style="color: var(--text-secondary); font-size: 14px;">\${item.uri}</p>
+          </div>
+          <div class="form-group">
+            <label>URI to Read</label>
+            <input type="text" id="resource-uri" value="\${item.uri.replace(/{[^}]+}/g, 'example')}" />
+          </div>
+          <button class="btn btn-primary" onclick="readResource()" id="call-btn">Read Resource</button>
+          <div id="result-container" style="margin-top: 16px;"></div>
+        \`;
+      } else if (type === 'prompts') {
+        const args = item.arguments || [];
+        html = \`
+          <div class="form-group">
+            <label>Description</label>
+            <p style="color: var(--text-secondary); font-size: 14px;">\${item.description || 'No description'}</p>
+          </div>
+          <div class="form-group">
+            <label>Arguments (JSON)</label>
+            <textarea id="prompt-args" placeholder='{"arg1": "value1"}'>\${JSON.stringify(args.reduce((acc, a) => ({ ...acc, [a.name]: '' }), {}), null, 2)}</textarea>
+          </div>
+          <button class="btn btn-primary" onclick="getPrompt()" id="call-btn">Get Prompt</button>
+          <div id="result-container" style="margin-top: 16px;"></div>
+        \`;
+      }
+      
+      document.getElementById('tester').innerHTML = html;
+    }
+    
+    // Call tool
+    async function callTool() {
+      if (isLoading) return;
+      isLoading = true;
+      
+      const btn = document.getElementById('call-btn');
+      btn.disabled = true;
+      btn.textContent = 'Calling...';
+      
+      try {
+        const input = JSON.parse(document.getElementById('tool-input').value || '{}');
+        const res = await fetch('/api/call-tool', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ name: selectedItem.item.name, input })
+        });
+        const data = await res.json();
+        showResult(data);
+      } catch (err) {
+        showResult({ success: false, error: err.message });
+      } finally {
+        isLoading = false;
+        btn.disabled = false;
+        btn.textContent = 'Call Tool';
+      }
+    }
+    
+    // Read resource
+    async function readResource() {
+      if (isLoading) return;
+      isLoading = true;
+      
+      const btn = document.getElementById('call-btn');
+      btn.disabled = true;
+      btn.textContent = 'Reading...';
+      
+      try {
+        const uri = document.getElementById('resource-uri').value;
+        const res = await fetch('/api/read-resource', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ uri })
+        });
+        const data = await res.json();
+        showResult(data);
+      } catch (err) {
+        showResult({ success: false, error: err.message });
+      } finally {
+        isLoading = false;
+        btn.disabled = false;
+        btn.textContent = 'Read Resource';
+      }
+    }
+    
+    // Get prompt
+    async function getPrompt() {
+      if (isLoading) return;
+      isLoading = true;
+      
+      const btn = document.getElementById('call-btn');
+      btn.disabled = true;
+      btn.textContent = 'Getting...';
+      
+      try {
+        const args = JSON.parse(document.getElementById('prompt-args').value || '{}');
+        const res = await fetch('/api/get-prompt', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ name: selectedItem.item.name, args })
+        });
+        const data = await res.json();
+        showResult(data);
+      } catch (err) {
+        showResult({ success: false, error: err.message });
+      } finally {
+        isLoading = false;
+        btn.disabled = false;
+        btn.textContent = 'Get Prompt';
+      }
+    }
+    
+    // Show result
+    function showResult(data) {
+      const container = document.getElementById('result-container');
+      const success = data.success;
+      const content = success ? JSON.stringify(data.result, null, 2) : data.error;
+      
+      container.innerHTML = \`
+        <div class="result \${success ? 'success' : 'error'}">
+          \${escapeHtml(content)}
+        </div>
+      \`;
+      
+      refreshHistory();
+    }
+    
+    // Escape HTML
+    function escapeHtml(text) {
+      const div = document.createElement('div');
+      div.textContent = text;
+      return div.innerHTML;
+    }
+    
+    // Poll history
+    async function pollHistory() {
+      await refreshHistory();
+      setTimeout(pollHistory, 2000);
+    }
+    
+    // Refresh history
+    async function refreshHistory() {
+      try {
+        const res = await fetch('/api/history');
+        history = await res.json();
+        renderHistory();
+      } catch (err) {
+        console.error('Failed to load history:', err);
+      }
+    }
+    
+    // Render history
+    function renderHistory() {
+      const container = document.getElementById('history');
+      
+      if (history.length === 0) {
+        container.innerHTML = '<div class="empty-state">No calls yet</div>';
+        return;
+      }
+      
+      container.innerHTML = history.slice(0, 50).map(entry => \`
+        <div class="history-item \${entry.error ? 'error' : ''}">
+          <span class="type \${entry.type}">\${entry.type}</span>
+          <span class="name">\${entry.name}</span>
+          <div class="time">
+            \${new Date(entry.timestamp).toLocaleTimeString()} - 
+            <span class="duration">\${entry.duration}ms</span>
+            \${entry.error ? '<span style="color: var(--error);"> - Error</span>' : ''}
+          </div>
+        </div>
+      \`).join('');
+    }
+    
+    // Clear history
+    function clearHistory() {
+      history = [];
+      renderHistory();
+    }
+    
+    // Start
+    init();
+  </script>
+</body>
+</html>`;
+  }
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  McpWebUI,
+  VERSION
+};
+/*! Bundled license information:
+
+reflect-metadata/Reflect.js:
+  (*! *****************************************************************************
+  Copyright (C) Microsoft. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
+  
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
+  
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** *)
+*/
+//# sourceMappingURL=index.mjs.map