mcp-use 1.2.1-canary.0 → 1.2.2-canary.0

package/dist/chunk-VPPILX7B.js

@@ -0,0 +1,239 @@
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/logging.ts
+import { createLogger, format, transports } from "winston";
+async function getNodeModules() {
+  if (typeof process !== "undefined" && process.platform) {
+    try {
+      const fs = await import("fs");
+      const path = await import("path");
+      return { fs: fs.default, path: path.default };
+    } catch {
+      return { fs: null, path: null };
+    }
+  }
+  return { fs: null, path: null };
+}
+__name(getNodeModules, "getNodeModules");
+var { combine, timestamp, label, printf, colorize, splat } = format;
+var DEFAULT_LOGGER_NAME = "mcp-use";
+function isNodeJSEnvironment() {
+  try {
+    if (typeof navigator !== "undefined" && navigator.userAgent?.includes("Cloudflare-Workers")) {
+      return false;
+    }
+    if (typeof globalThis.EdgeRuntime !== "undefined" || typeof globalThis.Deno !== "undefined") {
+      return false;
+    }
+    const hasNodeGlobals = typeof process !== "undefined" && typeof process.platform !== "undefined" && typeof __dirname !== "undefined";
+    const hasNodeModules = typeof createLogger === "function";
+    return hasNodeGlobals && hasNodeModules;
+  } catch {
+    return false;
+  }
+}
+__name(isNodeJSEnvironment, "isNodeJSEnvironment");
+var SimpleConsoleLogger = class {
+  static {
+    __name(this, "SimpleConsoleLogger");
+  }
+  _level;
+  name;
+  constructor(name = DEFAULT_LOGGER_NAME, level = "info") {
+    this.name = name;
+    this._level = level;
+  }
+  shouldLog(level) {
+    const levels = ["error", "warn", "info", "http", "verbose", "debug", "silly"];
+    const currentIndex = levels.indexOf(this._level);
+    const messageIndex = levels.indexOf(level);
+    return messageIndex <= currentIndex;
+  }
+  formatMessage(level, message) {
+    const timestamp2 = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+    return `${timestamp2} [${this.name}] ${level}: ${message}`;
+  }
+  error(message) {
+    if (this.shouldLog("error")) {
+      console.error(this.formatMessage("error", message));
+    }
+  }
+  warn(message) {
+    if (this.shouldLog("warn")) {
+      console.warn(this.formatMessage("warn", message));
+    }
+  }
+  info(message) {
+    if (this.shouldLog("info")) {
+      console.info(this.formatMessage("info", message));
+    }
+  }
+  debug(message) {
+    if (this.shouldLog("debug")) {
+      console.debug(this.formatMessage("debug", message));
+    }
+  }
+  http(message) {
+    if (this.shouldLog("http")) {
+      console.log(this.formatMessage("http", message));
+    }
+  }
+  verbose(message) {
+    if (this.shouldLog("verbose")) {
+      console.log(this.formatMessage("verbose", message));
+    }
+  }
+  silly(message) {
+    if (this.shouldLog("silly")) {
+      console.log(this.formatMessage("silly", message));
+    }
+  }
+  // Make it compatible with Winston interface
+  get level() {
+    return this._level;
+  }
+  set level(newLevel) {
+    this._level = newLevel;
+  }
+};
+function resolveLevel(env) {
+  const envValue = typeof process !== "undefined" && process.env ? env : void 0;
+  switch (envValue?.trim()) {
+    case "2":
+      return "debug";
+    case "1":
+      return "info";
+    default:
+      return "info";
+  }
+}
+__name(resolveLevel, "resolveLevel");
+var minimalFormatter = printf(({ level, message, label: label2, timestamp: timestamp2 }) => {
+  return `${timestamp2} [${label2}] ${level}: ${message}`;
+});
+var detailedFormatter = printf(({ level, message, label: label2, timestamp: timestamp2 }) => {
+  return `${timestamp2} [${label2}] ${level.toUpperCase()}: ${message}`;
+});
+var emojiFormatter = printf(({ level, message, label: label2, timestamp: timestamp2 }) => {
+  return `${timestamp2} [${label2}] ${level.toUpperCase()}: ${message}`;
+});
+var Logger = class {
+  static {
+    __name(this, "Logger");
+  }
+  static instances = {};
+  static simpleInstances = {};
+  static currentFormat = "minimal";
+  static get(name = DEFAULT_LOGGER_NAME) {
+    if (!isNodeJSEnvironment()) {
+      if (!this.simpleInstances[name]) {
+        const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
+        this.simpleInstances[name] = new SimpleConsoleLogger(name, resolveLevel(debugEnv));
+      }
+      return this.simpleInstances[name];
+    }
+    if (!this.instances[name]) {
+      this.instances[name] = createLogger({
+        level: resolveLevel(process.env.DEBUG),
+        format: combine(
+          colorize(),
+          splat(),
+          label({ label: name }),
+          timestamp({ format: "HH:mm:ss" }),
+          this.getFormatter()
+        ),
+        transports: []
+      });
+    }
+    return this.instances[name];
+  }
+  static getFormatter() {
+    switch (this.currentFormat) {
+      case "minimal":
+        return minimalFormatter;
+      case "detailed":
+        return detailedFormatter;
+      case "emoji":
+        return emojiFormatter;
+      default:
+        return minimalFormatter;
+    }
+  }
+  static async configure(options = {}) {
+    const { level, console: console2 = true, file, format: format2 = "minimal" } = options;
+    const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
+    const resolvedLevel = level ?? resolveLevel(debugEnv);
+    this.currentFormat = format2;
+    const root = this.get();
+    root.level = resolvedLevel;
+    const winstonRoot = root;
+    if (!isNodeJSEnvironment()) {
+      Object.values(this.simpleInstances).forEach((logger2) => {
+        logger2.level = resolvedLevel;
+      });
+      return;
+    }
+    winstonRoot.clear();
+    if (console2) {
+      winstonRoot.add(new transports.Console());
+    }
+    if (file) {
+      const { fs: nodeFs, path: nodePath } = await getNodeModules();
+      if (nodeFs && nodePath) {
+        const dir = nodePath.dirname(nodePath.resolve(file));
+        if (!nodeFs.existsSync(dir)) {
+          nodeFs.mkdirSync(dir, { recursive: true });
+        }
+        winstonRoot.add(new transports.File({ filename: file }));
+      }
+    }
+    Object.values(this.instances).forEach((logger2) => {
+      if (logger2 && "format" in logger2) {
+        logger2.level = resolvedLevel;
+        logger2.format = combine(
+          colorize(),
+          splat(),
+          label({ label: DEFAULT_LOGGER_NAME }),
+          timestamp({ format: "HH:mm:ss" }),
+          this.getFormatter()
+        );
+      }
+    });
+  }
+  static setDebug(enabled) {
+    let level;
+    if (enabled === 2 || enabled === true)
+      level = "debug";
+    else if (enabled === 1)
+      level = "info";
+    else level = "info";
+    Object.values(this.simpleInstances).forEach((logger2) => {
+      logger2.level = level;
+    });
+    Object.values(this.instances).forEach((logger2) => {
+      if (logger2) {
+        logger2.level = level;
+      }
+    });
+    if (typeof process !== "undefined" && process.env) {
+      process.env.DEBUG = enabled ? enabled === true ? "2" : String(enabled) : "0";
+    }
+  }
+  static setFormat(format2) {
+    this.currentFormat = format2;
+    this.configure({ format: format2 });
+  }
+};
+if (isNodeJSEnvironment()) {
+  Logger.configure();
+} else {
+  Logger.configure({ console: true });
+}
+var logger = Logger.get();
+
+export {
+  Logger,
+  logger
+};