Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++
21.0 KB
Raw Blame
/** The engine inside the installer: installed when missing or older, never over a newer or equal one, never without a matching manifest. */
import test from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, rmSync } from 'node:fs';
import { createHash } from 'node:crypto';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { installBundledEngine, removeVerifiedBundle, cleanupAfterInstall, compareVersions, wrongMakeNotice } from '../server/bundled-engine.mjs';

// the make of card is read from this computer unless a test names it; the existing tests are written for an NVIDIA PC
process.env.STRATA_ENGINE_BACKEND = 'cuda';
const sha = buffer => createHash('sha256').update(buffer).digest('hex');
function makePackage(root, version, { body = 'engine-' + version, backend = 'cuda', platform = 'windows-x86_64', variant = 'cuda13', minDriver = null } = {}) {
  const name = `${version}-${platform}-${backend}-${variant}`;
  const dir = join(root, name);
  mkdirSync(dir, { recursive: true });
  const files = { 'strata.exe': Buffer.from(body), 'strata_kq.dll': Buffer.from('kq-' + body), 'BUILD.json': Buffer.from('{}') };
  for (const [file, data] of Object.entries(files)) writeFileSync(join(dir, file), data);
  writeFileSync(join(dir, 'engine-component.json'), JSON.stringify({
    schema_version: 2, id: 'strata-engine', name: 'strata-engine', version, platform, backend, archs: ['sm_86'], ...(minDriver ? { min_driver: { nvidia: minDriver } } : {}), build_id: 'x', entrypoint: 'strata.exe',
    files: Object.entries(files).map(([path, data]) => ({ path, sha256: sha(data), bytes: data.length })), signature: null }));
  return name;
}
const setup = () => {
  const base = mkdtempSync(join(tmpdir(), 'st-bundled-engine-'));
  const bundle = join(base, 'engine-bundle'), components = join(base, 'components');
  mkdirSync(bundle); mkdirSync(components);
  return { base, bundle, components, engine: join(components, 'engine'), cleanup: () => rmSync(base, { recursive: true, force: true }) };
};

test('versions compare by number, not text', () => {
  assert.equal(compareVersions('0.1.45', '0.1.9'), 1);
  assert.equal(compareVersions('0.1.45', '0.1.45.1'), -1);
  assert.equal(compareVersions('0.1.45', '0.1.45'), 0);
});

test('no engine installed: the bundled one is installed, hash-checked, with nothing left over', async () => {
  const t = setup();
  try {
    const name = makePackage(t.bundle, '0.1.45');
    const result = await installBundledEngine({ bundleDir: t.bundle, components: t.components });
    assert.equal(result.action, 'installed');
    assert.equal(readFileSync(join(t.engine, name, 'strata.exe'), 'utf8'), 'engine-0.1.45');
    assert.ok(existsSync(join(t.engine, name, 'engine-component.json')));
    assert.deepEqual(readdirSync(t.engine), [name], 'no temporary folder remains');
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components })).action, 'kept', 'a second start does nothing');
  } finally { t.cleanup(); }
});

test('an older engine is installed: the bundled one is added beside it', async () => {
  const t = setup();
  try {
    const old = makePackage(t.engine, '0.1.44');
    const name = makePackage(t.bundle, '0.1.45');
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components })).action, 'installed');
    assert.deepEqual(readdirSync(t.engine).sort(), [old, name].sort());
  } finally { t.cleanup(); }
});

test('a newer or equal engine is never overwritten or touched', async () => {
  const t = setup();
  try {
    const newer = makePackage(t.engine, '0.1.46', { body: 'mine' });
    makePackage(t.bundle, '0.1.45');
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components })).action, 'kept');
    assert.deepEqual(readdirSync(t.engine), [newer]);
    assert.equal(readFileSync(join(t.engine, newer, 'strata.exe'), 'utf8'), 'mine');
    // same version, other build: the installed one stays
    const same = makePackage(t.engine, '0.1.45', { body: 'installed-build' });
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components })).action, 'kept');
    assert.equal(readFileSync(join(t.engine, same, 'strata.exe'), 'utf8'), 'installed-build');
  } finally { t.cleanup(); }
});

