@aopslabs/aops 0.2.0

package/dist/lib/community-release-verifier.js

@@ -0,0 +1,475 @@
+import { createHash } from 'node:crypto';
+import { lstatSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { bundleFromJSON } from '@sigstore/bundle';
+import { TrustedRoot } from '@sigstore/protobuf-specs';
+import sigstoreTufSeeds from '@sigstore/tuf/seeds.json' with { type: 'json' };
+import { toSignedEntity, toTrustMaterial, Verifier } from '@sigstore/verify';
+import { verify as verifySigstore } from 'sigstore';
+import { parseCommunityRelease } from './community-lifecycle.js';
+const SHA256 = /^sha256:[a-f0-9]{64}$/;
+const SHA256_HEX = /^[a-f0-9]{64}$/;
+const NPM_INTEGRITY_SHA512 = /^sha512-[A-Za-z0-9+/]{86}==$/;
+export const COMMUNITY_GITHUB_OIDC_ISSUER = 'https://token.actions.githubusercontent.com';
+export const COMMUNITY_PUBLIC_SOURCE_REPOSITORY = 'git+https://github.com/eeemzs/aops-community';
+export const COMMUNITY_PUBLIC_CLI_PACKAGE_NAME = '@aopslabs/aops';
+export const COMMUNITY_AGENT_ASSETS_MANIFEST_REF = 'agent-assets-release.json';
+export const COMMUNITY_AGENT_ASSETS_SIGNATURE_REF = 'agent-assets-release.sigstore.json';
+export const COMMUNITY_AGENT_ASSETS_CERTIFICATE_IDENTITY_URI = '^https://github\\.com/eeemzs/[A-Za-z0-9._-]+/\\.github/workflows/sign-community-agent-assets\\.yml@refs/heads/main$';
+function fail(code, detail) {
+    throw new Error(detail ? `${code}:${detail}` : code);
+}
+function digestFile(filePath) {
+    return `sha256:${createHash('sha256').update(readFileSync(filePath)).digest('hex')}`;
+}
+function npmIntegrityFile(filePath) {
+    return `sha512-${createHash('sha512').update(readFileSync(filePath)).digest('base64')}`;
+}
+function assertExactObject(value, keys, code) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        fail(code);
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    if (JSON.stringify(actual) !== JSON.stringify(expected))
+        fail(code);
+}
+function requireConfinedFile(root, ref, code) {
+    if (typeof ref !== 'string' || !ref || path.isAbsolute(ref))
+        fail(`${code}_ref_invalid`);
+    const normalizedRef = ref.replaceAll('\\', '/');
+    if (normalizedRef.split('/').some((segment) => segment === '..' || segment === ''))
+        fail(`${code}_ref_invalid`);
+    const candidate = path.resolve(root, ...normalizedRef.split('/'));
+    const relative = path.relative(root, candidate);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        fail(`${code}_ref_escape`);
+    let cursor = root;
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        cursor = path.join(cursor, segment);
+        const stat = lstatSync(cursor);
+        if (stat.isSymbolicLink())
+            fail(`${code}_reparse_refused`, cursor);
+    }
+    const stat = statSync(candidate);
+    if (!stat.isFile() || stat.size <= 0)
+        fail(`${code}_file_invalid`, candidate);
+    const realRoot = realpathSync(root);
+    const realCandidate = realpathSync(candidate);
+    const realRelative = path.relative(realRoot, realCandidate);
+    if (realRelative.startsWith('..') || path.isAbsolute(realRelative))
+        fail(`${code}_real_escape`);
+    return candidate;
+}
+function assertDigest(value, code) {
+    if (typeof value !== 'string' || !SHA256.test(value))
+        fail(code);
+}
+function assertHexDigest(value, code) {
+    if (typeof value !== 'string' || !SHA256_HEX.test(value))
+        fail(code);
+}
+function compareUnsignedUtf8(left, right) {
+    return Buffer.compare(Buffer.from(left, 'utf8'), Buffer.from(right, 'utf8'));
+}
+function agentAssetsSetSha256(files) {
+    const hash = createHash('sha256');
+    for (const file of files) {
+        hash.update(Buffer.from(file.ref, 'utf8'));
+        hash.update(Buffer.from([0]));
+        hash.update(file.sha256, 'ascii');
+        hash.update(Buffer.from('\n', 'ascii'));
+    }
+    return hash.digest('hex');
+}
+function assertAgentAssetsPackageRecord(value, code) {
+    assertExactObject(value, ['name', 'version', 'versionId', 'packageSha256', 'entryFile', 'manifestRef', 'optional'], code);
+    const record = value;
+    if (typeof record.name !== 'string' || !record.name ||
+        typeof record.version !== 'string' || !record.version ||
+        typeof record.versionId !== 'string' || !record.versionId ||
+        record.entryFile !== 'SKILL.md' ||
+        typeof record.manifestRef !== 'string' || !record.manifestRef.startsWith('agent-assets/') ||
+        typeof record.optional !== 'boolean')
+        fail(code);
+    assertHexDigest(record.packageSha256, `${code}_package_digest_invalid`);
+}
+function assertAgentAssetsRelease(value) {
+    assertExactObject(value, ['schemaVersion', 'kind', 'root', 'inventory', 'projection', 'gateway', 'core', 'catalog', 'files', 'setSha256'], 'community_release_agent_assets_invalid');
+    const record = value;
+    if (record.schemaVersion !== 1 ||
+        record.kind !== 'aops-community-agent-assets-release-v1' ||
+        record.root !== 'agent-assets')
+        fail('community_release_agent_assets_identity_invalid');
+    assertExactObject(record.inventory, ['ref', 'sha256'], 'community_release_agent_assets_inventory_invalid');
+    assertExactObject(record.projection, ['ref', 'sha256'], 'community_release_agent_assets_projection_invalid');
+    assertExactObject(record.gateway, ['name', 'ref', 'sha256', 'byteLength'], 'community_release_agent_assets_gateway_invalid');
+    for (const pointer of [record.inventory, record.projection, record.gateway]) {
+        if (typeof pointer.ref !== 'string' || !pointer.ref.startsWith('agent-assets/')) {
+            fail('community_release_agent_assets_ref_invalid');
+        }
+        assertHexDigest(pointer.sha256, 'community_release_agent_assets_digest_invalid');
+    }
+    if (record.gateway.name !== 'aops' ||
+        !Number.isSafeInteger(record.gateway.byteLength) || record.gateway.byteLength < 1)
+        fail('community_release_agent_assets_gateway_invalid');
+    assertAgentAssetsPackageRecord(record.core, 'community_release_agent_assets_core_invalid');
+    if (record.core.name !== 'aops' || record.core.optional !== false)
+        fail('community_release_agent_assets_core_invalid');
+    assertExactObject(record.catalog, ['mode', 'defaultActivation', 'packages'], 'community_release_agent_assets_catalog_invalid');
+    if (record.catalog.mode !== 'optional-inert' ||
+        record.catalog.defaultActivation !== false ||
+        !Array.isArray(record.catalog.packages))
+        fail('community_release_agent_assets_catalog_invalid');
+    for (const packageRecord of record.catalog.packages) {
+        assertAgentAssetsPackageRecord(packageRecord, 'community_release_agent_assets_catalog_package_invalid');
+        if (packageRecord.optional !== true)
+            fail('community_release_agent_assets_catalog_package_invalid');
+    }
+    if (!Array.isArray(record.files) || record.files.length === 0)
+        fail('community_release_agent_assets_files_invalid');
+    const refs = record.files.map((file) => {
+        assertExactObject(file, ['ref', 'sha256', 'byteLength'], 'community_release_agent_assets_file_invalid');
+        if (typeof file.ref !== 'string' || !file.ref.startsWith('agent-assets/') ||
+            !Number.isSafeInteger(file.byteLength) || file.byteLength < 0)
+            fail('community_release_agent_assets_file_invalid');
+        assertHexDigest(file.sha256, 'community_release_agent_assets_file_digest_invalid');
+        return file.ref;
+    });
+    if (JSON.stringify(refs) !== JSON.stringify([...new Set(refs)].sort(compareUnsignedUtf8))) {
+        fail('community_release_agent_assets_file_order_invalid');
+    }
+    assertHexDigest(record.setSha256, 'community_release_agent_assets_set_digest_invalid');
+    if (record.setSha256 !== agentAssetsSetSha256(record.files))
+        fail('community_release_agent_assets_set_digest_mismatch');
+    const closure = new Set(refs);
+    for (const ref of [
+        record.inventory.ref,
+        record.projection.ref,
+        record.gateway.ref,
+        record.core.manifestRef,
+        ...record.catalog.packages.map((entry) => entry.manifestRef),
+    ]) {
+        if (!closure.has(ref))
+            fail('community_release_agent_assets_pointer_not_in_closure', ref);
+    }
+}
+function parseManifest(content) {
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch {
+        fail('community_release_manifest_json_invalid');
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        fail('community_release_manifest_invalid');
+    const manifest = value;
+    if (manifest.schemaVersion !== 1 ||
+        typeof manifest.releaseVersion !== 'string' ||
+        !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(manifest.releaseVersion)) {
+        fail('community_release_manifest_invalid');
+    }
+    if (!manifest.source || !manifest.cli || !manifest.compose || !manifest.migrations || !manifest.agentAssets || !manifest.legal || !manifest.evidence) {
+        fail('community_release_manifest_incomplete');
+    }
+    if (manifest.source.repository !== COMMUNITY_PUBLIC_SOURCE_REPOSITORY) {
+        fail('community_release_source_repository_invalid');
+    }
+    if (manifest.image?.repository !== 'ghcr.io/eeemzs/aops-community' ||
+        manifest.image.tag !== `v${manifest.releaseVersion}`) {
+        fail('community_release_image_identity_invalid');
+    }
+    assertDigest(manifest.image.indexDigest, 'community_release_index_digest_invalid');
+    assertDigest(manifest.source.treeDigest, 'community_release_source_digest_invalid');
+    assertExactObject(manifest.cli, [
+        'packageName',
+        'version',
+        'commandSchemaVersion',
+        'bundleSha256',
+        'bundleByteLength',
+        'npmDistTag',
+        'artifactRef',
+        'artifactSha256',
+        'npmIntegrity',
+    ], 'community_release_cli_identity_invalid');
+    if (manifest.cli.packageName !== COMMUNITY_PUBLIC_CLI_PACKAGE_NAME ||
+        manifest.cli.version !== manifest.releaseVersion ||
+        manifest.cli.artifactRef !== `aopslab-aops-${manifest.releaseVersion}.tgz` ||
+        manifest.cli.npmDistTag !== (manifest.releaseVersion.includes('-') ? 'next' : 'latest') ||
+        !Number.isSafeInteger(manifest.cli.commandSchemaVersion) ||
+        manifest.cli.commandSchemaVersion <= 0 ||
+        !Number.isSafeInteger(manifest.cli.bundleByteLength) ||
+        manifest.cli.bundleByteLength <= 0 ||
+        !NPM_INTEGRITY_SHA512.test(manifest.cli.npmIntegrity)) {
+        fail('community_release_cli_identity_invalid');
+    }
+    if (manifest.cli.commandSchemaVersion !== 1)
+        fail('community_release_cli_command_schema_unsupported');
+    assertDigest(manifest.cli.bundleSha256, 'community_release_cli_bundle_digest_invalid');
+    assertDigest(manifest.cli.artifactSha256, 'community_release_cli_digest_invalid');
+    if (manifest.compose.ref !== 'compose.yaml')
+        fail('community_release_compose_ref_invalid');
+    assertDigest(manifest.compose.sha256, 'community_release_compose_digest_invalid');
+    assertDigest(manifest.migrations.setDigest, 'community_release_migration_digest_invalid');
+    for (const [kind, expectedRef] of [
+        ['license', 'LICENSE'],
+        ['notice', 'NOTICE'],
+        ['thirdPartyNotices', 'THIRD_PARTY_NOTICES'],
+        ['thirdPartyInventory', 'THIRD_PARTY_NOTICES.inventory.json'],
+    ]) {
+        const entry = manifest.legal[kind];
+        if (entry?.ref !== expectedRef)
+            fail(`community_release_legal_${kind}_ref_invalid`);
+        assertDigest(entry.sha256, `community_release_legal_${kind}_digest_invalid`);
+    }
+    assertDigest(manifest.evidence.sbom?.sha256, 'community_release_sbom_digest_invalid');
+    assertDigest(manifest.evidence.provenance?.sha256, 'community_release_provenance_digest_invalid');
+    if (manifest.evidence.signature?.bundleRef !== 'release.sigstore.json') {
+        fail('community_release_signature_ref_invalid');
+    }
+    if (!Array.isArray(manifest.migrations.files) || manifest.migrations.files.length === 0) {
+        fail('community_release_migration_files_invalid');
+    }
+    for (const entry of manifest.migrations.files)
+        assertDigest(entry?.sha256, 'community_release_migration_file_digest_invalid');
+    assertAgentAssetsRelease(manifest.agentAssets);
+    return manifest;
+}
+function parseAgentAssetsManifest(content) {
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch {
+        fail('community_agent_assets_manifest_json_invalid');
+    }
+    assertExactObject(value, ['schemaVersion', 'kind', 'releaseVersion', 'source', 'agentAssets', 'evidence'], 'community_agent_assets_manifest_invalid');
+    const manifest = value;
+    if (manifest.schemaVersion !== 1 ||
+        manifest.kind !== 'aops-community-agent-assets-bundle-v1' ||
+        typeof manifest.releaseVersion !== 'string' ||
+        !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(manifest.releaseVersion))
+        fail('community_agent_assets_manifest_identity_invalid');
+    assertExactObject(manifest.source, ['repository', 'commit', 'root'], 'community_agent_assets_manifest_source_invalid');
+    if (manifest.source.repository !== COMMUNITY_PUBLIC_SOURCE_REPOSITORY ||
+        !/^[a-f0-9]{40}$/.test(manifest.source.commit) ||
+        manifest.source.root !== 'apps/aops-cli/assets/agent-assets')
+        fail('community_agent_assets_manifest_source_invalid');
+    assertExactObject(manifest.evidence, ['signature'], 'community_agent_assets_manifest_evidence_invalid');
+    assertExactObject(manifest.evidence.signature, ['bundleRef'], 'community_agent_assets_manifest_signature_invalid');
+    if (manifest.evidence.signature.bundleRef !== COMMUNITY_AGENT_ASSETS_SIGNATURE_REF) {
+        fail('community_agent_assets_manifest_signature_invalid');
+    }
+    assertAgentAssetsRelease(manifest.agentAssets);
+    return manifest;
+}
+function defaultCertificateIdentity(manifest) {
+    const tag = manifest.image.tag || `v${manifest.releaseVersion}`;
+    const publicSourceRepository = COMMUNITY_PUBLIC_SOURCE_REPOSITORY.replace(/^git\+/, '');
+    return `${publicSourceRepository}/.github/workflows/community-release.yml@refs/tags/${tag}`;
+}
+function exactRegex(value) {
+    return `^${value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`;
+}
+function parseSignatureBundle(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        fail('community_release_signature_bundle_json_invalid');
+    }
+}
+function embeddedSigstoreTrustedRoot() {
+    const seeds = sigstoreTufSeeds;
+    const encoded = seeds['https://tuf-repo-cdn.sigstore.dev']?.targets?.['trusted_root.json'];
+    if (typeof encoded !== 'string' || encoded.length === 0) {
+        fail('community_release_offline_trusted_root_missing');
+    }
+    try {
+        return TrustedRoot.fromJSON(JSON.parse(Buffer.from(encoded, 'base64').toString('utf8')));
+    }
+    catch {
+        fail('community_release_offline_trusted_root_invalid');
+    }
+}
+async function verifySigstoreOffline(bundle, payload, options) {
+    const verifier = new Verifier(toTrustMaterial(embeddedSigstoreTrustedRoot()));
+    return verifier.verify(toSignedEntity(bundleFromJSON(bundle), payload), {
+        subjectAlternativeName: options.certificateIdentityURI,
+        extensions: { issuer: options.certificateIssuer },
+    });
+}
+async function verifyManifestSignature(options) {
+    const certificateIdentity = options.certificateIdentity ?? defaultCertificateIdentity(options.manifest);
+    const certificateOidcIssuer = options.certificateOidcIssuer ?? COMMUNITY_GITHUB_OIDC_ISSUER;
+    const verificationMode = options.verificationMode ?? 'online';
+    try {
+        const bundle = parseSignatureBundle(options.signatureBundleContent);
+        const payload = Buffer.from(options.manifestContent);
+        const verifierOptions = {
+            certificateIssuer: certificateOidcIssuer,
+            certificateIdentityURI: exactRegex(certificateIdentity),
+            verificationMode,
+        };
+        if (options.signatureVerifier) {
+            await options.signatureVerifier(bundle, payload, verifierOptions);
+        }
+        else if (verificationMode === 'offline') {
+            await verifySigstoreOffline(bundle, payload, verifierOptions);
+        }
+        else {
+            await verifySigstore(bundle, payload, verifierOptions);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('community_release_signature_bundle_json_invalid'))
+            throw error;
+        fail('community_release_sigstore_verification_failed', error instanceof Error ? error.message : String(error));
+    }
+    return { certificateIdentity, certificateOidcIssuer };
+}
+async function verifyAgentAssetsManifestSignature(options) {
+    const certificateIdentity = options.certificateIdentity ?? COMMUNITY_AGENT_ASSETS_CERTIFICATE_IDENTITY_URI;
+    const certificateOidcIssuer = options.certificateOidcIssuer ?? COMMUNITY_GITHUB_OIDC_ISSUER;
+    const verificationMode = options.verificationMode ?? 'online';
+    try {
+        const bundle = parseSignatureBundle(options.signatureBundleContent);
+        const payload = Buffer.from(options.manifestContent);
+        const verifierOptions = {
+            certificateIssuer: certificateOidcIssuer,
+            certificateIdentityURI: options.certificateIdentity === undefined
+                ? certificateIdentity
+                : exactRegex(certificateIdentity),
+            verificationMode,
+        };
+        if (options.signatureVerifier) {
+            await options.signatureVerifier(bundle, payload, verifierOptions);
+        }
+        else if (verificationMode === 'offline') {
+            await verifySigstoreOffline(bundle, payload, verifierOptions);
+        }
+        else {
+            await verifySigstore(bundle, payload, verifierOptions);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('community_release_signature_bundle_json_invalid'))
+            throw error;
+        fail('community_agent_assets_sigstore_verification_failed', error instanceof Error ? error.message : String(error));
+    }
+    return { certificateIdentity, certificateOidcIssuer };
+}
+export async function verifyCommunityReleaseDescriptor(options) {
+    const manifest = parseManifest(options.manifestContent);
+    if (options.expectedReleaseVersion !== undefined && manifest.releaseVersion !== options.expectedReleaseVersion) {
+        fail('community_release_descriptor_version_mismatch', `expected=${options.expectedReleaseVersion}:actual=${manifest.releaseVersion}`);
+    }
+    const identity = parseCommunityRelease(options.manifestContent, options.composeContent);
+    const certificate = await verifyManifestSignature({
+        manifest,
+        manifestContent: options.manifestContent,
+        signatureBundleContent: options.signatureBundleContent,
+        certificateIdentity: options.certificateIdentity,
+        certificateOidcIssuer: options.certificateOidcIssuer,
+        signatureVerifier: options.signatureVerifier,
+        verificationMode: options.verificationMode,
+    });
+    return {
+        manifestContent: options.manifestContent,
+        composeContent: options.composeContent,
+        identity,
+        ...certificate,
+        verifiedArtifactCount: 3,
+        agentAssets: manifest.agentAssets,
+    };
+}
+export async function verifyCommunityReleaseBundle(options) {
+    const releaseRoot = path.resolve(options.releaseRoot);
+    const rootStat = lstatSync(releaseRoot);
+    if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
+        fail('community_release_root_invalid');
+    const manifestPath = requireConfinedFile(releaseRoot, 'release.json', 'community_release_manifest');
+    const manifestContent = readFileSync(manifestPath, 'utf8');
+    const manifest = parseManifest(manifestContent);
+    const artifacts = [
+        { ref: manifest.source.treeRef, sha256: manifest.source.treeDigest, kind: 'source' },
+        { ref: manifest.cli.artifactRef, sha256: manifest.cli.artifactSha256, kind: 'cli' },
+        { ref: manifest.compose.ref, sha256: manifest.compose.sha256, kind: 'compose' },
+        ...manifest.migrations.files.map((entry) => ({ ...entry, kind: 'migration' })),
+        ...manifest.agentAssets.files.map((entry) => ({
+            ref: entry.ref,
+            sha256: `sha256:${entry.sha256}`,
+            kind: 'agent_assets',
+        })),
+        { ref: manifest.legal.license.ref, sha256: manifest.legal.license.sha256, kind: 'legal_license' },
+        { ref: manifest.legal.notice.ref, sha256: manifest.legal.notice.sha256, kind: 'legal_notice' },
+        { ref: manifest.legal.thirdPartyNotices.ref, sha256: manifest.legal.thirdPartyNotices.sha256, kind: 'legal_third_party_notices' },
+        { ref: manifest.legal.thirdPartyInventory.ref, sha256: manifest.legal.thirdPartyInventory.sha256, kind: 'legal_third_party_inventory' },
+        { ref: manifest.evidence.sbom.ref, sha256: manifest.evidence.sbom.sha256, kind: 'sbom' },
+        { ref: manifest.evidence.provenance.ref, sha256: manifest.evidence.provenance.sha256, kind: 'provenance' },
+    ];
+    let composePath = '';
+    for (const artifact of artifacts) {
+        const artifactPath = requireConfinedFile(releaseRoot, artifact.ref, `community_release_${artifact.kind}`);
+        if (digestFile(artifactPath) !== artifact.sha256)
+            fail(`community_release_${artifact.kind}_digest_mismatch`, artifact.ref);
+        if (artifact.kind === 'cli' && npmIntegrityFile(artifactPath) !== manifest.cli.npmIntegrity) {
+            fail('community_release_cli_npm_integrity_mismatch', artifact.ref);
+        }
+        if (artifact.kind === 'compose')
+            composePath = artifactPath;
+    }
+    const signatureBundlePath = requireConfinedFile(releaseRoot, manifest.evidence.signature?.bundleRef, 'community_release_signature');
+    const composeContent = readFileSync(composePath, 'utf8');
+    const descriptor = await verifyCommunityReleaseDescriptor({
+        manifestContent,
+        composeContent,
+        signatureBundleContent: readFileSync(signatureBundlePath, 'utf8'),
+        certificateIdentity: options.certificateIdentity,
+        certificateOidcIssuer: options.certificateOidcIssuer,
+        signatureVerifier: options.signatureVerifier,
+        verificationMode: options.verificationMode,
+    });
+    return {
+        releaseRoot,
+        manifestPath,
+        signatureBundlePath,
+        ...descriptor,
+        verifiedArtifactCount: artifacts.length + 2,
+    };
+}
+export async function verifyCommunityAgentAssetsReleaseBundle(options) {
+    const releaseRoot = path.resolve(options.releaseRoot);
+    const rootStat = lstatSync(releaseRoot);
+    if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
+        fail('community_release_root_invalid');
+    const manifestPath = requireConfinedFile(releaseRoot, COMMUNITY_AGENT_ASSETS_MANIFEST_REF, 'community_agent_assets_manifest');
+    const manifestContent = readFileSync(manifestPath, 'utf8');
+    const manifest = parseAgentAssetsManifest(manifestContent);
+    for (const artifact of manifest.agentAssets.files) {
+        const artifactPath = requireConfinedFile(releaseRoot, artifact.ref, 'community_release_agent_assets');
+        if (digestFile(artifactPath) !== `sha256:${artifact.sha256}`) {
+            fail('community_release_agent_assets_digest_mismatch', artifact.ref);
+        }
+    }
+    const signatureBundlePath = requireConfinedFile(releaseRoot, COMMUNITY_AGENT_ASSETS_SIGNATURE_REF, 'community_agent_assets_signature');
+    const certificate = await verifyAgentAssetsManifestSignature({
+        manifestContent,
+        signatureBundleContent: readFileSync(signatureBundlePath, 'utf8'),
+        certificateIdentity: options.certificateIdentity,
+        certificateOidcIssuer: options.certificateOidcIssuer,
+        signatureVerifier: options.signatureVerifier,
+        verificationMode: options.verificationMode,
+    });
+    return {
+        releaseRoot,
+        manifestPath,
+        signatureBundlePath,
+        manifestContent,
+        releaseVersion: manifest.releaseVersion,
+        source: manifest.source,
+        ...certificate,
+        verifiedArtifactCount: manifest.agentAssets.files.length + 2,
+        agentAssets: manifest.agentAssets,
+    };
+}