@empire-builder-kit/nx 1.0.0-rc.2 → 1.0.0-rc.21

package/src/supply-chain/generated-command.js

@@ -6,6 +6,8 @@ function renderSupplyChainCheckCommand() {
   createSupplyChainInventory,
   createInstalledLicenseFindings,
   createSupplyChainScannerInput,
+  assertWorkspaceImporterCoverage,
+  deriveWorkspaceManifestPathsFromPnpmLock,
   discoverLifecycleScripts,
   evaluateSupplyChainPolicy,
   frameworkActionPinInventory,
@@ -15,6 +17,7 @@ function renderSupplyChainCheckCommand() {
   assertSupplyChainScannerSubject,
   requireActiveVendoredSourceRegistry,
   validateReviewedBuildPermissions,
+  workspacePackageGlobs,
   vendoredSourceRegistryDigest,
   verifyActionPinInventory,
 } from '@empire-builder-kit/nx/supply-chain';
@@ -164,48 +167,51 @@ function hasExactKeys(value, keys) {
   );
 }
 
-function workspaceManifests() {
-  const listed = spawnSync(
-    'pnpm',
-    ['list', '--recursive', '--depth=-1', '--json'],
-    {
-      cwd: workspaceRoot,
-      encoding: 'utf8',
-      maxBuffer: MAX_INPUT_BYTES,
-      shell: false,
-    },
-  );
-  if (listed.status !== 0) {
-    throw new Error(
-      'pnpm workspace inventory failed: ' +
-        String(listed.stderr || listed.stdout).trim().slice(0, 2_000),
-    );
-  }
-  let projects;
-  try {
-    const parsed = JSON.parse(listed.stdout);
-    projects = Array.isArray(parsed) ? parsed : [parsed];
-  } catch {
-    throw new Error('pnpm workspace inventory did not return JSON.');
-  }
-  if (projects.length === 0 || projects.length > 2_000) {
-    throw new Error('pnpm workspace inventory is empty or exceeds 2,000 projects.');
-  }
-  const manifests = {};
-  for (const [index, project] of projects.entries()) {
-    if (!project || typeof project !== 'object' || typeof project.path !== 'string') {
-      throw new Error('pnpm workspace project ' + index + ' has no exact path.');
+function discoverGlobbedManifestPaths(globs) {
+  // Walk only the directory depth each glob declares so a manifest present on
+  // disk but absent from the lockfile importers is still observed.
+  const discovered = new Set();
+  const walk = (segments, index, prefix) => {
+    if (index === segments.length) {
+      const manifest = prefix ? prefix + '/package.json' : 'package.json';
+      if (existsSync(insideWorkspace(manifest))) discovered.add(manifest);
+      return;
+    }
+    const segment = segments[index];
+    const directory = prefix ? insideWorkspace(prefix) : workspaceRoot;
+    if (!existsSync(directory) || !statSync(directory).isDirectory()) return;
+    if (segment === '*' || segment === '**') {
+      for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+        if (entry.name === 'node_modules') continue;
+        const next = prefix ? prefix + '/' + entry.name : entry.name;
+        walk(segments, index + 1, next);
+        if (segment === '**') walk(segments, index, next);
+      }
+      return;
     }
-    const root = realpathSync(insideWorkspace(project.path));
-    const child = relative(workspaceRoot, root);
-    if (child === '..' || child.startsWith('..' + sep)) {
-      throw new Error('pnpm workspace project escapes the repository.');
+    if (segment.includes('*')) {
+      throw new Error(
+        'Workspace package glob segment ' + segment + ' is not supported by the manifest drift sweep.',
+      );
     }
-    const path = (child ? child.split(sep).join('/') + '/' : '') + 'package.json';
-    manifests[path] = readJson(path);
+    walk(segments, index + 1, prefix ? prefix + '/' + segment : segment);
+  };
+  for (const glob of globs) {
+    walk(glob.split('/').filter((segment) => segment !== '' && segment !== '.'), 0, '');
   }
-  if (!Object.hasOwn(manifests, 'package.json')) {
-    manifests['package.json'] = readJson('package.json');
+  return [...discovered];
+}
+
+function workspaceManifests(lockfile, workspacePolicy) {
+  const importerPaths = deriveWorkspaceManifestPathsFromPnpmLock(lockfile);
+  assertWorkspaceImporterCoverage(
+    discoverGlobbedManifestPaths(workspacePackageGlobs(workspacePolicy)),
+    importerPaths,
+  );
+  const manifests = {};
+  for (const path of importerPaths) {
+    manifests[path] = readJson(path);
   }
   return manifests;
 }
@@ -254,6 +260,7 @@ const ignoredDirectories = new Set([
   '.nx',
   '.open-next',
   '.sst',
+  '.venv',
   'coverage',
   'dist',
   'node_modules',
@@ -392,6 +399,11 @@ const workspacePolicy = readBounded(
   MAX_INPUT_BYTES,
   'pnpm workspace policy',
 );
+const lockfile = readBounded(
+  'pnpm-lock.yaml',
+  MAX_LOCK_BYTES,
+  'pnpm lockfile',
+);
 const packageMetadata = installedPackageMetadata();
 const lifecycleScripts = discoverLifecycleScripts(packageMetadata);
 const buildPermissions = records(
@@ -434,8 +446,8 @@ const inventory = createSupplyChainInventory({
     'supply-chain/downloaded-tools.json',
   ),
   lifecycleScripts,
-  lockfile: readBounded('pnpm-lock.yaml', MAX_LOCK_BYTES, 'pnpm lockfile'),
-  manifests: workspaceManifests(),
+  lockfile,
+  manifests: workspaceManifests(lockfile, workspacePolicy),
   nodeVersion: readBounded(
     '.node-version',
     64,
@@ -464,7 +476,7 @@ const containerInventoryDigest = digest({
 if (options.protected) {
   const normalizedScanner = createSupplyChainScannerInput(scannerInput);
   const requiredCoverage = [
-    ...(inventory.resolvedPackages.length > 0 ? ['npm'] : []),
+    'npm',
     ...(inventory.containers.length > 0 || workflowContainers.length > 0
       ? ['container']
       : []),
@@ -486,6 +498,78 @@ if (options.protected) {
     resultDigests.push(reference);
     const result = JSON.parse(bytes);
     if (reference.coverage === 'npm') {
+      const packageManager =
+        /^pnpm@(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\+sha512\.[a-f0-9]{128}$/.exec(
+          inventory.packageManager,
+        );
+      if (!packageManager?.[1]) {
+        throw new Error(
+          'Supply-chain inventory package manager is not one exact pnpm authority.',
+        );
+      }
+      const expectedPackageManagerInput = {
+        results: [
+          {
+            packages: [
+              {
+                package: {
+                  ecosystem: 'npm',
+                  name: 'pnpm',
+                  version: packageManager[1],
+                },
+              },
+            ],
+          },
+        ],
+      };
+      const expectedPackageManagerInputBytes =
+        JSON.stringify(expectedPackageManagerInput, null, 2) + '\n';
+      if (
+        !hasExactKeys(result, [
+          'kind',
+          'lockfile',
+          'packageManager',
+          'schemaVersion',
+        ]) ||
+        result.kind !== 'ebk-osv-npm-results' ||
+        result.schemaVersion !== 1 ||
+        !hasExactKeys(result.packageManager, [
+          'authority',
+          'input',
+          'inputSha256',
+          'result',
+        ]) ||
+        result.packageManager.authority !== inventory.packageManager ||
+        JSON.stringify(canonical(result.packageManager.input)) !==
+          JSON.stringify(canonical(expectedPackageManagerInput)) ||
+        result.packageManager.inputSha256 !==
+          digest(expectedPackageManagerInputBytes)
+      ) {
+        throw new Error(
+          'npm scanner result does not bind the exact package-manager authority and custom input.',
+        );
+      }
+      const packageManagerResults = result.packageManager.result;
+      const scannedPackageManagers =
+        packageManagerResults && Array.isArray(packageManagerResults.results)
+          ? packageManagerResults.results.flatMap((entry) =>
+              entry && Array.isArray(entry.packages)
+                ? entry.packages
+                    .map((scanned) => scanned?.package)
+                    .filter(Boolean)
+                : [],
+            )
+          : [];
+      if (
+        scannedPackageManagers.length !== 1 ||
+        scannedPackageManagers[0].ecosystem !== 'npm' ||
+        scannedPackageManagers[0].name !== 'pnpm' ||
+        scannedPackageManagers[0].version !== packageManager[1]
+      ) {
+        throw new Error(
+          'npm scanner result does not prove the exact package-manager scan.',
+        );
+      }
       normalizedVulnerabilities.push(
         ...normalizeOsvScannerResults({
           coverage: 'npm',
@@ -494,7 +578,11 @@ if (options.protected) {
           resultGroups: [
             {
               context: { releases: [], scope: 'unknown', slices: [] },
-              document: result,
+              document: result.lockfile,
+            },
+            {
+              context: { releases: [], scope: 'unknown', slices: [] },
+              document: packageManagerResults,
             },
           ],
         }),

package/src/supply-chain/generated-command.js.map

@@ -1 +1 @@
-{"version":3,"file":"generated-command.js","sourceRoot":"","sources":["../../../../../packages/nx/src/supply-chain/generated-command.ts"],"names":[],"mappings":";;AAAA,sEA0qBC;AA1qBD,SAAgB,6BAA6B;IAC3C,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwqBlB,CAAC;AACF,CAAC"}
+{"version":3,"file":"generated-command.js","sourceRoot":"","sources":["../../../../../packages/nx/src/supply-chain/generated-command.ts"],"names":[],"mappings":";;AAAA,sEAkwBC;AAlwBD,SAAgB,6BAA6B;IAC3C,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgwBlB,CAAC;AACF,CAAC"}

package/src/supply-chain/generated-container-release-command.js

@@ -6,6 +6,16 @@ const generated_ecr_collector_command_js_1 = require("./generated-ecr-collector-
 const safe_reference_1 = require("@empire-builder-kit/runtime/safe-reference");
 exports.CRANE_VERSION = '0.21.7';
 exports.CRANE_RELEASES = Object.freeze({
+    'darwin-arm64': {
+        archiveFormat: 'tar-gzip',
+        sha256: '1858c55dcd6053fe869bcb0c4ec20666383ddce445ad0f7e15e1e506b1f7fe52',
+        source: 'https://github.com/google/go-containerregistry/releases/download/v0.21.7/go-containerregistry_Darwin_arm64.tar.gz',
+    },
+    'darwin-x64': {
+        archiveFormat: 'tar-gzip',
+        sha256: '63a7dd15168d4dcac37933c7f6745438f2943d5898a1cf7896ad3341d8519bf2',
+        source: 'https://github.com/google/go-containerregistry/releases/download/v0.21.7/go-containerregistry_Darwin_x86_64.tar.gz',
+    },
     'linux-arm64': {
         archiveFormat: 'tar-gzip',
         sha256: 'b6ee979d9411dfb05ce35ab9e156fe5de7def11a230764a7856ffa2eb971fa88',
@@ -19,7 +29,7 @@ exports.CRANE_RELEASES = Object.freeze({
 });
 function validatedReleases(releases) {
     if (Object.keys(releases).length === 0 ||
-        Object.entries(releases).some(([platform, release]) => !/^linux-(?:arm64|x64)$/.test(platform) ||
+        Object.entries(releases).some(([platform, release]) => !/^(?:darwin|linux)-(?:arm64|x64)$/.test(platform) ||
             !['binary', 'tar-gzip'].includes(release.archiveFormat) ||
             !/^[a-f0-9]{64}$/.test(release.sha256) ||
             !/^https:\/\/github\.com\/anchore\/syft\/releases\/download\/v\d+\.\d+\.\d+\/[A-Za-z0-9._-]+$/.test(release.source))) {
@@ -29,10 +39,10 @@ function validatedReleases(releases) {
 }
 function validatedCraneReleases(releases) {
     if (Object.keys(releases).length === 0 ||
-        Object.entries(releases).some(([platform, release]) => !/^linux-(?:arm64|x64)$/.test(platform) ||
+        Object.entries(releases).some(([platform, release]) => !/^(?:darwin|linux)-(?:arm64|x64)$/.test(platform) ||
             release.archiveFormat !== 'tar-gzip' ||
             !/^[a-f0-9]{64}$/.test(release.sha256) ||
-            !/^https:\/\/github\.com\/google\/go-containerregistry\/releases\/download\/v\d+\.\d+\.\d+\/go-containerregistry_Linux_(?:arm64|x86_64)\.tar\.gz$/.test(release.source))) {
+            !/^https:\/\/github\.com\/google\/go-containerregistry\/releases\/download\/v\d+\.\d+\.\d+\/go-containerregistry_(?:Darwin|Linux)_(?:arm64|x86_64)\.tar\.gz$/.test(release.source))) {
         throw new Error('Container-release Crane assets must be exact official integrity-bound releases.');
     }
     return releases;
@@ -129,23 +139,82 @@ const sourceCommit =
 const stage = process.env.EBK_STAGE?.trim() ?? '';
 const accountId = process.env.AWS_EXPECTED_ACCOUNT_ID?.trim() ?? '';
 const region = process.env.AWS_REGION?.trim() ?? '';
-const runId = process.env.GITHUB_RUN_ID?.trim() ?? '';
-const runAttempt = process.env.GITHUB_RUN_ATTEMPT?.trim() ?? '';
-const workflow = process.env.GITHUB_WORKFLOW_REF?.trim() ?? '';
+const packageRegistryInput =
+  process.env.EBK_CONTAINER_PACKAGE_REGISTRY?.trim() ?? '';
+const localFederated =
+  process.env.GITHUB_ACTIONS !== 'true' &&
+  process.env.EBK_LOCAL_DEPLOYMENT_MODE === 'federated';
+if (localFederated) {
+  const policy = JSON.parse(
+    readFileSync(join(repositoryRoot, 'ebk.repository-policy.json'), 'utf8'),
+  );
+  if (
+    policy.deploymentProfile !== 'starter' ||
+    stage === 'production' ||
+    policy.deploymentAccounts?.[stage] !== accountId ||
+    policy.deploymentRegion !== region
+  ) {
+    throw new Error(
+      'Local container release requires a locally admitted exact starter deployment target; production requires protected GitHub authority.',
+    );
+  }
+}
+const runId = localFederated
+  ? (BigInt('0x' + sourceCommit.slice(0, 15)) + 1n).toString()
+  : process.env.GITHUB_RUN_ID?.trim() ?? '';
+const runAttempt = localFederated
+  ? '1'
+  : process.env.GITHUB_RUN_ATTEMPT?.trim() ?? '';
+const workflow = localFederated
+  ? 'local-federated/' + stage + '/' + accountId + '/' + region
+  : process.env.GITHUB_WORKFLOW_REF?.trim() ?? '';
 if (
   !COMMIT.test(deploymentSourceCommit) ||
   !COMMIT.test(sourceCommit) ||
   !['development', 'staging', 'production'].includes(stage) ||
   !/^\\d{12}$/.test(accountId) ||
   !AWS_REGION_NAME.test(region) ||
+  (!localFederated && process.env.GITHUB_ACTIONS !== 'true') ||
   !/^[1-9]\\d*$/.test(runId) ||
   !/^[1-9]\\d*$/.test(runAttempt) ||
   !REFERENCE.test(workflow)
 ) {
   throw new Error(
-    'Container release requires one exact protected source, run, account, Region, and stage.',
+    'Container release requires one exact GitHub or local-federated source, run, account, Region, and stage.',
   );
 }
+const packageRegistry = (() => {
+  if (packageRegistryInput === '') return undefined;
+  if (packageRegistryInput.length > 2_048) {
+    throw new Error('Container package registry authority is invalid.');
+  }
+  let parsed;
+  try {
+    parsed = new URL(packageRegistryInput);
+  } catch {
+    throw new Error('Container package registry authority is invalid.');
+  }
+  const normalized = parsed.href;
+  const canonicalInput =
+    packageRegistryInput === normalized ||
+    packageRegistryInput + '/' === normalized;
+  const localPlaintext =
+    parsed.protocol === 'http:' &&
+    ['127.0.0.1', 'localhost', 'host.docker.internal', '[::1]'].includes(
+      parsed.hostname,
+    );
+  if (
+    !canonicalInput ||
+    (parsed.protocol !== 'https:' && !localPlaintext) ||
+    parsed.username !== '' ||
+    parsed.password !== '' ||
+    parsed.search !== '' ||
+    parsed.hash !== ''
+  ) {
+    throw new Error('Container package registry authority is invalid.');
+  }
+  return normalized.endsWith('/') ? normalized.slice(0, -1) : normalized;
+})();
 const requireReviewedCheckout = () => {
   validateReviewedReleaseCheckout({
     deploymentSourceCommit,
@@ -332,11 +401,12 @@ const describeRepository = (repositoryName) => {
       throw new Error('ECR repository lookup returned invalid JSON.');
     }
   }
-  const error = String(result.stderr ?? '');
+  const error = String(result.stderr ?? '').trimStart();
+  const notFound =
+    'An error occurred (RepositoryNotFoundException) when calling the DescribeRepositories operation:';
   if (
-    !error.startsWith(
-      'An error occurred (RepositoryNotFoundException) when calling the DescribeRepositories operation:',
-    )
+    !error.startsWith(notFound) &&
+    !error.startsWith('aws: [ERROR]: ' + notFound)
   ) {
     throw new Error('ECR repository lookup failed outside the create-if-absent path.');
   }
@@ -792,7 +862,7 @@ const acquireCrane = async () => {
 const parseCycloneDx = (value, label) => {
   if (
     value?.bomFormat !== 'CycloneDX' ||
-    value.specVersion !== '1.6' ||
+    value.specVersion !== '1.7' ||
     value.version !== 1 ||
     !/^urn:uuid:[a-fA-F0-9-]{36}$/.test(value.serialNumber ?? '') ||
     !Array.isArray(value.components) ||
@@ -801,17 +871,30 @@ const parseCycloneDx = (value, label) => {
     !value.metadata ||
     typeof value.metadata !== 'object'
   ) {
-    throw new Error(label + ' is not complete CycloneDX 1.6.');
+    throw new Error(label + ' is not complete CycloneDX 1.7.');
   }
   return value;
 };
+const isVersionlessSyftFileComponent = (component) =>
+  component?.type === 'file' &&
+  component.version === undefined &&
+  component.purl === undefined &&
+  typeof component.name === 'string' &&
+  component.name.startsWith('/') &&
+  component.name.length <= 4_096 &&
+  Array.isArray(component.hashes) &&
+  component.hashes.length === 2 &&
+  component.hashes[0]?.alg === 'SHA-1' &&
+  /^[a-f0-9]{40}$/.test(component.hashes[0]?.content ?? '') &&
+  component.hashes[1]?.alg === 'SHA-256' &&
+  /^[a-f0-9]{64}$/.test(component.hashes[1]?.content ?? '');
 const componentSetFor = (sbom) =>
   sbom.components
     .map((component) => ({
       name: component?.name,
       purl: component?.purl ?? '',
       type: component?.type,
-      version: component?.version,
+      version: component?.version ?? '',
     }))
     .sort((left, right) =>
       JSON.stringify(left) < JSON.stringify(right)
@@ -881,8 +964,12 @@ const deriveExpectedProductionClosure = (syft, input) => {
     execute(
       'pnpm',
       [
+        '--config.store-dir=' +
+          safePath('.ebk/cache/pnpm-store', 'Workspace pnpm store'),
+        '--config.inject-workspace-packages=true',
         '--filter',
         input.packageName,
+        '--trust-lockfile',
         'deploy',
         '--prod',
         '--offline',
@@ -906,18 +993,51 @@ const deriveExpectedProductionClosure = (syft, input) => {
     } catch {
       throw new Error('Independent production closure inventory is invalid JSON.');
     }
+    const sourceManifest = readJson(
+      input.packageManifestPath,
+      'Container package manifest',
+    );
+    const deployedManifest = readJson(
+      join(deployed, 'package.json'),
+      'Deployed container package manifest',
+    );
+    if (
+      sourceManifest.name !== input.packageName ||
+      typeof sourceManifest.version !== 'string' ||
+      sourceManifest.version.length === 0 ||
+      sourceManifest.version.length > 128 ||
+      deployedManifest.name !== sourceManifest.name ||
+      deployedManifest.version !== sourceManifest.version
+    ) {
+      throw new Error(
+        'Independent production closure changed the workload package identity.',
+      );
+    }
     const packages = npmClosureFor(inventory);
     if (
-      !packages.some(
+      packages.some(
         ({ name, version }) =>
-          name === input.packageName &&
-          version === readJson(
-            input.packageManifestPath,
-            'Container package manifest',
-          ).version,
+          name === sourceManifest.name && version !== sourceManifest.version,
       )
     ) {
-      throw new Error('Independent production closure omits the workload package.');
+      throw new Error(
+        'Independent production closure contains a conflicting workload package identity.',
+      );
+    }
+    if (!packages.some(({ name }) => name === sourceManifest.name)) {
+      packages.push({
+        name: sourceManifest.name,
+        version: sourceManifest.version,
+      });
+      packages.sort(
+        (left, right) =>
+          (left.name < right.name ? -1 : left.name > right.name ? 1 : 0) ||
+          (left.version < right.version
+            ? -1
+            : left.version > right.version
+              ? 1
+              : 0),
+      );
     }
     return { digest: supplyChainDigest(packages), packages };
   } finally {
@@ -1210,13 +1330,26 @@ if (stage === 'development') {
     process.env.EBK_STAGING_PROMOTION_EXPECTED_ACCOUNT_ID?.trim() ?? '';
   const expectedSourceRegion =
     process.env.EBK_STAGING_PROMOTION_REGION?.trim() ?? '';
+  const deploymentProfile = process.env.EBK_DEPLOYMENT_PROFILE?.trim() ?? '';
+  if (
+    deploymentProfile !== 'starter' &&
+    deploymentProfile !== 'production-isolated' &&
+    deploymentProfile !== 'fully-isolated'
+  ) {
+    throw new Error('Container promotion requires one exact deployment profile.');
+  }
+  const sameAccountPromotion = deploymentProfile === 'starter';
   if (
     !/^\\d{12}$/.test(expectedSourceAccountId) ||
     !AWS_REGION_NAME.test(expectedSourceRegion) ||
-    expectedSourceAccountId === accountId
+    (sameAccountPromotion
+      ? expectedSourceAccountId !== accountId || expectedSourceRegion !== region
+      : expectedSourceAccountId === accountId)
   ) {
     throw new Error(
-      'Development retirement promotion requires one independent staging account and Region.',
+      sameAccountPromotion
+        ? 'Starter promotion requires the exact shared account and Region.'
+        : 'Isolated promotion requires one independent staging account and exact Region.',
     );
   }
   const sourceBindingPath = safePath(
@@ -1310,13 +1443,26 @@ if (mode === 'promote') {
     process.env.EBK_STAGING_PROMOTION_EXPECTED_ACCOUNT_ID?.trim() ?? '';
   const expectedSourceRegion =
     process.env.EBK_STAGING_PROMOTION_REGION?.trim() ?? '';
+  const deploymentProfile = process.env.EBK_DEPLOYMENT_PROFILE?.trim() ?? '';
+  if (
+    deploymentProfile !== 'starter' &&
+    deploymentProfile !== 'production-isolated' &&
+    deploymentProfile !== 'fully-isolated'
+  ) {
+    throw new Error('OCI promotion requires one exact deployment profile.');
+  }
+  const sameAccountPromotion = deploymentProfile === 'starter';
   if (
     !/^\\d{12}$/.test(expectedSourceAccountId) ||
     !AWS_REGION_NAME.test(expectedSourceRegion) ||
-    expectedSourceAccountId === accountId
+    (sameAccountPromotion
+      ? expectedSourceAccountId !== accountId || expectedSourceRegion !== region
+      : expectedSourceAccountId === accountId)
   ) {
     throw new Error(
-      'OCI promotion requires one bounded independent staging account and Region.',
+      sameAccountPromotion
+        ? 'Starter OCI promotion requires the exact shared account and Region.'
+        : 'Isolated OCI promotion requires one bounded independent staging account and exact Region.',
     );
   }
   const sourceBindingInput =
@@ -1591,15 +1737,6 @@ if (mode === 'promote') {
 }
 
 if (mode === 'platform') {
-  const nativeArchitecture = process.arch === 'x64' ? 'amd64' : process.arch;
-  if (
-    process.platform !== 'linux' ||
-    requestedPlatform !== 'linux/' + nativeArchitecture
-  ) {
-    throw new Error(
-      'Platform evidence must run on the matching native Linux architecture.',
-    );
-  }
   const syft = await acquireSyft();
   const crane = stage === 'development' ? await acquireCrane() : undefined;
   try {
@@ -1656,6 +1793,12 @@ if (mode === 'platform') {
           [
             'buildx',
             'build',
+            ...(packageRegistry
+              ? [
+                  '--build-arg',
+                  'NPM_CONFIG_REGISTRY=' + packageRegistry,
+                ]
+              : []),
             '--file',
             relative(repositoryRoot, input.dockerfile),
             '--label',
@@ -1796,14 +1939,20 @@ if (mode === 'platform') {
       }
       const componentSet = componentSetFor(sbom);
       if (
-        componentSet.some(
+        sbom.components.some(
           (component) =>
-            typeof component.name !== 'string' ||
+            typeof component?.name !== 'string' ||
+            component.name.length === 0 ||
             typeof component.type !== 'string' ||
-            typeof component.version !== 'string',
+            component.type.length === 0 ||
+            !(
+              (typeof component.version === 'string' &&
+                component.version.length > 0) ||
+              isVersionlessSyftFileComponent(component)
+            ),
         )
       ) {
-        throw new Error('Platform SBOM contains invalid or development components.');
+        throw new Error('Platform SBOM contains an invalid component identity.');
       }
       const serializedSbom = JSON.stringify(sbom, null, 2) + '\\n';
       const relativeSbomPath =

package/src/supply-chain/generated-container-release-command.js.map

@@ -1 +1 @@
-{"version":3,"file":"generated-container-release-command.js","sourceRoot":"","sources":["../../../../../packages/nx/src/supply-chain/generated-container-release-command.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA08D1E,CAAC;AACF,CAAC"}
+{"version":3,"file":"generated-container-release-command.js","sourceRoot":"","sources":["../../../../../packages/nx/src/supply-chain/generated-container-release-command.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqlE1E,CAAC;AACF,CAAC"}

package/src/supply-chain/generated-ecr-collector-command.js

@@ -6,6 +6,16 @@ const common_js_1 = require("./common.js");
 const safe_reference_1 = require("@empire-builder-kit/runtime/safe-reference");
 exports.SYFT_VERSION = '1.50.0';
 exports.SYFT_COLLECTOR_RELEASES = Object.freeze({
+    'darwin-arm64': {
+        archiveFormat: 'tar-gzip',
+        sha256: 'e32fdb9d47823fa633748a1efca2528fd77c37469ea93c9e40ab835da44e4cce',
+        source: 'https://github.com/anchore/syft/releases/download/v1.50.0/syft_1.50.0_darwin_arm64.tar.gz',
+    },
+    'darwin-x64': {
+        archiveFormat: 'tar-gzip',
+        sha256: 'd11a8c7bc27114853bd7c1e1b2f3be3ddda3a1de17aee585329f04c369341c75',
+        source: 'https://github.com/anchore/syft/releases/download/v1.50.0/syft_1.50.0_darwin_amd64.tar.gz',
+    },
     'linux-arm64': {
         archiveFormat: 'tar-gzip',
         sha256: '887c57cbcc2d0e8c5c110a4571a3fc7150058b24d74f993ee4663516e5c8ce86',
@@ -934,7 +944,7 @@ try {
       }
       if (
         sbom?.bomFormat !== 'CycloneDX' ||
-        sbom.specVersion !== '1.6' ||
+        sbom.specVersion !== '1.7' ||
         sbom.version !== 1 ||
         typeof sbom.serialNumber !== 'string' ||
         !/^urn:uuid:[a-fA-F0-9-]{36}$/.test(sbom.serialNumber) ||
@@ -945,7 +955,7 @@ try {
         typeof sbom.metadata !== 'object'
       ) {
         throw new Error(
-          'Syft output is not complete CycloneDX 1.6 evidence for ' +
+          'Syft output is not complete CycloneDX 1.7 evidence for ' +
             platform.platform + '.',
         );
       }