@wrongstack/core 0.256.1 → 0.257.2

package/dist/utils/index.d.ts

@@ -3,6 +3,8 @@ export { T as TaskItem, c as computeTaskItemProgress, f as formatTaskList, a as
 export { a as WstackPathOptions, W as WstackPaths, p as projectHash, b as projectSlug, r as resolveWstackPaths, w as wstackGlobalRoot } from '../wstack-paths-CJjEwPXn.js';
 export { expectDefined } from './expect-defined.js';
 import { a as ModelsDevPayload, t as CustomModelDefinition } from '../config-DuAu23zm.js';
+import * as https from 'node:https';
+import { Dispatcher } from 'undici';
 export { a as TaskPriority, b as TaskStatus, T as TaskType } from '../task-graph-u1q9Jkyk.js';
 
 interface AtomicWriteOptions {
@@ -602,4 +604,100 @@ declare function mergeModelsPayload(base: ModelsDevPayload, overlay: ModelsDevPa
  */
 declare function mergeCustomModelDefs(providerCustomModels: Record<string, CustomModelDefinition> | undefined, configModels: Record<string, CustomModelDefinition> | undefined): Record<string, CustomModelDefinition> | undefined;
 
-export { type AtomicWriteOptions, type BuildChildEnvOptions, type CompileFail, type CompileResult, type DeepMergeOptions, FORBIDDEN_PROTO_KEYS, type FileLockOptions, type MessageRepairReport, type MessageRepairResult, type NewlineStyle, type OutputLineGuard, type RequestTokenBreakdown, type SafeParseResult, type ToolOutputSerializerOptions, type UnifiedDiffOptions, type ValidationError, type ValidationResult, assertNever, atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, computeMessageTokens, createToolOutputSerializer, deepMerge, detectNewlineStyle, ensureDir, estimateMessageTokens, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, formatTodosList, getCalibrationState, getTermSize, isInteractive, isPrimitiveArray, isStdinTTY, isStdoutTTY, matchAny, matchGlob, mergeCustomModelDefs, mergeModelsPayload, normalizeToLf, onResize, recordActualUsage, repairToolUseAdjacency, resetCalibration, safeParse, safeStringify, sanitizeJsonString, setOutputLineGuard, setRawMode, sleep, stripAnsi, toStyle, truncate, unifiedDiff, validateAgainstSchema, withFileLock, writeErr, writeOut };
+/**
+ * Shared IP-address guards for SSRF protection.
+ *
+ * Exported so `fetch.ts` (tools), `web-search/index.ts` (plugins), and any
+ * other package that needs to validate IPs can all consume the same logic.
+ * Any future additions (e.g. extra CIDR blocks) need only be made here.
+ */
+/**
+ * True if `addr` is in a private / loopback / link-local / reserved / CGNAT /
+ * multicast range.  `net.isIP` is called by the caller first so `addr` is
+ * guaranteed to be a canonical dotted-quad at this point.
+ */
+declare function isPrivateIPv4(addr: string): boolean;
+/**
+ * True if `raw` (an IPv6 literal, already lowercased) is loopback / unique-local /
+ * link-local / unspecified / IPv4-mapped-private.
+ */
+declare function isPrivateIPv6(raw: string): boolean;
+/**
+ * Expand an IPv6 string into exactly 8 16-bit numbers.  Handles `::` compression.
+ * Returns null on malformed input — caller should treat that as "block".
+ */
+declare function expandIPv6(addr: string): number[] | null;
+/**
+ * Convenience: throw if `hostname` resolves to a private / loopback IP.
+ * Use as a pre-flight check before opening a socket.
+ *
+ * ⚠️  This is not sufficient alone — connections must also use a pinned
+ * dispatcher (so the OS re-uses the already-resolved address) or the same
+ * check must be applied after every redirect hop.  See `guardedLookup` in
+ * `fetch.ts` for the connection-level enforcement.
+ */
+declare function assertNotPrivateHost(hostname: string): Promise<void>;
+
+/**
+ * `dispatcher-types.d.ts` — Unify `https.Agent` and `undici.Dispatcher` types.
+ *
+ * Problem: `https.Agent` (Node.js built-in) and `undici.Dispatcher` implement the
+ * same interface at runtime — `fetch`'s `RequestInit.dispatcher` accepts anything
+ * with a `dispatch(req, opts)` method. However, TypeScript's type definitions
+ * treat them as unrelated types because they come from different `@types/*` packages
+ * (or undici@7 bundles its own Dispatcher type that conflicts with @types/node's
+ * copy of the same concept via undici-types).
+ *
+ * Solution: This module augments the global `RequestInit` type so that
+ * `https.Agent` is accepted as a valid `dispatcher` value without a cast.
+ *
+ * Usage:
+ *   import '@wrongstack/core/utils/dispatcher-types';
+ *   const agent = new https.Agent({ rejectUnauthorized: false });
+ *   fetch(url, { dispatcher: agent }); // ✅ no cast needed
+ *
+ * Alternatively, use `as HttpsAgentAsDispatcher` to silence any remaining
+ * conflicts at the call site.
+ *
+ * Verified at runtime: `https.Agent` has a `dispatch(req, opts)` method and
+ * is callable by the built-in fetch implementation — this shim is a type-level
+ * correction only, not a runtime polyfill.
+ */
+
+
+
+/**
+ * Marker type: a value that fetch's `RequestInit.dispatcher` accepts at runtime.
+ * Both `https.Agent` and `undici.Dispatcher` satisfy this structural interface.
+ */
+type HttpDispatcher = Pick<Dispatcher, 'dispatch'>;
+
+/**
+ * Augment `RequestInit` so that `https.Agent` is a valid dispatcher type.
+ * Without this, TypeScript rejects `https.Agent` for `dispatcher` because the
+ * two agent types are not structurally compatible in the installed @types set.
+ */
+declare global {
+  interface RequestInit {
+    /**
+     * Accepts `https.Agent` in addition to `undici.Dispatcher`.
+     * Runtime type-check is performed by Node.js / undici — this declaration
+     * only tells TypeScript the same thing.
+     */
+    dispatcher?: HttpDispatcher | undefined;
+  }
+}
+
+/**
+ * Use this cast at call sites where `https.Agent` must be passed to a function
+ * typed for `undici.Dispatcher`. Documents the trust boundary: the cast is safe
+ * because both types share a `dispatch(req, opts)` method at runtime.
+ *
+ * @example
+ * import type { HttpsAgentAsDispatcher } from '@wrongstack/core';
+ * const agent = new https.Agent({ rejectUnauthorized: false });
+ * fetch(url, { dispatcher: agent as HttpsAgentAsDispatcher });
+ */
+type HttpsAgentAsDispatcher = https.Agent;
+
+export { type AtomicWriteOptions, type BuildChildEnvOptions, type CompileFail, type CompileResult, type DeepMergeOptions, FORBIDDEN_PROTO_KEYS, type FileLockOptions, type HttpDispatcher, type HttpsAgentAsDispatcher, type MessageRepairReport, type MessageRepairResult, type NewlineStyle, type OutputLineGuard, type RequestTokenBreakdown, type SafeParseResult, type ToolOutputSerializerOptions, type UnifiedDiffOptions, type ValidationError, type ValidationResult, assertNever, assertNotPrivateHost, atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, computeMessageTokens, createToolOutputSerializer, deepMerge, detectNewlineStyle, ensureDir, estimateMessageTokens, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, expandIPv6, formatTodosList, getCalibrationState, getTermSize, isInteractive, isPrimitiveArray, isPrivateIPv4, isPrivateIPv6, isStdinTTY, isStdoutTTY, matchAny, matchGlob, mergeCustomModelDefs, mergeModelsPayload, normalizeToLf, onResize, recordActualUsage, repairToolUseAdjacency, resetCalibration, safeParse, safeStringify, sanitizeJsonString, setOutputLineGuard, setRawMode, sleep, stripAnsi, toStyle, truncate, unifiedDiff, validateAgainstSchema, withFileLock, writeErr, writeOut };

package/dist/utils/index.js

@@ -3,6 +3,8 @@ import * as fs from 'fs/promises';
 import * as path2 from 'path';
 import { isAbsolute, resolve } from 'path';
 import * as os from 'os';
+import * as dns from 'dns/promises';
+import * as net from 'net';
 
 // src/utils/atomic-write.ts
 async function atomicWrite(targetPath, content, opts = {}) {
@@ -1004,12 +1006,15 @@ function getCachedEstimate(key, compute) {
   const existing = ESTIMATE_CACHE.get(key);
   if (existing !== void 0) return existing;
   if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
-    const keys = [...ESTIMATE_CACHE.keys()];
-    for (let i = 0; i < Math.floor(ESTIMATE_CACHE_MAX_SIZE / 4); i++) {
-      ESTIMATE_CACHE.delete(expectDefined(keys[i]));
+    let evicted = 0;
+    const maxEvict = Math.floor(ESTIMATE_CACHE_MAX_SIZE / 4);
+    for (const k of ESTIMATE_CACHE.keys()) {
+      if (evicted >= maxEvict) break;
+      ESTIMATE_CACHE.delete(k);
+      evicted++;
     }
   }
-  const estimate = compute();
+  const estimate = compute(key);
   ESTIMATE_CACHE.set(key, estimate);
   return estimate;
 }
@@ -1018,13 +1023,11 @@ function estimateToolInputTokens(input) {
   if (input === null || typeof input !== "object") {
     return RoughTokenEstimate(String(input));
   }
-  const key = JSON.stringify(input);
-  return getCachedEstimate(key, () => RoughTokenEstimate(key));
+  return getCachedEstimate(JSON.stringify(input), (key) => RoughTokenEstimate(key));
 }
 function estimateToolResultTokens(content) {
   if (typeof content === "string") return RoughTokenEstimate(content);
-  const key = JSON.stringify(content);
-  return getCachedEstimate(key, () => RoughTokenEstimate(key));
+  return getCachedEstimate(JSON.stringify(content), (key) => RoughTokenEstimate(key));
 }
 function estimateTextTokens(text) {
   return RoughTokenEstimate(text);
@@ -1660,7 +1663,96 @@ function mergeCustomModelDefs(providerCustomModels, configModels) {
   if (Object.keys(out).length === 0) return void 0;
   return out;
 }
+function isPrivateIPv4(addr) {
+  const parts = addr.split(".").map((p) => Number.parseInt(p, 10));
+  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255)) {
+    return true;
+  }
+  const [a, b, c] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function isPrivateIPv6(raw) {
+  const lower = raw.toLowerCase();
+  if (lower === "::" || lower === "::1") return true;
+  const groups = expandIPv6(lower);
+  if (!groups) return true;
+  if (groups[0] === 0 && groups[1] === 0 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 65535) {
+    const a = (groups[6] ?? 0) >> 8;
+    const b = (groups[6] ?? 0) & 255;
+    const c = (groups[7] ?? 0) >> 8;
+    const d = (groups[7] ?? 0) & 255;
+    return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+  }
+  const high = groups[0] ?? 0;
+  if ((high & 65024) === 64512) return true;
+  if ((high & 65472) === 65152) return true;
+  if ((high & 65280) === 65280) return true;
+  return false;
+}
+function expandIPv6(addr) {
+  const parts = addr.split("::");
+  if (parts.length > 2) return null;
+  const parseGroups = (s) => {
+    if (s === "") return [];
+    const out = [];
+    for (const g of s.split(":")) {
+      if (g.length === 0 || g.length > 4) return null;
+      const n = Number.parseInt(g, 16);
+      if (Number.isNaN(n) || n < 0 || n > 65535) return null;
+      out.push(n);
+    }
+    return out;
+  };
+  if (parts.length === 1) {
+    const groups = parseGroups(parts[0] ?? "");
+    if (!groups || groups.length !== 8) return null;
+    return groups;
+  }
+  const head = parseGroups(parts[0] ?? "");
+  const tail = parseGroups(parts[1] ?? "");
+  if (!head || !tail) return null;
+  const fill = 8 - head.length - tail.length;
+  if (fill < 0) return null;
+  return [...head, ...new Array(fill).fill(0), ...tail];
+}
+async function assertNotPrivateHost(hostname) {
+  const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  if (host === "localhost" || host.endsWith(".localhost")) {
+    throw new Error("fetch: blocked localhost target");
+  }
+  const ipVersion = net.isIP(host);
+  if (ipVersion === 4) {
+    if (isPrivateIPv4(host)) {
+      throw new Error(`fetch: blocked private/loopback address "${host}"`);
+    }
+  } else if (ipVersion === 6) {
+    if (isPrivateIPv6(host)) {
+      throw new Error(`fetch: blocked private/loopback address "${host}"`);
+    }
+  } else {
+    try {
+      const records = await dns.lookup(host, { all: true });
+      for (const r of records) {
+        const bad = r.family === 4 ? isPrivateIPv4(r.address) : isPrivateIPv6(r.address);
+        if (bad) {
+          throw new Error(`fetch: resolved to private address ${r.address}`);
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("fetch:")) throw err;
+    }
+  }
+}
 
-export { FORBIDDEN_PROTO_KEYS, assertNever, atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, computeMessageTokens, computeTaskItemProgress, createToolOutputSerializer, deepMerge, detectNewlineStyle, ensureDir, estimateMessageTokens, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, expectDefined, formatTaskList, formatTaskProgress, formatTodosList, getCalibrationState, getTermSize, isInteractive, isPrimitiveArray, isStdinTTY, isStdoutTTY, matchAny, matchGlob, mergeCustomModelDefs, mergeModelsPayload, normalizeToLf, onResize, projectHash, projectSlug, recordActualUsage, repairToolUseAdjacency, resetCalibration, resolveWstackPaths, safeParse, safeStringify, sanitizeJsonString, setOutputLineGuard, setRawMode, sleep, stripAnsi, toStyle, truncate, unifiedDiff, validateAgainstSchema, withFileLock, writeErr, writeOut, wstackGlobalRoot };
+export { FORBIDDEN_PROTO_KEYS, assertNever, assertNotPrivateHost, atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, computeMessageTokens, computeTaskItemProgress, createToolOutputSerializer, deepMerge, detectNewlineStyle, ensureDir, estimateMessageTokens, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, expandIPv6, expectDefined, formatTaskList, formatTaskProgress, formatTodosList, getCalibrationState, getTermSize, isInteractive, isPrimitiveArray, isPrivateIPv4, isPrivateIPv6, isStdinTTY, isStdoutTTY, matchAny, matchGlob, mergeCustomModelDefs, mergeModelsPayload, normalizeToLf, onResize, projectHash, projectSlug, recordActualUsage, repairToolUseAdjacency, resetCalibration, resolveWstackPaths, safeParse, safeStringify, sanitizeJsonString, setOutputLineGuard, setRawMode, sleep, stripAnsi, toStyle, truncate, unifiedDiff, validateAgainstSchema, withFileLock, writeErr, writeOut, wstackGlobalRoot };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map