test('a damaged copy of the same package is put right; an engine for another backend does not count', async () => {
  const t = setup();
  try {
    const name = makePackage(t.bundle, '0.1.45');
    makePackage(t.engine, '0.1.45');
    writeFileSync(join(t.engine, name, 'strata.exe'), 'cut');          // wrong size
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components })).action, 'repaired');
    assert.equal(readFileSync(join(t.engine, name, 'strata.exe'), 'utf8'), 'engine-0.1.45');
    const t2 = setup();
    try {
      makePackage(t2.engine, '0.1.50', { backend: 'cpu' });
      makePackage(t2.bundle, '0.1.45');
      assert.equal((await installBundledEngine({ bundleDir: t2.bundle, components: t2.components })).action, 'installed');
    } finally { t2.cleanup(); }
  } finally { t.cleanup(); }
});

test('a bundle that does not match its manifest is refused and installs nothing', async () => {
  const t = setup();
  try {
    const name = makePackage(t.bundle, '0.1.45');
    writeFileSync(join(t.bundle, name, 'strata_kq.dll'), 'kq-engine-0.1.4X');   // same size, other bytes
    const result = await installBundledEngine({ bundleDir: t.bundle, components: t.components });
    assert.equal(result.action, 'refused');
    assert.equal(existsSync(join(t.engine, name)), false);
    assert.equal((await installBundledEngine({ bundleDir: join(t.base, 'nope'), components: t.components })).action, 'none');
  } finally { t.cleanup(); }
});

test('CUDA 13 and CUDA 12 builds of one version are different engines: both are installed when the driver runs both', async () => {
  const t = setup();
  try {
    const n13 = makePackage(t.bundle, '0.1.45', { platform: 'linux-x86_64', variant: 'cuda13', minDriver: '580.65', body: 'thirteen' });
    const n12 = makePackage(t.bundle, '0.1.45', { platform: 'linux-x86_64', variant: 'cuda12', minDriver: '575.51', body: 'twelve' });
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components, driver: '580.178.04' })).action, 'installed');
    assert.deepEqual(readdirSync(t.engine).sort(), [n12, n13].sort());
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components, driver: '580.178.04' })).action, 'kept', 'a second start does nothing');
  } finally { t.cleanup(); }
});

test('an older driver gets only the build it can run; a driver below both gets the lowest build so the app can name the driver', async () => {
  const t = setup(), u = setup(), v = setup();
  try {
    const n13 = makePackage(t.bundle, '0.1.45', { platform: 'linux-x86_64', variant: 'cuda13', minDriver: '580.65' });
    const n12 = makePackage(t.bundle, '0.1.45', { platform: 'linux-x86_64', variant: 'cuda12', minDriver: '575.51' });
    await installBundledEngine({ bundleDir: t.bundle, components: t.components, driver: '575.57.08' });
    assert.deepEqual(readdirSync(t.engine), [n12], 'driver 575 runs CUDA 12 only');
    for (const x of [u]) { makePackage(x.bundle, '0.1.45', { platform: 'linux-x86_64', variant: 'cuda13', minDriver: '580.65' }); makePackage(x.bundle, '0.1.45', { platform: 'linux-x86_64', variant: 'cuda12', minDriver: '575.51' }); }
    await installBundledEngine({ bundleDir: u.bundle, components: u.components, driver: '550.120' });
    assert.deepEqual(readdirSync(u.engine), [n12], 'driver 550 runs neither: the CUDA 12 build is installed so Control can say 575 is needed');
    // no driver at all (a PC without NVIDIA, or nvidia-smi cannot be read): nothing is held back
    makePackage(v.bundle, '0.1.45', { platform: 'linux-x86_64', variant: 'cuda13', minDriver: '580.65' }); makePackage(v.bundle, '0.1.45', { platform: 'linux-x86_64', variant: 'cuda12', minDriver: '575.51' });
    await installBundledEngine({ bundleDir: v.bundle, components: v.components, driver: null });
    assert.deepEqual(readdirSync(v.engine).sort(), [n12, n13].sort());
  } finally { t.cleanup(); u.cleanup(); v.cleanup(); }
});

