@veryfront/ext-content-mdx 0.1.1186 → 0.1.1189

package/esm/src/utils/logger/core.js

@@ -36,6 +36,71 @@ export const LEVEL_COLORS = {
 // ============================================================================
 // Pure Formatting Functions (no dependencies)
 // ============================================================================
+function consumeControlSequence(value, start, kind) {
+    if (kind === "csi") {
+        for (let index = start; index < value.length; index++) {
+            const code = value.charCodeAt(index);
+            if (code >= 0x40 && code <= 0x7e)
+                return index + 1;
+        }
+        return value.length;
+    }
+    for (let index = start; index < value.length; index++) {
+        const code = value.charCodeAt(index);
+        if (code === 0x07 || code === 0x9c)
+            return index + 1;
+        if (code === 0x1b && value.charCodeAt(index + 1) === 0x5c)
+            return index + 2;
+    }
+    return value.length;
+}
+/**
+ * Neutralize terminal control sequences and line-breaking control characters
+ * in untrusted log text before framework-owned ANSI styling is applied.
+ */
+export function sanitizeLogText(value) {
+    let sanitized = "";
+    for (let index = 0; index < value.length;) {
+        const code = value.charCodeAt(index);
+        if (code === 0x1b) {
+            const next = value.charCodeAt(index + 1);
+            if (next === 0x5b) {
+                index = consumeControlSequence(value, index + 2, "csi");
+            }
+            else if (next === 0x5d) {
+                index = consumeControlSequence(value, index + 2, "osc");
+            }
+            else {
+                index += Number.isNaN(next) ? 1 : 2;
+            }
+            continue;
+        }
+        if (code === 0x9b) {
+            index = consumeControlSequence(value, index + 1, "csi");
+            continue;
+        }
+        if (code === 0x9d) {
+            index = consumeControlSequence(value, index + 1, "osc");
+            continue;
+        }
+        if ((code >= 0x09 && code <= 0x0d) ||
+            code === 0x85 ||
+            code === 0x2028 ||
+            code === 0x2029) {
+            if (!sanitized.endsWith(" "))
+                sanitized += " ";
+            index++;
+            continue;
+        }
+        if (code <= 0x1f || (code >= 0x7f && code <= 0x9f)) {
+            index++;
+            continue;
+        }
+        sanitized += value[index];
+        index++;
+    }
+    return sanitized;
+}
 /**
  * Pad or truncate a tag to fixed width for aligned output.
  */
@@ -63,7 +128,7 @@ export function colorize(text, color, enable) {
  * Normalize whitespace in text (collapse multiple spaces to single space).
  */
 export function normalizeText(value) {
-    return value.replace(/\s+/g, " ");
+    return sanitizeLogText(value).replace(/\s+/g, " ");
 }
 /**
  * Truncate text to maxLength, adding ellipsis if truncated.
@@ -127,7 +192,7 @@ export function serializeError(error) {
 export function formatContextText(context, error, enableColor) {
     const entries = Object.entries(context)
         .filter(([_, value]) => value !== undefined)
-        .map(([key, value]) => `${key}=${formatValue(value)}`);
+        .map(([key, value]) => `${normalizeText(key)}=${formatValue(value)}`);
     if (error)
         entries.push(`err=${formatErrorText(error)}`);
     if (entries.length === 0)

package/esm/src/utils/logger/redact.d.ts

@@ -9,15 +9,24 @@
  * credential before serialization, so an accidental
  * `logger.info("...", { authorization: token })` cannot leak the secret.
  *
- * Scope is intentionally key-based: we do not attempt to find secrets embedded
- * in free-form message strings (too lossy). The deny-list errs toward
- * over-redaction — masking a benign `tokenCount` is acceptable; leaking a real
- * token is not. The traversal fails *closed*: on a cycle, depth overflow, or a
- * throwing getter it returns {@link REDACTED} rather than risk emitting an
- * unredacted object.
+ * Sensitive keys are masked and every string value is scrubbed for credentials
+ * embedded in URL userinfo, query parameters, or fragment parameters. The
+ * deny-list errs toward over-redaction — masking a benign `tokenCount` is
+ * acceptable; leaking a real token is not. The traversal fails *closed*: on a
+ * cycle, depth overflow, or a throwing getter it returns {@link REDACTED}
+ * rather than risk emitting an unredacted object.
  */
 /** Replacement value substituted for any sensitive field. */
 export declare const REDACTED = "[REDACTED]";
+/**
+ * Replace every non-overlapping occurrence of a trusted path in untrusted text.
+ *
+ * Comparison treats slash and backslash as equivalent. Windows drive and UNC
+ * paths additionally use ASCII-only case folding, matching Windows path
+ * identity without locale-sensitive conversion. The linear-time matcher keeps
+ * the path literal: regex syntax in either input cannot change what matches.
+ */
+export declare function redactPathFromText(input: string, path: string, replacement: string): string;
 /**
  * Whether a context key names a credential and should have its value masked.
  *
@@ -27,14 +36,27 @@ export declare const REDACTED = "[REDACTED]";
  * normalizes to `author`, which contains none of the patterns.
  */
 export declare function isSensitiveKey(key: string): boolean;
+export type RedactedValue = string | number | boolean | null | RedactedValue[] | {
+    [key: string]: RedactedValue;
+};
 /**
- * Returns a redacted deep copy of `context`. Any property whose key is
- * {@link isSensitiveKey} has its value replaced with {@link REDACTED}; nested
- * plain objects, class instances, and arrays are traversed. The input is never
- * mutated, and the pass fails closed (returns {@link REDACTED}) on cycles,
- * depth overflow, or a throwing getter.
+ * Returns a redacted copy of `context` while preserving the established source
+ * and runtime value shapes. Any property whose key is {@link isSensitiveKey}
+ * is replaced with {@link REDACTED}; nested records and arrays are traversed,
+ * while primitives and scalar-serializing objects retain their original types.
+ * The input is never mutated.
+ *
+ * Use {@link redactForSerialization} at JSON/logging boundaries where BigInt,
+ * functions, symbols, and custom `toJSON` implementations must be normalized.
  */
 export declare function redactSensitive<T>(context: T): T;
+/**
+ * Returns a JSON-safe redacted snapshot of `context`. Sensitive keys are
+ * masked, nested values are traversed, BigInts become decimal strings,
+ * non-finite numbers become `null`, and unsupported or unreadable values fail
+ * closed. Objects with `toJSON` are snapshotted exactly once before redaction.
+ */
+export declare function redactForSerialization(context: unknown): RedactedValue;
 /**
  * Strip credentials from URL-shaped strings so they can be safely emitted in
  * free-form text (error messages, stacks, lifted `request_url` fields). Unlike
@@ -47,7 +69,7 @@ export declare function redactSensitive<T>(context: T): T;
  * It is intentionally tolerant: it operates on any string (a DSN, a Mongo URI,
  * an axios error message containing a URL) via regex rather than requiring a
  * parseable URL, so malformed or partial URLs in error text are still scrubbed.
- * Non-URL strings pass through unchanged.
+ * Strings without credential-shaped content pass through unchanged.
  */
 export declare function sanitizeUrlCredentials(input: string): string;
 /**
@@ -61,13 +83,14 @@ export declare function sanitizeUrlCredentials(input: string): string;
  */
 export declare function sanitizeUrlForSpan(input: string): string;
 /**
- * Apply {@link sanitizeUrlCredentials} to the `message` and `stack` of a
+ * Apply {@link sanitizeUrlCredentials} to the `name`, `message`, and `stack` of a
  * serialized-error-shaped object, returning a new object. Used by the logger's
  * JSON and text paths so errors carrying DSNs, Mongo URIs, or
  * `?access_token=`-bearing URLs do not leak credentials (the serialized error
  * bypasses the key-based redactor). Returns the input unchanged when falsy.
  */
 export declare function sanitizeSerializedError<T extends {
+    name?: unknown;
     message?: unknown;
     stack?: unknown;
 } | undefined>(error: T): T;

package/esm/src/utils/logger/redact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/logger/redact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,6DAA6D;AAC7D,eAAO,MAAM,QAAQ,eAAe,CAAC;AAmDrC;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAcnD;AAoFD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAEhD;AA6BD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAyB5D;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAgBxD;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,SAAS;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,EAC5D,KAAK,EAAE,CAAC,GAAG,CAAC,CAMb"}
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/logger/redact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,6DAA6D;AAC7D,eAAO,MAAM,QAAQ,eAAe,CAAC;AAmErC;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,MAAM,CAiDR;AAoDD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAmBnD;AAED,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,aAAa,EAAE,GACf;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAAA;CAAE,CAAC;AAsKrC;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAKhD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,aAAa,CAKtE;AAiSD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA8F5D;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA2BxD;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,EAC5E,KAAK,EAAE,CAAC,GAAG,CAAC,CAOb"}