@tonyclaw/llm-inspector 1.6.0

package/.output/server/_libs/setimmediate.mjs

@@ -0,0 +1 @@
+

package/.output/server/_libs/space-separated-tokens.mjs

@@ -0,0 +1,6 @@
+function stringify(values) {
+  return values.join(" ").trim();
+}
+export {
+  stringify as s
+};

package/.output/server/_libs/srvx.mjs

@@ -0,0 +1,334 @@
+function lazyInherit(target, source, sourceKey) {
+  for (const key of [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)]) {
+    if (key === "constructor") continue;
+    const targetDesc = Object.getOwnPropertyDescriptor(target, key);
+    const desc = Object.getOwnPropertyDescriptor(source, key);
+    let modified = false;
+    if (desc.get) {
+      modified = true;
+      desc.get = targetDesc?.get || function() {
+        return this[sourceKey][key];
+      };
+    }
+    if (desc.set) {
+      modified = true;
+      desc.set = targetDesc?.set || function(value) {
+        this[sourceKey][key] = value;
+      };
+    }
+    if (!targetDesc?.value && typeof desc.value === "function") {
+      modified = true;
+      desc.value = function(...args) {
+        return this[sourceKey][key](...args);
+      };
+    }
+    if (modified) Object.defineProperty(target, key, desc);
+  }
+}
+const FastURL = /* @__PURE__ */ (() => {
+  const NativeURL = globalThis.URL;
+  const FastURL2 = class URL {
+    #url;
+    #href;
+    #protocol;
+    #host;
+    #pathname;
+    #search;
+    #searchParams;
+    #pos;
+    constructor(url) {
+      if (typeof url === "string") this.#href = url;
+      else {
+        this.#protocol = url.protocol;
+        this.#host = url.host;
+        this.#pathname = url.pathname;
+        this.#search = url.search;
+      }
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeURL;
+    }
+    get _url() {
+      if (this.#url) return this.#url;
+      this.#url = new NativeURL(this.href);
+      this.#href = void 0;
+      this.#protocol = void 0;
+      this.#host = void 0;
+      this.#pathname = void 0;
+      this.#search = void 0;
+      this.#searchParams = void 0;
+      this.#pos = void 0;
+      return this.#url;
+    }
+    get href() {
+      if (this.#url) return this.#url.href;
+      if (!this.#href) this.#href = `${this.#protocol || "http:"}//${this.#host || "localhost"}${this.#pathname || "/"}${this.#search || ""}`;
+      return this.#href;
+    }
+    #getPos() {
+      if (!this.#pos) {
+        const url = this.href;
+        const protoIndex = url.indexOf("://");
+        const pathnameIndex = protoIndex === -1 ? -1 : url.indexOf("/", protoIndex + 4);
+        this.#pos = [
+          protoIndex,
+          pathnameIndex,
+          pathnameIndex === -1 ? -1 : url.indexOf("?", pathnameIndex)
+        ];
+      }
+      return this.#pos;
+    }
+    get pathname() {
+      if (this.#url) return this.#url.pathname;
+      if (this.#pathname === void 0) {
+        const [, pathnameIndex, queryIndex] = this.#getPos();
+        if (pathnameIndex === -1) return this._url.pathname;
+        this.#pathname = this.href.slice(pathnameIndex, queryIndex === -1 ? void 0 : queryIndex);
+      }
+      return this.#pathname;
+    }
+    get search() {
+      if (this.#url) return this.#url.search;
+      if (this.#search === void 0) {
+        const [, pathnameIndex, queryIndex] = this.#getPos();
+        if (pathnameIndex === -1) return this._url.search;
+        const url = this.href;
+        this.#search = queryIndex === -1 || queryIndex === url.length - 1 ? "" : url.slice(queryIndex);
+      }
+      return this.#search;
+    }
+    get searchParams() {
+      if (this.#url) return this.#url.searchParams;
+      if (!this.#searchParams) this.#searchParams = new URLSearchParams(this.search);
+      return this.#searchParams;
+    }
+    get protocol() {
+      if (this.#url) return this.#url.protocol;
+      if (this.#protocol === void 0) {
+        const [protocolIndex] = this.#getPos();
+        if (protocolIndex === -1) return this._url.protocol;
+        this.#protocol = this.href.slice(0, protocolIndex + 1);
+      }
+      return this.#protocol;
+    }
+    toString() {
+      return this.href;
+    }
+    toJSON() {
+      return this.href;
+    }
+  };
+  lazyInherit(FastURL2.prototype, NativeURL.prototype, "_url");
+  Object.setPrototypeOf(FastURL2.prototype, NativeURL.prototype);
+  Object.setPrototypeOf(FastURL2, NativeURL);
+  return FastURL2;
+})();
+function resolvePortAndHost(opts) {
+  const _port = opts.port ?? globalThis.process?.env.PORT ?? 3e3;
+  const port = typeof _port === "number" ? _port : Number.parseInt(_port, 10);
+  if (port < 0 || port > 65535) throw new RangeError(`Port must be between 0 and 65535 (got "${port}").`);
+  return {
+    port,
+    hostname: opts.hostname ?? globalThis.process?.env.HOST
+  };
+}
+function fmtURL(host, port, secure) {
+  if (!host || !port) return;
+  if (host.includes(":")) host = `[${host}]`;
+  return `http${secure ? "s" : ""}://${host}:${port}/`;
+}
+function printListening(opts, url) {
+  if (!url || (opts.silent ?? globalThis.process?.env?.TEST)) return;
+  let additionalInfo = "";
+  try {
+    const _url = new URL(url);
+    if (_url.hostname === "[::]" || _url.hostname === "0.0.0.0") {
+      _url.hostname = "localhost";
+      url = _url.href;
+      additionalInfo = " (all interfaces)";
+    }
+  } catch {
+  }
+  let listeningOn = `➜ Listening on:`;
+  if (globalThis.process.stdout?.isTTY) {
+    listeningOn = `\x1B[32m${listeningOn}\x1B[0m`;
+    url = `\x1B[36m${url}\x1B[0m`;
+    additionalInfo = `\x1B[2m${additionalInfo}\x1B[0m`;
+  }
+  console.log(`${listeningOn} ${url}${additionalInfo}`);
+}
+function resolveTLSOptions(opts) {
+  if (!opts.tls || opts.protocol === "http") return;
+  const cert = resolveCertOrKey(opts.tls.cert);
+  const key = resolveCertOrKey(opts.tls.key);
+  if (!cert && !key) {
+    if (opts.protocol === "https") throw new TypeError("TLS `cert` and `key` must be provided for `https` protocol.");
+    return;
+  }
+  if (!cert || !key) throw new TypeError("TLS `cert` and `key` must be provided together.");
+  return {
+    cert,
+    key,
+    passphrase: opts.tls.passphrase
+  };
+}
+function resolveCertOrKey(value) {
+  if (!value) return;
+  if (typeof value !== "string") throw new TypeError("TLS certificate and key must be strings in PEM format or file paths.");
+  if (value.startsWith("-----BEGIN ")) return value;
+  const { readFileSync } = process.getBuiltinModule("node:fs");
+  return readFileSync(value, "utf8");
+}
+function createWaitUntil() {
+  const promises = /* @__PURE__ */ new Set();
+  return {
+    waitUntil: (promise) => {
+      if (typeof promise?.then !== "function") return;
+      promises.add(Promise.resolve(promise).catch(console.error).finally(() => {
+        promises.delete(promise);
+      }));
+    },
+    wait: () => {
+      return Promise.all(promises);
+    }
+  };
+}
+const noColor = /* @__PURE__ */ (() => {
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb";
+})();
+const _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
+const bold = /* @__PURE__ */ _c(1, 22);
+const red = /* @__PURE__ */ _c(31);
+const green = /* @__PURE__ */ _c(32);
+const gray = /* @__PURE__ */ _c(90);
+function wrapFetch(server) {
+  const fetchHandler = server.options.fetch;
+  const middleware = server.options.middleware || [];
+  return middleware.length === 0 ? fetchHandler : (request) => callMiddleware(request, fetchHandler, middleware, 0);
+}
+function callMiddleware(request, fetchHandler, middleware, index) {
+  if (index === middleware.length) return fetchHandler(request);
+  return middleware[index](request, () => callMiddleware(request, fetchHandler, middleware, index + 1));
+}
+const gracefulShutdownPlugin = (server) => {
+  const config = server.options?.gracefulShutdown;
+  if (!globalThis.process?.on || config === false || config === void 0 && (process.env.CI || process.env.TEST)) return;
+  const gracefulTimeout = config === true || !config?.gracefulTimeout ? Number.parseInt(process.env.SERVER_SHUTDOWN_TIMEOUT || "") || 5 : config.gracefulTimeout;
+  let isClosing = false;
+  let isClosed = false;
+  const w = server.options.silent ? () => {
+  } : process.stderr.write.bind(process.stderr);
+  const forceClose = async () => {
+    if (isClosed) return;
+    w(red("\x1B[2K\rForcibly closing connections...\n"));
+    isClosed = true;
+    await server.close(true);
+  };
+  const shutdown = async () => {
+    if (isClosing || isClosed) return;
+    setTimeout(() => {
+      globalThis.process.once("SIGINT", forceClose);
+    }, 100);
+    isClosing = true;
+    const closePromise = server.close();
+    for (let remaining = gracefulTimeout; remaining > 0; remaining--) {
+      w(gray(`\rStopping server gracefully (${remaining}s)... Press ${bold("Ctrl+C")} again to force close.`));
+      if (await Promise.race([closePromise.then(() => true), new Promise((r) => setTimeout(() => r(false), 1e3))])) {
+        w("\x1B[2K\r" + green("Server closed successfully.\n"));
+        isClosed = true;
+        return;
+      }
+    }
+    w("\x1B[2K\rGraceful shutdown timed out.\n");
+    await forceClose();
+  };
+  for (const sig of ["SIGINT", "SIGTERM"]) globalThis.process.on(sig, shutdown);
+};
+const FastResponse = Response;
+function serve(options) {
+  return new BunServer(options);
+}
+var BunServer = class {
+  runtime = "bun";
+  options;
+  bun = {};
+  serveOptions;
+  fetch;
+  waitUntil;
+  #wait;
+  constructor(options) {
+    this.options = {
+      ...options,
+      middleware: [...options.middleware || []]
+    };
+    for (const plugin of options.plugins || []) plugin(this);
+    gracefulShutdownPlugin(this);
+    const fetchHandler = wrapFetch(this);
+    const loader = globalThis.__srvxLoader__;
+    if (loader) {
+      this.fetch = fetchHandler;
+      loader(fetchHandler);
+      return;
+    }
+    this.#wait = createWaitUntil();
+    this.waitUntil = this.#wait.waitUntil;
+    this.fetch = (request, server) => {
+      Object.defineProperties(request, {
+        waitUntil: { value: this.#wait?.waitUntil },
+        runtime: {
+          enumerable: true,
+          value: {
+            name: "bun",
+            bun: { server }
+          }
+        },
+        ip: {
+          enumerable: true,
+          get() {
+            return server?.requestIP(request)?.address;
+          }
+        }
+      });
+      return fetchHandler(request);
+    };
+    const tls = resolveTLSOptions(this.options);
+    this.serveOptions = {
+      ...resolvePortAndHost(this.options),
+      reusePort: this.options.reusePort,
+      error: this.options.error,
+      ...this.options.bun,
+      tls: {
+        cert: tls?.cert,
+        key: tls?.key,
+        passphrase: tls?.passphrase,
+        ...this.options.bun?.tls
+      },
+      fetch: this.fetch
+    };
+    if (!options.manual) this.serve();
+  }
+  serve() {
+    if (!this.bun.server) this.bun.server = Bun.serve(this.serveOptions);
+    printListening(this.options, this.url);
+    return Promise.resolve(this);
+  }
+  get url() {
+    const server = this.bun?.server;
+    if (!server) return;
+    const address = server.address;
+    if (address) return fmtURL(address.address, address.port, server.protocol === "https");
+    return server.url.href;
+  }
+  ready() {
+    return Promise.resolve(this);
+  }
+  async close(closeAll) {
+    await Promise.all([this.#wait?.wait(), Promise.resolve(this.bun?.server?.stop(closeAll))]);
+  }
+};
+export {
+  FastURL as F,
+  FastResponse as a,
+  serve as s
+};

package/.output/server/_libs/stubborn-fs.mjs

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import { promisify } from "node:util";
+import { r as retryifySync, a as retryifyAsync, b as attemptifySync, c as attemptifyAsync } from "./stubborn-utils.mjs";
+import process from "node:process";
+const Handlers = {
+  /* API */
+  isChangeErrorOk: (error) => {
+    if (!Handlers.isNodeError(error))
+      return false;
+    const { code } = error;
+    if (code === "ENOSYS")
+      return true;
+    if (!IS_USER_ROOT && (code === "EINVAL" || code === "EPERM"))
+      return true;
+    return false;
+  },
+  isNodeError: (error) => {
+    return error instanceof Error;
+  },
+  isRetriableError: (error) => {
+    if (!Handlers.isNodeError(error))
+      return false;
+    const { code } = error;
+    if (code === "EMFILE" || code === "ENFILE" || code === "EAGAIN" || code === "EBUSY" || code === "EACCESS" || code === "EACCES" || code === "EACCS" || code === "EPERM")
+      return true;
+    return false;
+  },
+  onChangeError: (error) => {
+    if (!Handlers.isNodeError(error))
+      throw error;
+    if (Handlers.isChangeErrorOk(error))
+      return;
+    throw error;
+  }
+};
+const ATTEMPTIFY_CHANGE_ERROR_OPTIONS = {
+  onError: Handlers.onChangeError
+};
+const ATTEMPTIFY_NOOP_OPTIONS = {
+  onError: () => void 0
+};
+const IS_USER_ROOT = process.getuid ? !process.getuid() : false;
+const RETRYIFY_OPTIONS = {
+  isRetriable: Handlers.isRetriableError
+};
+const FS = {
+  attempt: {
+    /* ASYNC */
+    chmod: attemptifyAsync(promisify(fs.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chown: attemptifyAsync(promisify(fs.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    close: attemptifyAsync(promisify(fs.close), ATTEMPTIFY_NOOP_OPTIONS),
+    fsync: attemptifyAsync(promisify(fs.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+    mkdir: attemptifyAsync(promisify(fs.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+    realpath: attemptifyAsync(promisify(fs.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+    stat: attemptifyAsync(promisify(fs.stat), ATTEMPTIFY_NOOP_OPTIONS),
+    unlink: attemptifyAsync(promisify(fs.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+    /* SYNC */
+    chmodSync: attemptifySync(fs.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chownSync: attemptifySync(fs.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    closeSync: attemptifySync(fs.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+    existsSync: attemptifySync(fs.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+    fsyncSync: attemptifySync(fs.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+    mkdirSync: attemptifySync(fs.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+    realpathSync: attemptifySync(fs.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+    statSync: attemptifySync(fs.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+    unlinkSync: attemptifySync(fs.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
+  },
+  retry: {
+    /* ASYNC */
+    close: retryifyAsync(promisify(fs.close), RETRYIFY_OPTIONS),
+    fsync: retryifyAsync(promisify(fs.fsync), RETRYIFY_OPTIONS),
+    open: retryifyAsync(promisify(fs.open), RETRYIFY_OPTIONS),
+    readFile: retryifyAsync(promisify(fs.readFile), RETRYIFY_OPTIONS),
+    rename: retryifyAsync(promisify(fs.rename), RETRYIFY_OPTIONS),
+    stat: retryifyAsync(promisify(fs.stat), RETRYIFY_OPTIONS),
+    write: retryifyAsync(promisify(fs.write), RETRYIFY_OPTIONS),
+    writeFile: retryifyAsync(promisify(fs.writeFile), RETRYIFY_OPTIONS),
+    /* SYNC */
+    closeSync: retryifySync(fs.closeSync, RETRYIFY_OPTIONS),
+    fsyncSync: retryifySync(fs.fsyncSync, RETRYIFY_OPTIONS),
+    openSync: retryifySync(fs.openSync, RETRYIFY_OPTIONS),
+    readFileSync: retryifySync(fs.readFileSync, RETRYIFY_OPTIONS),
+    renameSync: retryifySync(fs.renameSync, RETRYIFY_OPTIONS),
+    statSync: retryifySync(fs.statSync, RETRYIFY_OPTIONS),
+    writeSync: retryifySync(fs.writeSync, RETRYIFY_OPTIONS),
+    writeFileSync: retryifySync(fs.writeFileSync, RETRYIFY_OPTIONS)
+  }
+};
+export {
+  FS as F
+};

package/.output/server/_libs/stubborn-utils.mjs

@@ -0,0 +1,66 @@
+const attemptifyAsync = (fn, options) => {
+  const { onError } = options;
+  return function attemptified(...args) {
+    return fn.apply(void 0, args).catch(onError);
+  };
+};
+const attemptifySync = (fn, options) => {
+  const { onError } = options;
+  return function attemptified(...args) {
+    try {
+      return fn.apply(void 0, args);
+    } catch (error) {
+      return onError(error);
+    }
+  };
+};
+const RETRY_INTERVAL = 250;
+const retryifyAsync = (fn, options) => {
+  const { isRetriable } = options;
+  return function retryified(options2) {
+    const { timeout } = options2;
+    const interval = options2.interval ?? RETRY_INTERVAL;
+    const timestamp = Date.now() + timeout;
+    return function attempt(...args) {
+      return fn.apply(void 0, args).catch((error) => {
+        if (!isRetriable(error))
+          throw error;
+        if (Date.now() >= timestamp)
+          throw error;
+        const delay = Math.round(interval * Math.random());
+        if (delay > 0) {
+          const delayPromise = new Promise((resolve) => setTimeout(resolve, delay));
+          return delayPromise.then(() => attempt.apply(void 0, args));
+        } else {
+          return attempt.apply(void 0, args);
+        }
+      });
+    };
+  };
+};
+const retryifySync = (fn, options) => {
+  const { isRetriable } = options;
+  return function retryified(options2) {
+    const { timeout } = options2;
+    const timestamp = Date.now() + timeout;
+    return function attempt(...args) {
+      while (true) {
+        try {
+          return fn.apply(void 0, args);
+        } catch (error) {
+          if (!isRetriable(error))
+            throw error;
+          if (Date.now() >= timestamp)
+            throw error;
+          continue;
+        }
+      }
+    };
+  };
+};
+export {
+  retryifyAsync as a,
+  attemptifySync as b,
+  attemptifyAsync as c,
+  retryifySync as r
+};

package/.output/server/_libs/style-to-js.mjs

@@ -0,0 +1,72 @@
+import { g as getDefaultExportFromCjs } from "./react.mjs";
+import { r as requireCjs$1 } from "./style-to-object.mjs";
+var utilities = {};
+var hasRequiredUtilities;
+function requireUtilities() {
+  if (hasRequiredUtilities) return utilities;
+  hasRequiredUtilities = 1;
+  Object.defineProperty(utilities, "__esModule", { value: true });
+  utilities.camelCase = void 0;
+  var CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9_-]+$/;
+  var HYPHEN_REGEX = /-([a-z])/g;
+  var NO_HYPHEN_REGEX = /^[^-]+$/;
+  var VENDOR_PREFIX_REGEX = /^-(webkit|moz|ms|o|khtml)-/;
+  var MS_VENDOR_PREFIX_REGEX = /^-(ms)-/;
+  var skipCamelCase = function(property) {
+    return !property || NO_HYPHEN_REGEX.test(property) || CUSTOM_PROPERTY_REGEX.test(property);
+  };
+  var capitalize = function(match, character) {
+    return character.toUpperCase();
+  };
+  var trimHyphen = function(match, prefix) {
+    return "".concat(prefix, "-");
+  };
+  var camelCase = function(property, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    if (skipCamelCase(property)) {
+      return property;
+    }
+    property = property.toLowerCase();
+    if (options.reactCompat) {
+      property = property.replace(MS_VENDOR_PREFIX_REGEX, trimHyphen);
+    } else {
+      property = property.replace(VENDOR_PREFIX_REGEX, trimHyphen);
+    }
+    return property.replace(HYPHEN_REGEX, capitalize);
+  };
+  utilities.camelCase = camelCase;
+  return utilities;
+}
+var cjs;
+var hasRequiredCjs;
+function requireCjs() {
+  if (hasRequiredCjs) return cjs;
+  hasRequiredCjs = 1;
+  var __importDefault = cjs && cjs.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  var style_to_object_1 = __importDefault(/* @__PURE__ */ requireCjs$1());
+  var utilities_1 = /* @__PURE__ */ requireUtilities();
+  function StyleToJS(style, options) {
+    var output = {};
+    if (!style || typeof style !== "string") {
+      return output;
+    }
+    (0, style_to_object_1.default)(style, function(property, value) {
+      if (property && value) {
+        output[(0, utilities_1.camelCase)(property, options)] = value;
+      }
+    });
+    return output;
+  }
+  StyleToJS.default = StyleToJS;
+  cjs = StyleToJS;
+  return cjs;
+}
+var cjsExports = /* @__PURE__ */ requireCjs();
+const styleToJs = /* @__PURE__ */ getDefaultExportFromCjs(cjsExports);
+export {
+  styleToJs as s
+};

package/.output/server/_libs/style-to-object.mjs

@@ -0,0 +1,38 @@
+import { r as requireCjs$1 } from "./inline-style-parser.mjs";
+var cjs = {};
+var hasRequiredCjs;
+function requireCjs() {
+  if (hasRequiredCjs) return cjs;
+  hasRequiredCjs = 1;
+  var __importDefault = cjs && cjs.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(cjs, "__esModule", { value: true });
+  cjs.default = StyleToObject;
+  const inline_style_parser_1 = __importDefault(/* @__PURE__ */ requireCjs$1());
+  function StyleToObject(style, iterator) {
+    let styleObject = null;
+    if (!style || typeof style !== "string") {
+      return styleObject;
+    }
+    const declarations = (0, inline_style_parser_1.default)(style);
+    const hasIterator = typeof iterator === "function";
+    declarations.forEach((declaration) => {
+      if (declaration.type !== "declaration") {
+        return;
+      }
+      const { property, value } = declaration;
+      if (hasIterator) {
+        iterator(property, value, declaration);
+      } else if (value) {
+        styleObject = styleObject || {};
+        styleObject[property] = value;
+      }
+    });
+    return styleObject;
+  }
+  return cjs;
+}
+export {
+  requireCjs as r
+};