stitchkit 0.104.2 → 0.105.1

package/dist/index-3h0ztg0z.js

@@ -0,0 +1,285 @@
+import {
+  raceAbort
+} from "./index-b0kddvzw.js";
+
+// src/internal/secure-fetch.ts
+import { lookup } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
+var NUMERIC_HOST = /^(0x[0-9a-f]+|[0-9.]+)$/i;
+var MAX_REDIRECTS = 5;
+function assertHttpUrl(url) {
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`refusing to fetch a non-http(s) URL (${url.protocol})`);
+  }
+}
+function mappedIpv4FromIpv6(ip) {
+  const rest = ip.startsWith("::ffff:") ? ip.slice("::ffff:".length) : ip.startsWith("0:0:0:0:0:ffff:") ? ip.slice("0:0:0:0:0:ffff:".length) : null;
+  if (rest === null)
+    return null;
+  if (isIP(rest) === 4)
+    return rest;
+  const [hiRaw, loRaw, extra] = rest.split(":");
+  if (hiRaw === undefined || loRaw === undefined || extra !== undefined)
+    return null;
+  if (!/^[0-9a-f]{1,4}$/i.test(hiRaw) || !/^[0-9a-f]{1,4}$/i.test(loRaw))
+    return null;
+  const hi = Number.parseInt(hiRaw, 16);
+  const lo = Number.parseInt(loRaw, 16);
+  return [hi >> 8, hi & 255, lo >> 8, lo & 255].join(".");
+}
+function ipv6Words(ip) {
+  const halves = ip.toLowerCase().split("::");
+  if (halves.length > 2)
+    return null;
+  const head = halves[0] ? halves[0].split(":") : [];
+  const tail = halves[1] ? halves[1].split(":") : [];
+  const missing = 8 - head.length - tail.length;
+  if (halves.length === 1 && missing !== 0 || missing < 0)
+    return null;
+  const parts = halves.length === 2 ? [...head, ...Array(missing).fill("0"), ...tail] : head;
+  if (parts.length !== 8)
+    return null;
+  const words = [];
+  for (const part of parts) {
+    if (!/^[0-9a-f]{1,4}$/i.test(part))
+      return null;
+    words.push(Number.parseInt(part, 16));
+  }
+  return words;
+}
+function isPrivateIp(ip) {
+  const normalized = ip.replace(/^\[|\]$/g, "");
+  const family = isIP(normalized);
+  if (family === 4) {
+    const [a, b] = normalized.split(".").map(Number);
+    if (a === undefined || b === undefined)
+      return true;
+    const value = normalized.split(".").map(Number).reduce((total, octet) => total * 256 + octet, 0);
+    const inCidr = (base, prefix) => {
+      const baseValue = base.split(".").map(Number).reduce((total, octet) => total * 256 + octet, 0);
+      const size = 2 ** (32 - prefix);
+      return value >= baseValue && value < baseValue + size;
+    };
+    const blockedRanges = [
+      ["0.0.0.0", 8],
+      ["10.0.0.0", 8],
+      ["100.64.0.0", 10],
+      ["127.0.0.0", 8],
+      ["169.254.0.0", 16],
+      ["172.16.0.0", 12],
+      ["192.0.0.0", 24],
+      ["192.0.2.0", 24],
+      ["192.31.196.0", 24],
+      ["192.52.193.0", 24],
+      ["192.88.99.0", 24],
+      ["192.168.0.0", 16],
+      ["192.175.48.0", 24],
+      ["198.18.0.0", 15],
+      ["198.51.100.0", 24],
+      ["203.0.113.0", 24],
+      ["224.0.0.0", 4],
+      ["240.0.0.0", 4]
+    ];
+    return blockedRanges.some(([base, prefix]) => inCidr(base, prefix));
+  }
+  if (family === 6) {
+    const lower = normalized.toLowerCase();
+    const mapped = mappedIpv4FromIpv6(lower);
+    if (mapped)
+      return isPrivateIp(mapped);
+    const words = ipv6Words(lower);
+    if (!words)
+      return true;
+    const [first, second, third] = words;
+    if (first === undefined || second === undefined || third === undefined)
+      return true;
+    return first === 0 || first === 100 && second === 65435 && third === 1 || first === 256 && second === 0 || first === 8193 && (second <= 511 || second === 3512) || first === 8194 || first === 16383 || first === 24320 || (first & 65024) === 64512 || (first & 65472) === 65152 || (first & 65280) === 65280;
+  }
+  return false;
+}
+async function assertPublicUrl(url, signal) {
+  await resolvePublicAddress(url, signal);
+}
+async function fetchGuarded(start, allowPrivate, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 15000;
+  const bodyTimeoutMs = options.bodyTimeoutMs ?? 120000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("timeoutMs must be positive");
+  }
+  if (!Number.isFinite(bodyTimeoutMs) || bodyTimeoutMs <= 0) {
+    throw new Error("bodyTimeoutMs must be positive");
+  }
+  const controller = new AbortController;
+  const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
+  const headerTimer = setTimeout(() => {
+    controller.abort(new Error(`fetch did not produce response headers within ${timeoutMs}ms`));
+  }, timeoutMs);
+  headerTimer.unref?.();
+  let settled = false;
+  try {
+    let url = start;
+    for (let hop = 0;hop <= MAX_REDIRECTS; hop++) {
+      if (allowPrivate)
+        assertHttpUrl(url);
+      else
+        await assertPublicUrl(url, signal);
+      const res = await fetch(url, { redirect: "manual", signal });
+      const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
+      if (location === null) {
+        settled = true;
+        clearTimeout(headerTimer);
+        const bodyTimer = setTimeout(() => {
+          controller.abort(new Error(`fetch body was not consumed within ${bodyTimeoutMs}ms`));
+        }, bodyTimeoutMs);
+        bodyTimer.unref?.();
+        return res;
+      }
+      await res.body?.cancel();
+      url = new URL(location, url);
+    }
+    throw new Error("too many redirects");
+  } finally {
+    if (!settled)
+      clearTimeout(headerTimer);
+  }
+}
+
+class PrivateAddressRefusal extends Error {
+  name = "PrivateAddressRefusal";
+}
+async function resolvePublicAddress(url, signal) {
+  assertHttpUrl(url);
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  if (!host)
+    throw new Error("refusing to fetch a URL with no host");
+  const ipFamily = isIP(host);
+  if (ipFamily) {
+    if (isPrivateIp(host))
+      throw new PrivateAddressRefusal("refusing to fetch a private address");
+    return { address: host, family: ipFamily === 6 ? 6 : 4 };
+  }
+  if (NUMERIC_HOST.test(host)) {
+    throw new PrivateAddressRefusal("refusing to fetch a non-canonical numeric host");
+  }
+  if (host === "localhost" || host.endsWith(".local") || host.endsWith(".internal")) {
+    throw new PrivateAddressRefusal("refusing to fetch an internal host");
+  }
+  const pending = lookup(host, { all: true });
+  const records = signal ? await raceAbort(pending, signal) : await pending;
+  for (const record of records) {
+    if (isPrivateIp(record.address)) {
+      throw new PrivateAddressRefusal("refusing to fetch a host that resolves to a private address");
+    }
+  }
+  const record = records[0];
+  if (!record)
+    throw new Error("public hostname resolved to no addresses");
+  return { address: record.address, family: record.family === 6 ? 6 : 4 };
+}
+async function fetchPinnedDocument(start, options) {
+  if (!Number.isInteger(options.maxBytes) || options.maxBytes < 1) {
+    throw new Error("maxBytes must be a positive integer");
+  }
+  if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
+    throw new Error("timeoutMs must be positive");
+  }
+  let url = start;
+  const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS;
+  if (!Number.isInteger(maxRedirects) || maxRedirects < 0) {
+    throw new Error("maxRedirects must be a non-negative integer");
+  }
+  const signal = AbortSignal.timeout(options.timeoutMs);
+  for (let hop = 0;hop <= maxRedirects; hop++) {
+    if (options.requireHttps && url.protocol !== "https:") {
+      throw new Error("document URL and every redirect must use https");
+    }
+    if (url.username || url.password) {
+      throw new Error("document URL cannot contain credentials");
+    }
+    const resolved = await resolvePublicAddress(url, signal);
+    const transport = url.protocol === "https:" ? httpsRequest : httpRequest;
+    const response = await new Promise((resolve, reject) => {
+      const request = transport({
+        protocol: url.protocol,
+        hostname: resolved.address,
+        family: resolved.family,
+        port: url.port || undefined,
+        path: `${url.pathname}${url.search}`,
+        method: "GET",
+        signal,
+        servername: url.hostname,
+        headers: {
+          host: url.host,
+          accept: "application/json",
+          ...options.headers
+        }
+      }, (incoming) => {
+        const headers = new Headers;
+        for (const [name, value] of Object.entries(incoming.headers)) {
+          if (Array.isArray(value)) {
+            for (const item of value)
+              headers.append(name, item);
+          } else if (value !== undefined) {
+            headers.set(name, value);
+          }
+        }
+        const chunks = [];
+        let total = 0;
+        incoming.on("data", (chunk) => {
+          total += chunk.byteLength;
+          if (total > options.maxBytes) {
+            incoming.destroy(new Error("response body exceeds configured byte limit"));
+            return;
+          }
+          chunks.push(chunk);
+        });
+        incoming.once("error", reject);
+        incoming.once("end", () => {
+          const body = new Uint8Array(total);
+          let offset = 0;
+          for (const chunk of chunks) {
+            body.set(chunk, offset);
+            offset += chunk.byteLength;
+          }
+          resolve({ status: incoming.statusCode ?? 0, headers, body, url });
+        });
+      });
+      request.once("error", reject);
+      request.end();
+    });
+    if (response.status < 300 || response.status >= 400)
+      return response;
+    const location = response.headers.get("location");
+    if (!location)
+      return response;
+    url = new URL(location, url);
+  }
+  throw new Error("too many redirects");
+}
+async function readCapped(res, max) {
+  const reader = res.body?.getReader();
+  if (!reader)
+    return Buffer.alloc(0);
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      total += value.length;
+      if (total > max) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks);
+}
+
+export { fetchGuarded, PrivateAddressRefusal, fetchPinnedDocument, readCapped };

