@mnemonik/shared 7.140.3 → 7.141.1

package/src/secretPatterns.ts

@@ -42,6 +42,86 @@
 
 export const SECRET_REDACTION_PLACEHOLDER = '[REDACTED]';
 
+const SECRET_LABEL = String.raw`[\w$-]*(?:api[_-]?key|secret|token|password|credential|auth)|aws_secret_access_key`;
+export const SECRET_LABEL_RE = new RegExp(`^(?:${SECRET_LABEL}|MYSQL_PWD|SSHPASS)$`, 'i');
+const LABELED_VALUE_RE = new RegExp(
+  String.raw`(?<![\w$-])((["']?)(?:${SECRET_LABEL})\2\s*[:=]\s*)(?=\S)`,
+  'gi'
+);
+
+/** Keep physical and escaped newline sequences, including JS line continuations. */
+export function redactSecretValue(value: string): string {
+  return (
+    SECRET_REDACTION_PLACEHOLDER +
+    (value.match(/\\(?:\r\n|[\r\n])|\r\n|[\r\n]|\\[rn]/g)?.join('') ?? '')
+  );
+}
+
+function redactLabeledValues(text: string): string {
+  let result = '';
+  let offset = 0;
+  LABELED_VALUE_RE.lastIndex = 0;
+  for (const match of text.matchAll(LABELED_VALUE_RE)) {
+    if (match.index < offset) continue;
+    const start = match.index + match[0].length;
+    const escaped = text[start] === '\\' && /^["']/.test(text.charAt(start + 1));
+    const quote = escaped
+      ? text.charAt(start + 1)
+      : /^["'`]/.test(text.charAt(start))
+        ? text.charAt(start)
+        : '';
+    const delimiter = (escaped ? '\\' : '') + quote;
+    let end = start;
+    let closed = false;
+    if (quote) {
+      end += delimiter.length;
+      while (end < text.length) {
+        if (text[end] === '\\') {
+          if (escaped) {
+            const begin = end;
+            while (text[end] === '\\') end++;
+            // A quoted value embedded in a string: \" closes, \\\" escapes its quote.
+            if (text[end] === quote && (end - begin) % 4 === 1) {
+              end++;
+              closed = true;
+              break;
+            }
+            end = Math.min(end + 1, text.length);
+          } else {
+            end = Math.min(end + 2, text.length);
+          }
+        } else if (text[end++] === quote && !escaped) {
+          closed = true;
+          break;
+        }
+      }
+    } else {
+      // Never split an escape pair and leave its quote as executable syntax.
+      end += /^(?:\\[^\r\n]|[^\s"'`,;()[\]{}\\])+/.exec(text.slice(start))?.[0].length ?? 0;
+    }
+    const value = text.slice(start, end);
+    if (!/[A-Za-z0-9]/.test(value) || ENV_READ_VALUE_RE.test(match[0] + value)) continue;
+    // The quote closes a command string or anchored label search, such as '^API_KEY='.
+    if (
+      quote &&
+      !escaped &&
+      (text[match.index - 1] === quote ||
+        (text[match.index - 1] === '^' &&
+          text[match.index - 2] === quote &&
+          (start + 1 === text.length || /\s/.test(text.charAt(start + 1)))))
+    )
+      continue;
+    if (/aws_secret_access_key/i.test(match[0]) && /^<[^>]*>$/.test(value)) continue;
+    const body = quote
+      ? value.slice(delimiter.length, closed ? -delimiter.length : undefined)
+      : value.replace(/(?:\*\/|[.!?]+)$/, '');
+    const tail = quote ? (closed ? delimiter : '') : value.slice(body.length);
+    result += text.slice(offset, start) + delimiter + redactSecretValue(body) + tail;
+    offset = end;
+  }
+  return result + text.slice(offset);
+}
+
 // Shared by the scanner daemon and server-side scrub paths.
 //
 // A value must hold a letter or a digit, in every pattern whose value is free
@@ -50,7 +130,7 @@ export const SECRET_REDACTION_PLACEHOLDER = '[REDACTED]';
 // flag: "--password=; repeated copies" in a stored checkpoint became
 // "--[REDACTED] repeated copies" (2026-10-13), and so did "password: ***".
 export const SECRET_PATTERNS: ReadonlyArray<RegExp> = [
-  /(?:api[_-]?key|secret|token|password|credential|auth)\s*[:=]\s*(?=\S*[A-Za-z0-9])\S+/gi,
+  LABELED_VALUE_RE, // Select the label; the linear reader consumes its complete value.
   // Stripe-shape: (sk|pk)_(live|test)_<24+ alphanumerics>. Catches modern
   // Stripe keys whose body is split by an environment separator that
   // breaks the contiguous-alphanum pattern below. Required `live|test`
@@ -71,10 +151,7 @@ export const SECRET_PATTERNS: ReadonlyArray<RegExp> = [
   // \b-delimited, so prose ("AKIAMIA is a place name") cannot match.
   /\bAKIA[0-9A-Z]{16}\b/g,
   /\bASIA[0-9A-Z]{16}\b/g,
-  // AWS secret access key, labeled. The generic key=value pattern above does
-  // NOT cover this: its `secret` alternative must be followed immediately by
-  // `[:=]`, and here it is followed by `_access_key`.
-  /\baws_secret_access_key\s*[:=]\s*[A-Za-z0-9/+=]{40}\b/gi,
+  // Labeled AWS secret access keys are covered by LABELED_VALUE_RE, including quotes.
   // JWT: three base64url segments. Length minimums keep dotted identifiers
   // (`payload.header.signature`) out.
   /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}\b/g,
@@ -253,9 +330,13 @@ export function scrubSecrets(text: string): string {
   if (!text) return text;
   let result = text;
   for (const pattern of SECRET_PATTERNS) {
-    result = result.replace(pattern, (match) =>
-      ENV_READ_VALUE_RE.test(match) ? match : SECRET_REDACTION_PLACEHOLDER
-    );
+    if (pattern === LABELED_VALUE_RE) {
+      result = redactLabeledValues(result);
+    } else {
+      result = result.replace(pattern, (match) =>
+        ENV_READ_VALUE_RE.test(match) ? match : redactSecretValue(match)
+      );
+    }
   }
   // Backstop for credentials with no recognizable prefix. Runs last so the
   // precise provider patterns get first claim on their own shapes.

package/src/sourceRedaction.ts

@@ -0,0 +1,149 @@
+import { extname } from 'node:path';
+import { Parser, type Node, type Tree } from 'web-tree-sitter';
+import { loadGrammar } from './ast/grammars.js';
+import { MAX_AST_PARSE_BYTES } from './ast/astChunker.js';
+import { redactCredentials } from './redactCredentials.js';
+import {
+  redactHighEntropyTokens,
+  redactSecretValue,
+  scrubSecrets,
+  SECRET_LABEL_RE,
+} from './secretPatterns.js';
+
+function scrubPayload(text: string): string {
+  return redactCredentials(scrubSecrets(text), { commandLineOnly: true }).text;
+}
+
+/** Source syntax stays executable; unsupported or incomplete input uses the conservative scrubber. */
+export async function scrubSourceSecrets(text: string, filePath: string): Promise<string> {
+  const extension = extname(filePath).toLowerCase();
+  const language = ['.ts', '.mts', '.cts'].includes(extension)
+    ? 'typescript'
+    : extension === '.tsx'
+      ? 'tsx'
+      : ['.js', '.jsx', '.mjs', '.cjs'].includes(extension)
+        ? 'javascript'
+        : null;
+  if (!text || !language || Buffer.byteLength(text, 'utf8') > MAX_AST_PARSE_BYTES) {
+    return scrubPayload(text);
+  }
+  let parser: Parser | undefined;
+  let tree: Tree | null = null;
+  try {
+    const grammar = await loadGrammar(language);
+    if ('unavailable' in grammar) return scrubPayload(text);
+    parser = new Parser();
+    parser.setLanguage(grammar.ok.language);
+    tree = parser.parse(text);
+    if (!tree || tree.rootNode.hasError) return scrubPayload(text);
+    const root = tree.rootNode;
+    return text.slice(0, root.startIndex) + redactNode(root) + text.slice(root.endIndex);
+  } catch {
+    return scrubPayload(text);
+  } finally {
+    tree?.delete();
+    parser?.delete();
+  }
+}
+
+function secretLabel(node: Node | null): boolean {
+  if (!node) return false;
+  const property = node.childForFieldName('property') ?? node;
+  const name = property.type === 'string' ? property.text.slice(1, -1) : property.text;
+  return SECRET_LABEL_RE.test(name);
+}
+
+function literalPayload(text: string, sensitive: boolean): string {
+  if (sensitive && /[A-Za-z0-9]/.test(text)) return redactSecretValue(text);
+  // Only the entropy backstop needs an opening quote; labeled values must not consume it.
+  return redactHighEntropyTokens('"' + scrubPayload(text) + '"').slice(1, -1);
+}
+
+function redactNode(node: Node, sensitive = false): string {
+  const original = node.text;
+  if (node.type === 'comment') {
+    return original.startsWith('/*')
+      ? '/*' + scrubPayload(original.slice(2, -2)) + '*/'
+      : '//' + scrubPayload(original.slice(2));
+  }
+  if (node.type === 'string') {
+    return original[0] + literalPayload(original.slice(1, -1), sensitive) + original.at(-1);
+  }
+  if (
+    node.type === 'property_identifier' &&
+    node.parent?.type === 'pair' &&
+    node.parent.childForFieldName('key')?.id === node.id
+  ) {
+    const payload = literalPayload(original, false);
+    return payload === original ? original : '"' + payload + '"';
+  }
+  if (node.type === 'number' && sensitive) return `'${redactSecretValue(original)}'`;
+  if (node.type === 'template_string') {
+    let result = '`';
+    let offset = node.startIndex + 1;
+    for (const child of node.namedChildren) {
+      if (child.type !== 'template_substitution') continue;
+      result += literalPayload(
+        original.slice(offset - node.startIndex, child.startIndex - node.startIndex),
+        sensitive
+      );
+      result += redactNode(child);
+      offset = child.endIndex;
+    }
+    return result + literalPayload(original.slice(offset - node.startIndex, -1), sensitive) + '`';
+  }
+  if (node.type === 'regex_pattern' || node.type === 'jsx_text') return scrubPayload(original);
+  // A bare `token: value` fragment is also a valid JS labeled statement.
+  if (node.type === 'labeled_statement' && secretLabel(node.childForFieldName('label'))) {
+    const body = node.childForFieldName('body');
+    if (body?.firstNamedChild?.type === 'identifier') return scrubPayload(original);
+  }
+
+  let value: Node | null = null;
+  let key: Node | null = null;
+  if (
+    [
+      'variable_declarator',
+      'pair',
+      'public_field_definition',
+      'assignment_pattern',
+      'required_parameter',
+    ].includes(node.type)
+  ) {
+    key =
+      node.childForFieldName('name') ??
+      node.childForFieldName('key') ??
+      node.childForFieldName('pattern') ??
+      node.childForFieldName('left');
+    value = node.childForFieldName('value') ?? node.childForFieldName('right');
+  } else if (node.type === 'assignment_expression') {
+    key = node.childForFieldName('left');
+    value = node.childForFieldName('right');
+  } else if (node.type === 'jsx_attribute') {
+    [key = null, value = null] = node.namedChildren;
+  }
+  const labeled = secretLabel(key);
+  let result = '';
+  let offset = node.startIndex;
+  for (const child of node.namedChildren) {
+    result += original.slice(offset - node.startIndex, child.startIndex - node.startIndex);
+    // Carry labels through value wrappers, never through call arguments or conditions.
+    const carry =
+      sensitive &&
+      (([
+        'parenthesized_expression',
+        'as_expression',
+        'satisfies_expression',
+        'non_null_expression',
+      ].includes(node.type) &&
+        child.id === node.firstNamedChild?.id) ||
+        (node.type === 'type_assertion' && child.id === node.lastNamedChild?.id) ||
+        (node.type === 'binary_expression' &&
+          ['+', '||', '&&', '??'].includes(node.childForFieldName('operator')?.text ?? '')) ||
+        (node.type === 'ternary_expression' &&
+          child.id !== node.childForFieldName('condition')?.id));
+    result += redactNode(child, carry || (labeled && child.id === value?.id));
+    offset = child.endIndex;
+  }
+  return result + original.slice(offset - node.startIndex);
+}