@miphamai/cli 0.22.0 → 0.24.0

package/src/core/credential-masker/matcher.ts

@@ -0,0 +1,106 @@
+import { homedir } from 'node:os'
+import type { CredentialMaskingConfig, CredentialFileRule } from '../../shared/index.ts'
+
+/**
+ * Check if a file path matches any credential file rule.
+ * Returns the matching rule, or null if no match.
+ */
+export function matchCredentialFile(
+  filePath: string,
+  config: CredentialMaskingConfig,
+): CredentialFileRule | null {
+  if (!config.enabled || config.files.length === 0) return null
+
+  const expanded = expandHome(filePath)
+  for (const rule of config.files) {
+    if (matchPath(expanded, rule.path)) {
+      return rule
+    }
+  }
+  return null
+}
+
+// ── Internal helpers ──
+
+/**
+ * Expand ~ to the user's home directory.
+ */
+export function expandHome(p: string): string {
+  if (p.startsWith('~')) {
+    return homedir() + p.slice(1)
+  }
+  return p
+}
+
+/**
+ * Match a file path against a glob-like pattern.
+ * Supports:
+ * - ** globstar (matches any number of path segments)
+ * - * wildcard within a single path segment
+ * - ? single char
+ * - ~ home directory expansion
+ * - basename-only matching (e.g. ".env*" matches any .env file)
+ */
+export function matchPath(filePath: string, pattern: string): boolean {
+  const expandedPattern = expandHome(pattern)
+  const normalizedFile = filePath.replace(/\\/g, '/')
+  const normalizedPattern = expandedPattern.replace(/\\/g, '/')
+
+  if (normalizedFile === normalizedPattern) return true
+
+  // File ends with pattern (for relative basename matching like ".env*")
+  if (normalizedFile.endsWith('/' + normalizedPattern)) return true
+
+  const regex = globToRegex(normalizedPattern)
+  if (regex.test(normalizedFile)) return true
+
+  // Basename-only matching: patterns without path separators match
+  // against the last component of the file path (e.g. ".env*" matches any .env file)
+  if (!normalizedPattern.includes('/')) {
+    const basename = normalizedFile.split('/').pop() || normalizedFile
+    if (regex.test(basename)) return true
+  }
+
+  return false
+}
+
+/**
+ * Convert a glob pattern to a RegExp.
+ * - ** → .* (matches any path segments)
+ * - *  → [^/]* (matches within a single segment)
+ * - ?  → . (single char)
+ * - All other special regex chars are escaped.
+ */
+export function globToRegex(pattern: string): RegExp {
+  let regexStr = ''
+  let i = 0
+  while (i < pattern.length) {
+    const ch = pattern[i]!
+    if (ch === '*' && pattern[i + 1] === '*') {
+      // ** — match zero or more path segments
+      regexStr += '.*'
+      i += 2
+      // Skip trailing slash after **
+      if (pattern[i] === '/') i++
+      continue
+    }
+    if (ch === '*') {
+      regexStr += '[^/]*'
+      i++
+      continue
+    }
+    if (ch === '?') {
+      regexStr += '.'
+      i++
+      continue
+    }
+    // Escape regex special chars
+    if ('\\^$.|+()[]{}'.includes(ch)) {
+      regexStr += '\\' + ch
+    } else {
+      regexStr += ch
+    }
+    i++
+  }
+  return new RegExp('^' + regexStr + '$')
+}

package/src/core/credential-masker/output-scrub.ts

