Initial curated chimera source from a8ae5b1db07fb49926c94585e2718e5130330974
This commit is contained in:
Public Source Publisher committed
commit
c737a37f71
531 files changed
+119270
No files matched your search
@@ -0,0 +1,261 @@
|
||||
'use strict';
|
||||
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const os = require('node:os');
|
||||
const path = require('node:path');
|
||||
const test = require('node:test');
|
||||
const { A8_DISTINCT_CONTROL } = require('../../src/services/ps5-native-pkg-builder-provider');
|
||||
const { createPs5FpkgDistinctControlPackageService } = require('../../src/services/ps5-fpkg-distinct-control-package-service');
|
||||
const { assessPs5FpkgControlMetadata } = require('../../src/services/ps5-fpkg-control-metadata-assessment');
|
||||
const { validatePs5NativePackageManifest } = require('../../src/services/ps5-native-package-registration-service');
|
||||
|
||||
test('repository distribution contains the exact frozen canonical artifact and Docker copies it', () => {
|
||||
const artifact = path.join('assets', 'ps5-controls', 'a9', A8_DISTINCT_CONTROL.selectedArtifact.filename);
|
||||
assert.equal(fs.statSync(artifact).size, A8_DISTINCT_CONTROL.selectedArtifact.size);
|
||||
const sha256 = require('node:crypto').createHash('sha256').update(fs.readFileSync(artifact)).digest('hex');
|
||||
assert.equal(sha256, A8_DISTINCT_CONTROL.selectedArtifact.sha256);
|
||||
const docker = fs.readFileSync('Dockerfile', 'utf8');
|
||||
assert.match(docker, /COPY --chown=chimera:chimera assets \.\/assets/);
|
||||
assert.match(docker, new RegExp(A8_DISTINCT_CONTROL.selectedArtifact.sha256));
|
||||
assert.match(docker, /chmod 0444 .*\/app\/assets\/ps5-controls\/a9/);
|
||||
});
|
||||
|
||||
function fixture({ registrar, assessMetadata } = {}) {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-a8-distinct-control-'));
|
||||
const registrations = [];
|
||||
let builds = 0;
|
||||
let validations = 0;
|
||||
const builder = {
|
||||
async buildDistinctControl({ outputPath }) {
|
||||
builds += 1;
|
||||
fs.writeFileSync(outputPath, Buffer.from(`fixed-identity-randomized-artifact-${builds}`), { flag: 'wx' });
|
||||
return { provider: { product: 'LibProsperoPkg', version: '2.6.0', revision: A8_DISTINCT_CONTROL.upstreamRevision, abi: 'chimera-prospero-bridge-v4', patched: false }, report: { fixedIdentity: true, licenseFree: true } };
|
||||
},
|
||||
async validatePackage() { validations += 1; return { accepted: true, checks: [{ name: 'Finalized image', status: 0 }] }; },
|
||||
async inspectPackage() { return { type: 'FullDebug', contentId: A8_DISTINCT_CONTROL.contentId }; },
|
||||
};
|
||||
const service = createPs5FpkgDistinctControlPackageService({
|
||||
outputRoot: path.join(root, 'vault'), stateFile: path.join(root, 'state.json'), builder,
|
||||
assessMetadata: assessMetadata || (() => ({ qualified: true, status: 'metadata_qualified', issues: [] })),
|
||||
registrar: registrar || (async manifest => { registrations.push(manifest); return { packageSetId: 71, titleId: 72 }; }),
|
||||
});
|
||||
return { root, registrations, service, builds: () => builds, validations: () => validations };
|
||||
}
|
||||
|
||||
test('builds, validates, freezes and registers one exact distinct-title control artifact', async t => {
|
||||
const f = fixture(); t.after(() => fs.rmSync(f.root, { recursive: true, force: true }));
|
||||
const ready = await f.service.buildAndRegister({ sourcePath: path.join(f.root, 'source') });
|
||||
assert.equal(ready.status, 'ready');
|
||||
assert.equal(ready.titleId, A8_DISTINCT_CONTROL.titleId);
|
||||
assert.equal(ready.contentId, A8_DISTINCT_CONTROL.contentId);
|
||||
assert.equal(ready.artifactVerified, true);
|
||||
assert.equal(ready.installAuthorized, false);
|
||||
assert.equal(ready.installed, false);
|
||||
assert.equal(ready.launchVerified, false);
|
||||
assert.equal(ready.productionRestorable, false);
|
||||
assert.equal(f.builds(), 1);
|
||||
assert.equal(f.registrations[0].controlProfile, A8_DISTINCT_CONTROL.controlProfile);
|
||||
assert.equal(f.registrations[0].packageFormat.licenseFree, true);
|
||||
assert.equal(f.registrations[0].components[0].structuralValidation.status, 'accepted');
|
||||
assert.equal(f.registrations[0].components[0].structuralValidation.upstream.accepted, true);
|
||||
assert.equal(f.registrations[0].components[0].metadataQualification.status, 'accepted');
|
||||
assert.deepEqual(f.registrations[0].components[0].structuralValidation.upstream.checks, [{ name: 'Finalized image', status: 0 }]);
|
||||
assert.equal(f.registrations[0].evidence.immutableArtifact.sha256, ready.sha256);
|
||||
assert.equal(f.registrations[0].evidence.immutableArtifact.rebuildSubstitutionAllowed, false);
|
||||
assert.equal((await f.service.buildAndRegister({ sourcePath: 'ignored-after-ready' })).sha256, ready.sha256);
|
||||
assert.equal(f.builds(), 1);
|
||||
assert.equal(f.validations(), 1);
|
||||
});
|
||||
|
||||
test('retains built_verified state when registration fails and retries without rebuilding', async t => {
|
||||
let attempts = 0;
|
||||
const f = fixture({ registrar: async () => {
|
||||
attempts += 1;
|
||||
if (attempts === 1) throw Object.assign(new Error('database unavailable'), { code: 'TEST_REGISTRATION' });
|
||||
return { packageSetId: 81, titleId: 82 };
|
||||
} });
|
||||
t.after(() => fs.rmSync(f.root, { recursive: true, force: true }));
|
||||
await assert.rejects(f.service.buildAndRegister({ sourcePath: path.join(f.root, 'source') }), /database unavailable/);
|
||||
assert.equal(f.service.status().status, 'built_verified');
|
||||
const ready = await f.service.buildAndRegister({ sourcePath: path.join(f.root, 'source') });
|
||||
assert.equal(ready.status, 'ready');
|
||||
assert.equal(f.builds(), 1);
|
||||
assert.equal(attempts, 2);
|
||||
assert.equal(f.validations(), 2);
|
||||
});
|
||||
|
||||
test('fails closed when the selected artifact drifts or an unmanaged target already exists', async t => {
|
||||
const f = fixture(); t.after(() => fs.rmSync(f.root, { recursive: true, force: true }));
|
||||
await f.service.buildAndRegister({ sourcePath: path.join(f.root, 'source') });
|
||||
fs.appendFileSync(f.service.targetPath(), 'drift');
|
||||
assert.equal(f.service.status().status, 'artifact_drift');
|
||||
await assert.rejects(f.service.buildAndRegister({ sourcePath: path.join(f.root, 'source') }), error => error.code === 'PS5_A8_CONTROL_ARTIFACT_DRIFT');
|
||||
|
||||
const other = fixture(); t.after(() => fs.rmSync(other.root, { recursive: true, force: true }));
|
||||
fs.mkdirSync(path.dirname(other.service.targetPath()), { recursive: true });
|
||||
fs.writeFileSync(other.service.targetPath(), 'unmanaged');
|
||||
await assert.rejects(other.service.buildAndRegister({ sourcePath: path.join(other.root, 'source') }), error => error.code === 'PS5_A8_CONTROL_UNOWNED_ARTIFACT');
|
||||
});
|
||||
|
||||
test('keeps an exact artifact distinct from a metadata assessment failure', async t => {
|
||||
let parserFails = false;
|
||||
const f = fixture({
|
||||
assessMetadata: () => {
|
||||
if (parserFails) throw Object.assign(new Error('host parser details'), { code: 'PS5_FPKG_METADATA_CONTAINER_INVALID' });
|
||||
return { qualified: true, status: 'metadata_qualified', issues: [] };
|
||||
},
|
||||
});
|
||||
t.after(() => fs.rmSync(f.root, { recursive: true, force: true }));
|
||||
|
||||
await f.service.buildAndRegister({ sourcePath: path.join(f.root, 'source') });
|
||||
parserFails = true;
|
||||
const state = f.service.status();
|
||||
assert.equal(state.status, 'metadata_rejected');
|
||||
assert.equal(state.artifactVerified, true);
|
||||
assert.equal(state.metadataQualified, false);
|
||||
await assert.rejects(
|
||||
f.service.buildAndRegister({ sourcePath: path.join(f.root, 'source') }),
|
||||
error => error.code === 'PS5_A8_CONTROL_METADATA_UNQUALIFIED'
|
||||
&& error.details.status === 'metadata_rejected'
|
||||
&& error.details.issues[0].actual === 'PS5_FPKG_METADATA_CONTAINER_INVALID'
|
||||
&& !JSON.stringify(error.details).includes('host parser details'),
|
||||
);
|
||||
});
|
||||
|
||||
test('fails closed on corrupt durable state without replacing its evidence', async t => {
|
||||
const f = fixture(); t.after(() => fs.rmSync(f.root, { recursive: true, force: true }));
|
||||
const statePath = path.join(f.root, 'state.json');
|
||||
fs.writeFileSync(statePath, '{invalid-json', 'utf8');
|
||||
assert.throws(() => f.service.status(), error => error.code === 'PS5_A8_CONTROL_STATE_CORRUPT');
|
||||
await assert.rejects(f.service.buildAndRegister({ sourcePath: path.join(f.root, 'source') }), error => error.code === 'PS5_A8_CONTROL_STATE_CORRUPT');
|
||||
assert.equal(fs.readFileSync(statePath, 'utf8'), '{invalid-json');
|
||||
assert.equal(f.builds(), 0);
|
||||
});
|
||||
|
||||
test('rejects a concurrent materialization before a second build can start', async t => {
|
||||
let releaseRegistration;
|
||||
let registrationStarted;
|
||||
const started = new Promise(resolve => { registrationStarted = resolve; });
|
||||
const f = fixture({ registrar: async () => {
|
||||
registrationStarted();
|
||||
await new Promise(resolve => { releaseRegistration = resolve; });
|
||||
return { packageSetId: 83, titleId: 84 };
|
||||
} });
|
||||
t.after(() => fs.rmSync(f.root, { recursive: true, force: true }));
|
||||
const first = f.service.buildAndRegister({ sourcePath: path.join(f.root, 'source') });
|
||||
await started;
|
||||
await assert.rejects(f.service.buildAndRegister({ sourcePath: path.join(f.root, 'source') }), error => error.code === 'PS5_A8_CONTROL_BUSY');
|
||||
assert.equal(f.builds(), 1);
|
||||
releaseRegistration();
|
||||
assert.equal((await first).status, 'ready');
|
||||
});
|
||||
|
||||
test('production preparation copies and registers only the exact frozen distribution bytes', async t => {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-a8-selected-control-'));
|
||||
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
||||
const selectedPath = path.join(root, 'selected.pkg');
|
||||
const bytes = Buffer.from('frozen-distribution-control');
|
||||
fs.writeFileSync(selectedPath, bytes);
|
||||
const sha256 = require('node:crypto').createHash('sha256').update(bytes).digest('hex');
|
||||
let builds = 0;
|
||||
const service = createPs5FpkgDistinctControlPackageService({
|
||||
outputRoot: path.join(root, 'vault'), stateFile: path.join(root, 'state.json'), selectedArtifactPath: selectedPath,
|
||||
descriptor: { ...A8_DISTINCT_CONTROL, selectedArtifact: { filename: 'selected.pkg', size: bytes.length, sha256 } },
|
||||
builder: {
|
||||
async buildDistinctControl() { builds += 1; throw new Error('must not rebuild selected artifact'); },
|
||||
async probe() { return { product: 'LibProsperoPkg', version: '2.6.0', revision: A8_DISTINCT_CONTROL.upstreamRevision, abi: 'chimera-prospero-bridge-v4', patched: false, pinned: true, clean: true, controlAvailable: true }; },
|
||||
async validatePackage() { return { accepted: true }; },
|
||||
async inspectPackage() { return { type: 'FullDebug', contentId: A8_DISTINCT_CONTROL.contentId }; },
|
||||
},
|
||||
assessMetadata: () => ({ qualified: true, status: 'metadata_qualified', issues: [] }),
|
||||
registrar: async manifest => {
|
||||
assert.equal(manifest.components[0].sha256, sha256);
|
||||
return { packageSetId: 91, titleId: 92 };
|
||||
},
|
||||
});
|
||||
const ready = await service.prepareSelectedAndRegister();
|
||||
assert.equal(ready.status, 'ready');
|
||||
assert.equal(ready.artifactSelection, 'frozen-distribution-artifact');
|
||||
assert.equal(ready.sha256, sha256);
|
||||
assert.deepEqual(fs.readFileSync(service.targetPath()), bytes);
|
||||
assert.equal(builds, 0);
|
||||
});
|
||||
|
||||
test('frozen canonical control carries structural and metadata qualification into registration', async t => {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-a8-registration-boundary-'));
|
||||
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
||||
const outputRoot = path.join(root, 'vault');
|
||||
const selectedArtifactPath = path.resolve('assets', 'ps5-controls', 'a9', A8_DISTINCT_CONTROL.selectedArtifact.filename);
|
||||
let registeredManifest = null;
|
||||
const service = createPs5FpkgDistinctControlPackageService({
|
||||
outputRoot,
|
||||
stateFile: path.join(root, 'state.json'),
|
||||
selectedArtifactPath,
|
||||
builder: {
|
||||
async buildDistinctControl() { throw new Error('production must not rebuild the frozen artifact'); },
|
||||
async probe() { return { product: 'LibProsperoPkg', version: '2.6.0', revision: A8_DISTINCT_CONTROL.upstreamRevision, abi: 'chimera-prospero-bridge-v4', patched: false, pinned: true, clean: true, controlAvailable: true }; },
|
||||
async validatePackage() { return { accepted: true, checks: [{ name: 'Finalized image', status: 0 }] }; },
|
||||
async inspectPackage() { return { type: 'FullDebug', contentId: A8_DISTINCT_CONTROL.contentId }; },
|
||||
},
|
||||
assessMetadata: sourcePath => assessPs5FpkgControlMetadata({
|
||||
sourcePath,
|
||||
expected: { titleId: A8_DISTINCT_CONTROL.titleId, contentId: A8_DISTINCT_CONTROL.contentId },
|
||||
}),
|
||||
registrar: async manifest => {
|
||||
validatePs5NativePackageManifest(manifest, { outputRoot, verifyArtifacts: true });
|
||||
registeredManifest = manifest;
|
||||
return { packageSetId: 93, titleId: 94 };
|
||||
},
|
||||
});
|
||||
const ready = await service.prepareSelectedAndRegister();
|
||||
assert.equal(ready.status, 'ready');
|
||||
assert.equal(ready.metadataQualified, true);
|
||||
assert.equal(registeredManifest.controlProfile, A8_DISTINCT_CONTROL.controlProfile);
|
||||
assert.equal(registeredManifest.components[0].structuralValidation.upstream.accepted, true);
|
||||
assert.equal(registeredManifest.components[0].metadataQualification.assessment.status, 'metadata_qualified');
|
||||
assert.equal(registeredManifest.components[0].metadataQualification.assessment.metadata.contentVersion, '01.000.000');
|
||||
});
|
||||
|
||||
test('production registry keeps preparation separate from the single-use exact-confirmed control install gate', () => {
|
||||
const registry = fs.readFileSync('src/server/create-registry.js', 'utf8');
|
||||
assert.match(registry, /ps5-native-packages:a8-distinct-control-status[\s\S]*classification: 'read-only'/);
|
||||
assert.match(registry, /ps5-native-packages:a8-distinct-control-prepare[\s\S]*classification: 'mutating'/);
|
||||
assert.match(registry, /prepareSelectedAndRegister\(\)/);
|
||||
assert.doesNotMatch(registry, /a8-distinct-control-build/);
|
||||
assert.match(registry, /a8-distinct-control-install-plan[\s\S]*classification: 'mutating'/);
|
||||
assert.match(registry, /CONFIRMATION: A8_CONTROL_INSTALL_CONFIRMATION/);
|
||||
assert.match(registry, /a8-distinct-control-install[\s\S]*classification: 'destructive'[\s\S]*confirmation: A8_CONTROL_INSTALL_CONFIRMATION/);
|
||||
assert.match(registry, /performConsoleScan\(A8_CONTROL_INSTALL_ROOTS\)/);
|
||||
assert.match(registry, /ps5FpkgDistinctControlInstallGate\.plan\(context\.session\?\.id\)/);
|
||||
assert.match(registry, /ps5FpkgDistinctControlInstallGate\.start\(input, context\.session\?\.id\)/);
|
||||
assert.match(registry, /PS5_A8_CONTROL_INSTALL_GATE_REQUIRED/g);
|
||||
});
|
||||
|
||||
test('server and desktop UI expose preflight, exact install, independent scan and launch qualification', () => {
|
||||
const preload = fs.readFileSync('preload.js', 'utf8');
|
||||
const web = fs.readFileSync('renderer/pork-web-shim.js', 'utf8');
|
||||
const main = fs.readFileSync('main.js', 'utf8');
|
||||
const modal = fs.readFileSync('renderer/modules/modal.js', 'utf8');
|
||||
const surface = `${fs.readFileSync('renderer/index.html', 'utf8')}\n${modal}`;
|
||||
for (const source of [preload, web]) assert.match(source, /ps5A8DistinctControl/);
|
||||
assert.match(main, /PS5_A8_CONTROL_SERVER_REQUIRED/);
|
||||
assert.match(surface, /ps5-a8-control-prepare/);
|
||||
assert.match(modal, /ps5A8DistinctControl\('prepare'\)/);
|
||||
assert.match(surface, /ps5-a8-control-preflight/);
|
||||
assert.match(modal, /ps5A8DistinctControl\('install-plan'\)/);
|
||||
assert.match(modal, /ps5A8DistinctControl\('install'/);
|
||||
assert.match(modal, /ps5A8Control\('trust'\)\.removeAttribute\('data-i18n'\)/);
|
||||
assert.match(modal, /ps5A8Control\('status'\)\.removeAttribute\('data-i18n'\)/);
|
||||
assert.match(modal, /ps5NativePackageRestoreVerify\(\{ titleId: 'CHIM00002'/);
|
||||
assert.match(modal, /ps5NativePackageRestoreLaunchPlan\(ps5A8ControlOperationId\)/);
|
||||
assert.match(modal, /Number\(item\.packageSetId\) === Number\(a8Control\.packageSetId\)/);
|
||||
assert.match(modal, /item\.components\[0\]\?\.sha256 === a8Control\.sha256/);
|
||||
for (const locale of ['en', 'nl']) {
|
||||
const catalog = JSON.parse(fs.readFileSync(`build/lang/${locale}.json`, 'utf8'));
|
||||
assert.equal(typeof catalog.strings?.['ps5NativePackages.a8Control.ready'], 'string');
|
||||
for (const key of ['preflight', 'install', 'verify', 'launch', 'confirm', 'boundary']) {
|
||||
assert.equal(typeof catalog.strings?.[`ps5NativePackages.a8Control.${key}`], 'string');
|
||||
}
|
||||
}
|
||||
});
|
||||
Reference in new issue
Block a user