@mnstry/atelier 0.2.0-alpha.1 → 0.2.0-alpha.10

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
 }

package/src/export/atelier-export-contract.mjs

@@ -191,8 +191,23 @@ function formatAjvError(error) {
   return `${location} ${error.message ?? 'failed schema validation'}`
 }
 
+// One compiled validator per schema object, for as long as the schema lives:
+// compilation is a pure function of the schema, and a registered contract is
+// validated many times per run (a large manifest, every journal entry).
+const compiledValidators = new WeakMap()
+
+function validatorFor(schema) {
+  if (schema === null || typeof schema !== 'object') return ajvForSchema().compile(schema)
+  let validate = compiledValidators.get(schema)
+  if (!validate) {
+    validate = ajvForSchema().compile(schema)
+    compiledValidators.set(schema, validate)
+  }
+  return validate
+}
+
 export function validateJsonSchema(schema, doc) {
-  const validate = ajvForSchema().compile(schema)
+  const validate = validatorFor(schema)
   if (validate(doc)) return []
   return asArray(validate.errors).map(formatAjvError)
 }

package/src/extension-packs/lifecycle.mjs

@@ -0,0 +1,154 @@
+import fs from 'node:fs'
+import { BASE_MIGRATIONS } from '../upgrade/upgrade.mjs'
+import { validReviewArtifact } from '../collaboration/review-contracts.mjs'
+import { fileURLToPath } from 'node:url'
+import { readBoundedSource } from '../readiness-protocols/source-read.mjs'
+
+const rootVersion = JSON.parse(
+  fs.readFileSync(
+    fileURLToPath(new URL('../../package.json', import.meta.url)),
+    'utf8',
+  ),
+).version
+
+export function inspectPackLifecycle(project, packs) {
+  const declared =
+    project.config.ext?.['mnstry.atelier']?.extensionPackLifecycle
+  if (!declared)
+    return {
+      ok: packs.length === 0,
+      schema: 'atelier-pack-lifecycle-report@v1',
+      rootVersion,
+      entries: packs.map((pack) => ({
+        id: pack.id,
+        status: 'legacy-unqualified',
+        admitted: false,
+      })),
+      errors: packs.length
+        ? [
+            'extension-pack lifecycle declaration required for evidence-bound review',
+          ]
+        : [],
+    }
+  let policy
+  try {
+    policy = JSON.parse(readBoundedSource(project.configDir, declared).text)
+  } catch {
+    return {
+      ok: false,
+      errors: ['lifecycle declaration unavailable or unsafe'],
+    }
+  }
+  if (
+    !validReviewArtifact('lifecycle', policy) ||
+    policy.schema !== 'atelier-pack-lifecycle@v1' ||
+    !Array.isArray(policy.packs) ||
+    policy.packs.length > 100 ||
+    Object.keys(policy).some(
+      (key) => !['schema', 'packs', 'ext', 'contractVersion'].includes(key),
+    )
+  )
+    return { ok: false, errors: ['invalid lifecycle declaration'] }
+  const ids = new Set(),
+    errors = []
+  for (const entry of policy.packs) {
+    if (
+      !entry ||
+      typeof entry.id !== 'string' ||
+      ids.has(entry.id) ||
+      !Array.isArray(entry.compatibleRootVersions) ||
+      !entry.compatibleRootVersions.length ||
+      entry.compatibleRootVersions.some(
+        (version) => typeof version !== 'string',
+      ) ||
+      !['active', 'deprecated', 'retired'].includes(entry.status) ||
+      typeof entry.version !== 'string' ||
+      !/^sha256:[a-f0-9]{64}$/.test(entry.digest ?? '') ||
+      Object.keys(entry).some(
+        (key) =>
+          ![
+            'id',
+            'version',
+            'digest',
+            'compatibleRootVersions',
+            'status',
+            'replacement',
+            'migrationId',
+            'ext',
+          ].includes(key),
+      )
+    )
+      errors.push('invalid or duplicate lifecycle pack entry')
+    if (
+      entry?.migrationId &&
+      !BASE_MIGRATIONS.some(
+        (migration) =>
+          migration.id === entry.migrationId &&
+          migration.class === 'extension_pack' &&
+          migration.active !== false,
+      )
+    )
+      errors.push('unknown pack migration; owner migration unavailable')
+    ids.add(entry?.id)
+  }
+  const entries = packs.map((pack) => {
+    const entry = policy.packs.find((item) => item?.id === pack.id)
+    const admitted = Boolean(
+      entry &&
+        entry.version === pack.version &&
+        entry.digest === pack.digest &&
+        entry.compatibleRootVersions?.includes(rootVersion) &&
+        entry.status !== 'retired',
+    )
+    if (!admitted)
+      errors.push(`pack ${pack.id} is not qualified for new execution`)
+    return {
+      id: pack.id,
+      status: entry?.status ?? 'legacy-unqualified',
+      admitted,
+      replacement: entry?.replacement ?? null,
+      migrationId: entry?.migrationId ?? null,
+    }
+  })
+  return {
+    ok: errors.length === 0,
+    schema: 'atelier-pack-lifecycle-report@v1',
+    rootVersion,
+    entries,
+    errors,
+    policy,
+  }
+}
+
+// This report names the existing data-only upgrade operation. It neither
+// changes declarations nor admits a replacement; the source owner applies it.
+export function planPackLifecycleMigration(project, packs) {
+  const report = inspectPackLifecycle(project, packs)
+  const migration = BASE_MIGRATIONS.find(
+    (entry) => entry.class === 'extension_pack' && entry.active !== false,
+  )
+  return {
+    ok: report.ok,
+    schema: 'atelier-pack-migration-plan@v1',
+    dryRun: true,
+    writes: false,
+    current: report,
+    migration: migration
+      ? {
+          id: migration.id,
+          files: migration.files,
+          requiredPostChecks: migration.requiredPostChecks,
+          authority: migration.authority,
+        }
+      : null,
+    steps: [
+      'Retain the prior package, pack declarations, lock and historical records.',
+      'Review replacement term and protocol meanings in the source owner workflow.',
+      'Update the declared version, digest and exact compatible root versions together.',
+      'Use the existing upgrade migration to verify and refresh the lock after owner review.',
+      'Create a new evidence-bound run; old runs retain their original meaning.',
+    ],
+    rollback:
+      'Restore the prior declarations, package and lock together. Retain contribution and evidence history.',
+  }
+}