// The app update (latest.json) is built without engine-bundle (tauri.update.conf.json), so one update fits every installer variant.
test('an engine-less app update (no engine-bundle folder, or one holding only .gitignore) leaves the installed engines exactly as they are', async () => {
  const t = setup();
  try {
    const amd = makePackage(t.engine, '0.1.45.3', { platform: 'windows-x86_64', backend: 'hip', variant: 'rx9070' });
    const before = readFileSync(join(t.engine, amd, 'engine-component.json'), 'utf8');
    assert.equal((await installBundledEngine({ bundleDir: join(t.base, 'no-such-engine-bundle'), components: t.components })).action, 'none');
    writeFileSync(join(t.bundle, '.gitignore'), '*\n!.gitignore\n');
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components, platform: 'windows-x86_64' })).action, 'none');
    assert.deepEqual(readdirSync(t.engine), [amd]);
    assert.equal(readFileSync(join(t.engine, amd, 'engine-component.json'), 'utf8'), before);
  } finally { t.cleanup(); }
});

test('why the update carries no engine: a CUDA installer on an AMD PC would copy its CUDA engine beside the AMD one (no NVIDIA driver to filter by)', async () => {
  const t = setup();
  try {
    const amd = makePackage(t.engine, '0.1.45.3', { platform: 'windows-x86_64', backend: 'hip', variant: 'rx9070' });
    const cuda = makePackage(t.bundle, '0.1.45.3', { platform: 'windows-x86_64', variant: 'cuda13', minDriver: '580.65' });
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components, driver: null })).action, 'installed');
    assert.deepEqual(readdirSync(t.engine).sort(), [amd, cuda].sort(), 'the AMD engine stays; a useless CUDA engine is added');
  } finally { t.cleanup(); }
});

test('an AMD build on an NVIDIA PC is not unpacked and the sentence names the right download', async () => {
  const t = setup();
  try {
    const name = makePackage(t.bundle, '0.2.0', { platform: 'linux-x86_64', backend: 'hip', variant: 'rx9070' });
    const manifest = JSON.parse(readFileSync(join(t.bundle, name, 'engine-component.json'), 'utf8'));
    manifest.archs = ['gfx1201'];
    writeFileSync(join(t.bundle, name, 'engine-component.json'), JSON.stringify(manifest));
    const result = await installBundledEngine({ bundleDir: t.bundle, components: t.components, backend: 'cuda' });
    assert.equal(result.action, 'wrong-make');
    assert.equal(result.notice, 'This Strata is for AMD RX 9000 cards. Your PC has an NVIDIA card: download the NVIDIA version from https://github.com/Niko1221/Strata/releases');
    assert.equal(existsSync(t.engine), false, 'nothing was copied');
    // the same build on an AMD PC is unpacked; an unknown card is not a reason to refuse
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components, backend: 'hip' })).action, 'installed');
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components, backend: null })).action, 'kept');
  } finally { t.cleanup(); }
});

test('wrongMakeNotice names the make, not a list of reasons', () => {
  assert.equal(wrongMakeNotice({ backend: 'cuda', archs: ['sm_86'] }, 'hip'), 'This Strata is for NVIDIA cards. Your PC has an AMD card: download the AMD version from https://github.com/Niko1221/Strata/releases');
});

test('Windows: the display adapters decide the make, and a leftover nvidia-smi does not outvote them (#3688)', async () => {
  const { gpuBackendHere, windowsDisplayVendors } = await import('../server/bundled-engine.mjs');
  assert.equal(gpuBackendHere({}, { vendors: new Set(['1002']) }), 'hip');
  assert.equal(gpuBackendHere({}, { vendors: new Set(['10de', '1002']) }), 'cuda');
  assert.equal(gpuBackendHere({}, { vendors: new Set(['8086']) }), 'sycl');
  assert.equal(gpuBackendHere({ STRATA_ENGINE_BACKEND: 'cuda' }, { vendors: new Set(['1002']) }), 'cuda', 'an explicit choice wins');
  const out = 'MatchingDeviceId    REG_SZ    PCI/VEN_1002&DEV_7551&SUBSYS_0' + String.fromCharCode(10) + 'MatchingDeviceId    REG_SZ    PCI/VEN_8086&DEV_46A6';
  assert.deepEqual([...windowsDisplayVendors({ platform: 'win32', run: () => out })].sort(), ['1002', '8086']);
  assert.equal(windowsDisplayVendors({ platform: 'linux', run: () => { throw new Error('must not run'); } }).size, 0);
  assert.equal(windowsDisplayVendors({ platform: 'win32', run: () => { throw new Error('no registry'); } }).size, 0);
});

