@agent-inspect/mcp-server 6.31.2 → 6.31.4

package/dist/cli.cjs

@@ -46,6 +46,80 @@ function extractCorrelationMetadata(record) {
   }
   return found ? out : void 0;
 }
+
+// packages/core/src/safety/sensitive-key.ts
+function keyHasExplicitSeparator(value) {
+  return /[_\-.]/.test(value);
+}
+function normalizeSensitiveKey(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+var NON_CREDENTIAL_TOKEN_CONFIG_KEYS = new Set(
+  [
+    "tokens",
+    "max_tokens",
+    "min_tokens",
+    "ls_max_tokens",
+    "token_count",
+    "token_limit",
+    "token_budget",
+    "input_tokens",
+    "output_tokens",
+    "total_tokens",
+    "cached_tokens",
+    "prompt_tokens",
+    "completion_tokens"
+  ].map(normalizeSensitiveKey)
+);
+var DEFAULT_CREDENTIAL_SENSITIVE_KEYS = [
+  "authorization",
+  "cookie",
+  "token",
+  "access_token",
+  "accesstoken",
+  "auth_token",
+  "authtoken",
+  "refresh_token",
+  "refreshtoken",
+  "id_token",
+  "idtoken",
+  "bearer_token",
+  "bearertoken",
+  "api_token",
+  "apitoken",
+  "apikey",
+  "api_key",
+  "password",
+  "secret",
+  "email"
+];
+function isTokenCredentialKey(normalized) {
+  if (NON_CREDENTIAL_TOKEN_CONFIG_KEYS.has(normalized)) return false;
+  if (normalized === "token") return true;
+  if (normalized.endsWith("tokens")) return false;
+  return normalized.endsWith("token");
+}
+function isCredentialSensitiveKey(key, sensitiveKeys = DEFAULT_CREDENTIAL_SENSITIVE_KEYS) {
+  if (!key) return false;
+  const normalized = normalizeSensitiveKey(key);
+  if (!normalized) return false;
+  if (NON_CREDENTIAL_TOKEN_CONFIG_KEYS.has(normalized)) return false;
+  const allowPrefixCompound = keyHasExplicitSeparator(key);
+  for (const sensitive of sensitiveKeys) {
+    const s = normalizeSensitiveKey(sensitive);
+    if (!s) continue;
+    if (s === "token") {
+      if (isTokenCredentialKey(normalized)) return true;
+      continue;
+    }
+    if (normalized === s) return true;
+    if (normalized.endsWith(`_${s}`)) return true;
+    if (allowPrefixCompound && normalized.startsWith(`${s}_`)) return true;
+  }
+  return false;
+}
+
+// packages/core/src/logs/redactor.ts
 var DEFAULT_REDACT_KEYS = [
   "authorization",
   "cookie",
@@ -69,7 +143,7 @@ function compileRules(rules, extraKeys) {
   const out = /* @__PURE__ */ new Map();
   const set = (r) => {
     const k = toKey(r.key);
-    out.set(k, { ...r, key: k });
+    out.set(k, { ...r, key: k, raw: r.raw ?? r.key });
   };
   for (const k of DEFAULT_REDACT_KEYS) {
     set({ key: k, strategy: "full" });
@@ -98,9 +172,13 @@ var Redactor = class {
   constructor(options) {
     this.#rules = compileRules(options?.rules, options?.extraKeys);
   }
+  /** Field names this redactor treats as sensitive, for value-level helpers. */
+  get sensitiveKeys() {
+    return this.#rules.map((rule) => rule.raw ?? rule.key);
+  }
   redactValue(key, value) {
     const k = toKey(key);
-    const rule = this.#rules.find((r) => r.key === k);
+    const rule = this.#rules.find((r) => r.key === k) ?? this.#rules.find((r) => isCredentialSensitiveKey(key, [r.raw ?? r.key]));
     if (!rule) {
       return this.#redactNested(value);
     }
@@ -139,6 +217,30 @@ var Redactor = class {
   }
 };
 
+// packages/core/src/safety/credential-value-patterns.ts
+var KEY_VALUE_SECRET_PATTERN = /\b(?:api[_-]?key|internal[_-]?token|access[_-]?token|auth[_-]?token|password|secret|token)=(?!\[(?:REDACTED(?::[^\]]*)?|HASH:[0-9a-f]{8})\](?![^\s"'\\&#?;/]))([^\s"'\\]{8,})/i;
+var HIGH_CONFIDENCE_CREDENTIAL_PATTERNS = [
+  /^(?:basic|bearer|digest|apikey)\s+[a-z0-9._~+/=-]+$/i,
+  /\bbearer\s+[a-z0-9._~+/=-]{12,}\b/i,
+  /\b[a-z0-9_.-]+=[^;\s]+(?:;\s*[a-z0-9_.-]+=[^;\s]+)+/i,
+  /\beyJ[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9_-]{8,}\b/,
+  /\b(?:sk-(?:proj-)?[a-zA-Z0-9_-]{16,}|sk-ant-[a-zA-Z0-9_-]{16,}|AIza[0-9A-Za-z_-]{20,})\b/,
+  /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b/,
+  /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*-----END [A-Z ]*PRIVATE KEY-----/,
+  KEY_VALUE_SECRET_PATTERN
+];
+function stringContainsHighConfidenceCredential(value) {
+  for (const pattern of HIGH_CONFIDENCE_CREDENTIAL_PATTERNS) {
+    pattern.lastIndex = 0;
+    if (pattern.test(value)) {
+      pattern.lastIndex = 0;
+      return true;
+    }
+  }
+  return false;
+}
+
 // packages/core/src/redaction-profiles.ts
 var SHARE_PROFILE_EXTRA_KEYS = [
   "userEmail",
@@ -2309,78 +2411,6 @@ function formatProgrammaticDiagnostic(code, detail) {
   return `${code}: ${summary} Remediation: ${spec.remediation}`;
 }
 
-// packages/core/src/safety/sensitive-key.ts
-function keyHasExplicitSeparator(value) {
-  return /[_\-.]/.test(value);
-}
-function normalizeSensitiveKey(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-}
-var NON_CREDENTIAL_TOKEN_CONFIG_KEYS = new Set(
-  [
-    "tokens",
-    "max_tokens",
-    "min_tokens",
-    "ls_max_tokens",
-    "token_count",
-    "token_limit",
-    "token_budget",
-    "input_tokens",
-    "output_tokens",
-    "total_tokens",
-    "cached_tokens",
-    "prompt_tokens",
-    "completion_tokens"
-  ].map(normalizeSensitiveKey)
-);
-var DEFAULT_CREDENTIAL_SENSITIVE_KEYS = [
-  "authorization",
-  "cookie",
-  "token",
-  "access_token",
-  "accesstoken",
-  "auth_token",
-  "authtoken",
-  "refresh_token",
-  "refreshtoken",
-  "id_token",
-  "idtoken",
-  "bearer_token",
-  "bearertoken",
-  "api_token",
-  "apitoken",
-  "apikey",
-  "api_key",
-  "password",
-  "secret",
-  "email"
-];
-function isTokenCredentialKey(normalized) {
-  if (NON_CREDENTIAL_TOKEN_CONFIG_KEYS.has(normalized)) return false;
-  if (normalized === "token") return true;
-  if (normalized.endsWith("tokens")) return false;
-  return normalized.endsWith("token");
-}
-function isCredentialSensitiveKey(key, sensitiveKeys = DEFAULT_CREDENTIAL_SENSITIVE_KEYS) {
-  if (!key) return false;
-  const normalized = normalizeSensitiveKey(key);
-  if (!normalized) return false;
-  if (NON_CREDENTIAL_TOKEN_CONFIG_KEYS.has(normalized)) return false;
-  const allowPrefixCompound = keyHasExplicitSeparator(key);
-  for (const sensitive of sensitiveKeys) {
-    const s = normalizeSensitiveKey(sensitive);
-    if (!s) continue;
-    if (s === "token") {
-      if (isTokenCredentialKey(normalized)) return true;
-      continue;
-    }
-    if (normalized === s) return true;
-    if (normalized.endsWith(`_${s}`)) return true;
-    if (allowPrefixCompound && normalized.startsWith(`${s}_`)) return true;
-  }
-  return false;
-}
-
 // packages/core/src/checks/logical-events.ts
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3331,7 +3361,7 @@ var DEFAULT_SECRET_PATTERNS = [
   // Keep in sync with packages/redact/src/key-value-secret.ts (KEY_VALUE_SECRET_PATTERN_SOURCE).
   {
     id: "key-value-secret",
-    pattern: /\b(?:api[_-]?key|internal[_-]?token|access[_-]?token|auth[_-]?token|password|secret|token)=([^\s"'\\]{8,})/i
+    pattern: /\b(?:api[_-]?key|internal[_-]?token|access[_-]?token|auth[_-]?token|password|secret|token)=(?!\[(?:REDACTED(?::[^\]]*)?|HASH:[0-9a-f]{8})\](?![^\s"'\\&#?;/]))([^\s"'\\]{8,})/i
   }
 ];
 function compareStrings(a, b) {
@@ -6672,6 +6702,99 @@ function openTrace(input, options = {}) {
 // packages/core/src/exporters/types.ts
 var EXPORT_PAYLOAD_VERSION = "0.1.2";
 
+// packages/core/src/safety/url-redaction.ts
+var HTTP_URL = /^https?:\/\/[^\s]+$/i;
+var UUID_SEGMENT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var HEX_SEGMENT = /^[0-9a-f]{12,}$/i;
+var NUMERIC_SEGMENT = /^\d{5,}$/;
+var OPAQUE_SEGMENT = /^[A-Za-z0-9_-]{20,}$/;
+function looksLikeHttpUrl(value) {
+  return HTTP_URL.test(value.trim());
+}
+function parseHttpUrl(value) {
+  try {
+    const url = new URL(value.trim());
+    return url.protocol === "http:" || url.protocol === "https:" ? url : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isIdentifierSegment(segment) {
+  if (UUID_SEGMENT.test(segment)) return true;
+  if (HEX_SEGMENT.test(segment)) return true;
+  if (NUMERIC_SEGMENT.test(segment)) return true;
+  return OPAQUE_SEGMENT.test(segment) && /\d/.test(segment) && /[A-Za-z]/.test(segment);
+}
+function decodeParam(value) {
+  try {
+    return decodeURIComponent(value.replace(/\+/g, " "));
+  } catch {
+    return value;
+  }
+}
+function redactParams(raw, options, replacement) {
+  let redacted = false;
+  const parts = raw.split("&").map((part) => {
+    if (part.length === 0) return part;
+    const separator = part.indexOf("=");
+    if (separator < 0) return part;
+    const rawKey = part.slice(0, separator);
+    const rawValue = part.slice(separator + 1);
+    const key = decodeParam(rawKey);
+    const value = decodeParam(rawValue);
+    if (isCredentialSensitiveKey(key, options.sensitiveKeys) || options.isSensitiveValue(value)) {
+      redacted = true;
+      return `${rawKey}=${replacement}`;
+    }
+    return part;
+  });
+  return { value: parts.join("&"), redacted };
+}
+function redactUrlString(value, options) {
+  const unchanged = {
+    value,
+    credentialRedacted: false,
+    identifiersMasked: false
+  };
+  if (!looksLikeHttpUrl(value)) return unchanged;
+  const url = parseHttpUrl(value);
+  if (!url) return unchanged;
+  const replacement = options.replacement ?? "[REDACTED]";
+  const idPlaceholder = options.idPlaceholder ?? "[id]";
+  let credentialRedacted = url.username.length > 0 || url.password.length > 0;
+  let identifiersMasked = false;
+  let pathname = url.pathname;
+  if (options.maskPathIds === true) {
+    pathname = url.pathname.split("/").map((segment) => {
+      if (segment.length === 0 || !isIdentifierSegment(decodeParam(segment))) {
+        return segment;
+      }
+      identifiersMasked = true;
+      return idPlaceholder;
+    }).join("/");
+  }
+  let search = "";
+  if (url.search.length > 1) {
+    const params = redactParams(url.search.slice(1), options, replacement);
+    if (params.redacted) credentialRedacted = true;
+    search = `?${params.value}`;
+  } else if (url.search.length === 1) {
+    search = "?";
+  }
+  let hash = url.hash;
+  if (url.hash.includes("=")) {
+    const params = redactParams(url.hash.slice(1), options, replacement);
+    if (params.redacted) credentialRedacted = true;
+    hash = `#${params.value}`;
+  }
+  if (!credentialRedacted && !identifiersMasked) return unchanged;
+  return {
+    value: `${url.protocol}//${url.host}${pathname}${search}${hash}`,
+    credentialRedacted,
+    identifiersMasked
+  };
+}
+
 // packages/core/src/exporters/redact-export.ts
 function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -6689,21 +6812,34 @@ function deepClone(value) {
   }
   return out;
 }
-function boundAttributeValues(record, maxMetadataValueLength, maxPreviewLength, seen, depth) {
+function boundAttributeValues(record, sensitiveKeys, maxMetadataValueLength, maxPreviewLength, seen, depth) {
   if (depth > 32) {
     return { truncated: true, reason: "maxDepth" };
   }
   const out = {};
   for (const [key, value] of Object.entries(record)) {
-    out[key] = boundValue(value, key, maxMetadataValueLength, maxPreviewLength, seen, depth);
+    out[key] = boundValue(
+      value,
+      key,
+      sensitiveKeys,
+      maxMetadataValueLength,
+      maxPreviewLength,
+      seen,
+      depth
+    );
   }
   return out;
 }
-function boundValue(value, key, maxMetadataValueLength, maxPreviewLength, seen, depth) {
+function boundValue(value, key, sensitiveKeys, maxMetadataValueLength, maxPreviewLength, seen, depth) {
   if (value === null || typeof value !== "object") {
     if (typeof value === "string") {
+      const rewritten = redactUrlString(value, {
+        sensitiveKeys,
+        isSensitiveValue: stringContainsHighConfidenceCredential,
+        maskPathIds: true
+      }).value;
       return truncateStringForProfile(
-        value,
+        stringContainsHighConfidenceCredential(rewritten) ? "[REDACTED]" : rewritten,
         key,
         maxMetadataValueLength,
         maxPreviewLength
@@ -6718,6 +6854,7 @@ function boundValue(value, key, maxMetadataValueLength, maxPreviewLength, seen,
       (item, index) => boundValue(
         item,
         String(index),
+        sensitiveKeys,
         maxMetadataValueLength,
         maxPreviewLength,
         seen,
@@ -6727,6 +6864,7 @@ function boundValue(value, key, maxMetadataValueLength, maxPreviewLength, seen,
   }
   return boundAttributeValues(
     value,
+    sensitiveKeys,
     maxMetadataValueLength,
     maxPreviewLength,
     seen,
@@ -6741,6 +6879,7 @@ function redactEventAttributes(attrs2, redactor, maxMetadataValueLength, maxPrev
   const seen = /* @__PURE__ */ new WeakSet();
   const bounded = boundAttributeValues(
     redacted,
+    [...DEFAULT_REDACT_KEYS, ...redactor.sensitiveKeys],
     maxMetadataValueLength,
     maxPreviewLength,
     seen,
@@ -7194,6 +7333,11 @@ function exportOpenInference(tree, options) {
 function hexFrom2(seed, byteLen) {
   return crypto__default.default.createHash("sha256").update(seed, "utf8").digest("hex").slice(0, byteLen * 2);
 }
+function unixNano2(ms) {
+  const whole = Math.trunc(ms);
+  const fractionNs = Math.round((ms - whole) * 1e6);
+  return BigInt(whole) * 1000000n + BigInt(fractionNs);
+}
 function stringAttr2(key, value) {
   return { key, value: { stringValue: value } };
 }
@@ -7227,10 +7371,10 @@ function exportOtlpJson(tree, options) {
     const ev = n.event;
     const spanId = hexFrom2(`${tree.runId}:${ev.eventId}`, 8);
     const parentSpanId = ev.parentId ? hexFrom2(`${tree.runId}:${ev.parentId}`, 8) : void 0;
-    const startNs = String(Math.round(ev.timestamp * 1e6));
+    const startNs = String(unixNano2(ev.timestamp));
     let endNs;
     if (ev.durationMs !== void 0 && Number.isFinite(ev.durationMs)) {
-      endNs = String(Math.round(ev.timestamp * 1e6 + ev.durationMs * 1e6));
+      endNs = String(unixNano2(ev.timestamp) + unixNano2(ev.durationMs));
     }
     const attrs2 = [
       stringAttr2("agent_inspect.kind", ev.kind),
@@ -7406,14 +7550,107 @@ function isCredentialSensitiveKey2(key, sensitiveKeys) {
 }
 
 // packages/redact/src/key-value-secret.ts
-var KEY_VALUE_SECRET_PATTERN_SOURCE = String.raw`\b(?:api[_-]?key|internal[_-]?token|access[_-]?token|auth[_-]?token|password|secret|token)=([^\s"'\\]{8,})`;
-var KEY_VALUE_SECRET_PATTERN = new RegExp(
+var KEY_VALUE_SECRET_PATTERN_SOURCE = String.raw`\b(?:api[_-]?key|internal[_-]?token|access[_-]?token|auth[_-]?token|password|secret|token)=(?!\[(?:REDACTED(?::[^\]]*)?|HASH:[0-9a-f]{8})\](?![^\s"'\\&#?;/]))([^\s"'\\]{8,})`;
+var KEY_VALUE_SECRET_PATTERN2 = new RegExp(
   KEY_VALUE_SECRET_PATTERN_SOURCE,
   "i"
 );
 function valueContainsKeyValueSecret(value) {
-  KEY_VALUE_SECRET_PATTERN.lastIndex = 0;
-  return KEY_VALUE_SECRET_PATTERN.test(value);
+  KEY_VALUE_SECRET_PATTERN2.lastIndex = 0;
+  return KEY_VALUE_SECRET_PATTERN2.test(value);
+}
+
+// packages/redact/src/url-redaction.ts
+var HTTP_URL2 = /^https?:\/\/[^\s]+$/i;
+var UUID_SEGMENT2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var HEX_SEGMENT2 = /^[0-9a-f]{12,}$/i;
+var NUMERIC_SEGMENT2 = /^\d{5,}$/;
+var OPAQUE_SEGMENT2 = /^[A-Za-z0-9_-]{20,}$/;
+function looksLikeHttpUrl2(value) {
+  return HTTP_URL2.test(value.trim());
+}
+function parseHttpUrl2(value) {
+  try {
+    const url = new URL(value.trim());
+    return url.protocol === "http:" || url.protocol === "https:" ? url : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isIdentifierSegment2(segment) {
+  if (UUID_SEGMENT2.test(segment)) return true;
+  if (HEX_SEGMENT2.test(segment)) return true;
+  if (NUMERIC_SEGMENT2.test(segment)) return true;
+  return OPAQUE_SEGMENT2.test(segment) && /\d/.test(segment) && /[A-Za-z]/.test(segment);
+}
+function decodeParam2(value) {
+  try {
+    return decodeURIComponent(value.replace(/\+/g, " "));
+  } catch {
+    return value;
+  }
+}
+function redactParams2(raw, options, replacement) {
+  let redacted = false;
+  const parts = raw.split("&").map((part) => {
+    if (part.length === 0) return part;
+    const separator = part.indexOf("=");
+    if (separator < 0) return part;
+    const rawKey = part.slice(0, separator);
+    const rawValue = part.slice(separator + 1);
+    const key = decodeParam2(rawKey);
+    const value = decodeParam2(rawValue);
+    if (isCredentialSensitiveKey2(key, options.sensitiveKeys) || options.isSensitiveValue(value)) {
+      redacted = true;
+      return `${rawKey}=${replacement}`;
+    }
+    return part;
+  });
+  return { value: parts.join("&"), redacted };
+}
+function redactUrlString2(value, options) {
+  const unchanged = {
+    value,
+    credentialRedacted: false,
+    identifiersMasked: false
+  };
+  if (!looksLikeHttpUrl2(value)) return unchanged;
+  const url = parseHttpUrl2(value);
+  if (!url) return unchanged;
+  const replacement = options.replacement ?? "[REDACTED]";
+  const idPlaceholder = options.idPlaceholder ?? "[id]";
+  let credentialRedacted = url.username.length > 0 || url.password.length > 0;
+  let identifiersMasked = false;
+  let pathname = url.pathname;
+  if (options.maskPathIds === true) {
+    pathname = url.pathname.split("/").map((segment) => {
+      if (segment.length === 0 || !isIdentifierSegment2(decodeParam2(segment))) {
+        return segment;
+      }
+      identifiersMasked = true;
+      return idPlaceholder;
+    }).join("/");
+  }
+  let search = "";
+  if (url.search.length > 1) {
+    const params = redactParams2(url.search.slice(1), options, replacement);
+    if (params.redacted) credentialRedacted = true;
+    search = `?${params.value}`;
+  } else if (url.search.length === 1) {
+    search = "?";
+  }
+  let hash = url.hash;
+  if (url.hash.includes("=")) {
+    const params = redactParams2(url.hash.slice(1), options, replacement);
+    if (params.redacted) credentialRedacted = true;
+    hash = `#${params.value}`;
+  }
+  if (!credentialRedacted && !identifiersMasked) return unchanged;
+  return {
+    value: `${url.protocol}//${url.host}${pathname}${search}${hash}`,
+    credentialRedacted,
+    identifiersMasked
+  };
 }
 
 // packages/redact/src/index.ts
@@ -7482,7 +7719,9 @@ function findCompiledKeyRule(key, rules) {
   const exact = toKey2(key);
   const direct = rules.find((candidate) => candidate.key === exact);
   if (direct) return direct;
-  return rules.find((candidate) => isCredentialSensitiveKey2(key, [candidate.key]));
+  return rules.find(
+    (candidate) => isCredentialSensitiveKey2(key, [candidate.raw ?? candidate.key])
+  );
 }
 function stableHash2(value) {
   const hash = crypto__default.default.createHash("sha256").update(value, "utf8").digest("hex");
@@ -7681,7 +7920,7 @@ function compileRules2(rules, extraKeys) {
   const out = /* @__PURE__ */ new Map();
   const set = (rule) => {
     const key = toKey2(rule.key);
-    out.set(key, { ...rule, key });
+    out.set(key, { ...rule, key, raw: rule.raw ?? rule.key });
   };
   for (const key of DEFAULT_REDACT_KEYS2) {
     set({ key, strategy: "full" });
@@ -7760,6 +7999,7 @@ function createRedactionProfile(profile = "local") {
 }
 var Redactor2 = class {
   #rules;
+  #sensitiveKeys;
   #detectors;
   #profile;
   #replacement;
@@ -7772,6 +8012,7 @@ var Redactor2 = class {
       ...resolved.extraKeys,
       ...options?.extraKeys ?? []
     ]);
+    this.#sensitiveKeys = this.#rules.map((rule) => rule.raw ?? rule.key);
     this.#detectors = [
       ...builtInDetectorsForProfile(this.#profile),
       ...options?.detectors ?? []
@@ -7805,6 +8046,14 @@ var Redactor2 = class {
   #recordFinding(state, finding) {
     if (this.#collectFindings) state.findings.push(finding);
   }
+  #detect(value, key, path17) {
+    for (const detector of this.#detectors) {
+      for (const detection of detector.detect({ path: path17, key, value })) {
+        if ((detection.action ?? "replace") !== "keep") return { detector, detection };
+      }
+    }
+    return void 0;
+  }
   #redactValue(value, key, path17, depth, state) {
     if (depth > this.#maxDepth) {
       this.#recordFinding(
@@ -7823,6 +8072,43 @@ var Redactor2 = class {
         return applyRule(rule, value, this.#replacement);
       }
     }
+    if (typeof value === "string" && looksLikeHttpUrl2(value)) {
+      const url = redactUrlString2(value, {
+        sensitiveKeys: this.#sensitiveKeys,
+        isSensitiveValue: (candidate) => this.#detect(candidate, key, path17) !== void 0,
+        replacement: this.#replacement,
+        maskPathIds: this.#profile !== "local"
+      });
+      if (url.value !== value) {
+        this.#recordFinding(
+          state,
+          makeFinding(
+            path17,
+            url.credentialRedacted ? "value.urlCredential" : "value.urlIdentifier",
+            "replace",
+            "value",
+            url.credentialRedacted ? "error" : "warning"
+          )
+        );
+        const residual = this.#detect(
+          url.value.split(this.#replacement).join(""),
+          key,
+          path17
+        );
+        if (residual === void 0) return url.value;
+        this.#recordFinding(
+          state,
+          makeFinding(
+            path17,
+            residual.detector.id,
+            "replace",
+            residual.detection.matchKind ?? residual.detector.matchKind ?? "custom",
+            residual.detection.severity ?? residual.detector.severity ?? "warning"
+          )
+        );
+        return this.#replacement;
+      }
+    }
     for (const detector of this.#detectors) {
       const detections = detector.detect({ path: path17, key, value });
       for (const detection of detections) {