@skrr-ai/cli 0.1.115 → 0.1.117

package/dist/node_modules/@skrr-ai/inference-broker/dist/cjs/loopback-server.js

@@ -1,284 +1,226 @@
 "use strict";
-/**
- * model-proxy/loopback-server.ts — in-sandbox loopback proxy.
- *
- * Runs inside the cloud sandbox. The Agent SDK is pointed here via
- * `ANTHROPIC_BASE_URL=http://127.0.0.1:<port>` and authenticates with a
- * per-session relay token via `ANTHROPIC_AUTH_TOKEN`. This server:
- *   1. binds to 127.0.0.1 ONLY (never routable off-box),
- *   2. constant-time validates the relay bearer the SDK presents,
- *   3. forwards each request through an injected {@link ModelProxyForwarder}
- *      (the Socket.IO tunnel up to the backend → home daemon),
- *   4. streams the upstream response back to the SDK unchanged.
- *
- * The sandbox therefore never holds the real subscription credential and never
- * needs egress to api.anthropic.com — only to the OverSky control plane.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelProxyLoopbackServer = void 0;
-const node_http_1 = require("node:http");
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
-const contract_js_1 = require("./contract.js");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loopback_server_exports = {};
+__export(loopback_server_exports, {
+  ModelProxyLoopbackServer: () => ModelProxyLoopbackServer
+});
+module.exports = __toCommonJS(loopback_server_exports);
+var import_node_http = require("node:http");
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_contract = require("./contract.js");
 class RequestBodyTooLargeError extends Error {
-    maxBodyBytes;
-    constructor(maxBodyBytes) {
-        super(`Request body exceeds ${maxBodyBytes} byte limit.`);
-        this.maxBodyBytes = maxBodyBytes;
-        this.name = 'RequestBodyTooLargeError';
-    }
+  maxBodyBytes;
+  constructor(maxBodyBytes) {
+    super(`Request body exceeds ${maxBodyBytes} byte limit.`);
+    this.maxBodyBytes = maxBodyBytes;
+    this.name = "RequestBodyTooLargeError";
+  }
 }
 class ModelProxyLoopbackServer {
-    server = null;
-    /**
-     * `server.close()` only stops accepting new connections.  A managed lease
-     * must also stop requests which have already reached this relay: otherwise a
-     * cancelled session can keep an upstream stream alive until the provider
-     * happens to finish.  Track both transport sockets and forward abort signals
-     * so `stop()` is an authority revocation, not merely a listener shutdown.
-     */
-    activeSockets = new Set();
-    activeRequests = new Set();
-    opts;
-    boundPort = 0;
-    constructor(opts) {
-        this.opts = {
-            host: '127.0.0.1',
-            port: 0,
-            maxBodyBytes: contract_js_1.MODEL_PROXY_MAX_BODY_BYTES,
-            ...opts,
-        };
+  server = null;
+  /**
+   * `server.close()` only stops accepting new connections.  A managed lease
+   * must also stop requests which have already reached this relay: otherwise a
+   * cancelled session can keep an upstream stream alive until the provider
+   * happens to finish.  Track both transport sockets and forward abort signals
+   * so `stop()` is an authority revocation, not merely a listener shutdown.
+   */
+  activeSockets = /* @__PURE__ */ new Set();
+  activeRequests = /* @__PURE__ */ new Set();
+  opts;
+  boundPort = 0;
+  constructor(opts) {
+    this.opts = {
+      host: "127.0.0.1",
+      port: 0,
+      maxBodyBytes: import_contract.MODEL_PROXY_MAX_BODY_BYTES,
+      ...opts
+    };
+  }
+  /** Starts the server and returns the base URL to put in `ANTHROPIC_BASE_URL`. */
+  async start() {
+    if (this.server) {
+      return { baseUrl: this.baseUrl(), port: this.boundPort };
     }
-    /** Starts the server and returns the base URL to put in `ANTHROPIC_BASE_URL`. */
-    async start() {
-        if (this.server) {
-            return { baseUrl: this.baseUrl(), port: this.boundPort };
+    const server = (0, import_node_http.createServer)((req, res) => {
+      this.handle(req, res).catch((err) => {
+        this.opts.onError?.(err);
+        if (!res.headersSent) {
+          const requestTooLarge = err instanceof RequestBodyTooLargeError;
+          const requestRejected = err instanceof import_contract.ModelProxyError && err.code === import_contract.MODEL_PROXY_ERROR.REQUEST_REJECTED;
+          writeError(res, requestTooLarge ? 413 : requestRejected ? 400 : 502, requestTooLarge ? import_contract.MODEL_PROXY_ERROR.REQUEST_TOO_LARGE : requestRejected ? import_contract.MODEL_PROXY_ERROR.REQUEST_REJECTED : import_contract.MODEL_PROXY_ERROR.UPSTREAM_FAILED, err.message);
+        } else {
+          res.destroy();
         }
-        const server = (0, node_http_1.createServer)((req, res) => {
-            this.handle(req, res).catch((err) => {
-                this.opts.onError?.(err);
-                if (!res.headersSent) {
-                    const requestTooLarge = err instanceof RequestBodyTooLargeError;
-                    const requestRejected = err instanceof contract_js_1.ModelProxyError && err.code === contract_js_1.MODEL_PROXY_ERROR.REQUEST_REJECTED;
-                    writeError(res, requestTooLarge ? 413 : requestRejected ? 400 : 502, requestTooLarge
-                        ? contract_js_1.MODEL_PROXY_ERROR.REQUEST_TOO_LARGE
-                        : requestRejected
-                            ? contract_js_1.MODEL_PROXY_ERROR.REQUEST_REJECTED
-                            : contract_js_1.MODEL_PROXY_ERROR.UPSTREAM_FAILED, err.message);
-                }
-                else {
-                    // Once a streamed 2xx response has started we cannot replace it with
-                    // a 502. A clean `end()` would falsely certify a truncated or failed
-                    // decompression stream as complete, so terminate the transport and
-                    // force the SDK to treat the exchange as failed/retryable.
-                    res.destroy();
-                }
-            });
-        });
-        this.server = server;
-        server.on('connection', (socket) => {
-            this.activeSockets.add(socket);
-            socket.once('close', () => this.activeSockets.delete(socket));
-        });
-        await new Promise((resolve, reject) => {
-            server.once('error', reject);
-            const onListening = () => {
-                server.removeListener('error', reject);
-                const addr = server.address();
-                this.boundPort = typeof addr === 'object' && addr ? addr.port : this.opts.port;
-                if (this.opts.socketPath && process.platform !== 'win32') {
-                    const sharedGroup = Number.isSafeInteger(this.opts.socketGroupId);
-                    if (sharedGroup) {
-                        (0, node_fs_1.chownSync)(this.opts.socketPath, typeof process.getuid === 'function' ? process.getuid() : -1, this.opts.socketGroupId);
-                    }
-                    // Private by default. A Dedicated Runtime explicitly names its
-                    // root-owned workload group because the daemon and harness use
-                    // different uids; no other local user gains access.
-                    (0, node_fs_1.chmodSync)(this.opts.socketPath, sharedGroup ? 0o660 : 0o600);
-                }
-                resolve();
-            };
-            if (this.opts.socketPath)
-                server.listen(this.opts.socketPath, onListening);
-            else
-                server.listen(this.opts.port, this.opts.host, onListening);
-        });
-        return { baseUrl: this.baseUrl(), port: this.boundPort };
-    }
-    async stop() {
-        const server = this.server;
-        if (!server)
-            return;
-        this.server = null;
-        for (const controller of this.activeRequests)
-            controller.abort();
-        // Destroying established sockets makes close deterministic even when a
-        // provider stream is slow or maliciously never-ending.
-        for (const socket of this.activeSockets)
-            socket.destroy();
-        await new Promise((resolve) => server.close(() => resolve()));
-        if (this.opts.socketPath && process.platform !== 'win32') {
-            try {
-                (0, node_fs_1.unlinkSync)(this.opts.socketPath);
-            }
-            catch {
-                // A failed/partial listener can already have removed the path.
-            }
+      });
+    });
+    this.server = server;
+    server.on("connection", (socket) => {
+      this.activeSockets.add(socket);
+      socket.once("close", () => this.activeSockets.delete(socket));
+    });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      const onListening = () => {
+        server.removeListener("error", reject);
+        const addr = server.address();
+        this.boundPort = typeof addr === "object" && addr ? addr.port : this.opts.port;
+        if (this.opts.socketPath && process.platform !== "win32") {
+          const sharedGroup = Number.isSafeInteger(this.opts.socketGroupId);
+          if (sharedGroup) {
+            (0, import_node_fs.chownSync)(this.opts.socketPath, typeof process.getuid === "function" ? process.getuid() : -1, this.opts.socketGroupId);
+          }
+          (0, import_node_fs.chmodSync)(this.opts.socketPath, sharedGroup ? 432 : 384);
         }
+        resolve();
+      };
+      if (this.opts.socketPath)
+        server.listen(this.opts.socketPath, onListening);
+      else
+        server.listen(this.opts.port, this.opts.host, onListening);
+    });
+    return { baseUrl: this.baseUrl(), port: this.boundPort };
+  }
+  async stop() {
+    const server = this.server;
+    if (!server)
+      return;
+    this.server = null;
+    for (const controller of this.activeRequests)
+      controller.abort();
+    for (const socket of this.activeSockets)
+      socket.destroy();
+    await new Promise((resolve) => server.close(() => resolve()));
+    if (this.opts.socketPath && process.platform !== "win32") {
+      try {
+        (0, import_node_fs.unlinkSync)(this.opts.socketPath);
+      } catch {
+      }
     }
-    baseUrl() {
-        if (this.opts.advertisedBaseUrl)
-            return this.opts.advertisedBaseUrl;
-        return `http://${this.opts.host}:${this.boundPort}`;
+  }
+  baseUrl() {
+    if (this.opts.advertisedBaseUrl)
+      return this.opts.advertisedBaseUrl;
+    return `http://${this.opts.host}:${this.boundPort}`;
+  }
+  async handle(req, res) {
+    if (!this.authorize(req)) {
+      writeError(res, 401, import_contract.MODEL_PROXY_ERROR.UNAUTHORIZED, "Invalid relay token.");
+      return;
     }
-    async handle(req, res) {
-        if (!this.authorize(req)) {
-            writeError(res, 401, contract_js_1.MODEL_PROXY_ERROR.UNAUTHORIZED, 'Invalid relay token.');
-            return;
-        }
-        // Judged after authentication, so an unauthenticated caller learns nothing
-        // about which request forms this relay accepts; and before the body is read,
-        // so a refused request is never buffered.
-        const path = originFormPath(req.url ?? '/', new URL(this.baseUrl()).origin);
-        if (path === null) {
-            req.resume();
-            throw new contract_js_1.ModelProxyError(contract_js_1.MODEL_PROXY_ERROR.REQUEST_REJECTED, 'model proxy loopback accepts only requests addressed to its own origin');
-        }
-        const body = await readBody(req, this.opts.maxBodyBytes);
-        const controller = new AbortController();
-        this.activeRequests.add(controller);
-        // Propagate SDK-side client abort down the tunnel so the home daemon stops
-        // the upstream call immediately.
-        req.on('aborted', () => controller.abort());
-        res.on('close', () => {
-            if (!res.writableEnded)
-                controller.abort();
-        });
-        const headers = normalizeIncomingHeaders(req.headers);
-        try {
-            const upstream = await this.opts.forwarder.forward({ method: req.method ?? 'POST', path, headers, body }, { signal: controller.signal });
-            res.writeHead(upstream.status, upstream.headers);
-            for await (const chunk of upstream.body) {
-                if (!res.write(chunk)) {
-                    await new Promise((resolve) => res.once('drain', resolve));
-                }
-            }
-            // End cleanly only after the upstream iterator reached EOF. Errors must
-            // escape to the outer handler, which destroys a response that has
-            // already started instead of blessing a partial body as complete.
-            res.end();
-        }
-        finally {
-            this.activeRequests.delete(controller);
-        }
+    const path = originFormPath(req.url ?? "/", new URL(this.baseUrl()).origin);
+    if (path === null) {
+      req.resume();
+      throw new import_contract.ModelProxyError(import_contract.MODEL_PROXY_ERROR.REQUEST_REJECTED, "model proxy loopback accepts only requests addressed to its own origin");
     }
-    authorize(req) {
-        const header = req.headers['authorization'];
-        const presented = Array.isArray(header) ? header[0] : header;
-        if (!presented)
-            return false;
-        const token = presented.replace(/^Bearer\s+/i, '');
-        return constantTimeEqual(token, this.opts.relayToken);
+    const body = await readBody(req, this.opts.maxBodyBytes);
+    const controller = new AbortController();
+    this.activeRequests.add(controller);
+    req.on("aborted", () => controller.abort());
+    res.on("close", () => {
+      if (!res.writableEnded)
+        controller.abort();
+    });
+    const headers = normalizeIncomingHeaders(req.headers);
+    try {
+      const upstream = await this.opts.forwarder.forward({ method: req.method ?? "POST", path, headers, body }, { signal: controller.signal });
+      res.writeHead(upstream.status, upstream.headers);
+      for await (const chunk of upstream.body) {
+        if (!res.write(chunk)) {
+          await new Promise((resolve) => res.once("drain", resolve));
+        }
+      }
+      res.end();
+    } finally {
+      this.activeRequests.delete(controller);
     }
+  }
+  authorize(req) {
+    const header = req.headers["authorization"];
+    const presented = Array.isArray(header) ? header[0] : header;
+    if (!presented)
+      return false;
+    const token = presented.replace(/^Bearer\s+/i, "");
+    return constantTimeEqual(token, this.opts.relayToken);
+  }
 }
-exports.ModelProxyLoopbackServer = ModelProxyLoopbackServer;
-// ---------------------------------------------------------------------------
-// helpers
-// ---------------------------------------------------------------------------
 function constantTimeEqual(a, b) {
-    const bufA = Buffer.from(a);
-    const bufB = Buffer.from(b);
-    if (bufA.length !== bufB.length)
-        return false;
-    return (0, node_crypto_1.timingSafeEqual)(bufA, bufB);
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  if (bufA.length !== bufB.length)
+    return false;
+  return (0, import_node_crypto.timingSafeEqual)(bufA, bufB);
 }
-/**
- * The request-target as the ORIGIN-FORM path the forwarder contract carries, or
- * null when the request was addressed somewhere else.
- *
- * HTTP/1.1 gives a POST two request-target forms. Origin-form (`/v1/messages`) is
- * what a client sends an origin server; absolute-form
- * (`http://host/v1/messages`) is what it sends a forward PROXY — and RFC 9112
- * §3.2.2 still requires a server to accept it. Node passes either through as
- * `req.url`, verbatim.
- *
- * OSK-8758 is why this matters here. A Dedicated Runtime guest exports
- * HTTP(S)_PROXY for its egress proxy, and the broker's synthetic
- * `oversky-inference-broker.invalid` is in no NO_PROXY. Bun keeps dialing the Unix
- * socket named by `fetch({ unix })` but writes the request line in proxy form, so
- * every managed turn reached the broker with an absolute URL for a "path", failed
- * its exact route allowlist, and was refused as an unapproved upstream route —
- * while a laptop, with no proxy configured, sent origin-form and worked.
- *
- * Accepted only when the target denotes EXACTLY the request origin-form would
- * have, so this is a parsing fix and never a widening:
- *
- *   - the origin must be this relay's own advertised origin. This loopback is not a
- *     forward proxy: a foreign origin is refused here, even one a downstream egress
- *     allowlist would accept — naming the upstream is not a way to reach it;
- *   - no userinfo, which a request-target may not carry;
- *   - the path and query must survive URL parsing byte-for-byte. The WHATWG parser
- *     resolves dot segments and rewrites `\` to `/`, and origin-form bytes reach the
- *     forwarder unnormalized, so a spelling the forwarder would refuse in one form
- *     cannot become an approved route in the other.
- *
- * Anything that is not absolute-form (origin-form and the odd `*`) is returned
- * untouched, exactly as before, for the forwarder to judge.
- */
 function originFormPath(rawTarget, ownOrigin) {
-    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(rawTarget))
-        return rawTarget;
-    let target;
-    try {
-        target = new URL(rawTarget);
-    }
-    catch {
-        return null;
-    }
-    // `origin` is the string "null" for every non-special scheme, so two unrelated
-    // opaque origins would otherwise compare equal.
-    if (target.origin === 'null' || target.origin !== ownOrigin)
-        return null;
-    if (target.username || target.password)
-        return null;
-    const authorityEnd = rawTarget.indexOf('/', rawTarget.indexOf('://') + 3);
-    if (authorityEnd < 0)
-        return null;
-    const path = rawTarget.slice(authorityEnd);
-    return path === `${target.pathname}${target.search}` ? path : null;
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(rawTarget))
+    return rawTarget;
+  let target;
+  try {
+    target = new URL(rawTarget);
+  } catch {
+    return null;
+  }
+  if (target.origin === "null" || target.origin !== ownOrigin)
+    return null;
+  if (target.username || target.password)
+    return null;
+  const authorityEnd = rawTarget.indexOf("/", rawTarget.indexOf("://") + 3);
+  if (authorityEnd < 0)
+    return null;
+  const path = rawTarget.slice(authorityEnd);
+  return path === `${target.pathname}${target.search}` ? path : null;
 }
 function normalizeIncomingHeaders(headers) {
-    const out = {};
-    for (const [key, value] of Object.entries(headers)) {
-        if (value == null)
-            continue;
-        out[key.toLowerCase()] = Array.isArray(value) ? value.join(', ') : value;
-    }
-    return out;
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value == null)
+      continue;
+    out[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return out;
 }
 async function readBody(req, maxBodyBytes) {
-    const contentLength = Number(req.headers['content-length']);
-    if (Number.isSafeInteger(contentLength) && contentLength > maxBodyBytes) {
-        // Keep the HTTP exchange orderly rather than forcing a TCP reset before
-        // the caller can receive its deterministic 413 response.
-        req.resume();
-        throw new RequestBodyTooLargeError(maxBodyBytes);
-    }
-    const chunks = [];
-    let totalBytes = 0;
-    for await (const chunk of req) {
-        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        totalBytes += bytes.length;
-        if (totalBytes > maxBodyBytes)
-            throw new RequestBodyTooLargeError(maxBodyBytes);
-        chunks.push(bytes);
-    }
-    if (chunks.length === 0)
-        return null;
-    return Buffer.concat(chunks);
+  const contentLength = Number(req.headers["content-length"]);
+  if (Number.isSafeInteger(contentLength) && contentLength > maxBodyBytes) {
+    req.resume();
+    throw new RequestBodyTooLargeError(maxBodyBytes);
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  for await (const chunk of req) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    totalBytes += bytes.length;
+    if (totalBytes > maxBodyBytes)
+      throw new RequestBodyTooLargeError(maxBodyBytes);
+    chunks.push(bytes);
+  }
+  if (chunks.length === 0)
+    return null;
+  return Buffer.concat(chunks);
 }
 function writeError(res, status, code, message) {
-    const payload = JSON.stringify({ type: 'error', error: { type: code, message } });
-    res.writeHead(status, { 'content-type': 'application/json' });
-    res.end(payload);
+  const payload = JSON.stringify({ type: "error", error: { type: code, message } });
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(payload);
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModelProxyLoopbackServer
+});