@@ -0,0 +1,27 @@
+import { CREDENTIAL_SENTINEL } from './types'
+import type { CredentialMaskingConfig } from '../../shared/index.ts'
+
+/**
+ * Scrub credential patterns from stdout/stderr output.
+ * Uses the configured output_scrubbing patterns to detect and replace
+ * credentials that may have leaked into command output.
+ */
+export function maskOutput(output: string, config: CredentialMaskingConfig): string {
+  if (!config.enabled || !config.output_scrubbing.enabled) return output
+
+  let masked = output
+  for (const pattern of config.output_scrubbing.patterns) {
+    try {
+      // Strip (?i) inline flags — JS uses the 'i' flag instead
+      const clean = pattern.replace(/^\(\?i\)/, '')
+      const regex = new RegExp(clean, 'gim')
+      masked = masked.replace(regex, (match) => {
+        // Replace everything after the separator (= or :)
+        return match.replace(/\s*[:=]\s*\S+/, `=${CREDENTIAL_SENTINEL}`)
+      })
+    } catch {
+      // Invalid regex — skip
+    }
+  }
+  return masked
+}

package/src/core/credential-masker/pipeline.ts

@@ -0,0 +1,67 @@
+import type { CredentialFileRule } from '../../shared/index.ts'
+import type { MaskingStrategy } from './types'
+import { CREDENTIAL_SENTINEL } from './types'
+
+/**
+ * MaskingPipeline chains multiple MaskingStrategy instances.
+ * When maskContent is called, the first strategy whose canHandle()
+ * returns true performs the masking. If no strategy matches, falls
+ * back to legacy full/extract behavior.
+ */
+export class MaskingPipeline {
+  private strategies: MaskingStrategy[] = []
+
+  /** Register a strategy. Later registrations take priority (checked first). */
+  register(strategy: MaskingStrategy): void {
+    this.strategies.unshift(strategy)
+  }
+
+  /** Apply masking to content according to a rule. */
+  maskContent(content: string, rule: CredentialFileRule): string {
+    for (const strategy of this.strategies) {
+      if (strategy.canHandle(rule)) {
+        return strategy.mask(content, rule)
+      }
+    }
+
+    // Fallback to legacy full/extract behavior
+    if ('mode' in rule && rule.mode === 'full') {
+      return CREDENTIAL_SENTINEL
+    }
+
+    // Legacy extract mode
+    if ('mode' in rule && 'extract' in rule && Array.isArray(rule.extract)) {
+      let masked = content
+      for (const extractRule of rule.extract) {
+        const replacement = extractRule.replacement || CREDENTIAL_SENTINEL
+        try {
+          const regex = new RegExp(extractRule.pattern, 'gm')
+          masked = masked.replace(regex, replacement)
+        } catch {
+          // Invalid regex — skip this rule silently
+        }
+      }
+      return masked
+    }
+
+    return content
+  }
+}
+
+/** Singleton pipeline instance. */
+let _pipeline: MaskingPipeline | null = null
+
+export function getPipeline(): MaskingPipeline {
+  if (!_pipeline) {
+    _pipeline = new MaskingPipeline()
+  }
+  return _pipeline
+}
+
+/**
+ * Convenience function matching the original maskContent signature.
+ * Uses the singleton pipeline.
+ */
+export function maskContent(content: string, rule: CredentialFileRule): string {
+  return getPipeline().maskContent(content, rule)
+}

package/src/core/credential-masker/strategies/aws.ts

