Files
wekan/tests/singleFile.test.cjs
T
Lauri Ojansivu c35c672ffb Single-file: the 32-bit host Node.js is the target bundle's exact version.
The v13.07 single files for armhf, armv6 and armv7 all stopped on "The
bundle's Node.js is v26.13.0 but this is v26.13.1: a single executable must
be built by the same Node.js version it embeds." A 32-bit target's SEA blob is
written by a 32-bit Node.js, and the workflow borrowed the i386 bundle's.
Every bundle takes the newest Node.js of the pinned major its platform has, so
i386 had v26.13.1 from wekan/node-patches while 32-bit ARM still had v26.13.0.

The host is now resolved with releases/resolve-node-source.sh at the target
bundle's exact version, checked against its published SHA256, and refused
unless it reports that version. libatomic1:i386, which the bundle used to
supply in node-runtime/, comes from apt, so HOST_LIBS is gone.

tests/singleFile.test.cjs pins the exact version, the checksum before the
first run, and that the host is never taken from another platform's bundle.

Thanks to xet7 !
2026-11-12 16:05:46 +02:00

837 lines
49 KiB
JavaScript

'use strict';
// Single-file WeKan (docs/Platforms/Single-File.md, releases/single-file/):
// one executable per platform, Node.js with WeKan and FerretDB inside it as a
// virtual file system, its data in wekan-files beside it, and a menu.
//
// Pure parts are tested as functions. The whole thing is then tested for real
// on this machine: a single executable is BUILT from a small stand-in bundle
// with this Node.js, started, asked for its status and version, driven
// through its menu, and stopped. The browser test against a real WeKan
// bundle is tests/playwright/specs/single-file.e2e.js.
//
// Run: node tests/singleFile.test.cjs
const { test } = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const net = require('node:net');
const os = require('node:os');
const path = require('node:path');
const { spawnSync, execFileSync } = require('node:child_process');
const ROOT = path.join(__dirname, '..');
const SF = path.join(ROOT, 'releases', 'single-file');
const read = rel => fs.readFileSync(path.join(ROOT, rel), 'utf8');
const lib = name => require(path.join(SF, 'lib', name));
const TMP_ROOT = path.join(ROOT, '.tools', 'tmp');
fs.mkdirSync(TMP_ROOT, { recursive: true });
const tmp = prefix => fs.mkdtempSync(path.join(TMP_ROOT, prefix));
const { isFilesRoot } = require(path.join(ROOT, 'models', 'lib', 'filesRoot.js'));
const { layout } = lib('paths.cjs');
const config = lib('config.cjs');
const { requestedRestore } = lib('restore.cjs');
const ferret = lib('ferretdb.cjs');
const backup = lib('backup.cjs');
const releases = lib('releases.cjs');
const autostart = lib('autostart.cjs');
const info = lib('info.cjs');
const { installVirtualCwd } = lib('server.cjs');
// node:vfs and --build-sea arrived in Node.js 26.11. An older Node.js running
// this suite skips the parts that need them, and says so.
const HAS_VFS = spawnSync(process.execPath, ['--no-warnings', '--experimental-vfs', '-e', "require('node:vfs')"]).status === 0;
// And a Node.js can be compiled without single executable applications (the
// Homebrew one on macOS is): it says so for any --build-sea, as build.mjs's
// seaSupported() asks it.
const HAS_SEA = !/Single executable application is disabled/.test(
spawnSync(process.execPath, ['--build-sea', path.join(__dirname, 'no-such-sea-config.json')], { encoding: 'utf8' }).stderr || '');
// And on Linux, LIEF (inside --build-sea) adds the SEA segments aligned to
// 4 KiB pages. A kernel with larger pages - 16 KiB on Apple-silicon Linux, 64
// KiB on some ARM servers - cannot map them, and the executable it writes dies
// with SIGSEGV before running a line: even a one-line `console.log` SEA does,
// so it is Node.js's injection and not WeKan's. The release builders have
// 4 KiB pages; elsewhere the real-executable test says why it did not run.
const PAGE_SIZE = process.platform === 'linux'
? Number(spawnSync('getconf', ['PAGESIZE'], { encoding: 'utf8' }).stdout) || 4096
: 4096;
// --- where files go --------------------------------------------------------
test('WRITABLE_PATH: "files" keeps its old rule exactly, "wekan-files" is a files root too', () => {
for (const p of ['/snap/wekan/common/files', 'C:\\w\\files', '/x/wekan-files', 'C:\\x\\wekan-files', 'wekan-files']) {
assert.equal(isFilesRoot(p), true, p);
}
// Negative: none of these may change where an existing install's files are.
for (const p of ['/data', '/srv/my-files', '/data/files/', 'files', '/x/wekan-files/', '/wekan-filesx', '', undefined]) {
assert.equal(isFilesRoot(p), false, String(p));
}
});
test('every place that derives the files root asks filesRoot.js (negative: no copy of the old check left)', () => {
const offenders = [];
const walk = rel => {
for (const e of fs.readdirSync(path.join(ROOT, rel), { withFileTypes: true })) {
const r = `${rel}/${e.name}`;
if (e.isDirectory()) {
if (!['tests', 'node_modules'].includes(e.name)) walk(r);
} else if (/\.(js|cjs|mjs)$/.test(e.name) && r !== 'models/lib/filesRoot.js') {
const src = fs.readFileSync(path.join(ROOT, r), 'utf8');
if (/endsWith\(['"]\/files['"]\)/.test(src)) offenders.push(r);
}
}
};
for (const dir of ['server', 'models', 'imports', 'client', 'config']) {
if (fs.existsSync(path.join(ROOT, dir))) walk(dir);
}
assert.deepEqual(offenders, []);
});
test('the layout: wekan-files beside the executable, every part inside it, on POSIX and Windows', () => {
const l = layout({ exePath: '/opt/wekan/wekan-12.40-amd64-single-file', env: {}, pathImpl: path.posix });
assert.equal(l.writable, '/opt/wekan/wekan-files');
assert.equal(l.files, '/opt/wekan/wekan-files');
assert.equal(l.attachments, '/opt/wekan/wekan-files/attachments');
assert.equal(l.db, '/opt/wekan/wekan-files/db');
assert.equal(l.bin, '/opt/wekan/wekan-files/bin');
assert.equal(l.backup, '/opt/wekan/wekan-files/backup');
assert.equal(l.envFile, '/opt/wekan/wekan-files/wekan.env');
const w = layout({ exePath: 'C:\\Users\\a\\WeKan\\wekan.exe', env: {}, pathImpl: path.win32 });
assert.equal(w.files, 'C:\\Users\\a\\WeKan\\wekan-files');
assert.equal(w.avatars, 'C:\\Users\\a\\WeKan\\wekan-files\\avatars');
// An explicit WRITABLE_PATH wins; one that is not a files root gets /files,
// as everywhere else in WeKan.
assert.equal(layout({ exePath: '/opt/w/x', env: { WRITABLE_PATH: '/data' }, pathImpl: path.posix }).files, '/data/files');
assert.equal(layout({ exePath: '/opt/w/x', env: { WRITABLE_PATH: '/srv/wekan-files' }, pathImpl: path.posix }).db, '/srv/wekan-files/db');
});
// --- the environment, as start-wekan.sh -------------------------------------
test('wekan.env: KEY=VALUE, comments and quotes; setting a value keeps every other line', () => {
assert.deepEqual(config.parseEnvFile('# c\nPORT=3000\nexport ROOT_URL="https://w.example"\nBAD LINE\nMAIL_FROM=\'a b\'\n'),
{ PORT: '3000', ROOT_URL: 'https://w.example', MAIL_FROM: 'a b' });
const text = '# keep\nPORT=1\nOTHER=x\n';
assert.equal(config.setEnvValue(text, 'PORT', '2'), '# keep\nPORT=2\nOTHER=x\n');
assert.equal(config.setEnvValue(text, 'NEW', 'y'), '# keep\nPORT=1\nOTHER=x\nNEW=y\n');
assert.deepEqual(config.parseEnvFile(config.ENV_TEMPLATE), {}, 'the template sets nothing by itself');
// CodeQL #574: the key used to be spliced into a RegExp. Only a variable
// name is a setting, it is compared literally, and a value is one line.
for (const bad of ['.*', 'PORT|X', '(a+)+$', 'A B', '', '1PORT', 'PORT\nX']) {
assert.throws(() => config.setEnvValue(text, bad, '1'), /Not a setting name/, JSON.stringify(bad));
}
assert.throws(() => config.setEnvValue(text, 'PORT', '1\nMAIL_URL=smtp://evil'), /one line/);
assert.equal(config.setEnvValue('PORTS=1\nPORT=1\n', 'PORT', '2'), 'PORTS=1\nPORT=2\n', 'a key is matched whole');
});
test('the memory budget is start-wekan.sh\'s: 3/5 for Node up to 4 GiB (1 GiB on 32-bit), 1/5 for Go up to 1 GiB', () => {
assert.deepEqual(config.memoryBudget({ totalMb: 30787 }), { memoryMb: 30787, heapMb: 4096, goMb: 1024 });
assert.deepEqual(config.memoryBudget({ totalMb: 2048 }), { memoryMb: 2048, heapMb: 1228, goMb: 409 });
assert.equal(config.memoryBudget({ totalMb: 8192, bits: 32 }).heapMb, 1024);
assert.equal(config.memoryBudget({ totalMb: 16384, cgroupMb: 1024 }).memoryMb, 1024, 'a lower cgroup limit wins');
assert.equal(config.memoryBudget({ totalMb: 1024, cgroupMb: 4096 }).memoryMb, 1024, 'a higher one does not');
const sh = read('releases/ferretdb/start-wekan.sh');
assert.match(sh, /_heap_mb=\$\(\(_memory_mb\*3\/5\)\); \[ "\$_heap_mb" -gt 4096 \]/);
assert.match(sh, /_go_mb=\$\(\(_memory_mb\/5\)\); \[ "\$_go_mb" -gt 1024 \]/);
});
test('the environment: start-wekan.sh\'s defaults, wekan.env over them, the real environment over both', () => {
const l = layout({ exePath: '/opt/w/wekan', env: {}, pathImpl: path.posix });
const cfg = config.buildEnv({ base: { WEKAN_SINGLE_FILE_ROLE: 'server' }, file: {}, layout: l, version: '12.40', target: 'amd64', totalMb: 4096, cgroupMb: 0, bits: 64 });
assert.equal(cfg.env.PORT, '8080');
assert.equal(cfg.env.ROOT_URL, 'http://localhost:8080');
assert.equal(cfg.env.MONGO_URL, 'mongodb://127.0.0.1:27017/wekan');
assert.equal(cfg.env.WITH_API, 'true', 'exports need the API');
assert.equal(cfg.env.CARDS_LOADING, 'auto');
assert.equal(cfg.env.WRITABLE_PATH, '/opt/w/wekan-files');
assert.equal(cfg.env.WEKAN_PACKAGING, 'single-file', 'Admin Panel / Version names it');
assert.equal(cfg.env.METEOR_REACTIVITY_ORDER, 'polling');
assert.equal(cfg.env.METEOR_POLLING_INTERVAL_MS, '30000');
assert.equal(cfg.env.FERRETDB_TELEMETRY, 'disable');
assert.equal(cfg.useFerret, true);
assert.equal('WEKAN_SINGLE_FILE_ROLE' in cfg.env, false, 'the role switch never leaks into what is started');
// Precedence.
const mine = config.buildEnv({ base: { PORT: '9000' }, file: { PORT: '3000', ROOT_URL: 'https://b.example' }, layout: l, totalMb: 4096 });
assert.equal(mine.env.PORT, '9000');
assert.equal(mine.env.ROOT_URL, 'https://b.example');
// An external database: no FerretDB, no forced polling.
const ext = config.buildEnv({ base: { MONGO_URL: 'mongodb://db.example/wekan' }, layout: l, totalMb: 4096 });
assert.equal(ext.useFerret, false);
assert.equal(ext.env.METEOR_REACTIVITY_ORDER, undefined);
assert.equal(config.buildEnv({ base: { WEKAN_DB: 'mongodb' }, layout: l, totalMb: 4096 }).useFerret, false);
// uws is coerced, loudly, as start-wekan.sh does.
const uws = config.buildEnv({ base: { DDP_TRANSPORT: 'uws' }, layout: l, totalMb: 4096 });
assert.equal(uws.env.DDP_TRANSPORT, 'sockjs');
assert.match(uws.notes[0], /uws is not available/);
// Negative: an unknown database is refused, not guessed at.
assert.throws(() => config.buildEnv({ base: { WEKAN_DB: 'postgres' }, layout: l, totalMb: 4096 }), /WEKAN_DB must be/);
const sh = read('releases/ferretdb/start-wekan.sh');
for (const same of ['PORT="${PORT:-8080}"', 'WITH_API="${WITH_API:-true}"', 'CARDS_LOADING="${CARDS_LOADING:-auto}"',
'FERRETDB_LISTEN_ADDR="${FERRETDB_LISTEN_ADDR:-127.0.0.1:27017}"', 'METEOR_POLLING_THROTTLE_MS:-2000', 'METEOR_POLLING_INTERVAL_MS:-30000']) {
assert.ok(sh.includes(same), `start-wekan.sh still says ${same}`);
}
});
// --- requested restore, as start-wekan.sh -----------------------------------
test('a requested restore copies the backup in, drops the side-files and clears the request', () => {
const dir = tmp('sf-restore-');
try {
const db = path.join(dir, 'db');
fs.mkdirSync(path.join(db, 'backup'), { recursive: true });
fs.writeFileSync(path.join(db, 'wekan.sqlite'), 'broken');
fs.writeFileSync(path.join(db, 'wekan.sqlite-wal'), 'stale wal');
fs.writeFileSync(path.join(db, 'backup', 'wekan.sqlite'), 'good');
fs.writeFileSync(path.join(db, 'RESTORE_REQUESTED'), 'backup\n');
const r = requestedRestore({ dbDir: db, env: {} });
assert.deepEqual(r, { mode: 'backup', result: 'restored' });
assert.equal(fs.readFileSync(path.join(db, 'wekan.sqlite'), 'utf8'), 'good');
assert.equal(fs.existsSync(path.join(db, 'wekan.sqlite-wal')), false);
assert.equal(fs.existsSync(path.join(db, 'RESTORE_REQUESTED')), false);
assert.equal(fs.readFileSync(path.join(db, 'backup', 'wekan.sqlite'), 'utf8'), 'good', 'the backup is never removed');
assert.match(fs.readFileSync(path.join(db, 'recovery-events.jsonl'), 'utf8'), /"type":"restore-backup"/);
assert.equal(requestedRestore({ dbDir: db, env: {} }), null, 'nothing requested: nothing done');
} finally {
fs.rmSync(dir, { recursive: true, force: true });
}
});
test('a restore from a missing source keeps the request and the live database (negative)', () => {
const dir = tmp('sf-restore-');
try {
fs.writeFileSync(path.join(dir, 'wekan.sqlite'), 'live');
fs.writeFileSync(path.join(dir, 'RESTORE_REQUESTED'), 'prev');
assert.deepEqual(requestedRestore({ dbDir: dir, env: {} }), { mode: 'prev', result: 'missing' });
assert.equal(fs.readFileSync(path.join(dir, 'wekan.sqlite'), 'utf8'), 'live');
assert.ok(fs.existsSync(path.join(dir, 'RESTORE_REQUESTED')), 'retained for retry');
assert.match(fs.readFileSync(path.join(dir, 'recovery-events.jsonl'), 'utf8'), /"manual-required"/);
// A continuous restore keeps the database it replaces.
fs.mkdirSync(path.join(dir, 'continuous-restore'));
fs.writeFileSync(path.join(dir, 'continuous-restore', 'wekan.sqlite'), 'rolled back');
assert.deepEqual(requestedRestore({ dbDir: dir, env: { WEKAN_FORCE_RESTORE: 'continuous' } }), { mode: 'continuous', result: 'restored' });
assert.equal(fs.readFileSync(path.join(dir, 'continuous-restore', 'replaced', 'wekan.sqlite'), 'utf8'), 'live');
assert.equal(fs.readFileSync(path.join(dir, 'wekan.sqlite'), 'utf8'), 'rolled back');
} finally {
fs.rmSync(dir, { recursive: true, force: true });
}
});
// --- FerretDB: the one extracted file ----------------------------------------
test('FerretDB is copied once to wekan-files/bin, verified, reused, and an older copy removed', () => {
const dir = tmp('sf-ferret-');
try {
const app = path.join(dir, 'app');
fs.mkdirSync(path.join(app, 'bin'), { recursive: true });
fs.writeFileSync(path.join(app, 'bin', 'ferretdb'), 'ferretdb v1');
const manifest = { ferretdb: { path: 'bin/ferretdb', sha256: ferret.sha256File(path.join(app, 'bin', 'ferretdb')) } };
const bin = path.join(dir, 'bin');
fs.mkdirSync(bin);
fs.writeFileSync(path.join(bin, 'ferretdb-0123456789abcdef'), 'older');
const first = ferret.ensureFerretdb({ appRoot: app, manifest, binDir: bin, platform: 'linux' });
assert.equal(path.basename(first), `ferretdb-${manifest.ferretdb.sha256.slice(0, 16)}`);
assert.equal(fs.readFileSync(first, 'utf8'), 'ferretdb v1');
assert.deepEqual(fs.readdirSync(bin), [path.basename(first)], 'the older copy is gone');
const mtime = fs.statSync(first).mtimeMs;
assert.equal(ferret.ensureFerretdb({ appRoot: app, manifest, binDir: bin, platform: 'linux' }), first);
assert.equal(fs.statSync(first).mtimeMs, mtime, 'a verified copy is reused, not rewritten');
// Negative: an archive whose FerretDB does not match its checksum is refused.
fs.writeFileSync(path.join(app, 'bin', 'ferretdb'), 'tampered');
fs.rmSync(first);
assert.throws(() => ferret.ensureFerretdb({ appRoot: app, manifest, binDir: bin, platform: 'linux' }), /does not match its checksum/);
assert.deepEqual(fs.readdirSync(bin), [], 'nothing unverified is left behind');
assert.equal(ferret.ferretdbFileName(manifest, 'win32').endsWith('.exe'), true);
assert.deepEqual(ferret.ferretdbArgs('C:\\w\\wekan-files\\db', '127.0.0.1:27017').slice(0, 3),
['--handler=sqlite', '--sqlite-url=file:C:/w/wekan-files/db/', '--listen-addr=127.0.0.1:27017']);
} finally {
fs.rmSync(dir, { recursive: true, force: true });
}
});
// --- backup -----------------------------------------------------------------
test('a backup is wekan-files/backup/YYYY-MM-DD_HH-MM-SS with the data and nothing else', () => {
const dir = tmp('sf-backup-');
try {
const l = layout({ exePath: path.join(dir, 'wekan'), env: {} });
for (const d of ['db/backup', 'attachments/a', 'avatars', 'bin', 'logs', 'versions']) fs.mkdirSync(path.join(l.files, d), { recursive: true });
fs.writeFileSync(path.join(l.db, 'wekan.sqlite'), 'db');
fs.writeFileSync(path.join(l.db, 'backup', 'wekan.sqlite'), 'snapshot');
fs.writeFileSync(path.join(l.attachments, 'a', 'file'), 'att');
fs.writeFileSync(path.join(l.bin, 'ferretdb-x'), 'program');
fs.writeFileSync(l.envFile, 'PORT=1\n');
const date = new Date(2026, 9, 13, 9, 5, 7);
assert.equal(backup.backupName(date), '2026-10-13_09-05-07');
const { dest, copied } = backup.backupTo(l, { date });
assert.equal(dest, path.join(l.backup, '2026-10-13_09-05-07'));
assert.deepEqual(copied, ['db', 'attachments', 'avatars', 'wekan.env']);
assert.equal(fs.readFileSync(path.join(dest, 'db', 'wekan.sqlite'), 'utf8'), 'db');
assert.equal(fs.readFileSync(path.join(dest, 'attachments', 'a', 'file'), 'utf8'), 'att');
// Negative: programs, logs, old versions and recovery's own snapshots are not data.
assert.equal(fs.existsSync(path.join(dest, 'bin')), false);
assert.equal(fs.existsSync(path.join(dest, 'versions')), false);
assert.equal(fs.existsSync(path.join(dest, 'db', 'backup')), false);
// The same second twice does not mix two backups.
assert.equal(backup.backupTo(l, { date }).dest, `${dest}-2`);
assert.deepEqual(backup.listBackups(l), ['2026-10-13_09-05-07-2', '2026-10-13_09-05-07']);
} finally {
fs.rmSync(dir, { recursive: true, force: true });
}
});
// --- versions ---------------------------------------------------------------
const RELEASES = [
{ tag_name: 'v12.41', draft: true, assets: [{ name: 'wekan-12.41-amd64-single-file', browser_download_url: 'u' }] },
{ tag_name: 'v12.40', published_at: '2026-10-20', assets: [
{ name: 'wekan-12.40-amd64-single-file', browser_download_url: 'https://x/12.40', size: 10 },
{ name: 'wekan-12.40-amd64-single-file.sha256sum', browser_download_url: 'https://x/12.40.sum' },
{ name: 'wekan-12.40-win64-single-file.exe', browser_download_url: 'https://x/w' }] },
{ tag_name: 'v12.39', published_at: '2026-10-13', assets: [{ name: 'wekan-12.39-amd64.zip', browser_download_url: 'z' }] },
{ tag_name: 'v12.100', prerelease: true, assets: [{ name: 'wekan-12.100-amd64-single-file', browser_download_url: 'https://x/p' }] },
];
test('the versions on offer: releases with a single file for THIS platform, newest first', () => {
const list = releases.releasesFor(RELEASES, 'amd64');
assert.deepEqual(list.map(r => r.version), ['12.100', '12.40'], 'no draft, no release without the file, 12.100 > 12.40');
assert.equal(list[0].prerelease, true);
assert.equal(list[1].shaUrl, 'https://x/12.40.sum');
assert.deepEqual(releases.releasesFor(RELEASES, 'win64').map(r => r.version), ['12.40']);
assert.equal(releases.assetName('12.40', 'win64'), 'wekan-12.40-win64-single-file.exe');
assert.equal(releases.assetName('12.40', 'freebsd-x64'), 'wekan-12.40-freebsd-x64-single-file');
assert.ok(releases.compareVersions('10.10', '10.9') > 0);
assert.equal(releases.parseSha256sum(`${'a'.repeat(64)} file\n`), 'a'.repeat(64));
assert.equal(releases.parseSha256sum('not a sum'), null);
});
function fakeFetch(map) {
return async url => {
if (!(url in map)) return { ok: false, status: 404 };
const body = Buffer.from(map[url]);
return {
ok: true,
status: 200,
text: async () => body.toString(),
json: async () => JSON.parse(body.toString()),
body: (async function* gen() { yield body.subarray(0, 3); yield body.subarray(3); }()),
};
};
}
test('a download is installed only when its checksum matches (negative: a wrong one changes nothing)', async () => {
const dir = tmp('sf-dl-');
try {
const l = layout({ exePath: path.join(dir, 'wekan'), env: {} });
const crypto = require('node:crypto');
const good = 'new wekan';
const sum = crypto.createHash('sha256').update(good).digest('hex');
const rel = { version: '12.40', url: 'https://x/12.40', shaUrl: 'https://x/12.40.sum', size: good.length };
const file = await releases.download(rel, l, { fetchImpl: fakeFetch({ 'https://x/12.40': good, 'https://x/12.40.sum': `${sum} f\n` }) });
assert.equal(fs.readFileSync(file, 'utf8'), good);
await assert.rejects(
releases.download(rel, l, { fetchImpl: fakeFetch({ 'https://x/12.40': 'evil', 'https://x/12.40.sum': `${sum} f\n` }) }),
/does not match its checksum/);
assert.deepEqual(fs.readdirSync(l.versions).filter(n => n.includes(String(process.pid)) && n !== path.basename(file)), [], 'no partial download left');
await assert.rejects(releases.download({ ...rel, shaUrl: '' }, l, { fetchImpl: fakeFetch({}) }), /no checksum/);
// Installing keeps the running version and puts the new one in its place.
fs.writeFileSync(l.exePath, 'old wekan');
const kept = releases.install({ layout: l, newFile: file, currentVersion: '12.39', target: 'amd64' });
assert.equal(kept, path.join(l.versions, 'wekan-12.39'));
assert.equal(fs.readFileSync(l.exePath, 'utf8'), good);
assert.equal(fs.readFileSync(kept, 'utf8'), 'old wekan');
assert.deepEqual(releases.keptVersions(l, 'amd64').map(k => k.version), ['12.39']);
// Going back to a kept version copies it, so it stays kept.
releases.install({ layout: l, newFile: kept, currentVersion: '12.40', target: 'amd64' });
assert.equal(fs.readFileSync(l.exePath, 'utf8'), 'old wekan');
assert.deepEqual(releases.keptVersions(l, 'amd64').map(k => k.version), ['12.40', '12.39']);
// A kept version's name is read literally (it used to be a half-escaped
// RegExp): only wekan-<version><exe> counts.
for (const junk of ['wekan-12.38x', 'wekan-12.38.exe.partial', 'wekan-latest', 'xwekan-12.37', '.download-12.36-1-ab']) {
fs.writeFileSync(path.join(l.versions, junk), '');
}
assert.deepEqual(releases.keptVersions(l, 'amd64').map(k => k.version), ['12.40', '12.39']);
fs.writeFileSync(path.join(l.versions, 'wekan-12.35.exe'), '');
fs.writeFileSync(path.join(l.versions, 'wekan-12.34Xexe'), '');
assert.deepEqual(releases.keptVersions(l, 'win64').map(k => k.version), ['12.35']);
// Negative: a new file that cannot be moved in leaves the old executable in place.
assert.throws(() => releases.install({ layout: l, newFile: path.join(dir, 'missing'), currentVersion: '12.39', target: 'amd64' }));
assert.equal(fs.readFileSync(l.exePath, 'utf8'), 'old wekan', 'the executable is put back');
} finally {
fs.rmSync(dir, { recursive: true, force: true });
}
});
// --- autostart ---------------------------------------------------------------
test('autostart: each method starts "<executable> start", and removing takes away only its own entry', () => {
const spec = { exePath: '/opt/my wekan/wekan', workDir: '/opt/my wekan/wekan-files', logFile: '/opt/my wekan/wekan-files/logs/wekan.log' };
const unit = autostart.systemdUnit({ ...spec, user: 'wekan' });
assert.match(unit, /^ExecStart="\/opt\/my wekan\/wekan" start$/m);
assert.match(unit, /^User=wekan$/m);
assert.match(unit, /^WantedBy=multi-user\.target$/m);
assert.match(autostart.systemdUnit(spec), /^WantedBy=default\.target$/m, 'a user unit');
const plist = autostart.launchdPlist({ ...spec, exePath: '/A&B/wekan' });
assert.match(plist, /<string>\/A&amp;B\/wekan<\/string>\s*<string>start<\/string>/);
assert.match(plist, /<key>RunAtLoad<\/key>\s*<true\/>/);
const line = autostart.cronLine(spec);
assert.match(line, /^@reboot cd '\/opt\/my wekan\/wekan-files' && '\/opt\/my wekan\/wekan' start >> /);
const others = 'MAILTO=a\n0 1 * * * backup.sh\n';
const withIt = autostart.crontabWith(others, spec.exePath, line);
assert.equal(withIt, `${others}${line}\n`);
assert.equal(autostart.crontabWith(withIt, spec.exePath, line), withIt, 'installing twice adds it once');
assert.equal(autostart.crontabWith(withIt, spec.exePath, null), others, 'removing keeps everything else');
assert.equal(autostart.crontabWith(withIt, '/other/wekan', null), withIt, 'another single file\'s entry is not touched');
assert.match(autostart.termuxBootScript(spec), /termux-wake-lock[\s\S]*exec '\/opt\/my wekan\/wekan' start/);
assert.deepEqual(autostart.schtasksCreateArgs({ exePath: 'C:\\w\\wekan.exe', admin: true }).slice(-7),
['ONSTART', '/RU', 'SYSTEM', '/RL', 'HIGHEST', '/TR', '"C:\\w\\wekan.exe" start']);
assert.ok(autostart.schtasksCreateArgs({ exePath: 'C:\\w\\wekan.exe', admin: false }).includes('ONLOGON'));
// Which method each system gets.
const m = o => autostart.method({ has: () => false, isRoot: false, env: {}, ...o });
assert.equal(m({ platform: 'win32' }), 'schtasks');
assert.equal(m({ platform: 'darwin' }), 'launchd-agent');
assert.equal(m({ platform: 'darwin', isRoot: true }), 'launchd-daemon');
assert.equal(m({ platform: 'android' }), 'termux-boot');
assert.equal(m({ platform: 'linux', env: { PREFIX: '/data/data/com.termux/files/usr' } }), 'termux-boot');
for (const bsd of ['freebsd', 'openbsd', 'netbsd']) assert.equal(m({ platform: bsd }), 'cron', bsd);
assert.equal(m({ platform: 'linux' }), 'cron', 'no systemd: cron');
});
// --- version info -----------------------------------------------------------
test('version info has what Admin Panel / Version shows, as text lines', () => {
const fakeOs = {
type: () => 'Linux', platform: () => 'linux', arch: () => 'x64', release: () => '6.1',
uptime: () => 90061, loadavg: () => [1, 0.5, 0.25], totalmem: () => 8 * 1073741824, freemem: () => 1073741824,
cpus: () => [{ model: 'CPU X ' }, { model: 'CPU X' }],
};
const l = layout({ exePath: '/nowhere/wekan', env: {}, pathImpl: path.posix });
const lines = info.versionLines({
manifest: { version: '12.40', target: 'amd64', node: 'v26.11.1', meteor: '3.6', built: '2026-10-13T00:00:00Z' },
layout: l, running: { pid: 42, started: new Date(Date.now() - 65000).toISOString(), rootUrl: 'http://localhost:8080' },
ferretdb: { version: 'v1.94.0', commit: 'abc' }, osImpl: fakeOs,
});
const text = lines.join('\n');
for (const want of [/WeKan version\s+: 12\.40/, /Package\s+: single-file/, /OS type\s+: Linux/, /OS uptime\s+: 1 days, 1 hours, 1 minutes, 1 seconds/,
/OS total memory\s+: 8\.0 GiB/, /OS CPU count\s+: 2 x CPU X/, /Node\.js version\s+: 26\.11\.1/, /Meteor version\s+: 3\.6/,
/WeKan server\s+: running, pid 42, for 1 minutes, 5 seconds/, /FerretDB version\s+: v1\.94\.0/, /Storage engine\s+: SQLite/,
/WRITABLE_PATH\s+: \/nowhere\/wekan-files/]) {
assert.match(text, want);
}
});
// --- the virtual working directory ------------------------------------------
test('the server\'s working directory is virtual inside the archive and real outside it', () => {
const calls = [];
const proc = { cwd: () => '/real', chdir: d => calls.push(d) };
const fsImpl = { statSync: p => ({ isDirectory: () => !p.endsWith('.js') }) };
installVirtualCwd('/vfs/0/bundle/programs/server', { proc, fsImpl, isVirtual: p => p.startsWith('/vfs/0') });
assert.equal(proc.cwd(), '/vfs/0/bundle/programs/server');
proc.chdir('../web.browser');
assert.equal(proc.cwd(), '/vfs/0/bundle/programs/web.browser');
assert.deepEqual(calls, [], 'the kernel was not asked to enter the archive');
assert.throws(() => proc.chdir('/vfs/0/main.js'), { code: 'ENOTDIR' });
proc.chdir('/tmp');
assert.deepEqual(calls, ['/tmp']);
assert.equal(proc.cwd(), '/tmp');
});
// --- Node.js itself: what the single file relies on, and the bug it works around
function vfsChild(code) {
return spawnSync(process.execPath, ['--no-warnings', '--experimental-vfs', '-e', code], { encoding: 'utf8', cwd: TMP_ROOT });
}
test('Node.js 26.11.1 breaks fs.writev/readv while a VFS is mounted, and the workaround fixes both', { skip: !HAS_VFS && 'needs node:vfs (Node.js 26.11+)' }, () => {
const dir = tmp('sf-writev-');
try {
// The paths reach the child through its environment, so the code it runs
// is a constant (CodeQL js/bad-code-sanitization, as alerts 567/568).
const env = { ...process.env, SF_TARGET: path.join(dir, 'out.txt'), SF_WORKAROUNDS: path.join(SF, 'lib', 'vfsWorkarounds.cjs') };
const body = `
const fs = require('fs');
const target = process.env.SF_TARGET;
const v = require('node:vfs').create(); v.writeFileSync('/x', 'x'); v.mount();
if (process.argv[1] === 'fix') require(process.env.SF_WORKAROUNDS).patchVectoredIo(fs);
const ws = fs.createWriteStream(target);
ws.cork(); for (let i = 0; i < 5; i++) ws.write('chunk' + i + '\\n'); process.nextTick(() => ws.uncork());
ws.on('error', e => { console.log('ERR ' + e.message); process.exit(2); });
ws.end(() => {
const fd = fs.openSync(target, 'r'); const a = Buffer.alloc(7), b = Buffer.alloc(7);
fs.readv(fd, [a, b], 0, (e, n) => console.log('OK ' + fs.readFileSync(target, 'utf8').split('\\n').length + ' ' + n + ' ' + JSON.stringify(a + '' + b)));
});`;
const broken = spawnSync(process.execPath, ['--no-warnings', '--experimental-vfs', '-e', body, 'nofix'], { encoding: 'utf8', env });
// When this assertion fails, Node.js has fixed it: the workaround and this
// half of the test can go.
assert.match(broken.stdout + broken.stderr, /h\.writev is not a function/, 'Node.js still has the bug the workaround is for');
const fixed = spawnSync(process.execPath, ['--no-warnings', '--experimental-vfs', '-e', body, 'fix'], { encoding: 'utf8', env });
assert.equal(fixed.stdout.trim(), 'OK 6 14 "chunk0\\nchunk1\\n"', fixed.stderr);
} finally {
fs.rmSync(dir, { recursive: true, force: true });
}
});
test('the archive writer\'s ZIP is read by Node\'s own VFS: deflated, stored, nested (negative: bad names refused)', { skip: !HAS_VFS && 'needs node:vfs (Node.js 26.11+)' }, async () => {
const { writeZip } = await import(path.join(SF, 'zip.mjs'));
const dir = tmp('sf-zip-');
try {
const zip = path.join(dir, 'a.zip');
const big = 'compressible '.repeat(5000);
writeZip(zip, [
{ name: 'package.json', data: '{"main":"main.js"}' },
{ name: 'main.js', data: `const fs=require('fs');console.log(JSON.stringify([fs.readFileSync(__dirname+'/d/big.txt','utf8').length, require('./d/m.js'), fs.readdirSync(__dirname+'/d').sort()]))` },
{ name: 'd/big.txt', data: big },
{ name: 'd/m.js', data: 'module.exports = "nested";' },
{ name: 'd/rand.bin', data: require('node:crypto').randomBytes(4096) },
]);
const run = spawnSync(process.execPath, ['--no-warnings', '--experimental-vfs', `--vfs-load=${zip}`], { encoding: 'utf8' });
assert.equal(run.stdout.trim(), JSON.stringify([big.length, 'nested', ['big.txt', 'm.js', 'rand.bin']]), run.stderr);
assert.ok(fs.statSync(zip).size < big.length / 4, 'text is deflated');
assert.throws(() => writeZip(path.join(dir, 'b.zip'), [{ name: '../x', data: 'x' }]), /Refusing/);
assert.throws(() => writeZip(path.join(dir, 'b.zip'), [{ name: 'x', data: '1' }, { name: 'x', data: '2' }]), /Duplicate/);
} finally {
fs.rmSync(dir, { recursive: true, force: true });
}
});
// --- the whole thing, for real ------------------------------------------------
function freePort() {
return new Promise((resolve, reject) => {
const s = net.createServer();
s.listen(0, '127.0.0.1', () => {
const { port } = s.address();
s.close(() => resolve(port));
});
s.on('error', reject);
});
}
// A stand-in Meteor bundle: boot.js reads program.json RELATIVELY (the virtual
// working directory), writes a multi-chunk stream to WRITABLE_PATH (the
// writev workaround), and serves what it saw.
function fakeBundle(dir) {
const server = path.join(dir, 'programs', 'server');
fs.mkdirSync(server, { recursive: true });
fs.writeFileSync(path.join(dir, 'main.js'), "require('./programs/server/boot.js');\n");
fs.writeFileSync(path.join(dir, 'star.json'), JSON.stringify({ meteorRelease: 'METEOR@3.6-test' }));
fs.writeFileSync(path.join(server, 'program.json'), JSON.stringify({ format: 'stand-in' }));
fs.writeFileSync(path.join(server, 'runtime.js'), 'module.exports = function enable() {};\n');
fs.writeFileSync(path.join(server, 'mini-files.js'), meteorMiniFiles());
fs.writeFileSync(path.join(server, 'boot.js'), `
const fs = require('fs'); const path = require('path'); const http = require('http');
const program = JSON.parse(fs.readFileSync('program.json', 'utf8'));
const out = path.join(process.env.WRITABLE_PATH, 'attachments', 'probe.bin');
const ws = fs.createWriteStream(out);
ws.cork(); for (let i = 0; i < 8; i++) ws.write(Buffer.alloc(70000, i)); process.nextTick(() => ws.uncork());
ws.end(() => {
http.createServer((q, r) => {
r.setHeader('content-type', 'application/json');
r.end(JSON.stringify({ cwd: process.cwd(), argv2: process.argv[2], program: program.format, written: fs.statSync(out).size, packaging: process.env.WEKAN_PACKAGING }));
}).listen(Number(process.env.PORT), '127.0.0.1');
});
`);
// node and ferretdb are what the platform ZIP would carry; the builder
// leaves node out of the archive and puts ferretdb under bin/.
fs.writeFileSync(path.join(dir, 'ferretdb'), '#!/bin/sh\necho "version: v0.0.0-stand-in"\necho "commit: 0123abc"\n', { mode: 0o755 });
fs.writeFileSync(path.join(dir, 'start-wekan.sh'), '#!/bin/sh\n');
fs.writeFileSync(path.join(dir, 'mongodump'), 'not carried');
}
// start --background and backup returned as soon as they had spawned WeKan,
// before it wrote its pid file, so a `stop` right after them said "WeKan was
// not running" and left it running (the real-executable test below, on a
// Node.js with single executable applications). They wait for it now.
test('waitUntilStarted: true once the pid file names the new process; false if it ends first (negative)', async () => {
const { waitUntilStarted } = lib('status.cjs');
const dir = tmp('sf-wait-');
const layout = { pidFile: path.join(dir, 'wekan.pid') };
const { spawn } = require('node:child_process');
const child = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 5000)'], { stdio: 'ignore' });
try {
setTimeout(() => fs.writeFileSync(layout.pidFile, JSON.stringify({ pid: child.pid })), 300);
assert.equal(await waitUntilStarted(layout, child.pid, { timeoutMs: 5000 }), true, 'written a moment later');
// Another process's pid file is not this one starting.
fs.writeFileSync(layout.pidFile, JSON.stringify({ pid: process.pid }));
assert.equal(await waitUntilStarted(layout, child.pid, { timeoutMs: 300 }), false, 'negative: someone else\'s pid');
} finally {
child.kill();
}
await new Promise(r => child.once('exit', r));
fs.rmSync(layout.pidFile, { force: true });
const started = Date.now();
assert.equal(await waitUntilStarted(layout, child.pid, { timeoutMs: 10000 }), false, 'negative: it ended without starting');
assert.ok(Date.now() - started < 2000, 'and that is known at once, not after the timeout');
const cli = read('releases/single-file/lib/cli.cjs');
assert.equal((cli.match(/await status\.waitUntilStarted\(c\.layout, pid\)/g) || []).length, 2, 'start --background and backup both wait');
fs.rmSync(dir, { recursive: true, force: true });
});
test('build, start, status, version, menu and stop a real single executable', {
skip: (!HAS_VFS && 'needs --build-sea with useVfs (Node.js 26.11+)')
|| (!HAS_SEA && 'this Node.js was compiled without single executable applications (Homebrew\'s is)')
|| (process.platform === 'win32' && 'the stand-in FerretDB is a shell script')
|| (PAGE_SIZE > 4096 && `--build-sea writes 4 KiB-aligned segments, which this kernel's ${PAGE_SIZE / 1024} KiB pages cannot map`),
timeout: 240000,
}, async () => {
const dir = tmp('sf-e2e-');
const exe = path.join(dir, 'wekan-test-single-file');
const sh = (...args) => spawnSync(exe, args, { encoding: 'utf8', cwd: dir, env: { ...process.env, WEKAN_DB: 'mongodb', MONGO_URL: 'mongodb://127.0.0.1:1/none' }, timeout: 60000 });
try {
const bundle = path.join(dir, 'bundle');
fakeBundle(bundle);
const { build, archiveEntries, excludedFromBundle } = await import(path.join(SF, 'build.mjs'));
// What goes in: the bundle without what a single file does not carry.
const { entries, manifest } = archiveEntries({ bundle, target: 'amd64', version: '0.0', ferretdb: path.join(bundle, 'ferretdb'), nodeVersion: process.version, built: 'now' });
const names = entries.map(e => e.name);
for (const want of ['bundle/main.js', 'bundle/programs/server/boot.js', 'bin/ferretdb', 'single-file.json', 'models/lib/filesRoot.js',
'releases/single-file/launcher.cjs', 'releases/single-file/lib/cli.cjs', 'releases/single-file/lib/vfsWorkarounds.cjs', 'releases/ferretdb/sqlite-recovery.mjs']) {
assert.ok(names.includes(want), want);
}
for (const never of ['bundle/ferretdb', 'bundle/start-wekan.sh', 'bundle/mongodump', 'bundle/node']) assert.ok(!names.includes(never), never);
assert.ok(excludedFromBundle('qemu-x86_64') && excludedFromBundle('mongo-tools.exe') && !excludedFromBundle('programs/server/node'));
assert.equal(manifest.meteor, '3.6-test');
// Negative: a directory that is not a bundle, and a Node.js of another version.
assert.throws(() => build({ bundle: dir, target: 'amd64', version: '0.0', out: exe }), /not a WeKan bundle/);
const otherNode = path.join(dir, 'node-other');
fs.writeFileSync(otherNode, 'https://nodejs.org/download/release/v1.2.3/ ...');
assert.throws(() => build({ bundle, node: otherNode, target: 'amd64', version: '0.0', out: exe }), /same Node\.js version/);
build({ bundle, node: process.execPath, target: 'amd64', version: '0.0', out: exe, built: 'test' });
assert.ok(fs.existsSync(`${exe}.sha256sum`));
let r = sh('help');
assert.equal(r.status, 0, r.stderr);
assert.match(r.stdout, /autostart install\|remove\|status/);
const port = await freePort();
r = sh('set', 'PORT', String(port));
assert.match(r.stdout, new RegExp(`PORT=${port}`));
assert.match(fs.readFileSync(path.join(dir, 'wekan-files', 'wekan.env'), 'utf8'), new RegExp(`^PORT=${port}$`, 'm'));
r = sh('version');
assert.equal(r.status, 0, r.stderr);
assert.match(r.stdout, /WeKan version\s+: 0\.0/);
assert.match(r.stdout, /FerretDB version\s+: v0\.0\.0-stand-in/, 'FerretDB was extracted and run');
assert.match(r.stdout, /Meteor version\s+: 3\.6-test/);
assert.equal(fs.readdirSync(path.join(dir, 'wekan-files', 'bin')).length, 1, 'FerretDB is the one extracted file');
r = sh('start', '--background');
assert.equal(r.status, 0, r.stderr);
let answer = null;
for (let i = 0; i < 60 && !answer; i += 1) {
await new Promise(res => setTimeout(res, 500));
try {
answer = await (await fetch(`http://127.0.0.1:${port}/`)).json();
} catch (e) {
answer = null;
}
}
const log = () => { try { return fs.readFileSync(path.join(dir, 'wekan-files', 'logs', 'wekan.log'), 'utf8'); } catch (e) { return ''; } };
assert.ok(answer, `the server answered\n${log()}`);
assert.match(answer.cwd, /bundle[\\/]programs[\\/]server$/, 'process.cwd() is the bundle\'s server directory');
assert.equal(answer.program, 'stand-in', 'a RELATIVE read found program.json inside the archive');
assert.match(answer.argv2, /program\.json$/);
assert.equal(answer.written, 8 * 70000, 'a multi-chunk write stream wrote everything (fs.writev)');
assert.equal(answer.packaging, 'single-file');
assert.equal(fs.statSync(path.join(dir, 'wekan-files', 'attachments', 'probe.bin')).size, 8 * 70000,
'WRITABLE_PATH is wekan-files, and attachments are directly in it');
r = sh('status');
assert.match(r.stdout, /Status:\s+running since/);
assert.match(r.stdout, /answers HTTP 200/);
// Negative: a second WeKan on the same wekan-files is refused.
r = sh('start');
assert.notEqual(r.status, 0);
assert.match(r.stderr, /already running/);
// The menu, driven as a script would: Status, then Quit.
const menu = spawnSync(exe, ['menu'], { input: '3\n0\n', encoding: 'utf8', cwd: dir, timeout: 60000 });
assert.equal(menu.status, 0, menu.stderr);
assert.match(menu.stdout, /1\) Start WeKan[\s\S]*7\) Backup now[\s\S]*0\) Quit/);
assert.match(menu.stdout, /Status:\s+running since/);
// End of input is Quit, not a crash.
const eof = spawnSync(exe, ['menu'], { input: '', encoding: 'utf8', cwd: dir, timeout: 60000 });
assert.equal(eof.status, 0, eof.stderr);
r = sh('backup');
assert.equal(r.status, 0, r.stderr);
assert.match(r.stdout, /Backed up .*attachments.* to .*wekan-files[\\/]backup[\\/]\d{4}-\d\d-\d\d_\d\d-\d\d-\d\d/);
assert.match(r.stdout, /Started WeKan again/);
r = sh('stop');
assert.match(r.stdout, /Stopped\./);
assert.equal(fs.existsSync(path.join(dir, 'wekan-files', 'run', 'wekan.pid')), false);
r = sh('status');
assert.match(r.stdout, /Status:\s+stopped/);
} finally {
try {
spawnSync(exe, ['stop'], { cwd: dir, timeout: 60000 });
} catch (e) {
// never built
}
fs.rmSync(dir, { recursive: true, force: true });
}
});
test('the workflow builds every platform with a bundle, from that bundle, and starts each where it can run', () => {
const targets = JSON.parse(read('releases/single-file/targets.json'));
const wf = read('.github/workflows/single-file.yml');
const names = targets.map(t => t.target);
// Every platform a WeKan Node.js bundle is published for, the BSDs
// (bsd.yml), and Android, whose Node.js wekan/node-patches builds.
for (const must of ['amd64', 'arm64', 'armv7', 'armhf', 'armv6', 'i386', 'ppc64le', 'riscv64', 's390x', 'loong64',
'win64', 'win32', 'win-arm64', 'mac-arm64', 'mac-x64',
'freebsd-x64', 'freebsd-arm64', 'openbsd-x64', 'openbsd-arm64', 'netbsd-x64', 'android-arm64', 'android-x64']) {
assert.ok(names.includes(must), must);
}
for (const t of targets) {
assert.match(t.zip, /^wekan-\{version\}-[a-z0-9-]+\.zip$/, t.target);
assert.ok(['ubuntu-24.04', 'ubuntu-24.04-arm', 'windows-2025', 'windows-11-arm', 'macos-15', 'none'].includes(t.smoke), `${t.target} smoke runner`);
// macOS refuses an arm64 binary whose signature broke when the archive was
// injected; only a Mac can re-sign it.
assert.equal(t.build_on, /^mac/.test(t.target) ? 'macos-15' : 'ubuntu-24.04', `${t.target} is built where it can be signed`);
}
assert.match(wf, /node releases\/single-file\/build\.mjs/);
assert.match(wf, /sha256sum -c/, 'the platform bundle is verified before it is repackaged');
assert.match(wf, /skip=true/, 'a platform whose bundle is not published is skipped, not failed');
assert.match(wf, /WEKAN_SINGLE_FILE_FILES/, 'the browser test runs against the built file');
assert.match(read('.github/workflows/release-all.yml'), /uses: \.\/\.github\/workflows\/single-file\.yml/);
});
test('the docs say what is extracted, where wekan-files is, and what each menu entry does', () => {
const doc = read('docs/Platforms/Single-File.md');
for (const want of ['wekan-files/attachments', 'wekan-files/db', 'wekan-files/bin', 'wekan-files/backup', 'WRITABLE_PATH',
'libatomic', 'Update to the newest version', 'Run automatically at boot', 'codesign']) {
assert.ok(doc.includes(want), want);
}
const { MENU } = require(path.join(SF, 'lib', 'cli.cjs'));
for (const [, label] of MENU) assert.ok(doc.includes(label), `the docs describe "${label}"`);
});
// --- The Windows single files (v12.41-v12.44): what stopped them ---------------
// Meteor's mini-files.js path conversion, as Meteor 3 ships it (bundle/programs/
// server/mini-files.js). Run on Windows path semantics.
function meteorMiniFiles() {
return `function toPosixPath(p) {
let partialPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
// Sometimes, you can have a path like \\Users\\IEUser on windows, and this
// actually means you want C:\\Users\\IEUser
if (p[0] === "\\\\" && !partialPath) {
p = process.env.SystemDrive + p;
}
p = p.replace(/\\\\/g, '/');
if (p[1] === ':' && !partialPath) {
// transform "C:/bla/bla" to "/c/bla/bla"
p = '/' + p[0] + p.slice(2);
}
return p;
}
function toDosPath(p) {
let partialPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
if (p[0] === '/' && !partialPath) {
if (!/^\\/[A-Za-z](\\/|$)/.test(p)) throw new Error("Surprising path: " + p);
// transform a previously windows path back
// "/C/something" to "c:/something"
p = p[1] + ":" + p.slice(2);
}
p = p.replace(/\\//g, '\\\\');
return p;
}
function pathResolve() {
const result = path.resolve.apply(path, Array.prototype.map.call(arguments, p => toDosPath(p)));
return toPosixPath(result);
}`;
}
function windowsMiniFiles(source) {
const sandbox = { process: { env: { SystemDrive: 'C:' } }, path: path.win32, Array };
require('node:vm').runInNewContext(`${source}\nthis.f = { toPosixPath, toDosPath, pathResolve };`, sandbox);
return sandbox.f;
}
test('Windows: Meteor finds a package inside the single file\'s archive (\\\\.\\NUL\\vfs), and drive paths are unchanged', async () => {
const { patchMiniFiles, MINI_FILES } = await import(path.join(SF, 'meteor-device-paths.mjs'));
const mount = '\\\\.\\NUL\\vfs\\1\\bundle\\programs\\server\\npm\\node_modules\\meteor\\meteor\\node_modules';
// Negative: as Meteor ships it, the device path loses its prefix - the
// "Cannot find module 'denque'" of the win64 and win-arm64 single files.
const before = windowsMiniFiles(meteorMiniFiles());
assert.equal(before.toPosixPath(mount), '/C//./NUL/vfs/1/bundle/programs/server/npm/node_modules/meteor/meteor/node_modules');
const patched = patchMiniFiles(meteorMiniFiles());
assert.equal(patchMiniFiles(patched), patched, 'applying it twice changes nothing');
const f = windowsMiniFiles(patched);
const standard = f.toPosixPath(mount);
assert.equal(standard, '//./NUL/vfs/1/bundle/programs/server/npm/node_modules/meteor/meteor/node_modules');
assert.equal(f.toDosPath(f.pathResolve(standard, 'denque')), `${mount}\\denque`, 'the package is looked for where it is');
assert.equal(f.toDosPath(f.toPosixPath('\\\\server\\share\\wekan')), '\\\\server\\share\\wekan', 'a UNC share too');
assert.equal(f.toPosixPath('C:\\wekan\\bundle'), '/C/wekan/bundle', 'a drive path as before');
assert.equal(f.toDosPath('/C/wekan/bundle'), 'C:\\wekan\\bundle');
assert.equal(f.toPosixPath('\\Users\\me'), '/C/Users/me', 'a rooted path still gets the system drive');
// Negative: Meteor's code changed - the build stops rather than ship it unpatched.
assert.throws(() => patchMiniFiles('function toPosixPath(p) { return p; }'), /not the code this patch was written for/);
assert.equal(MINI_FILES, 'bundle/programs/server/mini-files.js');
const build = read('releases/single-file/build.mjs');
assert.match(build, /miniFiles\.data = patchMiniFiles\(fs\.readFileSync\(miniFiles\.file, 'utf8'\)\);/, 'every single file gets it');
});
test('a Node.js without single executable applications is named, not run (negative: one with them passes)', {
skip: process.platform === 'win32' && 'the stand-in Node.js programs are shell scripts',
}, async () => {
const { seaSupported } = await import(path.join(SF, 'build.mjs'));
const dir = tmp('sf-sea-');
try {
const disabled = path.join(dir, 'node-without-sea');
fs.writeFileSync(disabled, '#!/bin/sh\necho "$0: Single executable application is disabled." >&2\nexit 9\n', { mode: 0o755 });
const enabled = path.join(dir, 'node-with-sea');
fs.writeFileSync(enabled, '#!/bin/sh\necho "Cannot read single executable configuration from $2" >&2\nexit 1\n', { mode: 0o755 });
assert.equal(seaSupported(disabled), false);
assert.equal(seaSupported(enabled), true);
} finally {
fs.rmSync(dir, { recursive: true, force: true });
}
});
test('a 32-bit target is built only by a 32-bit Node.js (negative: win32 from x64 is refused)', async () => {
const { build, targetBits, archBits } = await import(path.join(SF, 'build.mjs'));
for (const t of ['win32', 'i386', 'armv7', 'armhf', 'armv6']) assert.equal(targetBits(t), 32, t);
for (const t of ['win64', 'win-arm64', 'amd64', 'arm64', 'mac-arm64', 'freebsd-x64']) assert.equal(targetBits(t), 64, t);
assert.equal(archBits('ia32'), 32);
assert.equal(archBits('x64'), 64);
const dir = tmp('sf-bits-');
try {
const bundle = path.join(dir, 'bundle');
fs.mkdirSync(path.join(bundle, 'programs/server'), { recursive: true });
for (const f of ['main.js', 'programs/server/boot.js', 'programs/server/program.json']) fs.writeFileSync(path.join(bundle, f), '{}');
fs.writeFileSync(path.join(bundle, 'node.exe'), `nodejs.org/download/release/${process.version}/`);
fs.writeFileSync(path.join(bundle, 'ferretdb.exe'), 'x');
if (archBits(process.arch) === 64) {
assert.throws(() => build({ bundle, target: 'win32', version: '1.0', out: path.join(dir, 'out.exe') }),
// The building Node.js is named by its own arch: x64 on a PC, arm64 on a Mac.
new RegExp(`win32 is a 32-bit target, but the Node\\.js building it is ${process.arch}`));
}
} finally {
fs.rmSync(dir, { recursive: true, force: true });
}
const wf = read('.github/workflows/single-file.yml');
assert.match(wf, /contains\(fromJSON\('\["win32","i386","armv7","armhf","armv6"\]'\), matrix\.target\)/);
// The 32-bit host is an i386 Node.js of the TARGET BUNDLE'S exact version,
// verified against its published SHA256 before it builds anything. v13.07
// borrowed the i386 bundle's own Node.js instead: i386 had resolved v26.13.1
// and 32-bit ARM v26.13.0, so armhf, armv6 and armv7 all stopped on the
// version check in build.mjs.
const host = wf.slice(wf.indexOf('id: host32'), wf.indexOf('- name: Build the single file'));
assert.match(host, /NODE_VERSION: \$\{\{ steps\.fetch\.outputs\.node_version \}\}/, 'the host version is the target bundle\'s');
assert.match(host, /resolve-node-source\.sh i386 "\$NODE_VERSION"/, 'resolved at that exact version');
assert.match(host, /sha256sum -c -/, 'the i386 Node.js is checked before it builds anything');
assert.match(host, /"\$host" -p process\.version\)"[\s\S]*?= "\$NODE_VERSION"/, 'and it reports that version');
assert.ok(host.indexOf('sha256sum -c -') < host.indexOf('"$host" -p process.version'), 'checked before it is run');
// Negative: the host is never taken from another platform's bundle, whose
// Node.js may be a different patch release of the same major.
assert.doesNotMatch(host, /wekan-\$\{VERSION\}-i386\.zip|gh release download/);
assert.doesNotMatch(host, /resolve-node-source\.sh i386 "?(2[0-9]|\$NODE_MAJOR)/, 'not the newest of a major');
assert.doesNotMatch(wf, /HOST_LIBS/);
assert.match(wf, /\$\{HOST_NODE:\+--host-node "\$HOST_NODE"\}/);
});