@tonyclaw/llm-inspector 1.6.3 → 1.7.1

package/.output/server/_libs/readable-stream.mjs

@@ -6,7 +6,7 @@ import require$$2 from "events";
 import { r as requireSafeBuffer } from "./safe-buffer.mjs";
 import { r as requireUtil } from "./core-util-is.mjs";
 import { r as requireInherits } from "./inherits.mjs";
-import require$$1 from "util";
+import require$$0$1 from "util";
 import { r as requireNode } from "./util-deprecate.mjs";
 import require$$11 from "node:string_decoder";
 var readable = { exports: {} };
@@ -30,7 +30,7 @@ function requireBufferList() {
       }
     }
     var Buffer = requireSafeBuffer().Buffer;
-    var util = require$$1;
+    var util = require$$0$1;
     function copyBuffer(src, target, offset) {
       src.copy(target, offset);
     }
@@ -707,7 +707,7 @@ function require_stream_readable() {
   }
   var util = Object.create(/* @__PURE__ */ requireUtil());
   util.inherits = /* @__PURE__ */ requireInherits();
-  var debugUtil = require$$1;
+  var debugUtil = require$$0$1;
   var debug = void 0;
   if (debugUtil && debugUtil.debuglog) {
     debug = debugUtil.debuglog("stream");

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

@@ -1,3 +1,7 @@
+import nodeHTTP from "node:http";
+import { Readable, PassThrough } from "node:stream";
+import nodeHTTPS from "node:https";
+import nodeHTTP2 from "node:http2";
 function lazyInherit(target, source, sourceKey) {
   for (const key of [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)]) {
     if (key === "constructor") continue;
@@ -211,6 +215,18 @@ function callMiddleware(request, fetchHandler, middleware, index) {
   if (index === middleware.length) return fetchHandler(request);
   return middleware[index](request, () => callMiddleware(request, fetchHandler, middleware, index + 1));
 }
+const errorPlugin = (server) => {
+  const errorHandler = server.options.error;
+  if (!errorHandler) return;
+  server.options.middleware.unshift((_req, next) => {
+    try {
+      const res = next();
+      return res instanceof Promise ? res.catch((error) => errorHandler(error)) : res;
+    } catch (error) {
+      return errorHandler(error);
+    }
+  });
+};
 const gracefulShutdownPlugin = (server) => {
   const config = server.options?.gracefulShutdown;
   if (!globalThis.process?.on || config === false || config === void 0 && (process.env.CI || process.env.TEST)) return;
@@ -245,17 +261,388 @@ const gracefulShutdownPlugin = (server) => {
   };
   for (const sig of ["SIGINT", "SIGTERM"]) globalThis.process.on(sig, shutdown);
 };
-const FastResponse = Response;
+async function sendNodeResponse(nodeRes, webRes) {
+  if (!webRes) {
+    nodeRes.statusCode = 500;
+    return endNodeResponse(nodeRes);
+  }
+  if (webRes._toNodeResponse) {
+    const res = webRes._toNodeResponse();
+    writeHead(nodeRes, res.status, res.statusText, res.headers);
+    if (res.body) {
+      if (res.body instanceof ReadableStream) return streamBody(res.body, nodeRes);
+      else if (typeof res.body?.pipe === "function") {
+        res.body.pipe(nodeRes);
+        return new Promise((resolve) => nodeRes.on("close", resolve));
+      }
+      nodeRes.write(res.body);
+    }
+    return endNodeResponse(nodeRes);
+  }
+  const rawHeaders = [...webRes.headers];
+  writeHead(nodeRes, webRes.status, webRes.statusText, rawHeaders);
+  return webRes.body ? streamBody(webRes.body, nodeRes) : endNodeResponse(nodeRes);
+}
+function writeHead(nodeRes, status, statusText, rawHeaders) {
+  const writeHeaders = globalThis.Deno ? rawHeaders : rawHeaders.flat();
+  if (!nodeRes.headersSent) if (nodeRes.req?.httpVersion === "2.0") nodeRes.writeHead(status, writeHeaders);
+  else nodeRes.writeHead(status, statusText, writeHeaders);
+}
+function endNodeResponse(nodeRes) {
+  return new Promise((resolve) => nodeRes.end(resolve));
+}
+function streamBody(stream, nodeRes) {
+  if (nodeRes.destroyed) {
+    stream.cancel();
+    return;
+  }
+  const reader = stream.getReader();
+  function streamCancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error) nodeRes.destroy(error);
+  }
+  function streamHandle({ done, value }) {
+    try {
+      if (done) nodeRes.end();
+      else if (nodeRes.write(value)) reader.read().then(streamHandle, streamCancel);
+      else nodeRes.once("drain", () => reader.read().then(streamHandle, streamCancel));
+    } catch (error) {
+      streamCancel(error instanceof Error ? error : void 0);
+    }
+  }
+  nodeRes.on("close", streamCancel);
+  nodeRes.on("error", streamCancel);
+  reader.read().then(streamHandle, streamCancel);
+  return reader.closed.catch(streamCancel).finally(() => {
+    nodeRes.off("close", streamCancel);
+    nodeRes.off("error", streamCancel);
+  });
+}
+var NodeRequestURL = class extends FastURL {
+  #req;
+  constructor({ req }) {
+    const path = req.url || "/";
+    if (path[0] === "/") {
+      const qIndex = path.indexOf("?");
+      const pathname = qIndex === -1 ? path : path?.slice(0, qIndex) || "/";
+      const search = qIndex === -1 ? "" : path?.slice(qIndex) || "";
+      const host = req.headers.host || req.headers[":authority"] || `${req.socket.localFamily === "IPv6" ? "[" + req.socket.localAddress + "]" : req.socket.localAddress}:${req.socket?.localPort || "80"}`;
+      const protocol = req.socket?.encrypted || req.headers["x-forwarded-proto"] === "https" || req.headers[":scheme"] === "https" ? "https:" : "http:";
+      super({
+        protocol,
+        host,
+        pathname,
+        search
+      });
+    } else super(path);
+    this.#req = req;
+  }
+  get pathname() {
+    return super.pathname;
+  }
+  set pathname(value) {
+    this._url.pathname = value;
+    this.#req.url = this._url.pathname + this._url.search;
+  }
+};
+const NodeRequestHeaders = /* @__PURE__ */ (() => {
+  const NativeHeaders = globalThis.Headers;
+  class Headers2 {
+    #req;
+    #headers;
+    constructor(req) {
+      this.#req = req;
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeHeaders;
+    }
+    get _headers() {
+      if (!this.#headers) {
+        const headers = new NativeHeaders();
+        const rawHeaders = this.#req.rawHeaders;
+        const len = rawHeaders.length;
+        for (let i = 0; i < len; i += 2) {
+          const key = rawHeaders[i];
+          if (key.charCodeAt(0) === 58) continue;
+          const value = rawHeaders[i + 1];
+          headers.append(key, value);
+        }
+        this.#headers = headers;
+      }
+      return this.#headers;
+    }
+    get(name) {
+      if (this.#headers) return this.#headers.get(name);
+      const value = this.#req.headers[name.toLowerCase()];
+      return Array.isArray(value) ? value.join(", ") : value || null;
+    }
+    has(name) {
+      if (this.#headers) return this.#headers.has(name);
+      return name.toLowerCase() in this.#req.headers;
+    }
+    getSetCookie() {
+      if (this.#headers) return this.#headers.getSetCookie();
+      const value = this.#req.headers["set-cookie"];
+      return Array.isArray(value) ? value : value ? [value] : [];
+    }
+    *_entries() {
+      const rawHeaders = this.#req.rawHeaders;
+      const len = rawHeaders.length;
+      for (let i = 0; i < len; i += 2) {
+        const key = rawHeaders[i];
+        if (key.charCodeAt(0) === 58) continue;
+        yield [key.toLowerCase(), rawHeaders[i + 1]];
+      }
+    }
+    entries() {
+      return this.#headers ? this.#headers.entries() : this._entries();
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  }
+  lazyInherit(Headers2.prototype, NativeHeaders.prototype, "_headers");
+  Object.setPrototypeOf(Headers2, NativeHeaders);
+  Object.setPrototypeOf(Headers2.prototype, NativeHeaders.prototype);
+  return Headers2;
+})();
+const NodeRequest = /* @__PURE__ */ (() => {
+  const NativeRequest = globalThis.Request;
+  class Request {
+    runtime;
+    #req;
+    #url;
+    #bodyStream;
+    #request;
+    #headers;
+    #abortController;
+    constructor(ctx) {
+      this.#req = ctx.req;
+      this.runtime = {
+        name: "node",
+        node: ctx
+      };
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeRequest;
+    }
+    get ip() {
+      return this.#req.socket?.remoteAddress;
+    }
+    get method() {
+      if (this.#request) return this.#request.method;
+      return this.#req.method || "GET";
+    }
+    get _url() {
+      return this.#url ||= new NodeRequestURL({ req: this.#req });
+    }
+    set _url(url) {
+      this.#url = url;
+    }
+    get url() {
+      if (this.#request) return this.#request.url;
+      return this._url.href;
+    }
+    get headers() {
+      if (this.#request) return this.#request.headers;
+      return this.#headers ||= new NodeRequestHeaders(this.#req);
+    }
+    get _abortController() {
+      if (!this.#abortController) {
+        this.#abortController = new AbortController();
+        const { req, res } = this.runtime.node;
+        const abortController = this.#abortController;
+        const abort = (err) => abortController.abort?.(err);
+        if (res) res.once("close", () => {
+          const reqError = req.errored;
+          if (reqError) abort(reqError);
+          else if (!res.writableEnded) abort();
+        });
+        else req.once("close", () => {
+          if (!req.complete) abort();
+        });
+      }
+      return this.#abortController;
+    }
+    get signal() {
+      return this.#request ? this.#request.signal : this._abortController.signal;
+    }
+    get body() {
+      if (this.#request) return this.#request.body;
+      if (this.#bodyStream === void 0) {
+        const method = this.method;
+        this.#bodyStream = !(method === "GET" || method === "HEAD") ? Readable.toWeb(this.#req) : null;
+      }
+      return this.#bodyStream;
+    }
+    text() {
+      if (this.#request) return this.#request.text();
+      if (this.#bodyStream !== void 0) return this.#bodyStream ? new Response(this.#bodyStream).text() : Promise.resolve("");
+      return readBody(this.#req).then((buf) => buf.toString());
+    }
+    json() {
+      if (this.#request) return this.#request.json();
+      return this.text().then((text) => JSON.parse(text));
+    }
+    get _request() {
+      if (!this.#request) {
+        const body = this.body;
+        this.#request = new NativeRequest(this.url, {
+          method: this.method,
+          headers: this.headers,
+          signal: this._abortController.signal,
+          body,
+          duplex: body ? "half" : void 0
+        });
+        this.#headers = void 0;
+        this.#bodyStream = void 0;
+      }
+      return this.#request;
+    }
+  }
+  lazyInherit(Request.prototype, NativeRequest.prototype, "_request");
+  Object.setPrototypeOf(Request.prototype, NativeRequest.prototype);
+  return Request;
+})();
+function readBody(req) {
+  if ("rawBody" in req && Buffer.isBuffer(req.rawBody)) return Promise.resolve(req.rawBody);
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const onData = (chunk) => {
+      chunks.push(chunk);
+    };
+    const onError = (err) => {
+      reject(err);
+    };
+    const onEnd = () => {
+      req.off("error", onError);
+      req.off("data", onData);
+      resolve(Buffer.concat(chunks));
+    };
+    req.on("data", onData).once("end", onEnd).once("error", onError);
+  });
+}
+const NodeResponse = /* @__PURE__ */ (() => {
+  const NativeResponse = globalThis.Response;
+  const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
+  class NodeResponse2 {
+    #body;
+    #init;
+    #headers;
+    #response;
+    constructor(body, init) {
+      this.#body = body;
+      this.#init = init;
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeResponse;
+    }
+    get status() {
+      return this.#response?.status || this.#init?.status || 200;
+    }
+    get statusText() {
+      return this.#response?.statusText || this.#init?.statusText || STATUS_CODES[this.status] || "";
+    }
+    get headers() {
+      if (this.#response) return this.#response.headers;
+      if (this.#headers) return this.#headers;
+      const initHeaders = this.#init?.headers;
+      return this.#headers = initHeaders instanceof Headers ? initHeaders : new Headers(initHeaders);
+    }
+    get ok() {
+      if (this.#response) return this.#response.ok;
+      const status = this.status;
+      return status >= 200 && status < 300;
+    }
+    get _response() {
+      if (this.#response) return this.#response;
+      let body = this.#body;
+      if (body && typeof body.pipe === "function" && !(body instanceof Readable)) {
+        const stream = new PassThrough();
+        body.pipe(stream);
+        const abort = body.abort;
+        if (abort) stream.once("close", () => abort());
+        body = stream;
+      }
+      this.#response = new NativeResponse(body, this.#headers ? {
+        ...this.#init,
+        headers: this.#headers
+      } : this.#init);
+      this.#init = void 0;
+      this.#headers = void 0;
+      this.#body = void 0;
+      return this.#response;
+    }
+    _toNodeResponse() {
+      const status = this.status;
+      const statusText = this.statusText;
+      let body;
+      let contentType;
+      let contentLength;
+      if (this.#response) body = this.#response.body;
+      else if (this.#body) if (this.#body instanceof ReadableStream) body = this.#body;
+      else if (typeof this.#body === "string") {
+        body = this.#body;
+        contentType = "text/plain; charset=UTF-8";
+        contentLength = Buffer.byteLength(this.#body);
+      } else if (this.#body instanceof ArrayBuffer) {
+        body = Buffer.from(this.#body);
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof Uint8Array) {
+        body = this.#body;
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof DataView) {
+        body = Buffer.from(this.#body.buffer);
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof Blob) {
+        body = this.#body.stream();
+        contentType = this.#body.type;
+        contentLength = this.#body.size;
+      } else if (typeof this.#body.pipe === "function") body = this.#body;
+      else body = this._response.body;
+      const headers = [];
+      const initHeaders = this.#init?.headers;
+      const headerEntries = this.#response?.headers || this.#headers || (initHeaders ? Array.isArray(initHeaders) ? initHeaders : initHeaders?.entries ? initHeaders.entries() : Object.entries(initHeaders).map(([k, v]) => [k.toLowerCase(), v]) : void 0);
+      let hasContentTypeHeader;
+      let hasContentLength;
+      if (headerEntries) for (const [key, value] of headerEntries) {
+        if (Array.isArray(value)) for (const v of value) headers.push([key, v]);
+        else headers.push([key, value]);
+        if (key === "content-type") hasContentTypeHeader = true;
+        else if (key === "content-length") hasContentLength = true;
+      }
+      if (contentType && !hasContentTypeHeader) headers.push(["content-type", contentType]);
+      if (contentLength && !hasContentLength) headers.push(["content-length", String(contentLength)]);
+      this.#init = void 0;
+      this.#headers = void 0;
+      this.#response = void 0;
+      this.#body = void 0;
+      return {
+        status,
+        statusText,
+        headers,
+        body
+      };
+    }
+  }
+  lazyInherit(NodeResponse2.prototype, NativeResponse.prototype, "_response");
+  Object.setPrototypeOf(NodeResponse2, NativeResponse);
+  Object.setPrototypeOf(NodeResponse2.prototype, NativeResponse.prototype);
+  return NodeResponse2;
+})();
 function serve(options) {
-  return new BunServer(options);
+  return new NodeServer(options);
 }
-var BunServer = class {
-  runtime = "bun";
+var NodeServer = class {
+  runtime = "node";
   options;
-  bun = {};
+  node;
   serveOptions;
   fetch;
   waitUntil;
+  #isSecure;
+  #listeningPromise;
   #wait;
   constructor(options) {
     this.options = {
@@ -263,72 +650,81 @@ var BunServer = class {
       middleware: [...options.middleware || []]
     };
     for (const plugin of options.plugins || []) plugin(this);
-    gracefulShutdownPlugin(this);
-    const fetchHandler = wrapFetch(this);
+    errorPlugin(this);
+    const fetchHandler = this.fetch = wrapFetch(this);
     const loader = globalThis.__srvxLoader__;
     if (loader) {
-      this.fetch = fetchHandler;
       loader(fetchHandler);
       return;
     }
+    gracefulShutdownPlugin(this);
     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;
-          }
-        }
+    const handler = (nodeReq, nodeRes) => {
+      const request = new NodeRequest({
+        req: nodeReq,
+        res: nodeRes
       });
-      return fetchHandler(request);
+      request.waitUntil = this.#wait?.waitUntil;
+      const res = fetchHandler(request);
+      return res instanceof Promise ? res.then((resolvedRes) => sendNodeResponse(nodeRes, resolvedRes)) : sendNodeResponse(nodeRes, res);
     };
     const tls = resolveTLSOptions(this.options);
+    const { port, hostname: host } = resolvePortAndHost(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
+      port,
+      host,
+      exclusive: !this.options.reusePort,
+      ...tls ? {
+        cert: tls.cert,
+        key: tls.key,
+        passphrase: tls.passphrase
+      } : {},
+      ...this.options.node
+    };
+    let server;
+    this.#isSecure = !!this.serveOptions.cert && this.options.protocol !== "http";
+    if (this.options.node?.http2 ?? this.#isSecure) if (this.#isSecure) server = nodeHTTP2.createSecureServer({
+      allowHTTP1: true,
+      ...this.serveOptions
+    }, handler);
+    else throw new Error("node.http2 option requires tls certificate!");
+    else if (this.#isSecure) server = nodeHTTPS.createServer(this.serveOptions, handler);
+    else server = nodeHTTP.createServer(this.serveOptions, handler);
+    this.node = {
+      server,
+      handler
     };
     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);
+    if (this.#listeningPromise) return Promise.resolve(this.#listeningPromise).then(() => this);
+    this.#listeningPromise = new Promise((resolve) => {
+      this.node.server.listen(this.serveOptions, () => {
+        printListening(this.options, this.url);
+        resolve();
+      });
+    });
   }
   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;
+    const addr = this.node?.server?.address();
+    if (!addr) return;
+    return typeof addr === "string" ? addr : fmtURL(addr.address, addr.port, this.#isSecure);
   }
   ready() {
-    return Promise.resolve(this);
+    return Promise.resolve(this.#listeningPromise).then(() => this);
   }
   async close(closeAll) {
-    await Promise.all([this.#wait?.wait(), Promise.resolve(this.bun?.server?.stop(closeAll))]);
+    await Promise.all([this.#wait?.wait(), new Promise((resolve, reject) => {
+      const server = this.node?.server;
+      if (server && closeAll && "closeAllConnections" in server) server.closeAllConnections();
+      if (!server || !server.listening) return resolve();
+      server.close((error) => error ? reject(error) : resolve());
+    })]);
   }
 };
 export {
   FastURL as F,
-  FastResponse as a,
+  NodeResponse as N,
   serve as s
 };

package/.output/server/_libs/util-deprecate.mjs

@@ -1,10 +1,10 @@
-import require$$1 from "util";
+import require$$0 from "util";
 var node;
 var hasRequiredNode;
 function requireNode() {
   if (hasRequiredNode) return node;
   hasRequiredNode = 1;
-  node = require$$1.deprecate;
+  node = require$$0.deprecate;
   return node;
 }
 export {