@@ -0,0 +1,50 @@
+import type { MaskingStrategy } from '../types'
+import type { CredentialFileRule, AwsMaskingRule } from '../../../shared/index.ts'
+import { CREDENTIAL_SENTINEL } from '../types'
+
+/**
+ * AWS credential masking strategy.
+ *
+ * Phase 1: Detects AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY pairs
+ * and masks the secret key while preserving partial access key for context.
+ * SigV4 re-signing is deferred to Phase 2 (requires TLS termination).
+ */
+export class AwsMaskingStrategy implements MaskingStrategy {
+  readonly name = 'aws'
+
+  canHandle(rule: CredentialFileRule): rule is AwsMaskingRule {
+    return 'type' in rule && rule.type === 'aws'
+  }
+
+  mask(content: string, rule: AwsMaskingRule): string {
+    if (!rule.awsPairs) return content
+
+    let masked = content
+
+    // Mask access key values — keep prefix for model context
+    masked = masked.replace(/((?:AKIA|ASIA)[A-Z0-9]{12,})/g, (_full, key: string) => {
+      const prefix = key.slice(0, 8) // "AKIAXXXX"
+      return `${prefix}${CREDENTIAL_SENTINEL}`
+    })
+
+    // Mask secret access key values — fully mask (no context needed)
+    masked = masked.replace(
+      /(?:AWS_SECRET_ACCESS_KEY|aws_secret_access_key)\s*[:=]\s*([A-Za-z0-9/+=]{40,})/gi,
+      (match) => {
+        const parts = match.split(/[:=]\s*/)
+        return `${parts[0]}=${CREDENTIAL_SENTINEL}`
+      },
+    )
+
+    // Also mask inline secret key patterns (bare base64-like strings near key markers)
+    masked = masked.replace(
+      /(?:aws_secret_access_key|secret_access_key|SECRET_ACCESS_KEY)\s*[:=]\s*([A-Za-z0-9/+=]{40,})/gi,
+      (match) => {
+        const parts = match.split(/[:=]\s*/)
+        return `${parts[0]}=${CREDENTIAL_SENTINEL}`
+      },
+    )
+
+    return masked
+  }
+}

package/src/core/credential-masker/strategies/extract.ts

@@ -0,0 +1,106 @@
+import type { MaskingStrategy } from '../types'
+import type { CredentialFileRule, CredentialExtractRule } from '../../../shared/index.ts'
+import { CREDENTIAL_SENTINEL } from '../types'
+
+export class ExtractMaskingStrategy implements MaskingStrategy {
+  readonly name = 'extract'
+
+  canHandle(rule: CredentialFileRule): rule is CredentialExtractRule {
+    return 'mode' in rule && rule.mode === 'extract' && !('type' in rule)
+  }
+
+  mask(content: string, rule: CredentialExtractRule): string {
+    let masked = content
+    let anyMatch = false
+
+    for (const extractRule of rule.extract) {
+      const replacement = extractRule.replacement || CREDENTIAL_SENTINEL
+
+      if (extractRule.field) {
+        // Structured extraction: extract field by key before applying pattern
+        masked = this.maskField(masked, extractRule.field, extractRule.pattern, replacement)
+        anyMatch = true // field extraction always applies
+      } else {
+        // Traditional regex extraction
+        try {
+          const regex = new RegExp(extractRule.pattern, 'gm')
+          if (regex.test(masked)) {
+            anyMatch = true
+            // Re-create regex since test() advances lastIndex
+            const re = new RegExp(extractRule.pattern, 'gm')
+            masked = masked.replace(re, replacement)
+          }
+        } catch {
+          // Invalid regex — skip
+        }
+      }
+    }
+
+    // Handle onExtractNoMatch
+    const onNoMatch = rule.onExtractNoMatch || 'mask'
+    if (!anyMatch && onNoMatch === 'mask') {
+      return CREDENTIAL_SENTINEL
+    }
+
+    return masked
+  }
+
+  /**
+   * Extract a JSON field by key and apply pattern masking to its value.
+   * Supports nested keys with dot notation (e.g. "auth.api_key").
+   */
+  private maskField(
+    content: string,
+    fieldPath: string,
+    pattern: string,
+    replacement: string,
+  ): string {
+    try {
+      // Try parsing as JSON
+      const parsed = JSON.parse(content)
+      this.setNestedValue(parsed, fieldPath, (value) => {
+        if (typeof value === 'string') {
+          try {
+            const regex = new RegExp(pattern)
+            return value.replace(regex, replacement)
+          } catch {
+            return replacement
+          }
+        }
+        return replacement
+      })
+      return JSON.stringify(parsed, null, 2)
+    } catch {
+      // Not valid JSON — fall back to regex on raw content
+      try {
+        const regex = new RegExp(pattern, 'gm')
+        return content.replace(regex, replacement)
+      } catch {
+        return content
+      }
+    }
+  }
+
+  /**
+   * Set a nested value in an object using dot-notation path.
+   */
+  private setNestedValue(
+    obj: Record<string, unknown>,
+    path: string,
+    transform: (value: unknown) => unknown,
+  ): void {
+    const keys = path.split('.')
+    let current: Record<string, unknown> = obj
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i]!
+      if (!current[key] || typeof current[key] !== 'object') return
+      current = current[key] as Record<string, unknown>
+    }
+
+    const lastKey = keys[keys.length - 1]!
+    if (lastKey in current) {
+      current[lastKey] = transform(current[lastKey])
+    }
+  }
+}

