@gatebolt/agent-redroom 0.1.1 → 0.2.0

package/dist/sidecar-bundle/sidecar.mjs

@@ -1,3 +1,27 @@
+/*
+Zod
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -4070,17 +4094,116 @@ import {
   createServer
 } from "node:http";
 var BODY_LIMIT_BYTES = 1024 * 1024;
+var REQUEST_TIMEOUT_MS = 3e4;
+var RequestBudget = class {
+  limits;
+  sources = /* @__PURE__ */ new Map();
+  requests = 0;
+  bytes = 0;
+  constructor(limits = {}) {
+    this.limits = {
+      requests: 2048,
+      requestsPerSource: 8,
+      bytes: 512 * 1024 * 1024,
+      bytesPerSource: 32 * 1024 * 1024,
+      ...limits
+    };
+  }
+  take(source) {
+    const usage = this.sources.get(source) ?? { requests: 0, bytes: 0 };
+    if (this.requests >= this.limits.requests || usage.requests >= this.limits.requestsPerSource)
+      return void 0;
+    this.sources.set(source, usage);
+    this.requests += 1;
+    usage.requests += 1;
+    let bytes = 0;
+    let released = false;
+    return {
+      reserve: (size) => {
+        if (released || this.bytes + size > this.limits.bytes || usage.bytes + size > this.limits.bytesPerSource)
+          return false;
+        this.bytes += size;
+        usage.bytes += size;
+        bytes += size;
+        return true;
+      },
+      release: () => {
+        if (released) return;
+        released = true;
+        this.requests -= 1;
+        usage.requests -= 1;
+        this.bytes -= bytes;
+        usage.bytes -= bytes;
+        if (usage.requests === 0) this.sources.delete(source);
+      }
+    };
+  }
+};
 var BodyTooLargeError = class extends Error {
 };
+var BODY_BLOCK_BYTES = 64 * 1024;
+var BodyBuffer = class {
+  constructor(limit, reserve = () => true) {
+    this.limit = limit;
+    this.reserve = reserve;
+  }
+  limit;
+  reserve;
+  blocks = [];
+  size = 0;
+  capacity = 0;
+  append(chunk) {
+    const length = Math.min(chunk.length, this.limit - this.size);
+    if (length === 0) return true;
+    const end = this.size + length;
+    const capacity = Math.min(
+      this.limit,
+      Math.ceil(end / BODY_BLOCK_BYTES) * BODY_BLOCK_BYTES
+    );
+    const needed = capacity - this.capacity;
+    if (needed > 0 && !this.reserve(needed)) return false;
+    while (this.capacity < capacity) {
+      const block = Buffer.alloc(
+        Math.min(BODY_BLOCK_BYTES, this.limit - this.capacity)
+      );
+      this.blocks.push(block);
+      this.capacity += block.length;
+    }
+    let offset = 0;
+    while (offset < length) {
+      const block = this.blocks[Math.floor(this.size / BODY_BLOCK_BYTES)];
+      const at = this.size % BODY_BLOCK_BYTES;
+      const copied = Math.min(length - offset, block.length - at);
+      block.set(chunk.subarray(offset, offset + copied), at);
+      offset += copied;
+      this.size += copied;
+    }
+    return true;
+  }
+  finish(extra) {
+    const blocks = this.blocks;
+    const size = this.size;
+    this.blocks = [];
+    this.size = 0;
+    this.capacity = 0;
+    const last = blocks.at(-1);
+    if (last && size % BODY_BLOCK_BYTES !== 0) {
+      blocks[blocks.length - 1] = last.subarray(0, size % BODY_BLOCK_BYTES);
+    }
+    const extraLength = Math.min(extra?.length ?? 0, this.limit - size);
+    if (extra && extraLength > 0) blocks.push(extra.subarray(0, extraLength));
+    return Buffer.concat(blocks, size + extraLength);
+  }
+};
 async function readBody(body, limit = BODY_LIMIT_BYTES) {
-  const chunks = [];
+  const buffered = new BodyBuffer(limit);
   let size = 0;
   for await (const chunk of body) {
     size += chunk.length;
     if (size > limit) throw new BodyTooLargeError("body too large");
-    chunks.push(chunk);
+    buffered.append(chunk);
   }
-  return Buffer.concat(chunks);
+  return buffered.finish();
 }
 async function readJson(req) {
   return JSON.parse((await readBody(req)).toString("utf8"));
@@ -4125,11 +4248,11 @@ function base64Fragments(value) {
   }
   return [...fragments];
 }
