Files
Agent-Workbench/docs/task-control-j-release-evidence/0375-verify-task-control-j-formal-artifacts.mjs
T
2026-11-01 16:35:58 +08:00

62 lines
5.3 KiB
JavaScript

import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { createHash } from 'node:crypto';
import { DatabaseSync } from 'node:sqlite';
import { canonical, databaseSnapshot, digest } from './desktop-f-state.mjs';
import { snapshotPersistentData } from '../src/core/desktop/install-manager.mjs';
const deployed = JSON.parse(fs.readFileSync(process.argv[2] ?? '.qa/desktop-host-f-formal-start.json')); assert.equal(deployed.success, true);
const output = process.argv[3] ?? '.qa/desktop-host-f-formal-artifacts.json';
const before = JSON.parse(fs.readFileSync(JSON.parse(fs.readFileSync('.qa/task-control-j-formal-baseline-location.json')).before));
const database = new DatabaseSync(path.join(deployed.dataRoot, 'workbench.sqlite'), { readOnly: true });
let originalRecords;
try { originalRecords = database.prepare("SELECT * FROM records WHERE kind='artifact' ORDER BY rowid").all(); }
finally { database.close(); }
const original = new Map(), producers = [], referenced = new Map();
for (const row of originalRecords) {
const artifact = JSON.parse(row.payload);
assert.equal(artifact.id, row.id); assert.equal(original.has(row.id), false);
for (const [column, field] of [['session_id', 'sessionId'], ['project_id', 'projectId'], ['task_id', 'taskId'], ['run_id', 'runId']]) {
assert.equal(row[column] ?? null, artifact[field] ?? null, artifact.id + ': ' + field);
}
assert.match(artifact.sha256, /^[a-f0-9]{64}$/);
assert.equal(artifact.relative, artifact.sha256.slice(0, 2) + '/' + artifact.sha256 + '.blob');
const blob = { path: artifact.relative, bytes: artifact.bytes, sha256: artifact.sha256 };
if (referenced.has(blob.path)) assert.deepEqual(referenced.get(blob.path), blob);
referenced.set(blob.path, blob); original.set(row.id, artifact);
producers.push({ id: row.id, sessionId: row.session_id, projectId: row.project_id, taskId: row.task_id, runId: row.run_id,
rowSha256: digest(row), metadataSha256: digest(artifact) });
}
assert.deepEqual(canonical(databaseSnapshot(deployed.dataRoot).tables.records), canonical(before.database.tables.records));
const physical = snapshotPersistentData(deployed.dataRoot).artifacts;
assert.deepEqual(physical, before.persistent.artifacts, 'Every original physical blob byte remains exact.');
const physicalByPath = new Map(physical.map(value => [value.path, value]));
for (const blob of referenced.values()) assert.deepEqual(physicalByPath.get(blob.path), blob, 'Original referenced blob: ' + blob.path);
assert.equal(physical.length, deployed.counts.artifacts);
const base = 'http://127.0.0.1:4318';
const bootstrap = await (await fetch(base + '/api/bootstrap', { headers: { Connection: 'close' } })).json(); assert.equal(bootstrap.version, '1.20.1');
const health = await (await fetch(base + '/api/health', { headers: { Connection: 'close' } })).json(); assert.equal(health.pid, deployed.identity.pid);
const pages = [], ids = new Set(); let offset = 0, total = null;
while (total === null || offset < total) {
const response = await fetch(base + '/api/operations?artifactOffset=' + offset + '&artifactLimit=100',
{ headers: { 'X-Workbench-Token': bootstrap.token, Connection: 'close' }, signal: AbortSignal.timeout(30000) }); assert.equal(response.status, 200);
const report = await response.json(), page = report.artifacts; assert.equal(report.version, '1.20.1'); assert.equal(page.offset, offset);
if (total === null) total = page.total; assert.equal(page.total, total); assert.equal(page.checked, page.results.length);
for (const row of page.results) {
assert.equal(row.passed, true, row.id + ': ' + row.error); assert.equal(ids.has(row.id), false);
const artifact = original.get(row.id); assert.ok(artifact, 'Inspection returned an unknown original artifact ID.');
assert.equal(row.sha256, artifact.sha256); assert.equal(row.bytes, artifact.bytes); ids.add(row.id);
}
pages.push({ offset, checked: page.checked, total, results: page.results, checks: report.checks, checkedAt: report.checkedAt });
offset += page.checked; assert.ok(page.checked > 0 || total === 0);
}
assert.equal(ids.size, total); assert.equal(total, original.size);
assert.deepEqual([...ids].sort(), [...original.keys()].sort());
assert.deepEqual(canonical(databaseSnapshot(deployed.dataRoot).tables.records), canonical(before.database.tables.records));
const result = { success: true, version: '1.20.1', pid: health.pid, checked: ids.size, total, pages,
artifactRecords: original.size, blobFiles: physical.length, referencedBlobFiles: referenced.size,
unreferencedBlobFiles: physical.filter(value => !referenced.has(value.path)), producers, physical,
checkedAt: new Date().toISOString(), realModelRequests: 0, scope: 'Each API inspection ID/hash/byte length matched its original SQLite artifact metadata and recorded producer identity. All referenced deduplicated blobs matched physical byte hashes; every physical blob matched the user-started snapshot. Record and physical-file counts are separate. No source/tool/model/credential or persistent user-state mutation; unknown/source attention remains recorded in each original inspection.' };
const bytes = Buffer.from(JSON.stringify(result, null, 2)); fs.writeFileSync(output, bytes, { flag: 'wx' });
console.log(JSON.stringify({ success: true, total, checked: ids.size, pages: pages.length, reportSha256: createHash('sha256').update(bytes).digest('hex') }));