@mnstry/atelier 0.2.0-alpha.4 → 0.2.0-alpha.5

package/src/disclosure/content-scan.mjs

@@ -0,0 +1,193 @@
+import { execFileSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+export const STRUCTURAL_DISCLOSURE_PATTERNS = Object.freeze([
+  { pattern: new RegExp('\\/Users\\/'), label: 'absolute user path' },
+  { pattern: new RegExp('\\/var\\/folders\\/'), label: 'machine-local temp path' },
+  { pattern: new RegExp('\\.' + 'codex'), label: 'agent-local state path' },
+  {
+    pattern: new RegExp([
+      'BEGIN ',
+      '(?:[A-Z0-9]+ ){0,4}',
+      'PRIVATE KEY(?: BLOCK)?',
+      '|BEGIN (?:RSA|OPENSSH) KEY',
+    ].join('')),
+    label: 'private key material',
+  },
+  { pattern: /"d"\s*:\s*"[A-Za-z0-9_-]{20,}"/, label: 'JWK private key material' },
+  {
+    pattern: /\b(api[_-]?key|secret|password|(?<!id-)token)\b\s*[:=]/i,
+    label: 'secret-like assignment',
+  },
+])
+
+export function compileDisclosurePatterns(patternDocs = []) {
+  if (!Array.isArray(patternDocs)) throw new Error('denylist document must contain a patterns array')
+  return patternDocs.map(({ pattern, flags = '', label }) => {
+    if (typeof label !== 'string' || label.length === 0) throw new Error('denylist pattern label must be non-empty')
+    if (typeof pattern !== 'string' || pattern.length === 0) throw new Error(`denylist pattern failed to compile: ${label}`)
+    try {
+      return { pattern: new RegExp(pattern, String(flags).replace(/[gy]/g, '')), label }
+    } catch {
+      throw new Error(`denylist pattern failed to compile: ${label}`)
+    }
+  })
+}
+
+export function scanDisclosureContent({
+  root = process.cwd(),
+  staged = false,
+  denylistPatterns = [],
+  failOnBinary = false,
+} = {}) {
+  const resolvedRoot = path.resolve(root)
+  assertGitCheckout(resolvedRoot)
+  const patterns = [...STRUCTURAL_DISCLOSURE_PATTERNS, ...denylistPatterns]
+  const findings = []
+  const skippedBinary = []
+  let scannedFiles = 0
+
+  for (const entry of stagedEntries(resolvedRoot, staged)) {
+    const buffer = entry.buffer ?? readTrackedFile(resolvedRoot, entry.path)
+    if (buffer === null) continue
+    const text = decodeText(buffer)
+    if (text === null) {
+      skippedBinary.push(entry.path)
+      if (failOnBinary) findings.push({ label: 'binary content cannot be disclosure-scanned', path: entry.path, line: null })
+      continue
+    }
+
+    scannedFiles += 1
+    const lines = text.split('\n')
+    for (let index = 0; index < lines.length; index += 1) {
+      for (const { pattern, label } of patterns) {
+        if (pattern.test(lines[index])) findings.push({ label, path: entry.path, line: index + 1 })
+      }
+    }
+  }
+
+  return {
+    ok: findings.length === 0,
+    staged,
+    scannedFiles,
+    skippedBinary,
+    findings,
+  }
+}
+
+function decodeText(buffer) {
+  if (buffer.includes(0)) return null
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(buffer)
+  } catch {
+    return null
+  }
+}
+
+export function isPathTracked(root, candidatePath) {
+  const resolvedRoot = path.resolve(root)
+  const resolvedCandidate = path.resolve(candidatePath)
+  const relative = path.relative(resolvedRoot, resolvedCandidate)
+  if (relative.startsWith('..') || path.isAbsolute(relative)) return false
+  const gitRelative = relative.split(path.sep).join('/')
+  const result = execFileSync('git', ['-C', resolvedRoot, 'ls-files', '-z', '--', gitRelative], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+  if (result.split('\0').filter(Boolean).includes(gitRelative)) return true
+
+  // Git pathspec matching is case-sensitive even when the checkout filesystem
+  // is not. Compare filesystem identities so alternate-cased callers cannot
+  // make a tracked file appear local and untracked.
+  return execFileSync('git', [
+    '-C',
+    resolvedRoot,
+    'ls-files',
+    '-z',
+    '--',
+    `:(icase,literal)${gitRelative}`,
+  ], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+    .split('\0')
+    .filter(Boolean)
+    .some((trackedPath) => sameExistingFile(resolvedCandidate, path.join(resolvedRoot, trackedPath)))
+}
+
+function sameExistingFile(left, right) {
+  try {
+    if (fs.realpathSync.native(left) === fs.realpathSync.native(right)) return true
+    const leftStat = fs.statSync(left)
+    const rightStat = fs.statSync(right)
+    return leftStat.ino !== 0 && leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino
+  } catch {
+    return false
+  }
+}
+
+export function isPathIgnored(root, candidatePath) {
+  const resolvedRoot = path.resolve(root)
+  const relative = path.relative(resolvedRoot, path.resolve(candidatePath))
+  if (relative.startsWith('..') || path.isAbsolute(relative)) return false
+  const gitRelative = relative.split(path.sep).join('/')
+  try {
+    execFileSync('git', ['-C', resolvedRoot, 'check-ignore', '--quiet', '--', gitRelative], {
+      stdio: ['ignore', 'ignore', 'ignore'],
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+function assertGitCheckout(root) {
+  try {
+    execFileSync('git', ['-C', root, 'rev-parse', '--git-dir'], {
+      stdio: ['ignore', 'ignore', 'ignore'],
+    })
+  } catch {
+    throw new Error(`disclosure root is not a Git checkout`)
+  }
+}
+
+function stagedEntries(root, staged) {
+  if (!staged) {
+    return git(root, ['ls-files', '-z'])
+      .split('\0')
+      .filter(Boolean)
+      .map((filePath) => ({ path: filePath }))
+  }
+
+  return git(root, ['diff', '--cached', '--name-only', '--diff-filter=ACMR', '-z'])
+    .split('\0')
+    .filter(Boolean)
+    .map((filePath) => ({
+      path: filePath,
+      buffer: execFileSync('git', ['-C', root, 'show', `:${filePath}`], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        maxBuffer: 64 * 1024 * 1024,
+      }),
+    }))
+}
+
+function readTrackedFile(root, relativePath) {
+  const absolutePath = path.join(root, relativePath)
+  let stat
+  try {
+    stat = fs.lstatSync(absolutePath)
+  } catch {
+    return null
+  }
+  if (!stat.isFile()) return null
+  return fs.readFileSync(absolutePath)
+}
+
+function git(root, args) {
+  return execFileSync('git', ['-C', root, ...args], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    maxBuffer: 64 * 1024 * 1024,
+  })
+}

package/src/egress/check.mjs

@@ -1,44 +1,13 @@
-import fs from 'node:fs'
-import path from 'node:path'
+import { checkForbiddenEgress } from './forbidden-egress.mjs'
 
-const ROOT = path.resolve(new URL('../..', import.meta.url).pathname)
-const SCAN_DIRS = ['bin', 'src']
-const FORBIDDEN = [
-  { pattern: /fetch\(\s*['"]https?:\/\/(?!127\.0\.0\.1|localhost|\[::1\])/, label: 'non-localhost fetch' },
-  { pattern: /https?\.request\s*\(/, label: 'http request primitive' },
-  { pattern: /new\s+WebSocket\s*\(/, label: 'websocket egress primitive' },
-  { pattern: /net\.connect\s*\(/, label: 'net connect primitive' },
-  { pattern: /dns\./, label: 'dns primitive' },
-  { pattern: /\bcurl\s+https?:\/\//, label: 'shell network call' },
-]
-
-function walk(dir, files = []) {
-  if (!fs.existsSync(dir)) return files
-  for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
-    const abs = path.join(dir, ent.name)
-    if (ent.isDirectory()) walk(abs, files)
-    else if (/\.(mjs|js|sh)$/.test(ent.name)) files.push(abs)
-  }
-  return files
-}
-
-export function checkForbiddenEgress(root = ROOT) {
-  const failures = []
-  for (const rel of SCAN_DIRS) {
-    for (const file of walk(path.join(root, rel))) {
-      const text = fs.readFileSync(file, 'utf8')
-      for (const rule of FORBIDDEN) {
-        if (rule.pattern.test(text)) failures.push(`${path.relative(root, file)}:${rule.label}`)
-      }
-    }
-  }
-  return failures
-}
+export { checkForbiddenEgress } from './forbidden-egress.mjs'
 
 export function runEgressCommand() {
-  const failures = checkForbiddenEgress()
-  if (failures.length) {
-    console.error(failures.join('\n'))
+  const findings = checkForbiddenEgress()
+  if (findings.length) {
+    for (const finding of findings) {
+      console.error(`[atelier-egress] ${finding.file}:${finding.line} ${finding.type}: ${finding.detail}`)
+    }
     process.exit(1)
   }
   console.log('[egress:check] no forbidden non-localhost egress found in package runtime paths')

package/src/egress/forbidden-egress.mjs

@@ -22,20 +22,21 @@ export const DEFAULT_EGRESS_SCAN_PATHS = [
 const SCRIPT_EXTS = new Set(['.js', '.mjs', '.cjs', '.ts', '.mts', '.sh'])
 const MARKUP_EXTS = new Set(['.html', '.htm', '.svg'])
 const SKIP_DIRS = new Set(['node_modules', '.git'])
-const INTERNAL_SCANNER_FILES = new Set(['forbidden-egress.mjs'])
+const INTERNAL_SCANNER_PATH = 'src/egress/forbidden-egress.mjs'
 
 function isTestFile(file) {
   return /(?:^|[/.])test(?:s)?[/.]/.test(file) || /\.(?:test|spec)\.[cm]?[jt]s$/.test(file)
 }
 
-function isMarkedTestFixture(file, text) {
-  return isTestFile(file) && text.includes(TEST_FIXTURE_ALLOW_MARKER)
+function isMarkedTestFixture(file, text, allowTestFixtures) {
+  return allowTestFixtures && isTestFile(file) && text.includes(TEST_FIXTURE_ALLOW_MARKER)
 }
 
-function shouldScanFile(file, { includeTests = false } = {}) {
+function shouldScanFile(file, { includeTests = true, root = packageRoot } = {}) {
   const ext = path.extname(file)
   if (!SCRIPT_EXTS.has(ext) && !MARKUP_EXTS.has(ext)) return false
-  if (INTERNAL_SCANNER_FILES.has(path.basename(file))) return false
+  const relative = path.relative(path.resolve(root), path.resolve(file)).split(path.sep).join('/')
+  if (relative === INTERNAL_SCANNER_PATH) return false
   if (!includeTests && isTestFile(file)) return false
   return true
 }
@@ -61,17 +62,28 @@ function uniqueFiles(files) {
 export function discoverForbiddenEgressScanFiles({
   root = packageRoot,
   scanPaths = DEFAULT_EGRESS_SCAN_PATHS,
-  includeTests = false,
+  includeTests = true,
+  files = null,
 } = {}) {
-  const files = []
+  if (Array.isArray(files)) {
+    const resolvedRoot = path.resolve(root)
+    return uniqueFiles(
+      files
+        .map((file) => path.resolve(resolvedRoot, file))
+        .filter((file) => file === resolvedRoot || file.startsWith(`${resolvedRoot}${path.sep}`))
+        .filter((file) => fs.existsSync(file) && fs.statSync(file).isFile())
+        .filter((file) => shouldScanFile(file, { includeTests, root: resolvedRoot })),
+    )
+  }
+  const discovered = []
   for (const rel of scanPaths) {
     const abs = path.resolve(root, rel)
     if (!fs.existsSync(abs)) continue
     const stat = fs.statSync(abs)
-    if (stat.isDirectory()) files.push(...walk(abs, { includeTests }))
-    else if (shouldScanFile(abs, { includeTests })) files.push(abs)
+    if (stat.isDirectory()) discovered.push(...walk(abs, { includeTests, root }))
+    else if (shouldScanFile(abs, { includeTests, root })) discovered.push(abs)
   }
-  return uniqueFiles(files)
+  return uniqueFiles(discovered)
 }
 
 function hostnameFromNetworkUrl(value) {
@@ -135,8 +147,8 @@ function callBlock(lines, index) {
   return lines.slice(index, Math.min(lines.length, index + 5)).join('\n')
 }
 
-function isFixtureAllowed(lines, index, file) {
-  return isTestFile(file) && callBlock(lines, Math.max(0, index - 2)).includes(TEST_FIXTURE_ALLOW_MARKER)
+function isFixtureAllowed(lines, index, file, allowTestFixtures) {
+  return allowTestFixtures && isTestFile(file) && callBlock(lines, Math.max(0, index - 2)).includes(TEST_FIXTURE_ALLOW_MARKER)
 }
 
 function isLocalComputedAllowed(lines, index) {
@@ -256,14 +268,14 @@ function markupFindingsForLine(line, { findings, file, lineNumber }) {
   }
 }
 
-export function forbiddenEgressFindingsForText(text, { file = 'input' } = {}) {
-  if (isMarkedTestFixture(file, text)) return []
+export function forbiddenEgressFindingsForText(text, { file = 'input', allowTestFixtures = true } = {}) {
+  if (isMarkedTestFixture(file, text, allowTestFixtures)) return []
   const findings = []
   const lines = String(text || '').split(/\r?\n/)
   const isMarkup = MARKUP_EXTS.has(path.extname(file))
 
   for (let index = 0; index < lines.length; index += 1) {
-    if (isFixtureAllowed(lines, index, file)) continue
+    if (isFixtureAllowed(lines, index, file, allowTestFixtures)) continue
     const lineCode = trimmedCodeLine(lines[index])
     const hasJsPrimitive = /\b(?:fetch|https?\.(?:request|get)|http2\.connect|navigator\.sendBeacon|new\s+EventSource|new\s+WebSocket|net\.connect|net\.createConnection|dns\.(?:resolve|lookup|promises\.resolve|promises\.lookup)|import)\s*\(/.test(lineCode)
       || /\bnew\s+(?:XMLHttpRequest|Image)\b/.test(lineCode)
@@ -295,12 +307,14 @@ export function forbiddenEgressFindingsForText(text, { file = 'input' } = {}) {
 export function checkForbiddenEgress({
   root = packageRoot,
   scanPaths = DEFAULT_EGRESS_SCAN_PATHS,
-  includeTests = false,
+  includeTests = true,
+  files = null,
+  allowTestFixtures = true,
 } = {}) {
   const findings = []
-  for (const file of discoverForbiddenEgressScanFiles({ root, scanPaths, includeTests })) {
+  for (const file of discoverForbiddenEgressScanFiles({ root, scanPaths, includeTests, files })) {
     const rel = path.relative(root, file)
-    findings.push(...forbiddenEgressFindingsForText(fs.readFileSync(file, 'utf8'), { file: rel }))
+    findings.push(...forbiddenEgressFindingsForText(fs.readFileSync(file, 'utf8'), { file: rel, allowTestFixtures }))
   }
   return findings
 }