package/dist/{index-g95fk660.js → index-4vsby8n8.js}

@@ -1,6 +1,9 @@
 import {
   attemptExclusiveLock
-} from "./index-za6j7nwy.js";
+} from "./index-dsnjzb62.js";
+import {
+  sleep
+} from "./index-eemvahkc.js";
 
 // src/internal/with-exclusive-lock.ts
 class ExclusiveLockError2 extends Error {
@@ -16,7 +19,6 @@ class ExclusiveLockError2 extends Error {
   }
 }
 var DEFAULT_TIMEOUT_MS = 1e4;
-var DEFAULT_OWNERLESS_GRACE_MS = 5000;
 var FIRST_RETRY_MS = 10;
 var MAX_RETRY_MS = 100;
 function nonNegative(name, value, fallback) {
@@ -39,21 +41,10 @@ function describeEvidence(diagnosis) {
   const identity = diagnosis.identity === undefined ? "" : `, identity ${diagnosis.identity}`;
   return ` (${diagnosis.attribution}, liveness ${diagnosis.liveness}${identity})`;
 }
-function pause(ms, signal) {
-  return new Promise((resolve) => {
-    const done = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", done);
-      resolve();
-    };
-    const timer = setTimeout(done, ms);
-    signal?.addEventListener("abort", done, { once: true });
-  });
-}
 async function withExclusiveLock2(path, run, options = {}) {
   const label = options.label ?? path;
   const timeoutMs = nonNegative("timeoutMs", options.timeoutMs, DEFAULT_TIMEOUT_MS);
-  const ownerlessGraceMs = options.ownerlessGraceMs === null ? null : nonNegative("ownerlessGraceMs", options.ownerlessGraceMs, DEFAULT_OWNERLESS_GRACE_MS);
+  const ownerlessGraceMs = options.ownerlessGraceMs === undefined || options.ownerlessGraceMs === null ? options.ownerlessGraceMs : nonNegative("ownerlessGraceMs", options.ownerlessGraceMs, 0);
   const mode = options.mode ?? 384;
   if (!Number.isInteger(mode) || mode < 0 || mode > 511)
     throw new RangeError("[stitchkit] withExclusiveLock: mode must be permission bits from 0000 to 0777");
@@ -108,7 +99,9 @@ async function withExclusiveLock2(path, run, options = {}) {
       const holder = attempt.diagnosis?.owner ?? null;
       throw new ExclusiveLockError2("LOCK_TIMEOUT", label, holder, `[stitchkit] the lock on "${label}" is held by ${describeHolder(holder)}${describeEvidence(attempt.diagnosis)}; gave up after ${timeoutMs} ms`, { cause: attempt.diagnosis?.cause ?? attempt.error });
     }
-    await pause(Math.min(delay * (0.5 + Math.random() / 2), remaining), signal);
+    await sleep(Math.min(delay * (0.5 + Math.random() / 2), remaining), signal).catch(() => {
+      return;
+    });
     delay = Math.min(delay * 2, MAX_RETRY_MS);
   }
 }

package/dist/index-556g5hsh.js

@@ -0,0 +1,17 @@
+import {
+  AppError2
+} from "./index-j9gxbztg.js";
+
+// src/tools/internal/tool-error-projection.ts
+var TOOL_ERROR_PROJECTION = Symbol.for("stitchkit.toolErrorProjection");
+function projectedToolError(error) {
+  if (typeof error !== "object" || error === null)
+    return;
+  const project = Reflect.get(error, TOOL_ERROR_PROJECTION);
+  if (typeof project !== "function")
+    return;
+  const projected = Reflect.apply(project, error, []);
+  return AppError2.is(projected) ? projected : undefined;
+}
+
+export { TOOL_ERROR_PROJECTION, projectedToolError };