package/src/core/credential-masker/strategies/full.ts

@@ -0,0 +1,15 @@
+import type { MaskingStrategy } from '../types'
+import type { CredentialFileRule, CredentialFullMaskRule } from '../../../shared/index.ts'
+import { CREDENTIAL_SENTINEL } from '../types'
+
+export class FullMaskingStrategy implements MaskingStrategy {
+  readonly name = 'full'
+
+  canHandle(rule: CredentialFileRule): rule is CredentialFullMaskRule {
+    return 'mode' in rule && rule.mode === 'full' && !('type' in rule)
+  }
+
+  mask(_content: string, _rule: CredentialFullMaskRule): string {
+    return CREDENTIAL_SENTINEL
+  }
+}

package/src/core/credential-masker/strategies/jwt.ts

@@ -0,0 +1,75 @@
+import type { MaskingStrategy } from '../types'
+import type { CredentialFileRule, JwtMaskingRule } from '../../../shared/index.ts'
+
+export class JwtMaskingStrategy implements MaskingStrategy {
+  readonly name = 'jwt'
+
+  canHandle(rule: CredentialFileRule): rule is JwtMaskingRule {
+    return 'type' in rule && rule.type === 'jwt'
+  }
+
+  mask(content: string, rule: JwtMaskingRule): string {
+    return content
+      .split('\n')
+      .map((line) => this.maskLine(line, rule))
+      .join('\n')
+  }
+
+  private maskLine(line: string, rule: JwtMaskingRule): string {
+    const trimmed = line.trim()
+
+    // Check if this looks like a JWT (three base64url segments separated by dots)
+    const segments = trimmed.split('.')
+    if (segments.length !== 3) return line
+
+    // Verify each segment is base64url
+    const b64urlRegex = /^[A-Za-z0-9_-]+$/
+    if (!segments.every((s) => b64urlRegex.test(s))) return line
+
+    try {
+      const header = segments[0]!
+      const payload = segments[1]!
+      const signature = segments[2]!
+
+      // Decode payload
+      const decodedPayload = this.decodeBase64Url(payload)
+      let payloadObj: Record<string, unknown>
+      try {
+        payloadObj = JSON.parse(decodedPayload)
+      } catch {
+        return line // Not valid JSON — not a JWT
+      }
+
+      // Mask specified claims
+      let modified = false
+      for (const claim of rule.maskClaims) {
+        if (claim in payloadObj) {
+          payloadObj[claim] = '[MASKED]'
+          modified = true
+        }
+      }
+
+      if (!modified) return line
+
+      // Re-encode payload
+      const newPayload = this.encodeBase64Url(JSON.stringify(payloadObj))
+      return `${header}.${newPayload}.${signature}`
+    } catch {
+      return line // Decode failure — return unchanged
+    }
+  }
+
+  private decodeBase64Url(str: string): string {
+    // Convert base64url to base64
+    const base64 = str.replace(/-/g, '+').replace(/_/g, '/')
+    // Pad
+    const padded = base64 + '==='.slice(0, (4 - (base64.length % 4)) % 4)
+    // Decode
+    return Buffer.from(padded, 'base64').toString('utf-8')
+  }
+
+  private encodeBase64Url(str: string): string {
+    const base64 = Buffer.from(str, 'utf-8').toString('base64')
+    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+  }
+}