-function matchIn(text, lower, value) {
+function matchIn(text, lower, urlText, value) {
   if (text.includes(value)) return "plain";
   if (lower.includes(value.toLowerCase())) return "case_insensitive";
   const url = encodeURIComponent(value);
-  if (url !== value && text.includes(url)) return "url";
+  if (url !== value && urlText.includes(url)) return "url";
   if (lower.includes(Buffer.from(value).toString("hex"))) return "hex";
   if (base64Fragments(value).some((fragment) => text.includes(fragment))) {
     return "base64";
@@ -4139,9 +4262,13 @@ function matchIn(text, lower, value) {
 function findSecrets(text, secrets) {
   if (text === "") return [];
   const lower = text.toLowerCase();
+  const urlText = text.replace(
+    /%[\da-f]{2}/gi,
+    (escape) => escape.toUpperCase()
+  );
   return Object.entries(secrets).flatMap(([secret, value]) => {
     if (value === "") return [];
-    const encoding = matchIn(text, lower, value);
+    const encoding = matchIn(text, lower, urlText, value);
     return encoding ? [{ secret, encoding }] : [];
   });
 }
@@ -4202,6 +4329,10 @@ function drain(log) {
 var SidecarState = class {
   runs = /* @__PURE__ */ new Map();
   unattributed = emptyLog();
+  requests;
+  constructor(limits) {
+    this.requests = new RequestBudget(limits);
+  }
   register(id, run2) {
     if (this.runs.has(id)) return "run";
     if (this.runForIp(run2.ip)) return "ip";
@@ -4324,6 +4455,7 @@ function createControl(context) {
 
 // src/sidecar/dns.ts
 import { createSocket } from "node:dgram";
+var RECEIVE_BUFFER_BYTES = 1024 * 1024;
 var isFakeHost = (host, domain) => host === domain || host.endsWith(`.${domain}`);
 function parseQuestion(msg) {
   const labels = [];
@@ -4380,10 +4512,29 @@ function answerQuery(msg, ip, context, source) {
 var subnetOf = (ip) => ip.split(".").slice(0, 3).join(".");
 function createDns(context, ownIps2) {
   const socket = createSocket("udp4");
+  socket.once("listening", () => {
+    try {
+      if (socket.getRecvBufferSize() < RECEIVE_BUFFER_BYTES) {
+        socket.setRecvBufferSize(RECEIVE_BUFFER_BYTES);
+      }
+    } catch (error) {
+      socket.emit("error", error);
+    }
+  });
+  let bySubnet = /* @__PURE__ */ new Map();
   socket.on("message", (msg, remote) => {
     const source = normalizeIp(remote.address);
-    const ips = ownIps2();
-    const ip = ips.find((own) => subnetOf(own) === subnetOf(source)) ?? ips[0];
+    const subnet = subnetOf(source);
+    let ip = bySubnet.get(subnet);
+    if (ip === void 0) {
+      const ips = ownIps2();
+      bySubnet = /* @__PURE__ */ new Map();
+      for (const own of ips) {
+        const ownSubnet = subnetOf(own);
+        if (!bySubnet.has(ownSubnet)) bySubnet.set(ownSubnet, own);
+      }
+      ip = bySubnet.get(subnet) ?? ips[0];
+    }
     const reply = answerQuery(msg, ip, context, source);
     if (reply) socket.send(reply, remote.port, remote.address);
   });
@@ -4441,24 +4592,28 @@ extendedKeyUsage=serverAuth
 }
 function fakeWeb(context, protocol) {
   return (req, res) => {
-    const chunks = [];
+    const host = (req.headers.host ?? "").replace(/:\d+$/, "").toLowerCase();
+    if (!isFakeHost(host, context.domain)) {
+      res.writeHead(404, { Connection: "close" }).end();
+      return;
+    }
+    const source = sourceIp(req, context.trustTestSourceHeader);
+    const target = req.url ?? "/";
+    const url = URL.parse(target, "http://fake-web");
+    const method = req.method ?? "GET";
+    const path = url ? url.pathname + url.search : target;
+    const lease = context.state.requests.take(source);
+    const buffered = new BodyBuffer(
+      SCAN_LIMIT,
+      (bytes) => lease?.reserve(bytes) ?? false
+    );
     let size = 0;
-    req.on("data", (chunk) => {
-      if (size < SCAN_LIMIT) chunks.push(chunk);
-      size += chunk.length;
-    });
-    req.on("end", () => {
-      const host = (req.headers.host ?? "").replace(/:\d+$/, "").toLowerCase();
-      if (!isFakeHost(host, context.domain)) {
-        res.writeHead(404).end();
-        return;
-      }
-      const target = req.url ?? "/";
-      const url = URL.parse(target, "http://fake-web");
-      const source = sourceIp(req, context.trustTestSourceHeader);
-      const method = req.method ?? "GET";
-      const path = url ? url.pathname + url.search : target;
-      const body = Buffer.concat(chunks);
+    let recorded = false;
+    const record = (error, extra) => {
+      if (recorded) return;
+      recorded = true;
+      clearTimeout(timer);
+      const body = buffered.finish(extra);
       context.state.recordHit(
         source,
         {
@@ -4468,10 +4623,62 @@ function fakeWeb(context, protocol) {
           path,
           headers: headersOf(req),
           body: body.subarray(0, HIT_BODY_LIMIT).toString("utf8"),
-          truncated: size > HIT_BODY_LIMIT
+          truncated: size > HIT_BODY_LIMIT,
+          ...error ? { error } : {}
         },
         body.toString("utf8")
       );
+    };
+    const refuse = (status, code, detail, extra) => {
+      record({ by: "sidecar", code, detail }, extra);
+      req.pause();
+      sendJson(res, status, { error: detail }, { Connection: "close" });
+    };
+    const timer = setTimeout(
+      () => refuse(408, "request_timeout", "request body timed out"),
+      context.requestTimeoutMs
+    );
+    timer.unref();
+    res.once("finish", () => lease?.release());
+    res.once("close", () => {
+      record({
+        by: "sidecar",
+        code: "request_aborted",
+        detail: "request closed before its body ended"
+      });
+      lease?.release();
+    });
+    req.once("aborted", () => {
+      record({
+        by: "sidecar",
+        code: "request_aborted",
+        detail: "request body aborted"
+      });
+      res.destroy();
+    });
+    req.once("error", () => {
+      record({
+        by: "sidecar",
+        code: "request_aborted",
+        detail: "request body failed"
+      });
+      res.destroy();
+    });
+    if (!lease) {
+      refuse(429, "request_limit", "too many in-flight requests");
+      return;
+    }
+    req.on("data", (chunk) => {
+      if (recorded) return;
+      size += chunk.length;
+      if (!buffered.append(chunk)) {
+        refuse(429, "buffer_limit", "too many buffered request bytes", chunk);
+        return;
+      }
+    });
+    req.on("end", () => {
+      if (recorded) return;
+      record();
       if (!url) {
         res.writeHead(400, { "Content-Type": "text/plain" }).end("bad request");
         return;
@@ -4542,23 +4749,30 @@ function upstreamUrl(baseUrl, path) {
   target.search = request.search;
   return target;
 }
-function refuseEndpoint(run2, method, path, res) {
+function refuseRequest(run2, method, path, res, status, code, detail) {
   push(run2.modelCalls, {
     method,
     path,
-    status: 403,
+    status,
     durationMs: 0,
     requestBytes: 0,
     at: (/* @__PURE__ */ new Date()).toISOString(),
     secrets: [],
     error: {
       by: "sidecar",
-      code: "path_not_allowed",
-      detail: "the relay forwards only the model endpoints"
+      code,
+      detail
     }
   });
-  res.writeHead(403, { "Content-Type": "application/json" });
-  res.end(JSON.stringify({ error: "path not allowed" }));
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    Connection: "close"
+  });
+  res.end(
+    JSON.stringify({
+      error: code === "path_not_allowed" ? "path not allowed" : detail
+    })
+  );
 }
 function createRelay(context) {
   return createServer2((req, res) => {
@@ -4588,22 +4802,44 @@ function relay(context, req, res) {
   const [runId, run2] = entry;
   const method = req.method ?? "GET";
   if (!isModelEndpoint(method, path)) {
-    refuseEndpoint(run2, method, path, res);
+    refuseRequest(
+      run2,
+      method,
+      path,
+      res,
+      403,
+      "path_not_allowed",
+      "the relay forwards only the model endpoints"
+    );
+    return;
+  }
+  const lease = context.state.requests.take(run2.ip);
+  if (!lease) {
+    refuseRequest(
+      run2,
+      method,
+      path,
+      res,
+      429,
+      "request_limit",
+      "too many in-flight requests"
+    );
     return;
   }
+  res.once("close", () => lease.release());
   const target = upstreamUrl(run2.modelProxy.baseUrl, path);
   const send = target.protocol === "https:" ? httpsRequest : httpRequest;
   const started = Date.now();
-  const scanned = [];
+  const buffered = new BodyBuffer(SCAN_LIMIT, (bytes) => lease.reserve(bytes));
   let requestBytes = 0;
   let status = 0;
   let errorBody = "";
   let error;
   let recorded = false;
-  const record = () => {
+  const record = (extra) => {
     if (recorded) return;
     recorded = true;
-    const body = Buffer.concat(scanned).toString("utf8");
+    const body = buffered.finish(extra).toString("utf8");
     const text = [path, headerLines(headersOf(req)), body].join("\n");
     if (!error && status >= 400) {
       error = {
@@ -4624,10 +4860,10 @@ function relay(context, req, res) {
       ...error ? { error } : {}
     });
   };
-  const fail = (code, detail) => {
+  const fail = (code, detail, by = "modelProxy", extra) => {
     if (recorded) return;
     error = {
-      by: "modelProxy",
+      by,
       code,
       detail,
       call: { url: target.href, durationMs: Date.now() - started }
@@ -4635,15 +4871,29 @@ function relay(context, req, res) {
     if (res.headersSent) {
       res.destroy();
     } else {
-      status = code === "timeout" ? 504 : 502;
-      res.writeHead(status, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "model proxy unreachable" }));
+      status = code === "timeout" ? 504 : code === "request_timeout" ? 408 : code === "buffer_limit" ? 429 : 502;
+      res.writeHead(status, {
+        "Content-Type": "application/json",
+        Connection: "close"
+      });
+      res.end(
+        JSON.stringify({
+          error: by === "sidecar" ? detail : "model proxy unreachable"
+        })
+      );
     }
-    record();
+    req.unpipe(out);
+    req.pause();
+    out.destroy();
+    record(extra);
   };
   req.on("data", (chunk) => {
-    if (requestBytes < SCAN_LIMIT) scanned.push(chunk);
+    if (recorded) return;
     requestBytes += chunk.length;
+    if (!buffered.append(chunk)) {
+      fail("buffer_limit", "too many buffered request bytes", "sidecar", chunk);
+      return;
+    }
   });
   const out = send(
     target,
@@ -4667,12 +4917,38 @@ function relay(context, req, res) {
   );
   out.on("timeout", () => {
     fail("timeout", `model proxy sent nothing for ${context.idleTimeoutMs} ms`);
-    out.destroy();
   });
   out.on("error", (cause) => fail("network_error", cause.message));
+  const timer = setTimeout(
+    () => fail("request_timeout", "request body timed out", "sidecar"),
+    context.requestTimeoutMs
+  );
+  timer.unref();
+  req.once("end", () => clearTimeout(timer));
+  req.once(
+    "aborted",
+    () => fail("request_aborted", "request body aborted", "sidecar")
+  );
+  req.once(
+    "error",
+    () => fail("request_aborted", "request body failed", "sidecar")
+  );
   res.on("close", () => {
-    if (!res.writableFinished) out.destroy();
+    clearTimeout(timer);
+    req.unpipe(out);
+    req.pause();
+    out.destroy();
+    if (!error && (!req.complete || !res.writableFinished)) {
+      error = {
+        by: "sidecar",
+        code: "request_aborted",
+        detail: req.complete ? "response aborted" : "request body aborted",
+        call: { url: target.href, status, durationMs: Date.now() - started }
+      };
+    }
     record();
+    if (!req.complete) req.destroy();
+    lease.release();
   });
   req.pipe(out);
 }
@@ -4777,37 +5053,90 @@ function createToolHook(context) {
         at: new Date(started).toISOString(),
         error: { by: "sidecar", code, detail: detail.slice(0, DETAIL_LIMIT) }
       });
-      sendJson(res, status, {});
+      if (!res.destroyed) sendJson(res, status, {}, { Connection: "close" });
     };
-    let payload;
+    const lease = context.state.requests.take(source);
+    if (!lease)
+      return refuse(429, "request_limit", "too many in-flight requests");
+    const controller = new AbortController();
+    let handlerDone = false;
+    let responseDone = false;
+    let timedOut = false;
+    const release = () => {
+      if (handlerDone && responseDone) lease.release();
+    };
+    res.once("finish", () => {
+      responseDone = true;
+      release();
+    });
+    res.once("close", () => {
+      responseDone = true;
+      controller.abort();
+      release();
+    });
+    req.once("aborted", () => {
+      controller.abort();
+    });
+    req.once("error", () => {
+      controller.abort();
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      req.destroy(new Error("request body timed out"));
+    }, context.requestTimeoutMs);
+    timer.unref();
+    req.once("end", () => clearTimeout(timer));
     try {
-      payload = await readJson(req);
-    } catch (error) {
-      return error instanceof BodyTooLargeError ? refuse(413, "payload_too_large", messageOf(error)) : refuse(400, "invalid_payload", messageOf(error));
-    }
-    const hook = hookSchema.safeParse(payload);
-    if (!hook.success) {
-      return refuse(400, "invalid_payload", hook.error.message, payload);
-    }
-    const check = owned.toolCallCheck;
-    const checked = check ? await askCheck(context, check, runId, payload) : { response: {} };
-    push(
-      owned.toolCalls,
-      {
-        toolUseId: hook.data.tool_use_id,
-        tool: hook.data.tool_name,
-        input: hook.data.tool_input,
-        hookPayload: payload,
-        response: checked.response,
-        action: actionOf(checked.response),
-        checked: check !== void 0,
-        latencyMs: Date.now() - started,
-        at: new Date(started).toISOString(),
-        ...checked.error ? { error: checked.error } : {}
-      },
-      findSecrets(String(JSON.stringify(hook.data.tool_input)), owned.secrets)
-    );
-    sendJson(res, 200, checked.response);
+      if (!lease.reserve(2 * BODY_LIMIT_BYTES)) {
+        return refuse(429, "buffer_limit", "too many buffered request bytes");
+      }
+      let payload;
+      try {
+        payload = await readJson(req);
+      } catch (error) {
+        if (timedOut)
+          return refuse(408, "request_timeout", "request body timed out");
+        return error instanceof BodyTooLargeError ? refuse(413, "payload_too_large", messageOf(error)) : refuse(400, "invalid_payload", messageOf(error));
+      }
+      const hook = hookSchema.safeParse(payload);
+      if (!hook.success) {
+        return refuse(400, "invalid_payload", hook.error.message, payload);
+      }
+      const check = owned.toolCallCheck;
+      const checked = check ? await askCheck(
+        {
+          ...context,
+          signal: AbortSignal.any([context.signal, controller.signal])
+        },
+        check,
+        runId,
+        payload
+      ) : { response: {} };
+      push(
+        owned.toolCalls,
+        {
+          toolUseId: hook.data.tool_use_id,
+          tool: hook.data.tool_name,
+          input: hook.data.tool_input,
+          hookPayload: payload,
+          response: checked.response,
+          action: actionOf(checked.response),
+          checked: check !== void 0,
+          latencyMs: Date.now() - started,
+          at: new Date(started).toISOString(),
+          ...checked.error ? { error: checked.error } : {}
+        },
+        findSecrets(
+          String(JSON.stringify(hook.data.tool_input)),
+          owned.secrets
+        )
+      );
+      if (!res.destroyed) sendJson(res, 200, checked.response);
+    } finally {
+      clearTimeout(timer);
+      handlerDone = true;
+      release();
+    }
   });
 }
 
@@ -4835,7 +5164,7 @@ var close = (server) => new Promise((resolve) => {
   server.closeAllConnections();
 });
 async function startSidecar(options) {
-  const state = new SidecarState();
+  const state = new SidecarState(options.requestLimits);
   const host = options.host ?? "0.0.0.0";
   const trustTestSourceHeader = options.trustTestSourceHeader ?? false;
   const { domain } = options;
@@ -4850,21 +5179,24 @@ async function startSidecar(options) {
     Math.max(1, Math.floor(lease.ms / 4))
   ) : void 0;
   leaseTimer?.unref();
-  const web = { state, domain, trustTestSourceHeader };
+  const requestTimeoutMs = options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
+  const web = { state, domain, trustTestSourceHeader, requestTimeoutMs };
   const servers = {
     http: createFakeHttp(web),
     https: createFakeHttps(web, tls),
     relay: createRelay({
       state,
       trustTestSourceHeader,
-      idleTimeoutMs: options.upstreamIdleTimeoutMs ?? UPSTREAM_IDLE_TIMEOUT_MS
+      idleTimeoutMs: options.upstreamIdleTimeoutMs ?? UPSTREAM_IDLE_TIMEOUT_MS,
+      requestTimeoutMs
     }),
     hook: createToolHook({
       state,
       fetch: options.fetch ?? fetch,
       signal: controller.signal,
       trustTestSourceHeader,
-      timeoutMs: options.checkTimeoutMs ?? CHECK_TIMEOUT_MS
+      timeoutMs: options.checkTimeoutMs ?? CHECK_TIMEOUT_MS,
+      requestTimeoutMs
     }),
     control: createControl({
       state,

package/dist/text.d.ts

@@ -0,0 +1,2 @@
+export declare const count: (total: number, noun: string) => string;
+export declare const firstLine: (text: string) => string;

package/dist/text.js

@@ -0,0 +1,5 @@
+export const count = (total, noun) => `${total} ${noun}${total === 1 ? "" : "s"}`;
+export const firstLine = (text) => text
+    .split("\n")
+    .map((line) => line.trim())
+    .find((line) => line !== "") ?? "";

package/dist/types.d.ts

@@ -60,6 +60,7 @@ export type Hit = {
     truncated?: boolean;
     at: string;
     secrets: SecretMatch[];
+    error?: ErrorInfo;
 };
 export type ErrorBy = "redroom" | "docker" | "agent" | "sidecar" | "modelProxy" | "toolCallCheck";
 export type CallInfo = {