mcp-use 1.10.0-canary.8 → 1.10.0

package/dist/index.cjs

@@ -35,9 +35,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 async function getNodeModules() {
   if (typeof process !== "undefined" && process.platform) {
     try {
-      const fs3 = await import("fs");
-      const path3 = await import("path");
-      return { fs: fs3.default, path: path3.default };
+      const fs2 = await import("fs");
+      const path2 = await import("path");
+      return { fs: fs2.default, path: path2.default };
     } catch {
       return { fs: null, path: null };
     }
@@ -1053,6 +1053,7 @@ __export(index_exports, {
   BaseCodeExecutor: () => BaseCodeExecutor,
   BaseConnector: () => BaseConnector,
   BrowserOAuthClientProvider: () => BrowserOAuthClientProvider,
+  BrowserTelemetry: () => Tel,
   ConnectMCPServerTool: () => ConnectMCPServerTool,
   E2BCodeExecutor: () => E2BCodeExecutor,
   ElicitationDeclinedError: () => ElicitationDeclinedError,
@@ -1076,6 +1077,7 @@ __export(index_exports, {
   RemoteAgent: () => RemoteAgent,
   ServerManager: () => ServerManager,
   StdioConnector: () => StdioConnector,
+  Tel: () => Tel,
   Telemetry: () => Telemetry,
   ThemeProvider: () => ThemeProvider,
   VERSION: () => VERSION,
@@ -1089,6 +1091,7 @@ __export(index_exports, {
   loadConfigFile: () => loadConfigFile,
   logger: () => logger,
   onMcpAuthorization: () => onMcpAuthorization,
+  setBrowserTelemetrySource: () => setTelemetrySource,
   setTelemetrySource: () => setTelemetrySource,
   streamEventsToAISDK: () => streamEventsToAISDK,
   streamEventsToAISDKWithTools: () => streamEventsToAISDKWithTools,
@@ -2514,22 +2517,6 @@ var ObservabilityManager = class {
   }
 };
 
-// src/telemetry/telemetry.ts
-var fs = __toESM(require("fs"), 1);
-var os = __toESM(require("os"), 1);
-var path = __toESM(require("path"), 1);
-var import_posthog_node = require("posthog-node");
-
-// src/server/utils/runtime.ts
-var isDeno = typeof globalThis.Deno !== "undefined";
-function generateUUID() {
-  return globalThis.crypto.randomUUID();
-}
-__name(generateUUID, "generateUUID");
-
-// src/telemetry/telemetry.ts
-init_logging();
-
 // src/telemetry/events.ts
 var BaseTelemetryEvent = class {
   static {
@@ -2805,7 +2792,8 @@ var MCPClientInitEvent = class extends BaseTelemetryEvent {
       all_callbacks: this.data.allCallbacks,
       verify: this.data.verify,
       servers: this.data.servers,
-      num_servers: this.data.numServers
+      num_servers: this.data.numServers,
+      is_browser: this.data.isBrowser
     };
   }
 };
@@ -2830,9 +2818,65 @@ var ConnectorInitEvent = class extends BaseTelemetryEvent {
     };
   }
 };
+var ClientAddServerEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ClientAddServerEvent");
+  }
+  get name() {
+    return "client_add_server";
+  }
+  get properties() {
+    const { serverName, serverConfig } = this.data;
+    const url = serverConfig.url;
+    return {
+      server_name: serverName,
+      server_url_domain: url ? this._extractHostname(url) : null,
+      transport: serverConfig.transport ?? null,
+      has_auth: !!(serverConfig.authToken || serverConfig.authProvider)
+    };
+  }
+  _extractHostname(url) {
+    try {
+      return new URL(url).hostname;
+    } catch {
+      return null;
+    }
+  }
+};
+var ClientRemoveServerEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ClientRemoveServerEvent");
+  }
+  get name() {
+    return "client_remove_server";
+  }
+  get properties() {
+    return {
+      server_name: this.data.serverName
+    };
+  }
+};
+
+// src/server/utils/runtime.ts
+var isDeno = typeof globalThis.Deno !== "undefined";
+function generateUUID() {
+  return globalThis.crypto.randomUUID();
+}
+__name(generateUUID, "generateUUID");
+
+// src/telemetry/telemetry.ts
+init_logging();
 
 // src/version.ts
-var VERSION = "1.10.0-canary.8";
+var VERSION = "1.10.0";
 function getPackageVersion() {
   return VERSION;
 }
@@ -2886,12 +2930,12 @@ function detectRuntimeEnvironment() {
     if (typeof globalThis.EdgeRuntime !== "undefined") {
       return "edge";
     }
-    if (typeof process !== "undefined" && typeof process.versions?.node !== "undefined" && typeof fs !== "undefined" && typeof fs.existsSync === "function") {
-      return "node";
-    }
     if (typeof window !== "undefined" && typeof document !== "undefined") {
       return "browser";
     }
+    if (typeof process !== "undefined" && typeof process.versions?.node !== "undefined") {
+      return "node";
+    }
     return "unknown";
   } catch {
     return "unknown";
@@ -2928,11 +2972,6 @@ function getRuntimeEnvironment() {
   return cachedEnvironment;
 }
 __name(getRuntimeEnvironment, "getRuntimeEnvironment");
-function isNodeJSEnvironment2() {
-  const env = getRuntimeEnvironment();
-  return env === "node" || env === "bun";
-}
-__name(isNodeJSEnvironment2, "isNodeJSEnvironment");
 var ScarfEventLogger = class {
   static {
     __name(this, "ScarfEventLogger");
@@ -2964,71 +3003,40 @@ var ScarfEventLogger = class {
     }
   }
 };
-function getCacheHome() {
-  if (!isNodeJSEnvironment2()) {
-    return "/tmp/mcp_use_cache";
-  }
-  const envVar = process.env.XDG_CACHE_HOME;
-  if (envVar && path.isAbsolute(envVar)) {
-    return envVar;
-  }
-  const platform = process.platform;
-  const homeDir = os.homedir();
-  if (platform === "win32") {
-    const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
-    if (appdata) {
-      return appdata;
-    }
-    return path.join(homeDir, "AppData", "Local");
-  } else if (platform === "darwin") {
-    return path.join(homeDir, "Library", "Caches");
-  } else {
-    return path.join(homeDir, ".cache");
-  }
-}
-__name(getCacheHome, "getCacheHome");
 var Telemetry = class _Telemetry {
   static {
     __name(this, "Telemetry");
   }
   static instance = null;
-  USER_ID_PATH = path.join(
-    getCacheHome(),
-    "mcp_use_3",
-    "telemetry_user_id"
-  );
-  VERSION_DOWNLOAD_PATH = path.join(
-    getCacheHome(),
-    "mcp_use",
-    "download_version"
-  );
   PROJECT_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
   HOST = "https://eu.i.posthog.com";
   SCARF_GATEWAY_URL = "https://mcpuse.gateway.scarf.sh/events-ts";
   UNKNOWN_USER_ID = "UNKNOWN_USER_ID";
   _currUserId = null;
-  _posthogClient = null;
+  _posthogNodeClient = null;
+  _posthogBrowserClient = null;
+  _posthogLoading = null;
   _scarfClient = null;
   _runtimeEnvironment;
   _storageCapability;
   _source;
+  // Node.js specific paths (lazily computed)
+  _userIdPath = null;
+  _versionDownloadPath = null;
   constructor() {
     this._runtimeEnvironment = getRuntimeEnvironment();
     this._storageCapability = getStorageCapability(this._runtimeEnvironment);
     this._source = typeof process !== "undefined" && process.env?.MCP_USE_TELEMETRY_SOURCE || this._runtimeEnvironment;
-    const telemetryDisabled = typeof process !== "undefined" && process.env?.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === "false" || false;
+    const telemetryDisabled = this._checkTelemetryDisabled();
     const canSupportTelemetry = this._runtimeEnvironment !== "unknown";
-    const isServerlessEnvironment = [
-      "cloudflare-workers",
-      "edge",
-      "deno"
-    ].includes(this._runtimeEnvironment);
     if (telemetryDisabled) {
-      this._posthogClient = null;
+      this._posthogNodeClient = null;
+      this._posthogBrowserClient = null;
       this._scarfClient = null;
-      logger.debug("Telemetry disabled via environment variable");
+      logger.debug("Telemetry disabled via environment/localStorage");
     } else if (!canSupportTelemetry) {
-      this._posthogClient = null;
+      this._posthogNodeClient = null;
+      this._posthogBrowserClient = null;
       this._scarfClient = null;
       logger.debug(
         `Telemetry disabled - unknown environment: ${this._runtimeEnvironment}`
@@ -3037,27 +3045,7 @@ var Telemetry = class _Telemetry {
       logger.info(
         "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
       );
-      if (this._runtimeEnvironment !== "browser") {
-        try {
-          const posthogOptions = {
-            host: this.HOST,
-            disableGeoip: false
-          };
-          if (isServerlessEnvironment) {
-            posthogOptions.flushAt = 1;
-            posthogOptions.flushInterval = 0;
-          }
-          this._posthogClient = new import_posthog_node.PostHog(
-            this.PROJECT_API_KEY,
-            posthogOptions
-          );
-        } catch (e) {
-          logger.warn(`Failed to initialize PostHog telemetry: ${e}`);
-          this._posthogClient = null;
-        }
-      } else {
-        this._posthogClient = null;
-      }
+      this._posthogLoading = this._initPostHog();
       try {
         this._scarfClient = new ScarfEventLogger(this.SCARF_GATEWAY_URL, 3e3);
       } catch (e) {
@@ -3066,6 +3054,75 @@ var Telemetry = class _Telemetry {
       }
     }
   }
+  _checkTelemetryDisabled() {
+    if (typeof process !== "undefined" && process.env?.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === "false") {
+      return true;
+    }
+    if (typeof localStorage !== "undefined" && localStorage.getItem("MCP_USE_ANONYMIZED_TELEMETRY") === "false") {
+      return true;
+    }
+    return false;
+  }
+  async _initPostHog() {
+    const isBrowser = this._runtimeEnvironment === "browser";
+    if (isBrowser) {
+      await this._initPostHogBrowser();
+    } else {
+      await this._initPostHogNode();
+    }
+  }
+  async _initPostHogBrowser() {
+    try {
+      const posthogModule = await import("posthog-js");
+      const posthog = posthogModule.default || posthogModule.posthog;
+      if (!posthog || typeof posthog.init !== "function") {
+        throw new Error("posthog-js module did not export expected interface");
+      }
+      posthog.init(this.PROJECT_API_KEY, {
+        api_host: this.HOST,
+        persistence: "localStorage",
+        autocapture: false,
+        // We only want explicit captures
+        capture_pageview: false,
+        // We don't want automatic pageview tracking
+        disable_session_recording: true,
+        // No session recording
+        loaded: /* @__PURE__ */ __name(() => {
+          logger.debug("PostHog browser client initialized");
+        }, "loaded")
+      });
+      this._posthogBrowserClient = posthog;
+    } catch (e) {
+      logger.warn(`Failed to initialize PostHog browser telemetry: ${e}`);
+      this._posthogBrowserClient = null;
+    }
+  }
+  async _initPostHogNode() {
+    try {
+      const { PostHog } = await import("posthog-node");
+      const isServerlessEnvironment = [
+        "cloudflare-workers",
+        "edge",
+        "deno"
+      ].includes(this._runtimeEnvironment);
+      const posthogOptions = {
+        host: this.HOST,
+        disableGeoip: false
+      };
+      if (isServerlessEnvironment) {
+        posthogOptions.flushAt = 1;
+        posthogOptions.flushInterval = 0;
+      }
+      this._posthogNodeClient = new PostHog(
+        this.PROJECT_API_KEY,
+        posthogOptions
+      );
+      logger.debug("PostHog Node.js client initialized");
+    } catch (e) {
+      logger.warn(`Failed to initialize PostHog Node.js telemetry: ${e}`);
+      this._posthogNodeClient = null;
+    }
+  }
   /**
    * Get the detected runtime environment
    */
@@ -3101,10 +3158,9 @@ var Telemetry = class _Telemetry {
   }
   /**
    * Check if telemetry is enabled.
-   * Returns false if telemetry was disabled via environment variable or if not in Node.js environment.
    */
   get isEnabled() {
-    return this._posthogClient !== null || this._scarfClient !== null;
+    return this._posthogNodeClient !== null || this._posthogBrowserClient !== null || this._scarfClient !== null;
   }
   get userId() {
     if (this._currUserId) {
@@ -3113,10 +3169,10 @@ var Telemetry = class _Telemetry {
     try {
       switch (this._storageCapability) {
         case "filesystem":
-          this._currUserId = this.getUserIdFromFilesystem();
+          this._currUserId = this._getUserIdFromFilesystem();
           break;
         case "localStorage":
-          this._currUserId = this.getUserIdFromLocalStorage();
+          this._currUserId = this._getUserIdFromLocalStorage();
           break;
         case "session-only":
         default:
@@ -3127,7 +3183,7 @@ var Telemetry = class _Telemetry {
           break;
       }
       if (this._storageCapability === "filesystem" && this._currUserId) {
-        this.trackPackageDownloadInternal(this._currUserId, {
+        this._trackPackageDownloadInternal(this._currUserId, {
           triggered_by: "user_id_property"
         }).catch((e) => logger.debug(`Failed to track package download: ${e}`));
       }
@@ -3140,22 +3196,32 @@ var Telemetry = class _Telemetry {
   /**
    * Get or create user ID from filesystem (Node.js/Bun)
    */
-  getUserIdFromFilesystem() {
-    const isFirstTime = !fs.existsSync(this.USER_ID_PATH);
+  _getUserIdFromFilesystem() {
+    const fs2 = require("fs");
+    const os = require("os");
+    const path2 = require("path");
+    if (!this._userIdPath) {
+      this._userIdPath = path2.join(
+        this._getCacheHome(os, path2),
+        "mcp_use_3",
+        "telemetry_user_id"
+      );
+    }
+    const isFirstTime = !fs2.existsSync(this._userIdPath);
     if (isFirstTime) {
-      logger.debug(`Creating user ID path: ${this.USER_ID_PATH}`);
-      fs.mkdirSync(path.dirname(this.USER_ID_PATH), { recursive: true });
+      logger.debug(`Creating user ID path: ${this._userIdPath}`);
+      fs2.mkdirSync(path2.dirname(this._userIdPath), { recursive: true });
       const newUserId = generateUUID();
-      fs.writeFileSync(this.USER_ID_PATH, newUserId);
-      logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
+      fs2.writeFileSync(this._userIdPath, newUserId);
+      logger.debug(`User ID path created: ${this._userIdPath}`);
       return newUserId;
     }
-    return fs.readFileSync(this.USER_ID_PATH, "utf-8").trim();
+    return fs2.readFileSync(this._userIdPath, "utf-8").trim();
   }
   /**
    * Get or create user ID from localStorage (Browser)
    */
-  getUserIdFromLocalStorage() {
+  _getUserIdFromLocalStorage() {
     try {
       let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
       if (!userId) {
@@ -3169,60 +3235,89 @@ var Telemetry = class _Telemetry {
       return `session-${generateUUID()}`;
     }
   }
+  _getCacheHome(os, path2) {
+    const envVar = process.env.XDG_CACHE_HOME;
+    if (envVar && path2.isAbsolute(envVar)) {
+      return envVar;
+    }
+    const platform = process.platform;
+    const homeDir = os.homedir();
+    if (platform === "win32") {
+      const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
+      if (appdata) {
+        return appdata;
+      }
+      return path2.join(homeDir, "AppData", "Local");
+    } else if (platform === "darwin") {
+      return path2.join(homeDir, "Library", "Caches");
+    } else {
+      return path2.join(homeDir, ".cache");
+    }
+  }
   async capture(event) {
-    logger.debug(
-      `CAPTURE: posthog: ${this._posthogClient !== null}, scarf: ${this._scarfClient !== null}`
-    );
-    if (!this._posthogClient && !this._scarfClient) {
+    if (this._posthogLoading) {
+      await this._posthogLoading;
+    }
+    if (!this._posthogNodeClient && !this._posthogBrowserClient && !this._scarfClient) {
       return;
     }
-    if (this._posthogClient) {
+    const properties = { ...event.properties };
+    properties.mcp_use_version = getPackageVersion();
+    properties.language = "typescript";
+    properties.source = this._source;
+    properties.runtime = this._runtimeEnvironment;
+    if (this._posthogNodeClient) {
       try {
-        const properties = { ...event.properties };
-        properties.mcp_use_version = getPackageVersion();
-        properties.language = "typescript";
-        properties.source = this._source;
-        properties.runtime = this._runtimeEnvironment;
-        logger.debug(`CAPTURE: PostHog Event ${event.name}`);
-        logger.debug(
-          `CAPTURE: PostHog Properties ${JSON.stringify(properties)}`
-        );
-        this._posthogClient.capture({
+        logger.debug(`CAPTURE: PostHog Node Event ${event.name}`);
+        this._posthogNodeClient.capture({
           distinctId: this.userId,
           event: event.name,
           properties
         });
       } catch (e) {
-        logger.debug(`Failed to track PostHog event ${event.name}: ${e}`);
+        logger.debug(`Failed to track PostHog Node event ${event.name}: ${e}`);
+      }
+    }
+    if (this._posthogBrowserClient) {
+      try {
+        logger.debug(`CAPTURE: PostHog Browser Event ${event.name}`);
+        this._posthogBrowserClient.capture(event.name, {
+          ...properties,
+          distinct_id: this.userId
+        });
+      } catch (e) {
+        logger.debug(
+          `Failed to track PostHog Browser event ${event.name}: ${e}`
+        );
       }
     }
     if (this._scarfClient) {
       try {
-        const properties = {};
-        properties.mcp_use_version = getPackageVersion();
-        properties.user_id = this.userId;
-        properties.event = event.name;
-        properties.language = "typescript";
-        properties.source = this._source;
-        properties.runtime = this._runtimeEnvironment;
-        await this._scarfClient.logEvent(properties);
+        const scarfProperties = {
+          ...properties,
+          user_id: this.userId,
+          event: event.name
+        };
+        await this._scarfClient.logEvent(scarfProperties);
       } catch (e) {
         logger.debug(`Failed to track Scarf event ${event.name}: ${e}`);
       }
     }
   }
+  // ============================================================================
+  // Package Download Tracking (Node.js only)
+  // ============================================================================
   /**
    * Track package download event.
    * This is a public wrapper that safely accesses userId.
    */
   async trackPackageDownload(properties) {
-    return this.trackPackageDownloadInternal(this.userId, properties);
+    return this._trackPackageDownloadInternal(this.userId, properties);
   }
   /**
    * Internal method to track package download with explicit userId.
-   * This avoids circular dependency when called from the userId getter.
    */
-  async trackPackageDownloadInternal(userId, properties) {
+  async _trackPackageDownloadInternal(userId, properties) {
     if (!this._scarfClient) {
       return;
     }
@@ -3230,22 +3325,32 @@ var Telemetry = class _Telemetry {
       return;
     }
     try {
+      const fs2 = require("fs");
+      const path2 = require("path");
+      const os = require("os");
+      if (!this._versionDownloadPath) {
+        this._versionDownloadPath = path2.join(
+          this._getCacheHome(os, path2),
+          "mcp_use",
+          "download_version"
+        );
+      }
       const currentVersion = getPackageVersion();
       let shouldTrack = false;
       let firstDownload = false;
-      if (!fs.existsSync(this.VERSION_DOWNLOAD_PATH)) {
+      if (!fs2.existsSync(this._versionDownloadPath)) {
         shouldTrack = true;
         firstDownload = true;
-        fs.mkdirSync(path.dirname(this.VERSION_DOWNLOAD_PATH), {
+        fs2.mkdirSync(path2.dirname(this._versionDownloadPath), {
           recursive: true
         });
-        fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+        fs2.writeFileSync(this._versionDownloadPath, currentVersion);
       } else {
-        const savedVersion = fs.readFileSync(this.VERSION_DOWNLOAD_PATH, "utf-8").trim();
+        const savedVersion = fs2.readFileSync(this._versionDownloadPath, "utf-8").trim();
         if (currentVersion > savedVersion) {
           shouldTrack = true;
           firstDownload = false;
-          fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+          fs2.writeFileSync(this._versionDownloadPath, currentVersion);
         }
       }
       if (shouldTrack) {
@@ -3279,9 +3384,6 @@ var Telemetry = class _Telemetry {
   // ============================================================================
   /**
    * Track server run event directly from an MCPServer instance.
-   * This extracts the necessary data from the server and creates the event.
-   * @param server - The MCPServer instance (or any object conforming to MCPServerTelemetryInfo)
-   * @param transport - The transport type (e.g., "http", "stdio", "supabase")
    */
   async trackServerRunFromServer(server, transport) {
     if (!this.isEnabled) return;
@@ -3327,37 +3429,123 @@ var Telemetry = class _Telemetry {
     const event = new ConnectorInitEvent(data);
     await this.capture(event);
   }
+  async trackClientAddServer(serverName, serverConfig) {
+    if (!this.isEnabled) return;
+    const event = new ClientAddServerEvent({ serverName, serverConfig });
+    await this.capture(event);
+  }
+  async trackClientRemoveServer(serverName) {
+    if (!this.isEnabled) return;
+    const event = new ClientRemoveServerEvent({ serverName });
+    await this.capture(event);
+  }
+  // ============================================================================
+  // React Hook / Browser specific events
+  // ============================================================================
+  async trackUseMcpConnection(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_connection",
+      properties: {
+        url_domain: new URL(data.url).hostname,
+        // Only domain for privacy
+        transport_type: data.transportType,
+        success: data.success,
+        error_type: data.errorType ?? null,
+        connection_time_ms: data.connectionTimeMs ?? null,
+        has_oauth: data.hasOAuth,
+        has_sampling: data.hasSampling,
+        has_elicitation: data.hasElicitation
+      }
+    });
+  }
+  async trackUseMcpToolCall(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_tool_call",
+      properties: {
+        tool_name: data.toolName,
+        success: data.success,
+        error_type: data.errorType ?? null,
+        execution_time_ms: data.executionTimeMs ?? null
+      }
+    });
+  }
+  async trackUseMcpResourceRead(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_resource_read",
+      properties: {
+        resource_uri_scheme: data.resourceUri.split(":")[0],
+        // Only scheme for privacy
+        success: data.success,
+        error_type: data.errorType ?? null
+      }
+    });
+  }
+  // ============================================================================
+  // Browser-specific Methods
+  // ============================================================================
+  /**
+   * Identify the current user (useful for linking sessions)
+   * Browser only - no-op in Node.js
+   */
+  identify(userId, properties) {
+    if (this._posthogBrowserClient) {
+      try {
+        this._posthogBrowserClient.identify(userId, properties);
+      } catch (e) {
+        logger.debug(`Failed to identify user: ${e}`);
+      }
+    }
+  }
+  /**
+   * Reset the user identity (useful for logout)
+   * Browser only - no-op in Node.js
+   */
+  reset() {
+    if (this._posthogBrowserClient) {
+      try {
+        this._posthogBrowserClient.reset();
+      } catch (e) {
+        logger.debug(`Failed to reset user: ${e}`);
+      }
+    }
+    this._currUserId = null;
+  }
+  // ============================================================================
+  // Node.js-specific Methods
+  // ============================================================================
+  /**
+   * Flush the telemetry queue (Node.js only)
+   */
   flush() {
-    if (this._posthogClient) {
+    if (this._posthogNodeClient) {
       try {
-        this._posthogClient.flush();
+        this._posthogNodeClient.flush();
         logger.debug("PostHog client telemetry queue flushed");
       } catch (e) {
         logger.debug(`Failed to flush PostHog client: ${e}`);
       }
     }
-    if (this._scarfClient) {
-      logger.debug("Scarf telemetry events sent immediately (no flush needed)");
-    }
   }
+  /**
+   * Shutdown the telemetry client (Node.js only)
+   */
   shutdown() {
-    if (this._posthogClient) {
+    if (this._posthogNodeClient) {
       try {
-        this._posthogClient.shutdown();
+        this._posthogNodeClient.shutdown();
         logger.debug("PostHog client shutdown successfully");
       } catch (e) {
         logger.debug(`Error shutting down PostHog client: ${e}`);
       }
     }
-    if (this._scarfClient) {
-      logger.debug("Scarf telemetry client shutdown (no action needed)");
-    }
   }
 };
-
-// src/telemetry/index.ts
+var Tel = Telemetry;
 function setTelemetrySource(source) {
-  Telemetry.getInstance().setSource(source);
+  Tel.getInstance().setSource(source);
 }
 __name(setTelemetrySource, "setTelemetrySource");
 
@@ -5381,11 +5569,13 @@ var BaseMCPClient = class {
   addServer(name, serverConfig) {
     this.config.mcpServers = this.config.mcpServers || {};
     this.config.mcpServers[name] = serverConfig;
+    Tel.getInstance().trackClientAddServer(name, serverConfig);
   }
   removeServer(name) {
     if (this.config.mcpServers?.[name]) {
       delete this.config.mcpServers[name];
       this.activeSessions = this.activeSessions.filter((n) => n !== name);
+      Tel.getInstance().trackClientRemoveServer(name);
     }
   }
   getServerNames() {
@@ -7738,7 +7928,7 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
     const servers = Object.keys(this.config.mcpServers ?? {});
     const hasSamplingCallback = !!this._samplingCallback;
     const hasElicitationCallback = !!this._elicitationCallback;
-    Telemetry.getInstance().trackMCPClientInit({
+    Tel.getInstance().trackMCPClientInit({
       codeMode: this.codeMode,
       sandbox: false,
       // Sandbox not supported in TS yet
@@ -7746,14 +7936,16 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
       verify: false,
       // No verify option in TS client
       servers,
-      numServers: servers.length
+      numServers: servers.length,
+      isBrowser: false
+      // Node.js MCPClient
     }).catch((e) => logger.debug(`Failed to track MCPClient init: ${e}`));
   }
   static fromDict(cfg, options) {
     return new _MCPClient(cfg, options);
   }
-  static fromConfigFile(path3, options) {
-    return new _MCPClient(loadConfigFile(path3), options);
+  static fromConfigFile(path2, options) {
+    return new _MCPClient(loadConfigFile(path2), options);
   }
   /**
    * Save configuration to a file (Node.js only)
@@ -8033,15 +8225,15 @@ var OAuthHelper = class {
       // GitHub Copilot
       /api\.github\.com/i,
       // GitHub API
-      /[a-z0-9-]+\.googleapis\.com/i,
-      // Google APIs
+      /[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.googleapis\.com/i,
+      // Google APIs (DNS-safe, max 63 chars per label)
       /api\.openai\.com/i,
       // OpenAI
       /api\.anthropic\.com/i,
       // Anthropic
-      /[a-z0-9-]+\.atlassian\.net/i,
+      /[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.atlassian\.net/i,
       // Atlassian (Jira, Confluence)
-      /[a-z0-9-]+\.slack\.com/i,
+      /[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.slack\.com/i,
       // Slack
       /api\.notion\.com/i,
       // Notion
@@ -8055,7 +8247,7 @@ var OAuthHelper = class {
       // Local development
       /\.local/i,
       // Local development
-      /mcp\.[a-z0-9-]+\.com/i
+      /mcp\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.com/i
       // Generic MCP server pattern (often public)
     ];
     for (const pattern of noAuthPatterns) {
@@ -8772,6 +8964,7 @@ __name(onMcpAuthorization, "onMcpAuthorization");
 var import_react = require("react");
 
 // src/client/browser.ts
+init_logging();
 var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
   static {
     __name(this, "BrowserMCPClient");
@@ -8785,6 +8978,25 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
   }
   constructor(config) {
     super(config);
+    this._trackClientInit();
+  }
+  _trackClientInit() {
+    const servers = Object.keys(this.config.mcpServers ?? {});
+    Tel.getInstance().trackMCPClientInit({
+      codeMode: false,
+      // Browser client doesn't support code mode
+      sandbox: false,
+      // Sandbox not supported in browser
+      allCallbacks: false,
+      // Will be set per-server
+      verify: false,
+      servers,
+      numServers: servers.length,
+      isBrowser: true
+      // Browser MCPClient
+    }).catch(
+      (e) => logger.debug(`Failed to track BrowserMCPClient init: ${e}`)
+    );
   }
   static fromDict(cfg) {
     return new _BrowserMCPClient(cfg);
@@ -8963,8 +9175,20 @@ function useMcp(options) {
         }
       }
       connectingRef.current = false;
+      if (url) {
+        Tel.getInstance().trackUseMcpConnection({
+          url,
+          transportType,
+          success: false,
+          errorType: connectionError?.name || "UnknownError",
+          hasOAuth: !!authProviderRef.current,
+          hasSampling: !!samplingCallback,
+          hasElicitation: !!onElicitation
+        }).catch(() => {
+        });
+      }
     },
-    [addLog]
+    [addLog, url, transportType, samplingCallback, onElicitation]
   );
   const connect = (0, import_react.useCallback)(async () => {
     if (!enabled || !url) {
@@ -9073,6 +9297,15 @@ function useMcp(options) {
         );
         setState("ready");
         successfulTransportRef.current = transportTypeParam;
+        Tel.getInstance().trackUseMcpConnection({
+          url,
+          transportType: transportTypeParam,
+          success: true,
+          hasOAuth: !!authProviderRef.current,
+          hasSampling: !!samplingCallback,
+          hasElicitation: !!onElicitation
+        }).catch(() => {
+        });
         setTools(session.connector.tools || []);
         const resourcesResult = await session.connector.listAllResources();
         setResources(resourcesResult.resources || []);
@@ -9197,6 +9430,7 @@ function useMcp(options) {
         );
       }
       addLog("info", `Calling tool: ${name}`, args);
+      const startTime = Date.now();
       try {
         const serverName = "inspector-server";
         const session = clientRef.current.getSession(serverName);
@@ -9209,9 +9443,22 @@ function useMcp(options) {
           options2
         );
         addLog("info", `Tool "${name}" call successful:`, result);
+        Tel.getInstance().trackUseMcpToolCall({
+          toolName: name,
+          success: true,
+          executionTimeMs: Date.now() - startTime
+        }).catch(() => {
+        });
         return result;
       } catch (err) {
         addLog("error", `Tool "${name}" call failed:`, err);
+        Tel.getInstance().trackUseMcpToolCall({
+          toolName: name,
+          success: false,
+          errorType: err instanceof Error ? err.name : "UnknownError",
+          executionTimeMs: Date.now() - startTime
+        }).catch(() => {
+        });
         throw err;
       }
     },
@@ -9361,9 +9608,20 @@ function useMcp(options) {
         }
         const result = await session.connector.readResource(uri);
         addLog("info", "Resource read successful:", result);
+        Tel.getInstance().trackUseMcpResourceRead({
+          resourceUri: uri,
+          success: true
+        }).catch(() => {
+        });
         return result;
       } catch (err) {
         addLog("error", "Resource read failed:", err);
+        Tel.getInstance().trackUseMcpResourceRead({
+          resourceUri: uri,
+          success: false,
+          errorType: err instanceof Error ? err.name : "UnknownError"
+        }).catch(() => {
+        });
         throw err;
       }
     },
@@ -10329,8 +10587,8 @@ __name(WidgetControls, "WidgetControls");
 var import_react7 = __toESM(require("react"), 1);
 function getBasename() {
   if (typeof window === "undefined") return "/";
-  const path3 = window.location.pathname;
-  const match = path3.match(/^(\/inspector\/api\/dev-widget\/[^/]+)/);
+  const path2 = window.location.pathname;
+  const match = path2.match(/^(\/inspector\/api\/dev-widget\/[^/]+)/);
   if (match) {
     return match[1];
   }