package/src/core/credential-masker/types.ts

@@ -0,0 +1,16 @@
+import type { CredentialFileRule } from '../../shared/index.ts'
+
+/** Sentinel value used to replace masked credentials. */
+export const CREDENTIAL_SENTINEL = '__MIPHAM_CREDENTIAL_MASKED__'
+
+/** Strategy interface for credential masking. Each strategy handles one rule type. */
+export interface MaskingStrategy {
+  /** Unique name for this strategy. */
+  readonly name: string
+
+  /** Return true if this strategy handles the given rule. */
+  canHandle(rule: CredentialFileRule): boolean
+
+  /** Apply masking to content according to the rule. Returns masked content. */
+  mask(content: string, rule: CredentialFileRule): string
+}

package/src/core/credential-masker.ts

@@ -1,117 +1,23 @@
-import { homedir } from 'node:os'
-import type { CredentialMaskingConfig, CredentialFileRule } from '../shared/index.ts'
-
-/** Sentinel value used to replace masked credentials. */
-export const CREDENTIAL_SENTINEL = '__MIPHAM_CREDENTIAL_MASKED__'
-
 /**
- * Check if a file path matches any credential file rule.
- * Returns the matching rule, or null if no match.
+ * Backward-compatible re-exports from the modular credential-masker/ pipeline.
+ *
+ * This file preserves the original API surface while delegating to the
+ * modular strategy-based implementation under credential-masker/.
  */
-export function matchCredentialFile(
-  filePath: string,
-  config: CredentialMaskingConfig,
-): CredentialFileRule | null {
-  if (!config.enabled || config.files.length === 0) return null
-
-  const expanded = expandHome(filePath)
-  for (const rule of config.files) {
-    if (matchPath(expanded, rule.path)) {
-      return rule
-    }
-  }
-  return null
-}
 
-/**
- * Apply credential masking to file content.
- * - 'full' mode: return sentinel value only
- * - 'extract' mode: replace regex-matched tokens with sentinel
- */
-export function maskContent(content: string, rule: CredentialFileRule): string {
-  if (rule.mode === 'full') {
-    return CREDENTIAL_SENTINEL
-  }
-
-  // extract mode
-  let masked = content
-  for (const extractRule of rule.extract) {
-    const replacement = extractRule.replacement || CREDENTIAL_SENTINEL
-    try {
-      const regex = new RegExp(extractRule.pattern, 'gm')
-      masked = masked.replace(regex, replacement)
-    } catch {
-      // Invalid regex — skip this rule silently
-    }
-  }
-  return masked
-}
+// Re-export sentinel constant
+export { CREDENTIAL_SENTINEL } from './credential-masker/types'
 
