@warlock.js/logger 5.32.0 → 5.34.0

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to `@warlock.js/logger` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 5.33.0 - 2026-10-19
+
+### Added
+
+- Add `registerLogSecret(value, keys?)` and `maskRegisteredLogSecrets(text)` for process-lifetime credential masking. Registered keys and literal values remain protected with defaults disabled or custom censors, including free text, Error causes and channel failure diagnostics. The safety pass masks opaque objects and does not invoke serializers/getters.
+
 ## 5.32.0 - 2026-10-18
 
 ### Changed
@@ -59,73 +65,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Changed
 
-- Lockstep release; package APIs are unchanged. Skills refer to other topics by name instead of file paths, so cross-references keep working after `agent-kit` copies them into an app.
+- Skills refer to other topics by name instead of file paths, so cross-references keep working after `agent-kit` copies them into an app.
 
 ## 5.28.0 - 2026-10-01
 
 ### Changed
 
-- Lockstep release; package APIs are unchanged. `llms.txt` now lists every skill topic with its description (frontmatter in CRLF files was skipped).
-
-## 5.27.0 - 2026-10-01
-
-### Changed
-
-- Lockstep release; package APIs are unchanged.
-
-## 5.26.0 - 2026-09-30
-
-### Changed
-
-- Lockstep release; package APIs are unchanged.
-
-## 5.25.0 - 2026-09-28
-
-### Changed
-
-- Lockstep release; package APIs are unchanged.
-
-## 5.24.0 - 2026-09-27
-
-### Changed
-
-- Lockstep release; package APIs are unchanged.
-
-## 5.23.2 - 2026-09-26
-
-### Changed
-
-- Lockstep patch release; package APIs are unchanged.
-
-## 5.23.1 - 2026-09-26
-
-### Changed
-
-- Lockstep patch release; package APIs are unchanged.
-
-## 5.23.0 - 2026-09-25
-
-### Changed
-
-- Lockstep patch release; package APIs are unchanged.
-
-## 5.22.1 - 2026-09-25
-
-### Changed
-
-- Lockstep patch release; package APIs are unchanged.
-
-## 5.22.0 - 2026-09-25
-
-### Changed
-
-- Lockstep release maintenance and dependency refresh.
-
-## 5.21.0 - 2026-09-25
-
-### Changed
-
-- Lockstep release maintenance and dependency refresh.
+- `llms.txt` now lists every skill topic with its description (frontmatter in CRLF files was skipped).
 
 ## 5.20.0 - 2026-09-24
 
@@ -145,18 +91,6 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 - Use the package-resolved TypeScript binary for type checking.
 
-## 5.11.0 - 2026-09-14
-
-_Released in lockstep with the `@warlock.js/*` family; no package-specific changes in 5.11.0._
-
-## 5.10.0 - 2026-09-14
-
-_Released in lockstep with the `@warlock.js/*` family; no package-specific changes in 5.10.0._
-
-## 5.9.0 - 2026-09-13
-
-_Released in lockstep with the `@warlock.js/*` family; no package-specific changes in 5.9.0._
-
 ## 5.7.0 - 2026-09-11
 
 ### Fixed
@@ -173,12 +107,6 @@ _Released in lockstep with the `@warlock.js/*` family; no package-specific chang
 
 - Documentation shipped in this package's `skills/` told users to run `pnpm`-specific commands. `pnpm <binary>` has no npm equivalent, so those instructions failed outright for anyone not using pnpm. Commands are now package-manager neutral.
 
-## 5.2.3 - 2026-09-02
-
-### Fixed
-
-- Released in exact lockstep with Core's Web generator repairs so every family dependency remains installable at 5.2.3.
-
 ## 5.2.2
 
 - Documented: the README, CHANGELOG, and `overview` skill now describe the
@@ -189,29 +117,6 @@ _Released in lockstep with the `@warlock.js/*` family; no package-specific chang
   code must not value-import this package, type-only imports are allowed, and
   server loaders/controllers/modules may import it freely. No source change.
 
