@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
628 lines (600 loc) • 29.1 kB
text/typescript
/**
* Deny-by-default sanitization before artifact hashing/writing.
* Never persists prompts, secrets, paths, account IDs, raw URLs, or provider bodies.
*/
import type { ArtifactClass } from "../constants";
import { MAX_SANITIZED_STRING_FIELD } from "../constants";
import { jcsStringify } from "../digest";
import { redactSecretString } from "../../lib/redact";
const FORBIDDEN_KEY = /^(?:authorization|proxy-authorization|cookie|set-cookie|api[-_]?key|x-api-key|token|secret|password|email|prompt|messages|content|body|url|hostname|baseUrl|path|account|alias)$/i;
const SECRETISH = /sk-[a-z0-9]{10,}|credential-canary-[a-z0-9]{10,}|Bearer\s+[A-Za-z0-9._\-]+|ghp_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}/i;
const SECRETISH_GLOBAL = new RegExp(SECRETISH.source, "gi");
export function redactForArtifact(artifactClass: ArtifactClass, payload: unknown): unknown {
if (
artifactClass === "fixture" ||
artifactClass === "scenario_manifest" ||
artifactClass === "suite_manifest" ||
artifactClass === "claim_source_manifest"
) {
// Contract artifacts are already synthetic/canonical. Mutating them would
// invalidate content-addressed digests; reject secret-shaped material instead.
assertNoSecretMaterial(payload, 0);
return payload;
}
return scrubValue(payload, 0);
}
const FORBIDDEN_CONTRACT_KEYS = /^(?:authorization|proxy-authorization|cookie|set-cookie|api[-_]?key|x-api-key|token|secret|password|email|prompt|messages|baseUrl|hostname|account|alias)$/i;
function assertNoSecretMaterial(value: unknown, depth: number): void {
if (depth > 8) {
throw new Error("contract artifact exceeds sanitization inspection depth");
}
if (typeof value === "string") {
if (SECRETISH.test(value)) {
throw new Error("contract artifact contains forbidden secret-shaped material");
}
return;
}
if (Array.isArray(value)) {
for (const item of value) assertNoSecretMaterial(item, depth + 1);
return;
}
if (value && typeof value === "object") {
for (const [key, child] of Object.entries(value as object)) {
if (FORBIDDEN_CONTRACT_KEYS.test(key)) {
throw new Error(`contract artifact forbids key ${key}`);
}
assertNoSecretMaterial(child, depth + 1);
}
}
}
function scrubValue(value: unknown, depth: number): unknown {
if (depth > 8) return "[truncated_depth]";
if (value === null || typeof value === "boolean" || typeof value === "number") return value;
if (typeof value === "string") return scrubString(value);
if (value instanceof Uint8Array) {
const text = new TextDecoder().decode(value);
return new TextEncoder().encode(scrubString(text));
}
if (Array.isArray(value)) {
if (value.length > 256) return value.slice(0, 256).map((v) => scrubValue(v, depth + 1));
return value.map((v) => scrubValue(v, depth + 1));
}
if (typeof value === "object") {
const out: Record<string, unknown> = {};
const keys = Object.keys(value as object).slice(0, 64);
for (const key of keys) {
if (FORBIDDEN_KEY.test(key)) {
out[key] = "[redacted]";
continue;
}
out[key] = scrubValue((value as Record<string, unknown>)[key], depth + 1);
}
return out;
}
return "[unsupported]";
}
/**
* Provider-controlled text can carry network and account identifiers that the
* Compatibility Lab privacy contract forbids persisting. The rules below run in
* a fixed total order; the order is load-bearing and documented in
* `devlog/_fin/260810_release_train_and_triage/040_sec02_remediation.md`:
*
* email before hostname - else the hostname rule eats `example.com` in an address
* MAC before IPv6 - else `01:23:45:67:89:ab` matches as a mangled address
* IPv6 before IPv4 - else `::ffff:192.0.2.128` degrades to `::ffff:[ip]`
* HTTP before other URIs - and the URI rule refuses http(s) so it cannot
* re-match this rule's own `https://[host]/path` output
*
* Every rule replaces a value whole or not at all. A prefix replacement is
* worse than no rule, because the output looks redacted while the tail leaks.
*/
/** Bounded, non-nested. */
const JWT_RE = /\beyJ[A-Za-z0-9_-]{8,512}\.[A-Za-z0-9_-]{8,512}\.[A-Za-z0-9_-]{8,512}\b/g;
// Both patterns end with a lookahead rather than `\b`, because `\b` fires
// between a letter and `-`: `ops@…xn--p1ai` matched only up to the first
// hyphen and left `[email]--p1ai`, and `acct_abcdef-prod` left `[account]-prod`.
// A prefix replacement looks redacted while the tail leaks, which is the one
// thing this module must never do.
// The local part accepts more than an ASCII dot-atom: an internationalized or
// quoted local part is still the account-identifying half of the address, and
// matching only the domain left `用户@[host]` and `"ops"@[host]` behind.
const EMAIL_RE =
/(?:"[^"\n]{1,64}"|[^\s@<>()[\],;:"]{1,64})@[^\s@<>()[\],;:"]{1,255}\.(?:xn--[a-z0-9-]{1,55}|\p{L}{2,24})(?![\w.-])/giu;
// The value run includes hyphens so `acct_abcdef-prod` is consumed whole. A
// `\b`-terminated form matched only `acct_abcdef` and left `-prod` dangling
// after the token, which reads as redacted while leaking the remainder.
const PREFIXED_ACCOUNT_RE = /\b(?:acct|cus|sub|org)[_-][A-Za-z0-9][A-Za-z0-9-]{5,63}(?![\w-])/g;
const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
// `\b` treats `_` as a word character, so it does not fire between `_` and a
// digit: `backend_203.0.113.7_timeout` and `iface_01:23:45:67:89:ab_down` are
// ordinary machine-generated diagnostics that slipped past a `\b` form. These
// use explicit non-identifier boundaries on both sides instead.
// Colon notation is usual on POSIX, hyphen notation on Windows; separators
// must be consistent within one address.
const MAC_RE = /(?<![0-9A-Za-z:-])(?:(?:[0-9A-Fa-f]{2}:){5}|(?:[0-9A-Fa-f]{2}-){5})[0-9A-Fa-f]{2}(?![0-9A-Za-z:-])/g;
const IPV4_RE = /(?<![0-9A-Za-z.])(?:\d{1,3}\.){3}\d{1,3}(?![0-9A-Za-z.])/g;
// The final label is either an ordinary alphabetic TLD or a punycode one.
// Allowing hyphens and digits in every final label was too broad: it ate
// ordinary diagnostic tokens such as `foo.bar-baz` and `metric.p95`, which
// costs exactly the evidence quality the Lab exists to capture.
// A trailing `-` or word character after the TLD means this was never a
// hostname (`foo.bar-baz`), so the lookahead refuses the match. A trailing
// `.` is allowed and consumed: it is FQDN root notation and equally ordinary
// sentence punctuation, and forbidding it let `api.example.com.` through
// untouched.
//
// The leading `(?<![\w.-])` matters just as much: without it the engine
// backtracks to a later starting label and redacts a prefix, turning
// `provider.metric.p95` into `[host].p95` — evidence destruction dressed up
// as a redaction.
// An OPTIONAL trailing dot does not work: the engine simply skips it and takes
// a shorter match, so `provider.metric.p95` matched `provider.metric` and left
// `[host].p95`. The terminator is therefore mandatory and expressed as a
// single alternation — either the token ends cleanly, or it ends with an FQDN
// root dot that is itself followed by nothing label-shaped.
const HOSTNAME_RE = /(?<![\w.-])(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.){1,8}(?:xn--[a-z0-9-]{1,55}|[a-z]{2,24})(?:\.(?![\w-])|(?![\w.-]))/gi;
// The value is scanned to its delimiter, not to a word boundary: `\b` stops at
// the first `.` in `db_prod.internal`, which left `[host].internal` — a partial
// redaction that still names the host.
// `db.prod-1` and `api.us-east-1` are indistinguishable from ordinary dotted
// diagnostics by shape alone — a numeric or hyphenated final label is both a
// legitimate internal hostname and a legitimate metric or version namespace.
// Shape cannot decide it, so context does: these forms are redacted only when
// an unambiguous network marker introduces them. Outside such a marker they
// survive, and that is a recorded limit rather than an oversight.
//
// The marker grammar accepts the separators these messages actually use —
// whitespace, `=`, `:`, and JSON quoting — and the CANDIDATE IS VALIDATED
// before replacement. Accepting any following token turned
// `ETIMEDOUT after 30 seconds` into `ETIMEDOUT [host] 30 seconds`: a redaction
// that destroys the diagnostic and hides nothing.
// Markers differ in confidence, and treating them alike cost accuracy both
// ways. STRONG markers are resolver/socket errors and `host=`: the argument
// position is a host by construction, so a bare `redis` or `localhost` counts
// there while the prose that can follow a marker survives.
// WEAK markers appear in ordinary prose (`upstream provider.metric.p95
// exceeded`), so they only redact a candidate that is already host-shaped.
const STRONG_HOST_CONTEXT_RE =
/\b(?:ENOTFOUND|EAI_AGAIN|ECONNREFUSED|ETIMEDOUT|EHOSTUNREACH|dial\s+(?:tcp|udp)|connect(?:ing)?\s+to|host)["']?\s*[\s=:]\s*["']?((?:[A-Za-z0-9_.-]{1,255}[\s:]{1,3}){0,3}[A-Za-z0-9_.-]{1,255})/gi;
const WEAK_HOST_CONTEXT_RE =
/\b(?:upstream)["']?\s*[\s=:]\s*["']?([A-Za-z0-9_.-]{1,255})/gi;
/**
* A dotted run of plain alphabetic words, or the conventional
* `<name>.metric.p<digits>` shape, reads as a namespace rather than a host.
* Other digit-suffixed labels are host-shaped and must not receive this weak
* marker exemption. Under a STRONG marker the marker always decides.
*/
const DOTTED_NAMESPACE_RE = /^(?:[a-z]+(?:\.[a-z]+)+|[a-z]+(?:\.[a-z]+)*\.metric\.p[0-9]+)$/i;
/**
* Does this token look like a host rather than an English word?
*
* Even a strong marker does not guarantee the very next token is the
* destination: Go emits `dial tcp: lookup db.prod-1: no such host`, and errno
* codes are routinely followed by prose (`ETIMEDOUT request after 30s`).
* Replacing whatever follows destroyed the helper word and left the real host
* in place — the worst of both outcomes.
*
* A stopword list would repeat the delimiter-enumeration mistake, so the
* candidate is validated instead. A token qualifies when it carries host
* punctuation (dot, hyphen, underscore, digit) or is a reserved name; a bare
* English word does not — EXCEPT in a grammar position proven to hold the
* destination of a resolver or socket-state marker, where the argument is a
* name by construction and `ENOTFOUND redis` and `ECONNREFUSED redis` must
* still redact.
*/
const RESERVED_HOST_NAMES = new Set(["localhost", "broadcasthost"]);
const PROSE_AFTER_MARKER = new Set([
"lookup", "request", "connection", "attempt", "failed", "error", "timeout",
"after", "to", "for", "at", "no", "such", "the", "a", "an", "while", "during",
]);
function isHostCandidate(value: string, bareWordAllowed = false): boolean {
const lower = value.toLowerCase();
if (RESERVED_HOST_NAMES.has(lower)) return true;
if (/[.\-_0-9]/.test(value)) {
return AMBIGUOUS_HOST_RE.test(value) || CONTEXTUAL_HOST_TOKEN_RE.test(value);
}
// A bare word: only a destination-bearing marker makes it a host, and only
// when it is not one of the connective words those messages actually use.
return bareWordAllowed && !PROSE_AFTER_MARKER.has(lower);
}
/**
* A dotted label run whose final label may be numeric or hyphenated — the
* shape that is ambiguous between an internal hostname and a metric namespace.
* A single-label token is NOT a host: accepting one turned
* `upstream request failed` into `upstream [host] failed`.
*/
const AMBIGUOUS_HOST_RE = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.){1,8}[a-z0-9][a-z0-9-]{0,61}$/i;
/**
* A single-label internal name (`db-primary`, `db_prod.internal`'s owner). A
* bare word is only treated as a host inside an explicit network context, and
* it must still look like a name rather than an English word carrying the
* message — `request` and `after` are rejected by requiring a digit, hyphen,
* underscore, or dot somewhere in the token.
*/
const CONTEXTUAL_HOST_TOKEN_RE = /^[a-z0-9]+(?:[._-][a-z0-9]+)+$|^[a-z]+[0-9][a-z0-9]*$/i;
// `userID` is at least as common as `userId` in provider payloads, so the id
// suffix is matched case-insensitively.
// Case-insensitive throughout: `UserID`, `USER_ID`, and `AccountId` are all
// realistic field spellings, and matching only the lowercase base label left
// them intact.
// The id suffix may be joined (`userID`), underscored (`user_id`) or spaced
// (`User ID:`) — all three are ordinary provider phrasing.
const ACCOUNT_LABEL_RE = /\b(?:user|account|organization|org|tenant|workspace|project|customer)([\s_-]?id)?\b/gi;
const IDENTIFIER_ONLY_RE = /^[A-Za-z0-9_-]+$/;
const UNQUOTED_TERMINATOR = /[\s,;)\]}]/;
function isPrefixedAccount(value: string): boolean {
PREFIXED_ACCOUNT_RE.lastIndex = 0;
const m = PREFIXED_ACCOUNT_RE.exec(value);
PREFIXED_ACCOUNT_RE.lastIndex = 0;
return m?.[0] === value;
}
/**
* A retained URL path keeps an error message diagnosable, but its segments are
* provider-controlled: `/users/<uuid>` or `/orgs/acct_…` carries an account
* identifier past the host rewrite. Replace whole segments that are an
* identifier shape; leave route names alone.
*/
function scrubUrlPath(pathname: string): string {
return pathname
.split("/")
.map((segment) => {
if (!segment) return segment;
// Decode first, then re-split: an encoded slash (`%2F`) means the
// segment is itself a path, and matching only whole segments let
// `/u/%2F<uuid>` through. Decoding repeats to a fixed point because a
// single pass left `%252D` reversible.
const decoded = decodeToFixedPoint(segment);
if (isIdentifierShape(decoded)) return "[account]";
// Do NOT enumerate delimiters. Chasing them cost four rounds of review:
// first `/`, then `?#&=`, then `:` action suffixes and `;` matrix
// parameters would have been next. Instead, find identifier shapes
// wherever they appear in the decoded text; whatever separates them is
// irrelevant.
const replaced = redactIdentifiersInText(decoded);
return replaced === decoded ? segment : replaced;
})
.join("/");
}
function isIdentifierShape(value: string): boolean {
return UUID_RE.test(value) || isPrefixedAccount(value);
}
const UUID_ANYWHERE_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/gi;
/**
* Replace identifier shapes anywhere in a decoded path, independent of the
* punctuation around them. Delimiter enumeration is a losing game: colon
* action suffixes (`/ops/<uuid>:cancel`) and matrix parameters
* (`<uuid>;retry=1`) are both ordinary provider API syntax, and the next
* unlisted separator would leak again.
*/
function redactIdentifiersInText(value: string): string {
return value.replace(UUID_ANYWHERE_RE, "[account]").replace(PREFIXED_ACCOUNT_RE, "[account]");
}
/** Percent-decode until the value stops changing, bounded against a decode bomb. */
function decodeToFixedPoint(value: string): string {
let current = value;
for (let pass = 0; pass < 6 && current.includes("%"); pass += 1) {
let next: string;
try {
next = decodeURIComponent(current);
} catch {
return current; // malformed escapes: treat what we have as opaque
}
if (next === current) break;
current = next;
}
return current;
}
/** Valid IPv4 dotted quad: every octet in range and canonically written. */
function isIpv4(value: string): boolean {
const parts = value.split(".");
if (parts.length !== 4) return false;
return parts.every((p) => p.length >= 1 && p.length <= 3 && /^\d+$/.test(p) && Number(p) <= 255);
}
/** Full IPv6 validation, including `::` compression and a trailing mapped IPv4. */
function isIpv6(value: string): boolean {
if (!value.includes(":")) return false;
let head = value;
let tailGroups = 0;
const lastColon = head.lastIndexOf(":");
const afterLastColon = head.slice(lastColon + 1);
if (afterLastColon.includes(".")) {
if (!isIpv4(afterLastColon)) return false;
head = head.slice(0, lastColon + 1);
tailGroups = 2;
} else if (head.includes(".")) {
return false;
}
const doubleColons = head.split("::").length - 1;
if (doubleColons > 1) return false;
const compressed = doubleColons === 1;
const [leftRaw = "", rightRaw = ""] = compressed ? head.split("::") : [head, ""];
const splitGroups = (part: string): string[] | null => {
if (part === "" || part === ":") return [];
const trimmed = part.replace(/^:|:$/g, "");
if (trimmed === "") return [];
const groups = trimmed.split(":");
return groups.every((g) => /^[0-9A-Fa-f]{1,4}$/.test(g)) ? groups : null;
};
const left = splitGroups(leftRaw);
const right = compressed ? splitGroups(rightRaw) : [];
if (left === null || right === null) return false;
const total = left.length + right.length + tailGroups;
return compressed ? total <= 7 : total === 8;
}
/**
* Two-stage IPv6 replacement: scan the address alphabet, validate the base,
* then extend the replaced span across an optional `%zone`. A single-alphabet
* scan would leave `fe80::1%en0` as `[ip]%en0`.
*/
function redactIpv6(value: string): string {
let out = "";
let i = 0;
while (i < value.length) {
const ch = value[i]!;
if (!/[0-9A-Fa-f:.]/.test(ch)) {
out += ch;
i += 1;
continue;
}
let end = i;
while (end < value.length && /[0-9A-Fa-f:.]/.test(value[end]!) && end - i < 45) end += 1;
// The candidate alphabet includes `.` for IPv4-mapped forms, so a trailing
// sentence period is swallowed too and `2001:db8::1.` failed validation as
// a whole. Retry on progressively shorter prefixes so ordinary punctuation
// after an address cannot defeat the rule.
let matched = 0;
for (let stop = end; stop > i; stop -= 1) {
// A candidate may not end on `.` — that is sentence punctuation after an
// address. It MAY end on `:`, because `2001:db8::` and `fe80::` are valid
// compressed forms; rejecting every trailing colon skipped them entirely.
// `isIpv6` is the arbiter, so a stray single trailing colon simply fails
// validation and the loop backs off one more character.
if (value[stop - 1] === ".") continue;
if (isIpv6(value.slice(i, stop))) {
matched = stop;
break;
}
}
if (matched > i) {
let zoneEnd = matched;
if (value[zoneEnd] === "%") {
let z = zoneEnd + 1;
while (z < value.length && /[A-Za-z0-9_.-]/.test(value[z]!) && z - zoneEnd <= 64) z += 1;
if (z > zoneEnd + 1) zoneEnd = z;
}
out += "[ip]";
i = zoneEnd;
continue;
}
out += value.slice(i, end);
i = end;
}
return out;
}
/** Scan a delimited span (UNC path, non-HTTP URI) and replace it whole. */
function redactScannedSpans(value: string, start: RegExp, token: string, accept?: (span: string) => boolean): string {
let out = "";
let i = 0;
while (i < value.length) {
start.lastIndex = i;
const m = start.exec(value);
if (!m) {
out += value.slice(i);
break;
}
let end = m.index + m[0].length;
while (end < value.length && !/[\s"']/.test(value[end]!)) end += 1;
const span = value.slice(m.index, end);
out += value.slice(i, m.index);
out += accept && !accept(span) ? span : token;
i = end;
}
return out;
}
/**
* Account identifiers under a label. The value span is resolved from its
* syntax (quote pair, or run to a terminator) BEFORE it is validated, so an
* out-of-grammar character or a missing closing quote leaves the text
* untouched instead of producing a partially redacted prefix.
*
* ID-bearing labels (`user_id`, `accountId`, ...) redact any value of six or
* more characters. Bare labels (`user`, `account`, ...) redact only an
* unambiguous account shape, because `org: engineering` is ordinary prose.
*/
function redactContextualAccounts(value: string): string {
let out = "";
let cursor = 0;
ACCOUNT_LABEL_RE.lastIndex = 0;
let label: RegExpExecArray | null;
while ((label = ACCOUNT_LABEL_RE.exec(value)) !== null) {
if (label.index < cursor) continue;
const idBearing = Boolean(label[1]);
let p = label.index + label[0].length;
// A JSON field name is quoted: `"userId": "v"`. Step over the label's own
// closing quote before looking for the separator.
if (value[p] === '"' || value[p] === "'") p += 1;
while (p < value.length && /\s/.test(value[p]!)) p += 1;
if (value[p] !== "=" && value[p] !== ":") continue;
p += 1;
while (p < value.length && /\s/.test(value[p]!)) p += 1;
const quote = value[p] === '"' || value[p] === "'" ? value[p]! : "";
let spanStart = quote ? p + 1 : p;
let spanEnd: number;
if (quote) {
const close = value.indexOf(quote, spanStart);
if (close === -1) continue;
spanEnd = close;
} else {
spanEnd = spanStart;
while (spanEnd < value.length && !UNQUOTED_TERMINATOR.test(value[spanEnd]!)) spanEnd += 1;
}
const span = value.slice(spanStart, spanEnd);
if (!span || !IDENTIFIER_ONLY_RE.test(span)) continue;
const redact = idBearing ? span.length >= 6 : isPrefixedAccount(span) || UUID_RE.test(span);
if (!redact) continue;
out += value.slice(cursor, spanStart) + "[account]";
cursor = spanEnd;
ACCOUNT_LABEL_RE.lastIndex = spanEnd;
}
out += value.slice(cursor);
return out;
}
function scrubString(value: string): string {
// 1. Existing secret redaction.
let s = redactSecretString(value);
s = s.replace(SECRETISH_GLOBAL, "[REDACTED]");
// 2. Filesystem paths, including UNC shares.
s = s.replace(/(?:[A-Za-z]:\\|\/(?:home|Users|tmp|var|etc|root|mnt)\/)[^\s"']+/g, "[path]");
s = redactScannedSpans(s, /\\\\[^\\\s"']{1,255}\\/g, "[path]");
// 3. HTTP(S) URLs. The retained pathname keeps the diagnostic useful, so its
// segments are scrubbed of identifier shapes rather than trusted: a
// provider error citing `/users/<uuid>` would otherwise persist an
// account id that the host rewrite alone does not touch.
s = s.replace(/https?:\/\/[^\s"']+/gi, (url) => {
try {
const u = new URL(url);
if (u.username || u.password) return "[redacted-url]";
const path = scrubUrlPath(u.pathname);
if (/^(localhost|127\.|10\.|192\.168\.|172\.(1[6-9]|2\d|3[0-1])\.)/i.test(u.hostname)) {
return `${u.protocol}//[private-host]${path}`;
}
return `${u.protocol}//[host]${path}`;
} catch {
return "[redacted-url]";
}
});
// 4. Other-scheme URIs, which may carry credentials. Refuses http(s) so it
// cannot re-match the output of rule 3.
s = redactScannedSpans(s, /\b[a-z][a-z0-9+.-]{1,15}:\/\//gi, "[uri]", (span) => !/^https?:\/\//i.test(span));
// 5-8. Bounded token shapes.
s = s.replace(JWT_RE, "[jwt]");
s = s.replace(EMAIL_RE, "[email]");
s = s.replace(PREFIXED_ACCOUNT_RE, "[account]");
s = redactContextualAccounts(s);
s = s.replace(MAC_RE, "[mac]");
// 9-10. Addresses: IPv6 first so mapped forms are replaced whole.
s = redactIpv6(s);
s = s.replace(IPV4_RE, (m) => (isIpv4(m) ? "[ip]" : m));
// 11. Multi-label hostnames, plus single-label names in a host-bearing context.
s = s.replace(HOSTNAME_RE, "[host]");
s = s.replace(STRONG_HOST_CONTEXT_RE, (m, tail: string) => {
// Scan the few tokens after the marker for the first host-shaped one:
// Go writes `dial tcp: lookup <host>: no such host`, so the destination
// is not always adjacent to the marker. The destination sits inside
// `tail`, so the rewrite is spliced at an offset in it — replacing
// against the whole match lets a marker word that repeats the
// destination (`connect to connect failed`) take the `[host]` instead.
const head = m.slice(0, m.length - tail.length);
const redact = (at: number, token: string) =>
head + tail.slice(0, at) + "[host]" + tail.slice(at + token.length);
// A name paired with a port is a destination whatever else is true:
// `dial tcp redis:6379` needs no other evidence. Both notations count —
// adjacent `host:443` and spelled-out `gateway on port 443` — because the
// port is the evidence, not the punctuation.
const ported =
tail.match(/(?<![\w.-])([A-Za-z0-9_.-]{1,255}):\d{1,5}(?![\w.])/) ??
tail.match(/(?<![\w.-])([A-Za-z0-9_.-]{1,255})\s+(?:on\s+)?port\s+\d{1,5}\b/i);
if (ported?.[1] && !PROSE_AFTER_MARKER.has(ported[1].toLowerCase())) {
return redact(ported.index ?? 0, ported[1]);
}
// A failure immediately following an unported connect-to target supplies
// the missing network context without making ordinary connective prose
// (`connect to your account`) host-bearing.
const failedConnectTarget = /\bconnect(?:ing)?\s+to\b/i.test(m)
? tail.match(/^([A-Za-z][A-Za-z0-9]{0,254})\s+(?:failed|refused|unreachable|reset|timed\s+out)\b/i)
: null;
if (failedConnectTarget?.[1]) {
return redact(failedConnectTarget.index ?? 0, failedConnectTarget[1]);
}
// A bare destination name is licensed only where the grammar proves the
// position is the destination: directly after a resolver or explicit host
// marker, as a socket marker's sole argument
// (`ECONNREFUSED redis`, `dial tcp redis`) or as the argument of `lookup`
// (`dial tcp: lookup redis`). Past an open-ended connective chain nothing
// proves the next word is a destination — `ETIMEDOUT while waiting for
// response` is prose. Natural-language `connect to` licenses nothing:
// `Unable to connect to your account` is prose.
const destinationContext =
/ENOTFOUND|EAI_AGAIN|ECONNREFUSED|ETIMEDOUT|EHOSTUNREACH|dial\s+(?:tcp|udp)|lookup|\bhost\b/i.test(m);
// Direct resolver and explicit host markers name their first argument even
// when explanatory prose follows; socket-state prose remains ambiguous.
const directHostArgument = /^(?:ENOTFOUND|EAI_AGAIN|host)\b/i.test(head);
const tokens = tail.split(/[\s:]+/).filter(Boolean);
let cursor = 0;
for (let i = 0; i < tokens.length; i += 1) {
const token = tokens[i]!;
const at = tail.indexOf(token, cursor);
cursor = at + token.length;
// A sentence-final period travels with the token (`ECONNREFUSED redis.`):
// classify the name without it, and leave it outside the mask so the
// message still reads as a sentence.
const core = token.replace(/\.+$/, "");
if (!core) continue;
if (isHostCandidate(core)) return redact(at, core);
const bareLicensed =
destinationContext && (tokens.length === 1 || tokens[i - 1]?.toLowerCase() === "lookup" || (i === 0 && directHostArgument));
if (bareLicensed && isHostCandidate(core, true)) return redact(at, core);
}
return m;
});
s = s.replace(WEAK_HOST_CONTEXT_RE, (m, name: string) =>
CONTEXTUAL_HOST_TOKEN_RE.test(name) && !DOTTED_NAMESPACE_RE.test(name) ? m.replace(name, "[host]") : m,
);
const bytes = new TextEncoder().encode(s);
if (bytes.byteLength > MAX_SANITIZED_STRING_FIELD) {
return new TextDecoder().decode(bytes.slice(0, MAX_SANITIZED_STRING_FIELD));
}
return s;
}
const TRUNCATION_MARKERS = [
"[REDACTED]",
"[redacted-url]",
"[private-host]",
"[account]",
"[email]",
"[host]",
"[path]",
"[uri]",
"[jwt]",
"[mac]",
"[ip]",
];
/**
* Byte-bounded truncation for persisted summaries.
*
* `String.prototype.slice` counts UTF-16 code units, so it can split a
* surrogate pair or leave a partial `[em` fragment that a reader could mistake
* for literal content. Bytes are the right unit because
* `enforceEventStructureLimits` also measures encoded byte length.
*/
export function truncateUtf8(value: string, maxBytes: number): string {
const encoder = new TextEncoder();
if (encoder.encode(value).byteLength <= maxBytes) return value;
let cut = 0;
let used = 0;
for (const char of value) {
const size = encoder.encode(char).byteLength;
if (used + size > maxBytes) break;
used += size;
cut += char.length;
}
// If the cut lands strictly inside a marker, drop the whole marker: a
// fragment such as `[accoun` reads as literal content. Sanitization has
// already replaced the raw value, so the marker's opening bracket is a safe
// cut point and everything before it is intact.
const open = value.lastIndexOf("[", cut - 1);
if (open !== -1) {
const tail = value.slice(open, cut);
for (const marker of TRUNCATION_MARKERS) {
if (tail.length < marker.length && marker.startsWith(tail)) return value.slice(0, open);
}
}
return value.slice(0, cut);
}
/** Stable privacy boundary for diagnostic text that may be persisted. */
export function sanitizeDiagnostic(value: unknown): string {
return scrubString(value instanceof Error ? value.message : String(value));
}
export function sanitizedJsonBytes(value: unknown): Uint8Array {
return new TextEncoder().encode(jcsStringify(scrubValue(value, 0)));
}