agentic-qe 3.14.4 → 3.14.6

package/dist/logging/console-logger.js

@@ -10,6 +10,7 @@
  * - Error stack trace handling
  */
 import { LogLevel, LOG_LEVEL_NAMES, } from './logger.js';
+import { redactLogText, redactLogValue } from './redaction.js';
 /**
  * Default configuration for ConsoleLogger
  */
@@ -61,11 +62,11 @@ export class ConsoleLogger {
                 if (error.stack) {
                     errorContext.stack = error.stack;
                 }
-                // Capture any additional properties on the error
+                // Keep the cause structured; format() redacts it with everything else
                 // Use type assertion for ES2022 Error.cause compatibility
                 const errorWithCause = error;
                 if (errorWithCause.cause !== undefined) {
-                    errorContext.cause = String(errorWithCause.cause);
+                    errorContext.cause = errorWithCause.cause;
                 }
             }
             this.output(LogLevel.ERROR, message, errorContext);
@@ -115,8 +116,8 @@ export class ConsoleLogger {
         }
         // Add domain
         parts.push(`[${this.domain}]`);
-        // Add message
-        parts.push(message);
+        // Add message (#740: redaction is a sink invariant, at every level)
+        parts.push(redactLogText(message));
         // Add context if provided
         const mergedContext = this.mergeContext(context);
         if (mergedContext && Object.keys(mergedContext).length > 0) {
@@ -159,58 +160,21 @@ export class ConsoleLogger {
         };
     }
     /**
-     * Format context object for display
+     * Format context object for display. The context is first reduced to a
+     * redacted, bounded, cycle-free copy (#740), so it serializes safely.
      */
     formatContext(context) {
         try {
+            const safe = redactLogValue(context, { maxDepth: this.config.maxContextDepth + 1 });
             if (this.config.prettyPrint) {
-                return '\n' + JSON.stringify(context, this.createReplacer(), 2);
+                return '\n' + JSON.stringify(safe, null, 2);
             }
-            return JSON.stringify(context, this.createReplacer());
+            return JSON.stringify(safe);
         }
         catch {
             return '[unserializable context]';
         }
     }
-    /**
-     * Create a JSON replacer that handles circular references and depth limiting
-     */
-    createReplacer() {
-        const seen = new WeakSet();
-        let depth = 0;
-        return (_key, value) => {
-            // Handle depth limiting
-            if (typeof value === 'object' && value !== null) {
-                if (depth >= this.config.maxContextDepth) {
-                    return '[object]';
-                }
-                // Handle circular references
-                if (seen.has(value)) {
-                    return '[circular]';
-                }
-                seen.add(value);
-                depth++;
-            }
-            // Handle special types
-            if (value instanceof Error) {
-                return {
-                    name: value.name,
-                    message: value.message,
-                    stack: value.stack,
-                };
-            }
-            if (typeof value === 'bigint') {
-                return value.toString();
-            }
-            if (typeof value === 'function') {
-                return '[function]';
-            }
-            if (typeof value === 'symbol') {
-                return value.toString();
-            }
-            return value;
-        };
-    }
 }
 /**
  * No-op Logger implementation for use when logging is disabled

package/dist/logging/index.d.ts

@@ -39,4 +39,6 @@ export type { ConsoleLoggerConfig } from './console-logger.js';
 export { ConsoleLogger, NullLogger, DEFAULT_CONSOLE_LOGGER_CONFIG } from './console-logger.js';
 export type { LoggerFactoryConfig, LoggerProvider } from './logger-factory.js';
 export { LoggerFactory, createLogger, getLogger } from './logger-factory.js';
+export type { LogRedactionOptions } from './redaction.js';
+export { redactLogValue, redactLogText, formatErrorForLog, isSensitiveLogKey } from './redaction.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/logging/index.js

@@ -36,4 +36,5 @@
 export { LogLevel, LOG_LEVEL_NAMES, parseLogLevel, isLogger } from './logger.js';
 export { ConsoleLogger, NullLogger, DEFAULT_CONSOLE_LOGGER_CONFIG } from './console-logger.js';
 export { LoggerFactory, createLogger, getLogger } from './logger-factory.js';
+export { redactLogValue, redactLogText, formatErrorForLog, isSensitiveLogKey } from './redaction.js';
 //# sourceMappingURL=index.js.map

package/dist/logging/redaction.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Agentic QE v3 - Log redaction (issue #740)
+ *
+ * Sink-side sanitizer applied before any log text is written. Redacts values
+ * under sensitive keys and credential-shaped strings anywhere in a value.
+ * Non-mutating, cycle-safe, bounded, never invokes getters or toJSON, and
+ * fails closed: a value that cannot be inspected is replaced, not printed.
+ *
+ * Heuristic redaction is defense in depth: it does not replace keeping
+ * payloads, headers and configuration out of log events in the first place.
+ */
+export interface LogRedactionOptions {
+    /** Nesting depth beyond which objects become '[object]' */
+    maxDepth?: number;
+    /** Array items / object keys kept per level */
+    maxEntries?: number;
+    /** Characters kept per string after redaction */
+    maxStringLength?: number;
+}
+export declare function isSensitiveLogKey(key: string): boolean;
+/** Redact credential-shaped substrings from free text. */
+export declare function redactLogText(text: string, maxLength?: number): string;
+/** Return a sanitized, JSON-safe copy of `value`. The input is never modified. */
+export declare function redactLogValue(value: unknown, options?: LogRedactionOptions): unknown;
+/** Render a thrown value (Error or not) as redacted text for direct console output. */
+export declare function formatErrorForLog(error: unknown): string;
+//# sourceMappingURL=redaction.d.ts.map