test('after an update, the engine bundle of the old install folder is removed only when the same engine is complete in the store', async () => {
  const t = setup();
  try {
    const name = makePackage(t.bundle, '0.1.48');
    writeFileSync(join(t.bundle, '.gitignore'), 'ignore-all');
    const lines = [];
    // 1. nothing in the store yet: kept, and one line says why
    let r = await removeVerifiedBundle({ bundleDir: t.bundle, components: t.components, log: l => lines.push(l) });
    assert.equal(r.removed, false);
    assert.equal(lines.length, 1);
    assert.match(lines[0], /kept in the install folder.*not \(or not completely\) in the engine store/);
    assert.ok(existsSync(join(t.bundle, name)));
    // 2. the engine is copied (the app's own first start does this)
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components })).action, 'installed');
    // 3. a store file with the right size and the wrong content: kept (the hash is checked, not only the size)
    const target = join(t.engine, name, 'strata.exe');
    const good = readFileSync(target);
    writeFileSync(target, Buffer.alloc(good.length, 'x'));
    lines.length = 0;
    r = await removeVerifiedBundle({ bundleDir: t.bundle, components: t.components, log: l => lines.push(l) });
    assert.equal(r.removed, false);
    assert.equal(lines.length, 1, 'exactly one line');
    assert.ok(existsSync(join(t.bundle, name)));
    // 4. a store file with the wrong size: kept
    writeFileSync(target, Buffer.concat([good, Buffer.from('extra')]));
    assert.equal((await removeVerifiedBundle({ bundleDir: t.bundle, components: t.components })).removed, false);
    // 5. the store copy is whole: the bundle goes, its .gitignore stays, and the store is untouched
    writeFileSync(target, good);
    lines.length = 0;
    r = await removeVerifiedBundle({ bundleDir: t.bundle, components: t.components, log: l => lines.push(l) });
    assert.equal(r.removed, true);
    assert.equal(existsSync(join(t.bundle, name)), false);
    assert.ok(existsSync(join(t.bundle, '.gitignore')));
    assert.equal(readFileSync(target, 'utf8'), 'engine-0.1.48');
    assert.match(lines.at(-1), /was removed; the same engine is complete in the engine store/);
    // 6. nothing left to do
    assert.equal((await removeVerifiedBundle({ bundleDir: t.bundle, components: t.components })).removed, false);
    // 7. a different version in the store does not count
    const other = makePackage(t.bundle, '0.1.49');
    assert.equal((await removeVerifiedBundle({ bundleDir: t.bundle, components: t.components })).removed, false);
    assert.ok(existsSync(join(t.bundle, other)));
  } finally { t.cleanup(); }
});

test('the bundle cleanup lines reach the output of the host (the desktop log copies it), for "removed" and for "kept"', async () => {
  const t = setup();
  const seen = [], real = console.log;
  try {
    const name = makePackage(t.bundle, '0.1.48');
    console.log = line => { seen.push(String(line)); };
    // kept: the engine is not in the store yet
    await cleanupAfterInstall(Promise.resolve({ action: 'kept' }), { bundleDir: t.bundle, components: t.components });
    assert.equal(seen.length, 1);
    assert.match(seen[0], /^engine bundle: kept in the install folder/);
    // removed: the engine is in the store and whole
    const installed = await installBundledEngine({ bundleDir: t.bundle, components: t.components });
    assert.equal(installed.action, 'installed');
    seen.length = 0;
    await cleanupAfterInstall(Promise.resolve({ action: 'kept' }), { bundleDir: t.bundle, components: t.components });
    assert.equal(seen.length, 1);
    assert.match(seen[0], /^engine bundle: the copy that came with the installer \(.*\) was removed/);
    assert.equal(existsSync(join(t.bundle, name)), false);
    // nothing to say when the engine step did nothing (no bundle) or was refused
    seen.length = 0;
    await cleanupAfterInstall(Promise.resolve({ action: 'none' }), { bundleDir: t.bundle, components: t.components });
    await cleanupAfterInstall(Promise.resolve({ action: 'wrong-make' }), { bundleDir: t.bundle, components: t.components });
    await cleanupAfterInstall(Promise.reject(new Error('boom')), { bundleDir: t.bundle, components: t.components });
    assert.deepEqual(seen, []);
  } finally { console.log = real; t.cleanup(); }
});