-## 5.1.0
-
-No changes to `@warlock.js/logger`. Released in lockstep with the `@warlock.js/web`
-React-execution fix and the `@warlock.js/core` CLI additions — see those packages'
-changelogs.
-
-## 5.0.2 - 2026-08-25
-
-No changes to `@warlock.js/logger`. Released in lockstep with the `@warlock.js/web` SSR
-fix (`ssr.noExternal`) — see that package's changelog.
-
-## 5.0.1 - 2026-08-25
-
-No changes to `@warlock.js/logger`. Released in lockstep with the `create-warlock` vite
-resolution pin and the `@warlock.js/web` peer narrowing — see those packages'
-changelogs.
-
-## 5.0.0 - 2026-08-25
-
-### Changed
-
-- This package is unchanged in 5.0.0; its version moved only because the Warlock family releases in lockstep.
-
 ## 4.16.0 - 2026-08-18
 
 ### Security

package/cjs/index.cjs

@@ -39,6 +39,221 @@ path = __toESM(path, 1);
 let safe_stable_stringify = require("safe-stable-stringify");
 let _mongez_reinforcements = require("@mongez/reinforcements");
 
+//#region ../../packages/logger/src/redact/default-keys.ts
+/**
+* Built-in secret-key denylist — the redaction floor that applies with no
+* configuration at all.
+*
+* ## Why a default list exists
+*
+* Path-based `redact.paths` is a *tool*; it only protects an application whose
+* every call site was configured correctly, and nothing warns you when one
+* wasn't. The overwhelmingly common leak is mundane and needs no attacker
+* input: `log.error("auth", "login", "failed", { headers: req.headers, body:
+* req.body })` puts a live bearer token and a cleartext password into every
+* sink. A key denylist that runs by default turns redaction from a tool into a
+* default protection.
+*
+* ## Matching semantics — exact, on a normalized key
+*
+* Keys are compared after {@link normalizeRedactKey}: lower-cased with every
+* non-alphanumeric character removed. So one entry covers every spelling
+* convention a codebase might use —
+* `apiKey` / `api_key` / `API-KEY` / `apikey` all normalize to `apikey`.
+*
+* The match is **exact on the normalized key, not a substring**. That is a
+* deliberate trade: substring matching (`*token*`) would also swallow
+* `tokenCount`, `passwordUpdatedAt`, `secretsLoaded` — silent, hard-to-debug
+* data loss in the one place engineers look when something is broken. An exact
+* list is auditable: you can read it and know precisely what disappears. The
+* cost is that unusual spellings are missed, which is why the list carries the
+* concrete wire-format variants that actually show up in HTTP headers
+* (`x-api-key`, `proxy-authorization`, `set-cookie`) and why apps can extend it
+* with `redact.keys`.
+*
+* ## What is deliberately NOT here
+*
+* `key`, `auth`, `hash`, `signature`, `salt`, `id` — all too generic. Each
+* would redact far more non-secret fields than secret ones (`key` alone would
+* blank out every `key` in a keyed collection). Applications that want them
+* add them via `redact.keys`.
+*/
+/**
+* Normalize a key for denylist comparison: lower-case, strip every
+* non-alphanumeric character. Collapses `apiKey`, `api_key`, `API-KEY`,
+* `Api Key` and `apikey` onto a single entry.
+*/
+function normalizeRedactKey(key) {
+	return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+/**
+* The default denylist, in source spelling. Anything whose normalized key
+* matches one of these is replaced by the configured censor (`"[REDACTED]"`
+* by default) at any depth of `context`, `message`, or an `Error`'s own
+* enumerable properties.
+*
+* Exported so applications can inspect, log, or build on the exact set they
+* are getting rather than guessing at it.
+*/
+const DEFAULT_REDACT_KEYS = [
+	"password",
+	"passwd",
+	"pwd",
+	"passphrase",
+	"passwordHash",
+	"currentPassword",
+	"newPassword",
+	"passwordConfirmation",
+	"secret",
+	"clientSecret",
+	"appSecret",
+	"apiSecret",
+	"secretKey",
+	"token",
+	"accessToken",
+	"refreshToken",
+	"idToken",
+	"authToken",
+	"apiToken",
+	"bearerToken",
+	"csrfToken",
+	"sessionToken",
+	"resetToken",
+	"verificationToken",
+	"jwt",
+	"otp",
+	"apiKey",
+	"privateKey",
+	"encryptionKey",
+	"signingKey",
+	"authorization",
+	"proxyAuthorization",
+	"x-api-key",
+	"x-auth-token",
+	"cookie",
+	"set-cookie",
+	"sessionId",
+	"credentials",
+	"credential",
+	"connectionString",
+	"creditCard",
+	"creditCardNumber",
+	"cardNumber",
+	"cvv",
+	"cvc",
+	"ssn",
+	"socialSecurityNumber",
+	"iban",
+	"taxId"
+];
+/**
+* The default denylist, pre-normalized. Frozen at module load so the hot path
+* never rebuilds it.
+*/
+const DEFAULT_REDACT_KEY_SET = new Set(DEFAULT_REDACT_KEYS.map(normalizeRedactKey));
+
+//#endregion
+//#region ../../packages/logger/src/redact/registered-secrets.ts
+const keys = /* @__PURE__ */ new Set();
+const values = /* @__PURE__ */ new Set();
+const MASK = "[REDACTED]";
+let orderedValues = [];
+/**
+* Register credentials for process-lifetime masking in every Logger instance.
+* Empty values are ignored. Old values remain protected after rotation/removal.
+* This safety floor is independent of redact config and custom censors.
+*/
+function registerLogSecret(value, secretKeys = []) {
+	for (const key of secretKeys) {
+		const normalized = normalizeRedactKey(key);
+		if (normalized) keys.add(normalized);
+	}
+	if (!value || values.has(value)) return;
+	values.add(value);
+	orderedValues = [...values].sort((left, right) => right.length - left.length);
+}
+/** Exact substring masking; no encoding, hashing, or fuzzy matching. */
+function maskRegisteredLogSecrets(text) {
+	if (orderedValues.length === 0) return text;
+	let cursor = 0;
+	let result = "";
+	while (cursor < text.length) {
+		let next = -1;
+		let length = 0;
+		for (const secret of orderedValues) {
+			const index = text.indexOf(secret, cursor);
+			if (index !== -1 && (next === -1 || index < next)) {
+				next = index;
+				length = secret.length;
+			}
+		}
+		if (next === -1) return result + text.slice(cursor);
+		result += text.slice(cursor, next) + MASK;
+		cursor = next + length;
+	}
+	return result;
+}
+/** @internal Final safety pass, after user censors have run. */
+function redactRegisteredSecrets(value) {
+	if (keys.size === 0 && values.size === 0) return value;
+	const seen = /* @__PURE__ */ new WeakMap();
+	function visit(value) {
+		if (typeof value === "string") return maskRegisteredLogSecrets(value);
+		if (typeof value === "function" || typeof value === "symbol") return MASK;
+		if (value === null || typeof value !== "object") return value;
+		if (seen.has(value)) return seen.get(value);
+		if (value instanceof Date) return new Date(Date.prototype.getTime.call(value));
+		if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof WeakMap || value instanceof WeakSet || value instanceof Promise || value instanceof RegExp) return MASK;
+		if (value instanceof Map) {
+			const copy = /* @__PURE__ */ new Map();
+			seen.set(value, copy);
+			for (const [key, child] of Map.prototype.entries.call(value)) copy.set(visit(key), typeof key === "string" && keys.has(normalizeRedactKey(key)) ? MASK : visit(child));
+			return copy;
+		}
+		if (value instanceof Set) {
+			const copy = /* @__PURE__ */ new Set();
+			seen.set(value, copy);
+			for (const child of Set.prototype.values.call(value)) copy.add(visit(child));
+			return copy;
+		}
+		const copy = value instanceof Error ? /* @__PURE__ */ new Error() : Array.isArray(value) ? [] : {};
+		seen.set(value, copy);
+		for (const key of Reflect.ownKeys(value)) {
+			if (Array.isArray(value) && key === "length") continue;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (!descriptor) continue;
+			if (typeof key === "symbol") continue;
+			const name = maskRegisteredLogSecrets(key);
+			const hidden = keys.has(normalizeRedactKey(key));
+			const child = "value" in descriptor ? descriptor.value : MASK;
+			Object.defineProperty(copy, name, {
+				value: hidden ? MASK : visit(child),
+				enumerable: descriptor.enumerable,
+				writable: true,
+				configurable: true
+			});
+		}
+		if (value instanceof Error && !Object.hasOwn(copy, "name")) {
+			let prototype = Object.getPrototypeOf(value);
+			while (prototype) {
+				const descriptor = Object.getOwnPropertyDescriptor(prototype, "name");
+				if (descriptor) {
+					const name = "value" in descriptor ? descriptor.value : MASK;
+					Object.defineProperty(copy, "name", {
+						value: typeof name === "string" ? maskRegisteredLogSecrets(name) : MASK,
+						configurable: true
+					});
+					break;
+				}
+				prototype = Object.getPrototypeOf(prototype);
+			}
+		}
+		return copy;
+	}
+	return visit(value);
+}
+
+//#endregion
 //#region ../../packages/logger/src/log-channel.ts
 var LogChannel = class {
 	/**
@@ -74,7 +289,7 @@ var LogChannel = class {
 				return;
 			}
 			const reason = error instanceof Error ? error.message : String(error);
-			process.stderr.write(`[@warlock.js/logger] channel "${this.name}" failed: ${reason}\n`);
+			process.stderr.write(maskRegisteredLogSecrets(`[@warlock.js/logger] channel "${this.name}" failed: ${reason}\n`));
 		} catch {}
 	}
 	/**
@@ -1082,120 +1297,6 @@ var SentryLog = class extends LogChannel {
 	}
 };
 
-//#endregion
-//#region ../../packages/logger/src/redact/default-keys.ts
-/**
-* Built-in secret-key denylist — the redaction floor that applies with no
-* configuration at all.
-*
-* ## Why a default list exists
-*
-* Path-based `redact.paths` is a *tool*; it only protects an application whose
-* every call site was configured correctly, and nothing warns you when one
-* wasn't. The overwhelmingly common leak is mundane and needs no attacker
-* input: `log.error("auth", "login", "failed", { headers: req.headers, body:
-* req.body })` puts a live bearer token and a cleartext password into every
-* sink. A key denylist that runs by default turns redaction from a tool into a
-* default protection.
-*
-* ## Matching semantics — exact, on a normalized key
-*
-* Keys are compared after {@link normalizeRedactKey}: lower-cased with every
-* non-alphanumeric character removed. So one entry covers every spelling
-* convention a codebase might use —
-* `apiKey` / `api_key` / `API-KEY` / `apikey` all normalize to `apikey`.
-*
-* The match is **exact on the normalized key, not a substring**. That is a
-* deliberate trade: substring matching (`*token*`) would also swallow
-* `tokenCount`, `passwordUpdatedAt`, `secretsLoaded` — silent, hard-to-debug
-* data loss in the one place engineers look when something is broken. An exact
-* list is auditable: you can read it and know precisely what disappears. The
-* cost is that unusual spellings are missed, which is why the list carries the
-* concrete wire-format variants that actually show up in HTTP headers
-* (`x-api-key`, `proxy-authorization`, `set-cookie`) and why apps can extend it
-* with `redact.keys`.
-*
-* ## What is deliberately NOT here
-*
-* `key`, `auth`, `hash`, `signature`, `salt`, `id` — all too generic. Each
-* would redact far more non-secret fields than secret ones (`key` alone would
-* blank out every `key` in a keyed collection). Applications that want them
-* add them via `redact.keys`.
-*/
-/**
-* Normalize a key for denylist comparison: lower-case, strip every
-* non-alphanumeric character. Collapses `apiKey`, `api_key`, `API-KEY`,
-* `Api Key` and `apikey` onto a single entry.
-*/
-function normalizeRedactKey(key) {
-	return key.toLowerCase().replace(/[^a-z0-9]/g, "");
-}
-/**
-* The default denylist, in source spelling. Anything whose normalized key
-* matches one of these is replaced by the configured censor (`"[REDACTED]"`
-* by default) at any depth of `context`, `message`, or an `Error`'s own
-* enumerable properties.
-*
-* Exported so applications can inspect, log, or build on the exact set they
-* are getting rather than guessing at it.
-*/
-const DEFAULT_REDACT_KEYS = [
-	"password",
-	"passwd",
-	"pwd",
-	"passphrase",
-	"passwordHash",
-	"currentPassword",
-	"newPassword",
-	"passwordConfirmation",
-	"secret",
-	"clientSecret",
-	"appSecret",
-	"apiSecret",
-	"secretKey",
-	"token",
-	"accessToken",
-	"refreshToken",
-	"idToken",
-	"authToken",
-	"apiToken",
-	"bearerToken",
-	"csrfToken",
-	"sessionToken",
-	"resetToken",
-	"verificationToken",
-	"jwt",
-	"otp",
-	"apiKey",
-	"privateKey",
-	"encryptionKey",
-	"signingKey",
-	"authorization",
-	"proxyAuthorization",
-	"x-api-key",
-	"x-auth-token",
-	"cookie",
-	"set-cookie",
-	"sessionId",
-	"credentials",
-	"credential",
-	"connectionString",
-	"creditCard",
-	"creditCardNumber",
-	"cardNumber",
-	"cvv",
-	"cvc",
-	"ssn",
-	"socialSecurityNumber",
-	"iban",
-	"taxId"
-];
-/**
-* The default denylist, pre-normalized. Frozen at module load so the hot path
-* never rebuilds it.
-*/
-const DEFAULT_REDACT_KEY_SET = new Set(DEFAULT_REDACT_KEYS.map(normalizeRedactKey));
-
 //#endregion
 //#region ../../packages/logger/src/redact/redact.ts
 const DEFAULT_CENSOR = "[REDACTED]";
@@ -1402,17 +1503,19 @@ function resolveRedactKeys(config) {
 *
 * ## Residual gaps (by design, documented rather than silently absent)
 *
-* - **Secrets interpolated into a `message` string** (`` `token=${t}` ``)
-*   cannot be reached — neither a path nor a key names a substring.
-* - **`Map`/`Set`/`Buffer` contents** are not traversed (see {@link isOpaque}).
-* - **Non-enumerable / getter-backed properties** are not walked, so an HTTP
-*   client that exposes request config behind a getter still slips through.
-*   Enumerable ones (axios's `.config`, `.response`) *are* covered.
+* - **Unregistered secrets interpolated into strings** cannot be reached.
+*   registerLogSecret protects known literal values, including Error text.
+* - Without registered credentials, **`Map`/`Set`/`Buffer` contents** are
+*   not traversed (see {@link isOpaque}). Registered credentials add a
+*   final safety pass that traverses Maps/Sets and masks opaque objects.
+* - Key/path redaction does not walk non-enumerable properties. With
+*   registered credentials the final pass walks data descriptors and replaces
+*   accessors without invoking them.
 */
 function applyRedact(data, config) {
 	const paths = config?.paths ?? [];
 	const keys = resolveRedactKeys(config);
-	if (paths.length === 0 && !keys) return data;
+	if (paths.length === 0 && !keys) return redactRegisteredSecrets(data);
 	const censor = config?.censor ?? DEFAULT_CENSOR;
 	let result = data;
 	const censored = /* @__PURE__ */ new Set();
@@ -1429,7 +1532,7 @@ function applyRedact(data, config) {
 		censor,
 		alreadyCensored: censored
 	});
-	return result;
+	return redactRegisteredSecrets(result);
 }
 /**
 * Combine two redact configs into one effective config. Used to merge a
@@ -1774,7 +1877,7 @@ var Logger = class {
 	}
 	reportChannelError(error, channel, entry) {
 		try {
-			const outcome = this.channelErrorHandler(error, channel, entry);
+			const outcome = this.channelErrorHandler(redactRegisteredSecrets(error), channel, redactRegisteredSecrets(entry));
 			if (outcome && typeof outcome.then === "function") outcome.then(void 0, () => {});
 		} catch {}
 	}
@@ -2013,7 +2116,7 @@ function redactionFailedEntry(data) {
 function reportChannelError(error, channel) {
 	const reason = error instanceof Error ? error.message : String(error);
 	try {
-		process.stderr.write(`[@warlock.js/logger] channel "${channel.name}" failed to log: ${reason}\n`);
+		process.stderr.write(maskRegisteredLogSecrets(`[@warlock.js/logger] channel "${channel.name}" failed to log: ${reason}\n`));
 	} catch {}
 }
 /**
@@ -2102,8 +2205,10 @@ exports.escapeLogValue = escapeLogValue;
 exports.log = log;
 exports.maskEmail = maskEmail;
 exports.maskEmailsInText = maskEmailsInText;
+exports.maskRegisteredLogSecrets = maskRegisteredLogSecrets;
 exports.mergeRedact = mergeRedact;
 exports.normalizeRedactKey = normalizeRedactKey;
+exports.registerLogSecret = registerLogSecret;
 exports.resolveRedactKeys = resolveRedactKeys;
 exports.safeJsonStringify = safeJsonStringify;
 //# sourceMappingURL=index.cjs.map