-/**
- * Scrub credential patterns from stdout/stderr output.
- * Uses the configured output_scrubbing patterns to detect and replace
- * credentials that may have leaked into command output.
- */
-export function maskOutput(output: string, config: CredentialMaskingConfig): string {
-  if (!config.enabled || !config.output_scrubbing.enabled) return output
-
-  let masked = output
-  for (const pattern of config.output_scrubbing.patterns) {
-    try {
-      // Strip (?i) inline flags — JS uses the 'i' flag instead
-      const clean = pattern.replace(/^\(\?i\)/, '')
-      const regex = new RegExp(clean, 'gim')
-      masked = masked.replace(regex, (match) => {
-        // Replace everything after the separator (= or :)
-        return match.replace(/\s*[:=]\s*\S+/, `=${CREDENTIAL_SENTINEL}`)
-      })
-    } catch {
-      // Invalid regex — skip
-    }
-  }
-  return masked
-}
-
-/**
- * Filter sensitive environment variables before spawning a subprocess.
- * Returns a sanitized copy of process.env with matching vars removed.
- */
-export function filterEnv(
-  env: Record<string, string | undefined>,
-  config: CredentialMaskingConfig,
-): Record<string, string | undefined> {
-  if (!config.enabled || !config.env_filter.enabled) return { ...env }
-
-  const filtered: Record<string, string | undefined> = {}
-  for (const [key, value] of Object.entries(env)) {
-    let blocked = false
-    for (const pattern of config.env_filter.patterns) {
-      try {
-        // Strip (?i) inline flags — JS uses the 'i' flag instead
-        const clean = pattern.replace(/^\(\?i\)/, '')
-        const regex = new RegExp(clean, 'i')
-        if (regex.test(key)) {
-          blocked = true
-          break
-        }
-      } catch {
-        // Invalid regex — skip
-      }
-    }
-    if (blocked) {
-      // Replace with sentinel so tools can detect they're filtered
-      filtered[key] = CREDENTIAL_SENTINEL
-    } else {
-      filtered[key] = value
-    }
-  }
+// Re-export core functions
+export { matchCredentialFile } from './credential-masker/matcher'
+export { maskContent } from './credential-masker/pipeline'
+export { maskOutput } from './credential-masker/output-scrub'
+export { filterEnv } from './credential-masker/env-filter'
 
-  return filtered
-}
+import { CREDENTIAL_SENTINEL } from './credential-masker/types'
 
 /**
  * Get the file display name for a sentinel value (for model visibility).
- * The model sees the sentinel, doesn't know the original file path.
  */
 export function getSentinelDisplay(hint?: string): string {
   if (hint) {
@@ -119,84 +25,3 @@ export function getSentinelDisplay(hint?: string): string {
   }
   return CREDENTIAL_SENTINEL
 }
-
-// ── Internal helpers ──
-
-/**
- * Expand ~ to the user's home directory.
- */
-function expandHome(p: string): string {
-  if (p.startsWith('~')) {
-    return homedir() + p.slice(1)
-  }
-  return p
-}
-
-/**
- * Match a file path against a glob-like pattern.
- * Supports:
- * - ** globstar (matches any number of path segments)
- * - * wildcard within a single path segment
- * - ~ home directory expansion
- * - basename-only matching (e.g. ".env*" matches any .env file)
- */
-function matchPath(filePath: string, pattern: string): boolean {
-  const expandedPattern = expandHome(pattern)
-  const normalizedFile = filePath.replace(/\\/g, '/')
-  const normalizedPattern = expandedPattern.replace(/\\/g, '/')
-
-  // Exact match
-  if (normalizedFile === normalizedPattern) {
-    return true
-  }
-
-  // File ends with pattern (for relative basename matching like ".env*")
-  if (normalizedFile.endsWith('/' + normalizedPattern)) {
-    return true
-  }
-
-  // Convert glob pattern to regex
-  const regex = globToRegex(normalizedPattern)
-  return regex.test(normalizedFile)
-}
-
-/**
- * Convert a glob pattern to a RegExp.
- * - ** → .* (matches any path segments)
- * - *  → [^/]* (matches within a single segment)
- * - ?  → . (single char)
- * - All other special regex chars are escaped.
- */
-function globToRegex(pattern: string): RegExp {
-  let regexStr = ''
-  let i = 0
-  while (i < pattern.length) {
-    const ch = pattern[i]!
-    if (ch === '*' && pattern[i + 1] === '*') {
-      // ** — match zero or more path segments
-      regexStr += '.*'
-      i += 2
-      // Skip trailing slash after **
-      if (pattern[i] === '/') i++
-      continue
-    }
-    if (ch === '*') {
-      regexStr += '[^/]*'
-      i++
-      continue
-    }
-    if (ch === '?') {
-      regexStr += '.'
-      i++
-      continue
-    }
-    // Escape regex special chars
-    if ('\\^$.|+()[]{}'.includes(ch)) {
-      regexStr += '\\' + ch
-    } else {
-      regexStr += ch
-    }
-    i++
-  }
-  return new RegExp('^' + regexStr + '$')
-}