test('macOS: the engine bundle inside a signed .app stays (deleting it breaks the signature); outside an .app, or on another system, it is removed as before', async () => {
  const t = setup();
  const platform = Object.getOwnPropertyDescriptor(process, 'platform');
  const as = value => Object.defineProperty(process, 'platform', { value, configurable: true });
  try {
    const app = join(t.base, 'Strata.app', 'Contents', 'Resources', 'engine-bundle');
    mkdirSync(app, { recursive: true });
    const inApp = makePackage(app, '0.1.48');
    const outside = makePackage(t.bundle, '0.1.48');
    // the engine is in the store (the app's own first start copies it), so the bundle would be removable
    assert.equal((await installBundledEngine({ bundleDir: t.bundle, components: t.components })).action, 'installed');
    const lines = [];
    // 1. macOS, bundle inside Strata.app: kept, with one line that says why
    as('darwin');
    let r = await removeVerifiedBundle({ bundleDir: app, components: t.components, log: l => lines.push(l) });
    assert.equal(r.removed, false);
    assert.ok(existsSync(join(app, inApp, 'strata.exe')), 'the signed app keeps its engine files');
    assert.equal(lines.length, 1);
    assert.match(lines[0], /kept in the install folder.*macOS app bundles must remain unchanged after signing/);
    // 2. macOS, bundle outside an .app: removed as before
    r = await removeVerifiedBundle({ bundleDir: t.bundle, components: t.components, log: () => {} });
    assert.equal(r.removed, true);
    assert.equal(existsSync(join(t.bundle, outside)), false);
    // 3. another system, bundle inside a folder called .app: removed as before (the guard is for macOS only)
    as('linux');
    r = await removeVerifiedBundle({ bundleDir: app, components: t.components, log: () => {} });
    assert.equal(r.removed, true);
    assert.equal(existsSync(join(app, inApp)), false);
  } finally {
    Object.defineProperty(process, 'platform', platform);
    t.cleanup();
  }
});

test('a card taken out of the PC does not decide the make; two present makes accept a build for either (#3892)', async () => {
  const { gpuBackendsHere, windowsDisplayVendors } = await import('../server/bundled-engine.mjs');
  const nl = String.fromCharCode(10);
  const registry = 'MatchingDeviceId    REG_SZ    PCI/VEN_10DE&DEV_2882' + nl + 'MatchingDeviceId    REG_SZ    PCI/VEN_1002&DEV_7550';
  // the NVIDIA card was swapped for a Radeon: Windows still lists its driver entry, but only the AMD card is present
  assert.deepEqual([...windowsDisplayVendors({ platform: 'win32', run: () => registry, present: () => new Set(['1002']) })], ['1002']);
  assert.equal(gpuBackendsHere({}, { vendors: new Set(['1002']) })[0], 'hip');
  // both cards present: both makes count, NVIDIA first
  assert.deepEqual([...windowsDisplayVendors({ platform: 'win32', run: () => registry, present: () => new Set(['1002', '10de']) })].sort(), ['1002', '10de']);
  assert.deepEqual(gpuBackendsHere({}, { vendors: new Set(['10de', '1002']) }), ['cuda', 'hip']);
  // present cannot be read: the registry answer stands
  assert.equal(windowsDisplayVendors({ platform: 'win32', run: () => registry, present: () => new Set() }).size, 2);
  // the second source is only asked when two makes are listed
  assert.equal(windowsDisplayVendors({ platform: 'win32', run: () => 'MatchingDeviceId    REG_SZ    PCI/VEN_1002&DEV_7550', present: () => { throw new Error('must not run'); } }).size, 1);
  assert.deepEqual(gpuBackendsHere({ STRATA_ENGINE_BACKEND: 'hip' }, { vendors: new Set(['10de', '1002']) }), ['hip']);

  const t = setup();
  try {
    const name = makePackage(t.bundle, '0.2.0', { platform: 'windows-x86_64', backend: 'hip', variant: 'rx9070' });
    const manifest = JSON.parse(readFileSync(join(t.bundle, name, 'engine-component.json'), 'utf8'));
    manifest.archs = ['gfx1201'];
    writeFileSync(join(t.bundle, name, 'engine-component.json'), JSON.stringify(manifest));
    // an AMD build on a PC with an NVIDIA desktop card and an AMD model card is unpacked, not refused
    const result = await installBundledEngine({ bundleDir: t.bundle, components: t.components, backend: ['cuda', 'hip'] });
    assert.equal(result.action, 'installed');
  } finally { t.cleanup(); }
});