@tonyclaw/agent-inspector 3.0.15 → 3.0.17

package/.output/server/_libs/google-logging-utils.mjs

@@ -0,0 +1,385 @@
+import require$$1 from "process";
+import require$$0 from "events";
+import require$$2 from "util";
+var src = {};
+var loggingUtils = {};
+var colours = {};
+var hasRequiredColours;
+function requireColours() {
+  if (hasRequiredColours) return colours;
+  hasRequiredColours = 1;
+  Object.defineProperty(colours, "__esModule", { value: true });
+  colours.Colours = void 0;
+  class Colours {
+    /**
+     * @param stream The stream (e.g. process.stderr)
+     * @returns true if the stream should have colourization enabled
+     */
+    static isEnabled(stream) {
+      return stream && // May happen in browsers.
+      stream.isTTY && (typeof stream.getColorDepth === "function" ? stream.getColorDepth() > 2 : true);
+    }
+    static refresh() {
+      Colours.enabled = Colours.isEnabled(process === null || process === void 0 ? void 0 : process.stderr);
+      if (!this.enabled) {
+        Colours.reset = "";
+        Colours.bright = "";
+        Colours.dim = "";
+        Colours.red = "";
+        Colours.green = "";
+        Colours.yellow = "";
+        Colours.blue = "";
+        Colours.magenta = "";
+        Colours.cyan = "";
+        Colours.white = "";
+        Colours.grey = "";
+      } else {
+        Colours.reset = "\x1B[0m";
+        Colours.bright = "\x1B[1m";
+        Colours.dim = "\x1B[2m";
+        Colours.red = "\x1B[31m";
+        Colours.green = "\x1B[32m";
+        Colours.yellow = "\x1B[33m";
+        Colours.blue = "\x1B[34m";
+        Colours.magenta = "\x1B[35m";
+        Colours.cyan = "\x1B[36m";
+        Colours.white = "\x1B[37m";
+        Colours.grey = "\x1B[90m";
+      }
+    }
+  }
+  colours.Colours = Colours;
+  Colours.enabled = false;
+  Colours.reset = "";
+  Colours.bright = "";
+  Colours.dim = "";
+  Colours.red = "";
+  Colours.green = "";
+  Colours.yellow = "";
+  Colours.blue = "";
+  Colours.magenta = "";
+  Colours.cyan = "";
+  Colours.white = "";
+  Colours.grey = "";
+  Colours.refresh();
+  return colours;
+}
+var hasRequiredLoggingUtils;
+function requireLoggingUtils() {
+  if (hasRequiredLoggingUtils) return loggingUtils;
+  hasRequiredLoggingUtils = 1;
+  (function(exports$1) {
+    var __createBinding = loggingUtils && loggingUtils.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = loggingUtils && loggingUtils.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = loggingUtils && loggingUtils.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.env = exports$1.DebugLogBackendBase = exports$1.placeholder = exports$1.AdhocDebugLogger = exports$1.LogSeverity = void 0;
+    exports$1.getNodeBackend = getNodeBackend;
+    exports$1.getDebugBackend = getDebugBackend;
+    exports$1.getStructuredBackend = getStructuredBackend;
+    exports$1.setBackend = setBackend;
+    exports$1.log = log;
+    const events_1 = require$$0;
+    const process2 = __importStar(require$$1);
+    const util = __importStar(require$$2);
+    const colours_1 = requireColours();
+    var LogSeverity;
+    (function(LogSeverity2) {
+      LogSeverity2["DEFAULT"] = "DEFAULT";
+      LogSeverity2["DEBUG"] = "DEBUG";
+      LogSeverity2["INFO"] = "INFO";
+      LogSeverity2["WARNING"] = "WARNING";
+      LogSeverity2["ERROR"] = "ERROR";
+    })(LogSeverity || (exports$1.LogSeverity = LogSeverity = {}));
+    class AdhocDebugLogger extends events_1.EventEmitter {
+      /**
+       * @param upstream The backend will pass a function that will be
+       *   called whenever our logger function is invoked.
+       */
+      constructor(namespace, upstream) {
+        super();
+        this.namespace = namespace;
+        this.upstream = upstream;
+        this.func = Object.assign(this.invoke.bind(this), {
+          // Also add an instance pointer back to us.
+          instance: this,
+          // And pull over the EventEmitter functionality.
+          on: (event, listener) => this.on(event, listener)
+        });
+        this.func.debug = (...args) => this.invokeSeverity(LogSeverity.DEBUG, ...args);
+        this.func.info = (...args) => this.invokeSeverity(LogSeverity.INFO, ...args);
+        this.func.warn = (...args) => this.invokeSeverity(LogSeverity.WARNING, ...args);
+        this.func.error = (...args) => this.invokeSeverity(LogSeverity.ERROR, ...args);
+        this.func.sublog = (namespace2) => log(namespace2, this.func);
+      }
+      invoke(fields, ...args) {
+        if (this.upstream) {
+          try {
+            this.upstream(fields, ...args);
+          } catch (e) {
+          }
+        }
+        try {
+          this.emit("log", fields, args);
+        } catch (e) {
+        }
+      }
+      invokeSeverity(severity, ...args) {
+        this.invoke({ severity }, ...args);
+      }
+    }
+    exports$1.AdhocDebugLogger = AdhocDebugLogger;
+    exports$1.placeholder = new AdhocDebugLogger("", () => {
+    }).func;
+    class DebugLogBackendBase {
+      constructor() {
+        var _a;
+        this.cached = /* @__PURE__ */ new Map();
+        this.filters = [];
+        this.filtersSet = false;
+        let nodeFlag = (_a = process2.env[exports$1.env.nodeEnables]) !== null && _a !== void 0 ? _a : "*";
+        if (nodeFlag === "all") {
+          nodeFlag = "*";
+        }
+        this.filters = nodeFlag.split(",");
+      }
+      log(namespace, fields, ...args) {
+        try {
+          if (!this.filtersSet) {
+            this.setFilters();
+            this.filtersSet = true;
+          }
+          let logger = this.cached.get(namespace);
+          if (!logger) {
+            logger = this.makeLogger(namespace);
+            this.cached.set(namespace, logger);
+          }
+          logger(fields, ...args);
+        } catch (e) {
+          console.error(e);
+        }
+      }
+    }
+    exports$1.DebugLogBackendBase = DebugLogBackendBase;
+    class NodeBackend extends DebugLogBackendBase {
+      constructor() {
+        super(...arguments);
+        this.enabledRegexp = /.*/g;
+      }
+      isEnabled(namespace) {
+        return this.enabledRegexp.test(namespace);
+      }
+      makeLogger(namespace) {
+        if (!this.enabledRegexp.test(namespace)) {
+          return () => {
+          };
+        }
+        return (fields, ...args) => {
+          var _a;
+          const nscolour = `${colours_1.Colours.green}${namespace}${colours_1.Colours.reset}`;
+          const pid = `${colours_1.Colours.yellow}${process2.pid}${colours_1.Colours.reset}`;
+          let level;
+          switch (fields.severity) {
+            case LogSeverity.ERROR:
+              level = `${colours_1.Colours.red}${fields.severity}${colours_1.Colours.reset}`;
+              break;
+            case LogSeverity.INFO:
+              level = `${colours_1.Colours.magenta}${fields.severity}${colours_1.Colours.reset}`;
+              break;
+            case LogSeverity.WARNING:
+              level = `${colours_1.Colours.yellow}${fields.severity}${colours_1.Colours.reset}`;
+              break;
+            default:
+              level = (_a = fields.severity) !== null && _a !== void 0 ? _a : LogSeverity.DEFAULT;
+              break;
+          }
+          const msg = util.formatWithOptions({ colors: colours_1.Colours.enabled }, ...args);
+          const filteredFields = Object.assign({}, fields);
+          delete filteredFields.severity;
+          const fieldsJson = Object.getOwnPropertyNames(filteredFields).length ? JSON.stringify(filteredFields) : "";
+          const fieldsColour = fieldsJson ? `${colours_1.Colours.grey}${fieldsJson}${colours_1.Colours.reset}` : "";
+          console.error("%s [%s|%s] %s%s", pid, nscolour, level, msg, fieldsJson ? ` ${fieldsColour}` : "");
+        };
+      }
+      // Regexp patterns below are from here:
+      // https://github.com/nodejs/node/blob/c0aebed4b3395bd65d54b18d1fd00f071002ac20/lib/internal/util/debuglog.js#L36
+      setFilters() {
+        const totalFilters = this.filters.join(",");
+        const regexp = totalFilters.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^");
+        this.enabledRegexp = new RegExp(`^${regexp}$`, "i");
+      }
+    }
+    function getNodeBackend() {
+      return new NodeBackend();
+    }
+    class DebugBackend extends DebugLogBackendBase {
+      constructor(pkg) {
+        super();
+        this.debugPkg = pkg;
+      }
+      makeLogger(namespace) {
+        const debugLogger = this.debugPkg(namespace);
+        return (fields, ...args) => {
+          debugLogger(args[0], ...args.slice(1));
+        };
+      }
+      setFilters() {
+        var _a;
+        const existingFilters = (_a = process2.env["NODE_DEBUG"]) !== null && _a !== void 0 ? _a : "";
+        process2.env["NODE_DEBUG"] = `${existingFilters}${existingFilters ? "," : ""}${this.filters.join(",")}`;
+      }
+    }
+    function getDebugBackend(debugPkg) {
+      return new DebugBackend(debugPkg);
+    }
+    class StructuredBackend extends DebugLogBackendBase {
+      constructor(upstream) {
+        var _a;
+        super();
+        this.upstream = (_a = upstream) !== null && _a !== void 0 ? _a : void 0;
+      }
+      makeLogger(namespace) {
+        var _a;
+        const debugLogger = (_a = this.upstream) === null || _a === void 0 ? void 0 : _a.makeLogger(namespace);
+        return (fields, ...args) => {
+          var _a2;
+          const severity = (_a2 = fields.severity) !== null && _a2 !== void 0 ? _a2 : LogSeverity.INFO;
+          const json = Object.assign({
+            severity,
+            message: util.format(...args)
+          }, fields);
+          const jsonString = JSON.stringify(json);
+          if (debugLogger) {
+            debugLogger(fields, jsonString);
+          } else {
+            console.log("%s", jsonString);
+          }
+        };
+      }
+      setFilters() {
+        var _a;
+        (_a = this.upstream) === null || _a === void 0 ? void 0 : _a.setFilters();
+      }
+    }
+    function getStructuredBackend(upstream) {
+      return new StructuredBackend(upstream);
+    }
+    exports$1.env = {
+      /**
+       * Filter wildcards specific to the Node syntax, and similar to the built-in
+       * utils.debuglog() environment variable. If missing, disables logging.
+       */
+      nodeEnables: "GOOGLE_SDK_NODE_LOGGING"
+    };
+    const loggerCache = /* @__PURE__ */ new Map();
+    let cachedBackend = void 0;
+    function setBackend(backend) {
+      cachedBackend = backend;
+      loggerCache.clear();
+    }
+    function log(namespace, parent) {
+      if (!cachedBackend) {
+        const enablesFlag = process2.env[exports$1.env.nodeEnables];
+        if (!enablesFlag) {
+          return exports$1.placeholder;
+        }
+      }
+      if (!namespace) {
+        return exports$1.placeholder;
+      }
+      if (parent) {
+        namespace = `${parent.instance.namespace}:${namespace}`;
+      }
+      const existing = loggerCache.get(namespace);
+      if (existing) {
+        return existing.func;
+      }
+      if (cachedBackend === null) {
+        return exports$1.placeholder;
+      } else if (cachedBackend === void 0) {
+        cachedBackend = getNodeBackend();
+      }
+      const logger = (() => {
+        let previousBackend = void 0;
+        const newLogger = new AdhocDebugLogger(namespace, (fields, ...args) => {
+          if (previousBackend !== cachedBackend) {
+            if (cachedBackend === null) {
+              return;
+            } else if (cachedBackend === void 0) {
+              cachedBackend = getNodeBackend();
+            }
+            previousBackend = cachedBackend;
+          }
+          cachedBackend === null || cachedBackend === void 0 ? void 0 : cachedBackend.log(namespace, fields, ...args);
+        });
+        return newLogger;
+      })();
+      loggerCache.set(namespace, logger);
+      return logger.func;
+    }
+  })(loggingUtils);
+  return loggingUtils;
+}
+var hasRequiredSrc;
+function requireSrc() {
+  if (hasRequiredSrc) return src;
+  hasRequiredSrc = 1;
+  (function(exports$1) {
+    var __createBinding = src && src.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = src && src.__exportStar || function(m, exports$12) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$12, p)) __createBinding(exports$12, m, p);
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    __exportStar(requireLoggingUtils(), exports$1);
+  })(src);
+  return src;
+}
+export {
+  requireSrc as r
+};