Initial curated chimera source from a8ae5b1db07fb49926c94585e2718e5130330974

test/server/ecosystem-intelligence-service.test.js

@@ -0,0 +1,315 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { SettingsStore } = require('../../src/persistence/settings-store');
+const { createEcosystemIntelligenceService, repoSlug, sameVersion, compareVersionish, versionFromFilename, componentForPayload } = require('../../src/services/ecosystem-intelligence-service');
+
+function fixture({ withWebhook = false, payloadManager = null } = {}) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ecosystem-intelligence-'));
+  const paths = Object.fromEntries(['backups', 'cache', 'tmp'].map(name => [name, path.join(root, name)]));
+  for (const directory of Object.values(paths)) fs.mkdirSync(directory, { recursive: true });
+  const settings = new SettingsStore(path.join(root, 'config', 'settings.json'));
+  settings.set('ftp.host', '127.0.0.1');
+  settings.set('ecosystem.componentVersions', { elfldr: 'v1.0.0', websrv: 'v1.0.0' });
+  const secretValues = new Map(withWebhook ? [['discord.webhookUrl', 'https://discord.com/api/webhooks/1/test']] : []);
+  const secrets = {
+    has: name => secretValues.has(name),
+    get: name => secretValues.get(name) || '',
+  };
+  const components = [
+    { id: 'elfldr', name: 'ELF Loader', kind: 'daemon', platform: 'ps5', repo: 'ps5-payload-dev/elfldr', trust: 'official', risk: 'normal', dependencies: [], release: { tag: 'v1.0.0' }, compatibility: { status: 'compatible', reason: 'Testprofiel.' } },
+    { id: 'websrv', name: 'PS5 websrv', kind: 'daemon', platform: 'ps5', repo: 'ps5-payload-dev/websrv', trust: 'official', risk: 'normal', dependencies: ['elfldr'], release: { tag: 'v2.0.0' }, compatibility: { status: 'compatible', reason: 'Testprofiel.' } },
+  ];
+  const catalog = {
+    sources: [
+      { id: 1, name: 'ELF Loader', github_url: 'https://github.com/ps5-payload-dev/elfldr', latest_tag: 'v1.0.0', category: 'loader', description: 'ELF loader', enabled: 1 },
+      { id: 2, name: 'Web Server', github_url: 'https://github.com/ps5-payload-dev/websrv', latest_tag: 'v2.0.0', category: 'network', description: 'PS5 web server', enabled: 1 },
+    ],
+    files: [
+      { id: 10, source_id: 1, asset_name: 'elfldr.elf', asset_url: 'https://github.com/ps5-payload-dev/elfldr/releases/download/v1/elfldr.elf', asset_size: 100, version: 'v1.0.0', remote_hash: 'a'.repeat(64), local_path: null },
+      { id: 20, source_id: 2, asset_name: 'websrv.elf', asset_url: 'https://github.com/ps5-payload-dev/websrv/releases/download/v2/websrv.elf', asset_size: 200, version: 'v2.0.0', remote_hash: 'b'.repeat(64), local_path: null },
+    ],
+    stats: { updates: 1 },
+  };
+  const downloads = [];
+  let refreshes = 0;
+  let syncs = 0;
+  const base = {
+    listComponents: () => ({ checkedAt: Date.now(), components }),
+    refreshComponents: async () => { refreshes += 1; return { checkedAt: Date.now(), components }; },
+    serviceStatus: async () => ({ host: '127.0.0.1', services: [{ port: 9021, label: 'ELF loader', reachable: true }, { port: 8080, label: 'websrv', reachable: true }] }),
+    listPlugins: () => ({ items: [] }),
+    cheatIndex: () => ({ syncedAt: Date.now(), items: [], total: 0 }),
+    listSaveVault: () => [],
+  };
+  const db = {
+    getPayloadCatalog: () => catalog,
+    listGames: () => [{ game_id: 'PPSA00001', title: 'PPSA00001', prospero_name: null, prospero_icon_url: null }],
+    listBackups: () => [],
+  };
+  const payloadCatalog = {
+    sync: async () => { syncs += 1; return []; },
+    download: async input => { downloads.push(input); catalog.files.find(file => file.source_id === input.source_id && file.asset_name === input.asset_name).local_path = path.join(root, input.asset_name); return { localPath: path.join(root, input.asset_name), local_hash: 'b'.repeat(64), verified: true }; },
+  };
+  const service = createEcosystemIntelligenceService({
+    base, db, ftp: {}, settings, secrets, paths, payloadCatalog, payloadManager,
+    capabilities: { features: { https: { configured: true } } },
+    logger: { info() {}, warn() {}, error() {} },
+  });
+  return { root, paths, settings, service, components, catalog, downloads, counts: () => ({ refreshes, syncs }) };
+}
+
+test('repository and version normalization only accepts GitHub repositories', () => {
+  assert.equal(repoSlug('https://github.com/etaHEN/etaHEN/releases/latest'), 'etahen/etahen');
+  assert.equal(repoSlug('https://github.com/etaHEN/etaHEN.git'), 'etahen/etahen');
+  assert.equal(repoSlug('https://example.test/etaHEN/etaHEN'), '');
+  assert.equal(sameVersion('Release-v2.5B', '2.5b'), true);
+  assert.equal(sameVersion('1.0', '1.0.1'), false);
+  assert.equal(compareVersionish('2.6B', '2.5B'), 1);
+  assert.equal(compareVersionish('v0.23', '0.23'), 0);
+  assert.equal(compareVersionish('1.6beta16', '1.6beta17'), -1);
+  assert.equal(compareVersionish('1.0.0-beta1', '1.0.0'), null);
+  assert.equal(versionFromFilename('websrv_v0.33.elf'), '0.33');
+  assert.equal(componentForPayload('SystemStateManager.elf'), 'system-state');
+});
+
+test('health is unscored until a PS5 profile is configured', async () => {
+  const f = fixture();
+  try {
+    f.settings.set('ftp.host', '');
+    const report = await f.service.runHealth({ persist: true, notify: true });
+    assert.equal(report.hostConfigured, false);
+    assert.equal(report.score, null);
+    assert.equal(report.grade, 'not-configured');
+    assert.equal(report.notification.reason, 'not-configured');
+    assert.equal(report.alerts.find(item => item.id === 'ps5-host').severity, 'info');
+    assert.equal(f.service.healthHistory()[0].score, null);
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('update planner detects newer console payloads and blocks downgrades', () => {
+  const f = fixture();
+  try {
+    f.settings.set('ecosystem.componentVersions', { ...f.settings.get('ecosystem.componentVersions', {}), etahen: '2.6B' });
+    f.components.push({ id: 'etahen', name: 'etaHEN', kind: 'hen', platform: 'ps5', repo: 'etaHEN/etaHEN', trust: 'official', risk: 'normal', dependencies: [], release: { tag: '2.5B' }, compatibility: { status: 'compatible', reason: 'Testprofiel.' } });
+    f.catalog.sources.push({ id: 3, name: 'etaHEN', github_url: 'https://github.com/etaHEN/etaHEN', latest_tag: '2.5B', category: 'homebrew', enabled: 1 });
+    f.catalog.files.push({ id: 30, source_id: 3, asset_name: 'etaHEN-2.5B.bin', asset_url: 'https://github.com/etaHEN/etaHEN/releases/download/2.5B/etaHEN-2.5B.bin', version: '2.5B', remote_hash: 'c'.repeat(64) });
+    const inventory = f.service.componentInventory();
+    assert.equal(inventory.stats.ahead, 1);
+    assert.equal(inventory.components.find(item => item.id === 'etahen').state, 'ahead');
+    const plan = f.service.updatePlan({ selected: ['etahen'] });
+    assert.equal(plan.steps[0].stageable, false);
+    assert.match(plan.steps[0].blockers.join(' '), /downgrade/);
+    assert.throws(() => f.service.selectUpdateAsset({ componentId: 'etahen' }), /downgrade/);
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('Payload Manager inventory automatically supplies installed component versions', async () => {
+  const payloadManager = {
+    probe: async () => ({
+      version: '0.3.1',
+      autoload: { list: 'SystemStateManager.elf' },
+      inventory: { payloads: [{ filename: 'SystemStateManager.elf', path: '/data/pldmgr/payloads/SystemStateManager/SystemStateManager.elf', version: '1.0', checksumVerified: true }] },
+      sources: { items: [{ id: 'default', name: 'Official Repository', url: 'https://example.test/payloads.json' }] },
+      repository: { total: 20 },
+    }),
+  };
+  const f = fixture({ payloadManager });
+  try {
+    f.components.push({ id: 'system-state', name: 'System State Manager', kind: 'daemon', platform: 'ps5', repo: 'StonedModder/PS5-SystemStateManager', trust: 'official', risk: 'advanced', dependencies: ['elfldr'], release: { tag: 'v1.0' }, compatibility: { status: 'compatible', reason: 'Testprofiel.' } });
+    const snapshot = await f.service.refreshConsolePayloads();
+    assert.equal(snapshot.online, true);
+    assert.equal(snapshot.payloads[0].componentId, 'system-state');
+    const component = f.service.componentInventory().components.find(item => item.id === 'system-state');
+    assert.equal(component.installedVersion, '1.0');
+    assert.equal(component.installedSource, 'payload-manager');
+    assert.equal(component.state, 'current');
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('runtime evidence beats manual fallback and clears stale masking', async () => {
+  const payloadManager = {
+    probe: async () => ({
+      version: '0.4.0',
+      autoload: { list: 'websrv.elf' },
+      inventory: { payloads: [{ filename: 'websrv.elf', path: '/data/pldmgr/payloads/PS5-Plugins/websrv/websrv.elf', version: '2.0.0', checksumVerified: true }] },
+      sources: { items: [{ id: 'default', name: 'Official Repository', url: 'https://example.test/payloads.json' }] },
+      repository: { total: 20 },
+    }),
+  };
+  const f = fixture({ payloadManager });
+  try {
+    f.settings.set('ecosystem.componentVersions', { websrv: '1.0.0' });
+    await f.service.refreshConsolePayloads();
+    const component = f.service.componentInventory().components.find(item => item.id === 'websrv');
+    assert.equal(component.installedVersion, '2.0.0');
+    assert.equal(component.installedSource, 'payload-manager');
+    assert.equal(component.installedSourceConfidence, 'high');
+    assert.equal(component.installedVersionConflicts.length, 0);
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('manual override is explicitly stored with manual source and used as fallback', () => {
+  const f = fixture();
+  try {
+    const updated = f.service.setComponentVersion({ id: 'websrv', version: '2.0.0' });
+    const component = updated.components.find(item => item.id === 'websrv');
+    assert.equal(component.installedSource, 'manual');
+    assert.equal(component.installedSourceConfidence, 'manual');
+    assert.equal(component.installedVersion, '2.0.0');
+    assert.ok(Number.isFinite(component.installedSourceSeenAt) && component.installedSourceSeenAt > 0);
+    const stored = f.settings.get('ecosystem.componentVersions', {});
+    assert.equal(stored.websrv.version, '2.0.0');
+    assert.equal(stored.websrv.source, 'manual');
+    assert.equal(stored.websrv.confidence, 'manual');
+    assert.equal(stored.websrv.mode, 'override');
+    assert.ok(Number.isFinite(stored.websrv.seenAt) && stored.websrv.seenAt > 0);
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('explicit manual override exposes conflicts and follow automatic restores runtime priority', async () => {
+  const payloadManager = { probe: async () => ({
+    version: '0.4.0', autoload: { list: 'websrv.elf' },
+    inventory: { payloads: [{ filename: 'websrv.elf', path: '/data/pldmgr/payloads/websrv.elf', version: '2.0.0', checksumVerified: true }] },
+    sources: { items: [] }, repository: { total: 1 },
+  }) };
+  const f = fixture({ payloadManager });
+  try {
+    await f.service.refreshConsolePayloads();
+    f.service.setComponentVersion({ id: 'websrv', version: '1.5.0' });
+    let component = f.service.componentInventory().components.find(item => item.id === 'websrv');
+    assert.equal(component.installedVersion, '1.5.0');
+    assert.equal(component.trackingMode, 'manual-override');
+    assert.equal(component.evidenceState, 'conflict');
+    assert.ok(component.installedVersionConflicts.some(item => item.version === '2.0.0'));
+    f.service.followAutomatic({ id: 'websrv' });
+    component = f.service.componentInventory().components.find(item => item.id === 'websrv');
+    assert.equal(component.installedVersion, '2.0.0');
+    assert.equal(component.installedSource, 'payload-manager');
+    assert.equal(component.trackingMode, 'automatic');
+    assert.equal(component.manualEvidence, null);
+    assert.equal(f.settings.get('ecosystem.componentVersions', {}).websrv, undefined);
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('conflict and unknown evidence states are visible', () => {
+  const f = fixture();
+  try {
+    const websrvAsset = f.catalog.files.find(file => file.id === 20);
+    websrvAsset.local_path = path.join(f.root, 'websrv-local.elf');
+    websrvAsset.version = '1.0.0';
+    websrvAsset.asset_name = 'websrv_v1.1.elf';
+    fs.writeFileSync(websrvAsset.local_path, Buffer.from('websrv-payload'));
+    const component = f.service.componentInventory().components.find(entry => entry.id === 'websrv');
+    assert.equal(component.installedVersion, '1.0.0');
+    assert.equal(component.installedSource, 'file-hash');
+    assert.ok(component.installedVersionConflicts.length >= 1);
+
+    f.components.push({ id: 'ghost', name: 'Ghost payload', kind: 'daemon', platform: 'ps5', repo: 'invalid/ghost', trust: 'official', risk: 'normal', dependencies: [], release: {}, compatibility: { status: 'compatible', reason: 'Testprofiel.' } });
+    const ghost = f.service.componentInventory().components.find(entry => entry.id === 'ghost');
+    assert.equal(ghost.installedSource, null);
+    assert.equal(ghost.state, 'not-tracked');
+    assert.equal(ghost.installedVersion, '');
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('update planner orders dependencies and never declares automatic execution', async () => {
+  const f = fixture();
+  try {
+    const inventory = f.service.componentInventory();
+    assert.equal(inventory.stats.updates, 1);
+    assert.equal(inventory.components.find(item => item.id === 'websrv').state, 'update-available');
+    const plan = f.service.updatePlan();
+    assert.deepEqual(plan.steps.map(step => step.component.id), ['elfldr', 'websrv']);
+    assert.equal(plan.steps[0].dependencyOnly, true);
+    assert.equal(plan.steps[1].stageable, true);
+    assert.equal(plan.safety.autoExecute, false);
+
+    const refreshed = await f.service.refreshUpdates();
+    assert.equal(refreshed.safety.autoExecute, false);
+    assert.deepEqual(f.counts(), { refreshes: 1, syncs: 1 });
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('preparing an update only stages the selected catalog asset and records it', async () => {
+  const f = fixture();
+  try {
+    const result = await f.service.prepareUpdate({ componentId: 'websrv', assetName: 'websrv.elf' });
+    assert.equal(result.ok, true);
+    assert.equal(result.file.name, 'websrv.elf');
+    assert.equal(result.file.verified, true);
+    assert.deepEqual(f.downloads, [{ source_id: 2, asset_name: 'websrv.elf' }]);
+    assert.match(result.nextStep, /bewust/);
+    assert.equal(f.service.activityHistory()[0].type, 'updates');
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('Payload Manager repository exports only public upstream metadata and checksums', () => {
+  const f = fixture();
+  try {
+    const repository = f.service.payloadManagerRepository();
+    assert.equal(repository.name, 'Chimera Verified Payloads');
+    assert.equal(repository.payloads.length, 2);
+    assert.deepEqual(Object.keys(repository), ['name', 'payloads']);
+    const websrv = repository.payloads.find(item => item.filename === 'websrv.elf');
+    assert.equal(websrv.version, 'v2.0.0');
+    assert.equal(websrv.category, 'network');
+    assert.equal(websrv.checksum, 'b'.repeat(64));
+    assert.equal(Object.prototype.hasOwnProperty.call(websrv, 'localPath'), false);
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('Payload Supply-Chain Vault rehashes staged assets and blocks mismatches', async () => {
+  const f = fixture();
+  try {
+    const vault = path.join(f.root, 'payloads');
+    fs.mkdirSync(vault, { recursive: true });
+    f.settings.set('payload.localPath', vault);
+    const content = Buffer.from('trusted payload bytes');
+    const localPath = path.join(vault, 'websrv.elf');
+    fs.writeFileSync(localPath, content);
+    const asset = f.catalog.files.find(file => file.asset_name === 'websrv.elf');
+    const source = f.catalog.sources.find(item => item.id === asset.source_id);
+    source.trust = 'official';
+    asset.local_path = localPath;
+    asset.local_hash = crypto.createHash('sha256').update(content).digest('hex');
+    asset.remote_hash = asset.local_hash;
+    let report = await f.service.supplyChainAudit();
+    assert.equal(report.stats.verified, 1);
+    assert.equal(report.stats.blocked, 0);
+    fs.appendFileSync(localPath, 'tamper');
+    report = await f.service.supplyChainAudit();
+    assert.equal(report.stats.verified, 0);
+    assert.equal(report.stats.blocked, 1);
+    assert.match(report.assets.find(item => item.name === 'websrv.elf').issues.join(' '), /wijkt af/);
+    assert.equal(report.policy.automaticExecution, false);
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('console health persists actionable alerts, history and acknowledgements', async () => {
+  const f = fixture();
+  try {
+    const report = await f.service.runHealth({ persist: true, notify: false });
+    assert.ok(report.score < 100);
+    assert.ok(report.alerts.some(alert => alert.id === 'game-metadata'));
+    assert.ok(report.alerts.some(alert => alert.id === 'backup-coverage' && alert.severity === 'critical'));
+    assert.equal(f.service.healthHistory().length, 1);
+    const acknowledged = f.service.acknowledgeAlert({ id: 'game-metadata' });
+    assert.equal(acknowledged.alerts.find(alert => alert.id === 'game-metadata').acknowledged, true);
+    assert.equal(f.service.latestHealth().alerts.find(alert => alert.id === 'game-metadata').acknowledged, true);
+    assert.ok(f.service.activityHistory().some(item => item.type === 'health'));
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});
+
+test('health notifications cannot be enabled without an encrypted webhook', () => {
+  const f = fixture();
+  try {
+    assert.throws(() => f.service.setHealthOptions({ notificationsEnabled: true }), /Discord-webhook/);
+    assert.equal(f.service.setHealthOptions({ notificationsEnabled: false }).notificationsEnabled, false);
+  } finally { fs.rmSync(f.root, { recursive: true, force: true }); }
+});