@mcp-use/inspector 0.6.1 → 0.7.0

package/dist/client/assets/path-QsnVvLoj.js

@@ -0,0 +1,62 @@
+function join(...paths) {
+  return paths.filter(Boolean).join("/").replace(/\/+/g, "/").replace(/\/$/, "");
+}
+function resolve(...paths) {
+  return join(...paths);
+}
+function dirname(filepath) {
+  const parts = filepath.split("/");
+  parts.pop();
+  return parts.join("/") || "/";
+}
+function basename(filepath, ext) {
+  const parts = filepath.split("/");
+  let name = parts[parts.length - 1] || "";
+  if (ext && name.endsWith(ext)) {
+    name = name.slice(0, -ext.length);
+  }
+  return name;
+}
+function extname(filepath) {
+  const name = basename(filepath);
+  const index = name.lastIndexOf(".");
+  return index > 0 ? name.slice(index) : "";
+}
+function normalize(filepath) {
+  return filepath.replace(/\/+/g, "/");
+}
+function isAbsolute(filepath) {
+  return filepath.startsWith("/");
+}
+const sep = "/";
+const delimiter = ":";
+const path = {
+  join,
+  resolve,
+  dirname,
+  basename,
+  extname,
+  normalize,
+  isAbsolute,
+  sep,
+  delimiter
+};
+const path$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  basename,
+  default: path,
+  delimiter,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  normalize,
+  resolve,
+  sep
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  dirname as d,
+  isAbsolute as i,
+  join as j,
+  path$1 as p
+};

package/dist/client/assets/transport-wrapper-browser-ChPHVnHg.js

@@ -0,0 +1,165 @@
+class SimpleEventEmitter {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event, ...args) {
+    this.listeners.get(event)?.forEach((listener) => {
+      try {
+        listener(...args);
+      } catch (e) {
+        console.error("Error in event listener:", e);
+      }
+    });
+  }
+}
+class RpcLogBus {
+  emitter = new SimpleEventEmitter();
+  bufferByServer = /* @__PURE__ */ new Map();
+  publish(event) {
+    const buffer = this.bufferByServer.get(event.serverId) ?? [];
+    buffer.push(event);
+    if (buffer.length > 1e3) {
+      buffer.shift();
+    }
+    this.bufferByServer.set(event.serverId, buffer);
+    this.emitter.emit("event", event);
+  }
+  subscribe(serverIds, listener) {
+    const filter = new Set(serverIds);
+    const handler = (event) => {
+      if (filter.size === 0 || filter.has(event.serverId)) listener(event);
+    };
+    this.emitter.on("event", handler);
+    return () => this.emitter.off("event", handler);
+  }
+  getBuffer(serverIds, limit) {
+    const filter = new Set(serverIds);
+    const all = [];
+    for (const [serverId, buf] of this.bufferByServer.entries()) {
+      if (filter.size > 0 && !filter.has(serverId)) continue;
+      all.push(...buf);
+    }
+    all.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    if (limit === 0) return [];
+    if (!Number.isFinite(limit) || limit < 0) return all;
+    return all.slice(0, limit);
+  }
+  clear(serverIds) {
+    if (serverIds && serverIds.length > 0) {
+      const filter = new Set(serverIds);
+      for (const serverId of filter) {
+        this.bufferByServer.delete(serverId);
+      }
+    } else {
+      this.bufferByServer.clear();
+    }
+  }
+}
+const rpcLogBus = new RpcLogBus();
+const browserRpcLogBus = {
+  publish: async (event) => {
+    console.log("[RPC Log Bus Browser] Publishing event:", {
+      serverId: event.serverId,
+      direction: event.direction,
+      method: event.message?.method || "unknown"
+    });
+    try {
+      rpcLogBus.publish(event);
+      console.log("[RPC Log Bus Browser] Published to local bus");
+    } catch (e) {
+      console.error("[RPC Log Bus Browser] Failed to publish to local bus:", e);
+    }
+    try {
+      console.log("[RPC Log Bus Browser] Sending to server...");
+      const response = await fetch("/inspector/api/rpc/log", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(event)
+      });
+      if (!response.ok) {
+        console.warn(
+          "[RPC Log Bus Browser] Server returned non-OK status:",
+          response.status
+        );
+      } else {
+        console.log("[RPC Log Bus Browser] Sent to server successfully");
+      }
+    } catch (err) {
+      console.warn(
+        "[RPC Log Bus Browser] Failed to send event to server:",
+        err
+      );
+    }
+  },
+  subscribe: rpcLogBus.subscribe.bind(rpcLogBus),
+  getBuffer: rpcLogBus.getBuffer.bind(rpcLogBus),
+  clear: rpcLogBus.clear.bind(rpcLogBus)
+};
+function wrapTransportForLogging(transport, serverId) {
+  console.log("[RPC Logger] Wrapping transport for server:", serverId);
+  class LoggingTransport {
+    constructor(inner) {
+      this.inner = inner;
+      this.inner.onmessage = (message, extra) => {
+        browserRpcLogBus.publish({
+          serverId,
+          direction: "receive",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          message
+        }).catch((err) => {
+          console.warn("[RPC Logger] Failed to publish receive event:", err);
+        });
+        this.onmessage?.(message, extra);
+      };
+      this.inner.onclose = () => {
+        this.onclose?.();
+      };
+      this.inner.onerror = (error) => {
+        this.onerror?.(error);
+      };
+    }
+    onclose;
+    onerror;
+    onmessage;
+    async start() {
+      if (typeof this.inner.start === "function") {
+        await this.inner.start();
+      }
+    }
+    async send(message, options) {
+      browserRpcLogBus.publish({
+        serverId,
+        direction: "send",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message
+      }).catch((err) => {
+        console.warn("[RPC Logger] Failed to publish send event:", err);
+      });
+      await this.inner.send(message, options);
+    }
+    async close() {
+      await this.inner.close();
+    }
+    get sessionId() {
+      return this.inner.sessionId;
+    }
+    setProtocolVersion(version) {
+      if (typeof this.inner.setProtocolVersion === "function") {
+        this.inner.setProtocolVersion(version);
+      }
+    }
+  }
+  return new LoggingTransport(transport);
+}
+export {
+  wrapTransportForLogging
+};