package/dist/logging/redaction.js

@@ -0,0 +1,170 @@
+/**
+ * Agentic QE v3 - Log redaction (issue #740)
+ *
+ * Sink-side sanitizer applied before any log text is written. Redacts values
+ * under sensitive keys and credential-shaped strings anywhere in a value.
+ * Non-mutating, cycle-safe, bounded, never invokes getters or toJSON, and
+ * fails closed: a value that cannot be inspected is replaced, not printed.
+ *
+ * Heuristic redaction is defense in depth: it does not replace keeping
+ * payloads, headers and configuration out of log events in the first place.
+ */
+import { redact } from '../routing/advisor/redaction.js';
+const DEFAULTS = { maxDepth: 6, maxEntries: 100, maxStringLength: 8192 };
+/** Strings above this size are dropped rather than scanned. */
+const MAX_SCAN_LENGTH = 1_000_000;
+const SENSITIVE_KEYS = new Set([
+    'auth', 'dsn', 'pwd', 'proxyauthorization', 'setcookie', 'sessionid',
+]);
+const SENSITIVE_SUFFIXES = [
+    'token', 'secret', 'password', 'passwd', 'passphrase', 'apikey', 'privatekey',
+    'accesskey', 'secretkey', 'credential', 'credentials', 'cookie', 'authorization',
+    'sessionid', 'connectionstring',
+];
+/** Log-specific credential shapes, applied before the shared advisor patterns. */
+const LOG_PATTERNS = [
+    // Anchored on '://' rather than a scheme prefix: `\b[a-z][a-z0-9+.-]*://`
+    // backtracks quadratically on inputs such as 'a.a.a.…' (seconds per call at
+    // 100 KB). The scheme is left in place; an empty user (://:pw@) is covered.
+    [/(:\/\/)[^\s/@:"']*:[^\s/@"']+@/g, '$1<REDACTED:credentials>@'],
+    [/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, '$1 <REDACTED:credential>'],
+    [/\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{16,}/g, '<REDACTED:api_key>'],
+    [/\b(set-cookie|cookie):\s*[^\n]+/gi, '$1: <REDACTED:cookie>'],
+    // Compound query/assignment keys the shared pattern misses: access_token=, client_secret=
+    [/\b([A-Za-z0-9_-]{0,64}?[_-](?:token|secret|password|passwd))=([^\s&"'#]+)/gi, '$1=<REDACTED:credential>'],
+];
+/**
+ * JSON / repr serialized fields ("apiKey":"…", 'password': 123). The key is
+ * checked with isSensitiveLogKey() so text and structured values agree.
+ * Unterminated strings are redacted to end of line (fail closed).
+ */
+const SERIALIZED_FIELD = /(["'])([A-Za-z0-9_.-]{1,64})\1(\s*:\s*)("(?:[^"\\\n]|\\.)*"?|'(?:[^'\\\n]|\\.)*'?|-?\d[\d.eE+-]*)/g;
+function redactSerializedFields(text) {
+    return text.replace(SERIALIZED_FIELD, (match, q, key, sep) => isSensitiveLogKey(key) ? `${q}${key}${q}${sep}${q}<REDACTED:sensitive-key>${q}` : match);
+}
+export function isSensitiveLogKey(key) {
+    const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, '');
+    return SENSITIVE_KEYS.has(normalized) || SENSITIVE_SUFFIXES.some(suffix => normalized.endsWith(suffix));
+}
+/** Redact credential-shaped substrings from free text. */
+export function redactLogText(text, maxLength = DEFAULTS.maxStringLength) {
+    // Untyped (JS / `any`) callers may pass a non-string message; render it
+    // safely instead of throwing from inside the logger.
+    if (typeof text !== 'string')
+        return formatErrorForLog(text);
+    if (text.length > MAX_SCAN_LENGTH)
+        return `[REDACTED:size-limit ${text.length} chars]`;
+    let result = text;
+    for (const [regex, replacement] of LOG_PATTERNS)
+        result = result.replace(regex, replacement);
+    result = redactSerializedFields(result);
+    result = redact(result, 'balanced').text;
+    return result.length > maxLength
+        ? `${result.slice(0, maxLength)}…[truncated ${result.length - maxLength} chars]`
+        : result;
+}
+/** Return a sanitized, JSON-safe copy of `value`. The input is never modified. */
+export function redactLogValue(value, options = {}) {
+    return sanitize(value, { ...DEFAULTS, ...options }, 0, []);
+}
+/** Render a thrown value (Error or not) as redacted text for direct console output. */
+export function formatErrorForLog(error) {
+    try {
+        if (error instanceof Error) {
+            let text = redactLogText(error.stack || `${error.name}: ${error.message}`);
+            let cause = error.cause;
+            for (let hops = 0; cause !== undefined && hops < 3; hops++) {
+                text += `\nCaused by: ${cause instanceof Error
+                    ? redactLogText(cause.stack || `${cause.name}: ${cause.message}`)
+                    : JSON.stringify(redactLogValue(cause, { maxDepth: 3 }))}`;
+                cause = cause instanceof Error ? cause.cause : undefined;
+            }
+            return text;
+        }
+        return typeof error === 'string'
+            ? redactLogText(error)
+            : JSON.stringify(redactLogValue(error, { maxDepth: 3 })) ?? String(error);
+    }
+    catch {
+        return '[REDACTED:sanitization-failed]';
+    }
+}
+function sanitize(value, opts, depth, ancestors) {
+    try {
+        if (value === null || value === undefined || typeof value === 'number' || typeof value === 'boolean')
+            return value;
+        if (typeof value === 'string')
+            return redactLogText(value, opts.maxStringLength);
+        if (typeof value === 'bigint')
+            return value.toString();
+        if (typeof value === 'symbol')
+            return value.toString();
+        if (typeof value === 'function')
+            return '[function]';
+        const obj = value;
+        if (ancestors.includes(obj))
+            return '[circular]';
+        if (depth >= opts.maxDepth)
+            return '[object]';
+        if (ArrayBuffer.isView(obj))
+            return `[binary ${obj.byteLength} bytes]`;
+        if (obj instanceof ArrayBuffer)
+            return `[binary ${obj.byteLength} bytes]`;
+        if (obj instanceof Date)
+            return Number.isNaN(obj.getTime()) ? '[invalid date]' : obj.toISOString();
+        if (obj instanceof Map || obj instanceof Set)
+            return `[${obj.constructor.name}(${obj.size})]`;
+        const path = [...ancestors, obj];
+        if (Array.isArray(obj)) {
+            const items = obj.slice(0, opts.maxEntries).map(item => sanitize(item, opts, depth + 1, path));
+            if (obj.length > opts.maxEntries)
+                items.push(`[+${obj.length - opts.maxEntries} more]`);
+            return items;
+        }
+        if (obj instanceof Error)
+            return sanitizeError(obj, opts, depth, path);
+        return sanitizeRecord(obj, Object.keys(obj), opts, depth, path);
+    }
+    catch {
+        return '[REDACTED:sanitization-failed]';
+    }
+}
+function sanitizeError(error, opts, depth, path) {
+    const out = {
+        name: redactLogText(String(error.name), opts.maxStringLength),
+        message: redactLogText(String(error.message), opts.maxStringLength),
+    };
+    if (typeof error.stack === 'string')
+        out.stack = redactLogText(error.stack, opts.maxStringLength);
+    const code = error.code;
+    if (typeof code === 'string' || typeof code === 'number')
+        out.code = code;
+    const cause = error.cause;
+    if (cause !== undefined)
+        out.cause = sanitize(cause, opts, depth + 1, path);
+    return out;
+}
+function sanitizeRecord(obj, keys, opts, depth, path) {
+    const out = {};
+    for (const key of keys.slice(0, opts.maxEntries)) {
+        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+        if (!descriptor)
+            continue;
+        if (!('value' in descriptor)) {
+            out[key] = '[getter]';
+            continue;
+        }
+        const v = descriptor.value;
+        // Numbers are redacted too (numeric PINs, session IDs); counters such as
+        // maxTokens/tokensUsed do not match a sensitive suffix in the first place.
+        if (isSensitiveLogKey(key) && v !== null && v !== undefined && typeof v !== 'boolean') {
+            out[key] = '[REDACTED:sensitive-key]';
+            continue;
+        }
+        out[key] = sanitize(v, opts, depth + 1, path);
+    }
+    if (keys.length > opts.maxEntries)
+        out['[truncated]'] = `${keys.length - opts.maxEntries} more keys`;
+    return out;
+}
+//# sourceMappingURL=redaction.js.map