105 lines
7.2 KiB
JavaScript
105 lines
7.2 KiB
JavaScript
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import assert from 'node:assert/strict';
|
|
import { createHash, randomUUID } from 'node:crypto';
|
|
import { spawn, execFileSync } from 'node:child_process';
|
|
import { projectEnvironment } from '../src/core/process-environment.mjs';
|
|
|
|
if (process.argv.includes('--help')) {
|
|
console.log('node scripts/verify-packaged-build.mjs — independently rebuild a source ZIP and compare all compiled files with the latest program. AGENT_WORKBENCH_SOURCE_RELEASE selects a standalone source-code JSON receipt; otherwise use the legacy source bundle. Set AGENT_WORKBENCH_TEST_PYTHON. No model calls or formal-host changes.');
|
|
process.exit(0);
|
|
}
|
|
assert.equal(process.argv.length, 2);
|
|
assert.match(process.version, /^v24\./);
|
|
const release = JSON.parse(fs.readFileSync('releases/latest.json'));
|
|
const sourceReceipt = process.env.AGENT_WORKBENCH_SOURCE_RELEASE;
|
|
const standaloneSource = sourceReceipt ? JSON.parse(fs.readFileSync(sourceReceipt)) : null;
|
|
if (standaloneSource) assert.equal(standaloneSource.kind, 'source-code');
|
|
const sourceZip = standaloneSource ?? release.source;
|
|
const manifest = JSON.parse(fs.readFileSync(path.join(release.portableRoot, 'MANIFEST.json')));
|
|
const root = path.resolve('.qa', 'packaged-build-' + randomUUID()), destination = path.join(root, 'source');
|
|
fs.mkdirSync(destination, { recursive: true });
|
|
const env = projectEnvironment();
|
|
const python = process.env.AGENT_WORKBENCH_TEST_PYTHON;
|
|
assert.ok(python && path.isAbsolute(python) && fs.existsSync(python), 'Select an explicit QA Python.');
|
|
const npm = path.join(path.dirname(process.execPath), 'node_modules/npm/bin/npm-cli.js');
|
|
assert.ok(fs.existsSync(npm), 'Use Node with its bundled npm.');
|
|
const sha = bytes => createHash('sha256').update(bytes).digest('hex');
|
|
async function digestFile(file) {
|
|
const hash = createHash('sha256');
|
|
for await (const bytes of fs.createReadStream(file)) hash.update(bytes);
|
|
return hash.digest('hex');
|
|
}
|
|
const startedAt = new Date().toISOString();
|
|
const extract = `import sys,zipfile,pathlib,json,hashlib
|
|
archive,destination,top,receipt=sys.argv[1:]
|
|
folders={'src','public','scripts','tests','examples','benchmarks','research'}
|
|
names={'package.json','package-lock.json','vite.config.ts','tsconfig.json','index.html','mobile.html'}
|
|
output=pathlib.Path(destination).resolve()
|
|
with zipfile.ZipFile(archive) as bundle:
|
|
manifest=json.loads(pathlib.Path(receipt).read_text(encoding='utf-8')) if receipt else json.loads(bundle.read(top+'/MANIFEST.json'))
|
|
selected=[item for item in manifest['files'] if item['path'].split('/')[0] in folders or item['path'] in names]
|
|
assert manifest['kind'] in {'source','source-code'} and selected
|
|
for item in selected:
|
|
relative=pathlib.PurePosixPath(item['path'])
|
|
assert not relative.is_absolute() and '..' not in relative.parts
|
|
contents=bundle.read(top+'/'+item['path'])
|
|
assert len(contents)==item['bytes']
|
|
if manifest['kind']=='source-code' and 'sha256' not in item:
|
|
assert hashlib.sha1(b'blob '+str(len(contents)).encode()+b'\\0'+contents).hexdigest()==item['gitBlob']
|
|
item['sha256']=hashlib.sha256(contents).hexdigest()
|
|
else:
|
|
assert hashlib.sha256(contents).hexdigest()==item['sha256']
|
|
target=(output/str(relative)).resolve()
|
|
assert target.is_relative_to(output)
|
|
target.parent.mkdir(parents=True,exist_ok=True)
|
|
target.write_bytes(contents)
|
|
print(json.dumps({'version':manifest['version'],'inputs':selected}))`;
|
|
const logs = [];
|
|
async function run(args, name) {
|
|
const file = path.join(root, name + '.log'), log = fs.openSync(file, 'wx');
|
|
let code;
|
|
try {
|
|
code = await new Promise((resolve, reject) => {
|
|
const child = spawn(process.execPath, [npm, ...args], { cwd: destination, env, windowsHide: true, stdio: ['ignore', log, log] });
|
|
child.once('error', reject); child.once('close', resolve);
|
|
});
|
|
} finally { fs.closeSync(log); }
|
|
logs.push({ name, file, code, sha256: await digestFile(file) });
|
|
assert.equal(code, 0, name + ': inspect original log ' + file);
|
|
console.log('PASS ' + name);
|
|
}
|
|
let result, stage = 'source archive identity', inputs = [], compiled = [], mismatches = [];
|
|
try {
|
|
assert.equal(await digestFile(sourceZip.path), sourceZip.sha256);
|
|
stage = 'extract fixed compile inputs';
|
|
const extraction = JSON.parse(execFileSync(python, ['-I', '-c', extract, sourceZip.path, destination, standaloneSource ? 'Agent-Workbench-' + standaloneSource.version + '-source' : path.basename(release.sourceRoot), sourceReceipt || ''],
|
|
{ env, encoding: 'utf8', windowsHide: true, maxBuffer: 8 * 1024 * 1024 }));
|
|
assert.equal(extraction.version, manifest.version); inputs = extraction.inputs;
|
|
stage = 'offline install'; await run(['ci', '--offline', '--ignore-scripts', '--no-audit', '--no-fund'], 'offline-install');
|
|
stage = 'actual source build'; await run(['run', 'build'], 'build');
|
|
stage = 'source and compiled bytes';
|
|
for (const input of inputs) assert.equal(await digestFile(path.join(destination, input.path)), input.sha256, 'Source input changed: ' + input.path);
|
|
const folders = ['dist-client', 'dist-server', 'dist-desktop'];
|
|
const walk = folder => fs.readdirSync(path.join(destination, folder), { withFileTypes: true })
|
|
.flatMap(entry => entry.isDirectory() ? walk(path.posix.join(folder, entry.name)) : [path.posix.join(folder, entry.name)]);
|
|
const expected = manifest.files.filter(item => folders.some(folder => item.path.startsWith(folder + '/')));
|
|
assert.deepEqual(folders.flatMap(walk).sort(), expected.map(item => item.path).sort(), 'Exact compiled directory');
|
|
for (const item of expected) {
|
|
const file = path.join(destination, item.path), actual = { bytes: fs.statSync(file).size, sha256: await digestFile(file) };
|
|
assert.equal(await digestFile(path.join(release.portableRoot, item.path)), item.sha256, 'Portable input drift: ' + item.path);
|
|
compiled.push({ path: item.path, expected: { bytes: item.bytes, sha256: item.sha256 }, actual });
|
|
if (actual.bytes !== item.bytes || actual.sha256 !== item.sha256) mismatches.push(compiled.at(-1));
|
|
}
|
|
assert.deepEqual(mismatches, [], 'Source ZIP rebuild differs from portable compilation.');
|
|
result = { success: true };
|
|
} catch (error) { result = { success: false, stage, error: error.stack }; process.exitCode = 1; }
|
|
result = { ...result, startedAt, finishedAt: new Date().toISOString(), version: manifest.version, sourceCommit: standaloneSource?.sourceCommit ?? release.documentation.sourceCommit,
|
|
root, destination, sourceZip, portableManifestSha256: await digestFile(path.join(release.portableRoot, 'MANIFEST.json')),
|
|
node: { version: process.version, sha256: await digestFile(process.execPath) }, inputCount: inputs.length, inputs, compiled, mismatches, logs, realModelRequests: 0,
|
|
scope: 'Independent compile-input extraction from the exact source ZIP, offline dependency installation and actual TypeScript/Vite/mobile/server/desktop rebuild. Every source input retained and every compiled file compared. Historical source tests and full archive checks keep their separate receipts.' };
|
|
const output = path.join(root, 'result.json');
|
|
fs.writeFileSync(output, JSON.stringify(result, null, 2) + '\n', { flag: 'wx' });
|
|
console.log(JSON.stringify({ success: result.success, stage: result.stage, root, output, inputCount: inputs.length,
|
|
compiledFiles: compiled.length, mismatches: mismatches.length, error: result.error }));
|