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++
15.6 KB
Raw Blame
import './helpers/isolate-profile.mjs';   // a test run never writes the owner's real Strata profile
import test from 'node:test';
import assert from 'node:assert/strict';
import { EventEmitter } from 'node:events';
import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { createNativeControl } from '../server/native-control.mjs';
import { createControl } from '../server/control-runtime.mjs';

/** The host in the packaged app with a stand-in for Strata Control: the move itself is Control's (tests/terminal/test_models_move.py). */
function fixture(t, { plan = {}, move = null, unfinished = null } = {}) {
  const root = realpathSync(mkdtempSync(join(tmpdir(), 'strata-mfolder-')));
  const install = join(root, 'install'), data = join(root, 'host'), oldFolder = join(root, 'old'), newFolder = join(root, 'new');
  for (const d of [install, data, oldFolder, newFolder]) mkdirSync(d, { recursive: true });
  const earlier = { install: process.env.STRATA_INSTALL_DIR, terminal: process.env.STRATA_TERMINAL_SETTINGS_FILE, settings: process.env.STRATA_SETTINGS_FILE, comp: process.env.STRATA_COMPONENTS_DIR };
  process.env.STRATA_INSTALL_DIR = install;
  process.env.STRATA_TERMINAL_SETTINGS_FILE = join(root, 'terminal-settings.json');
  process.env.STRATA_COMPONENTS_DIR = join(root, 'components');
  delete process.env.STRATA_SETTINGS_FILE;
  const calls = [];
  const control = {
    control: { dir: join(root, 'control'), python: join(root, 'control', 'python.exe'), cli: join(root, 'control', 'strata.py') }, version: '0.2.2',
    async installedModels() { return { install_dir: install, models: [] }; },
    async engine() { return { usable: true, engine: { version: '0.2.2', root: root } }; },
    async importPlan() { return {}; },
    async planModelsMove(from, to) {
      calls.push(['plan', from, to]);
      return { ok: true, issue: null, old: from, new: to, same_drive: false, free_bytes: 900e9, models_bytes: 74e9, needed_bytes: 77.7e9, models: [{ group: 'gyro-s', name: 'gyro-s', bytes: 58e9 }, { group: 'coder', name: 'coder', bytes: 16e9 }],
        choices: { move: { possible: true, reason: '' }, keep: { possible: true, reason: '' }, empty: { possible: true, reason: '' } }, ...plan };
    },
    async moveModels(from, to, options) {
      calls.push(['move', from, to, options.installDir]);
      if (move) return move(from, to, options);
      options.onEvent({ event: 'progress', done: 5e9, total: 74e9, file: 'models/gyro-s/a.gguf', group: 'gyro-s', index: 1, count: 3, seconds_left: 300, same_drive: false });
      return { ok: true, event: 'result', done: true, stopped: false, moved: ['gyro-s', 'coder'], remaining: [], bytes_moved: 74e9, total_bytes: 74e9, files_moved: 3, same_drive: false };
    },
    async interruptedModelsMove(from) { calls.push(['status', from]); return unfinished; },
    async resumeModelsMove(from, options) {
      calls.push(['resume', from, options.installDir]);
      options.onEvent({ event: 'progress', done: 20e9, total: 74e9, file: 'models/coder/c.gguf', group: 'coder', index: 2, count: 3, seconds_left: 120, same_drive: false });
      return { ok: true, event: 'result', done: true, stopped: false, moved: ['coder'], remaining: [], bytes_moved: 74e9, total_bytes: 74e9, files_moved: 2, same_drive: false };
    },
    async leaveModelsMove(from, options) { calls.push(['leave', from, options.installDir]); return { ok: true, removed: 1, restored: 1, bytes_removed: 5 }; },
    async stop() { return { ok: true }; },
  };
  const spawnProcess = () => { throw new Error('the host starts no process here'); };
  const native = createNativeControl({ control, directory: data, spawnProcess, fetcher: async () => Response.json({}), requests: () => [] });
  t.after(() => {
    for (const [key, name] of [['install', 'STRATA_INSTALL_DIR'], ['terminal', 'STRATA_TERMINAL_SETTINGS_FILE'], ['settings', 'STRATA_SETTINGS_FILE'], ['comp', 'STRATA_COMPONENTS_DIR']]) {
      if (earlier[key] === undefined) delete process.env[name]; else process.env[name] = earlier[key];
    }
    rmSync(root, { recursive: true, force: true });
  });
  native.setDownloadDirectory(oldFolder);
  return { native, control, calls, root, install, oldFolder, newFolder, terminalFile: process.env.STRATA_TERMINAL_SETTINGS_FILE };
}
const finish = async (native, id) => { for (let i = 0; i < 400; i++) { const job = native.state().jobs.find(j => j.id === id); if (job.state !== 'running') return job; await new Promise(r => setTimeout(r, 10)); } throw new Error('job did not finish'); };

test('the plan says what the picked folder means and keeps the person\'s spelling of it', async t => {
  const f = fixture(t);
  const plan = await f.native.planModelsFolder(f.newFolder);
  assert.equal(plan.current, f.oldFolder);
  assert.equal(plan.folder, f.newFolder);
  assert.equal(plan.wholeDrive, false);
  assert.equal(plan.shown, f.newFolder);
  assert.equal(plan.models.length, 2);
  assert.deepEqual(f.calls[0], ['plan', f.oldFolder, f.newFolder]);
});

test('a whole drive is planned as <drive>\\Strata, shown as <drive>\\Strata\\Models', async t => {
  const f = fixture(t);
  const root = f.root.slice(0, f.root.indexOf(process.platform === 'win32' ? '\\' : '/') + 1) || '/';
  const plan = await f.native.planModelsFolder(root);
  assert.equal(plan.wholeDrive, true);
  assert.equal(plan.folder, join(root, 'Strata'));
  assert.equal(plan.shown, join(root, 'Strata', 'Models'));
  rmSync(join(root, 'Strata'), { recursive: true, force: true });
});

test('the card is blocked while a model runs or a job runs: a running model must be stopped on purpose', async t => {
  const f = fixture(t);
  await assert.rejects(f.native.startModelsFolder({ folder: f.newFolder, choice: 'bogus' }), /Choose what to do/);
  const refused = fixture(t, { plan: { choices: { move: { possible: false, reason: 'Your models need 77 GB, this drive has 38 GB free.' }, keep: { possible: true, reason: '' }, empty: { possible: true, reason: '' } } } });
  await assert.rejects(refused.native.startModelsFolder({ folder: refused.newFolder, choice: 'move' }), /need 77 GB/);
  assert.equal(refused.calls.some(c => c[0] === 'move'), false);
});

test('Keep: the new folder is used for new downloads, nothing is moved, both settings files follow', async t => {
  const f = fixture(t);
  writeFileSync(f.terminalFile, JSON.stringify({ data_dir: f.oldFolder, data_dir_at: 1 }));   // the Terminal had chosen the old folder
  const result = await f.native.startModelsFolder({ folder: f.newFolder, choice: 'keep' });
  assert.equal(result.done, true);
  assert.equal(f.native.state().downloadDirectory, f.newFolder);
  assert.equal(f.calls.some(c => c[0] === 'move'), false);
  assert.equal(JSON.parse(readFileSync(f.terminalFile, 'utf8')).data_dir, f.newFolder);
});

test('Start empty: the old models are no longer listed (their run configs are set aside, not deleted), the model files stay', async t => {
  const f = fixture(t);
  const oldFile = join(f.oldFolder, 'models', 'gyro-s', 'a.gguf');
  mkdirSync(join(f.oldFolder, 'models', 'gyro-s'), { recursive: true });
  writeFileSync(oldFile, 'x');
  writeFileSync(join(f.install, 'strata-gyro-s.json'), JSON.stringify({ args: ['--native', oldFile] }));
  writeFileSync(join(f.install, 'strata-other.json'), JSON.stringify({ args: ['--native', join(f.root, 'elsewhere', 'b.gguf')] }));
  const result = await f.native.startModelsFolder({ folder: f.newFolder, choice: 'empty' });
  assert.deepEqual(result.setAside, ['strata-gyro-s.json']);
  assert.equal(existsSync(join(f.install, 'strata-gyro-s.json')), false);
  assert.equal(existsSync(join(f.install, 'old-models', 'strata-gyro-s.json')), true);
  assert.equal(existsSync(join(f.install, 'strata-other.json')), true, 'a model elsewhere is not touched');
  assert.equal(existsSync(oldFile), true);
  assert.equal(f.native.state().downloadDirectory, f.newFolder);
});

test('Move: a job with progress; the folder changes only when everything moved', async t => {
  const f = fixture(t);
  const job = await f.native.startModelsFolder({ folder: f.newFolder, choice: 'move' });
  assert.equal(job.kind, 'models-move');
  const done = await finish(f.native, job.id);
  assert.equal(done.state, 'done');
  assert.equal(done.result.done, true);
  assert.equal(done.result.sameDrive, false);
  assert.equal(f.native.state().downloadDirectory, f.newFolder);
  assert.deepEqual(f.calls.find(c => c[0] === 'move').slice(1), [f.oldFolder, f.newFolder, f.install]);
});

test('Move stopped: the folder stays, what moved is reported', async t => {
  const f = fixture(t, { move: async () => ({ ok: true, event: 'result', done: false, stopped: true, moved: ['coder'], remaining: ['gyro-s'], bytes_moved: 16e9, total_bytes: 74e9, files_moved: 1, same_drive: false }) });
  const job = await f.native.startModelsFolder({ folder: f.newFolder, choice: 'move' });
  const done = await finish(f.native, job.id);
  assert.equal(done.result.stopped, true);
  assert.deepEqual(done.result.moved, ['coder']);
  assert.equal(f.native.state().downloadDirectory, f.oldFolder, 'a partial move never points the app at an incomplete folder');
});

test('Move failed (disk full): the folder stays and the job says what happened', async t => {
  const f = fixture(t, { move: async () => { throw Object.assign(new Error('The drive ran out of space.'), { code: 'disk_full', details: 'ENOSPC: no space left on device', output: { moved: ['coder'], remaining: ['gyro-s'], bytes_moved: 52e9, total_bytes: 74e9 } }); } });
  const job = await f.native.startModelsFolder({ folder: f.newFolder, choice: 'move' });
  const done = await finish(f.native, job.id);
  assert.equal(done.state, 'error');
  assert.equal(done.result.code, 'disk_full');
  assert.equal(done.result.bytes, 52e9);
  assert.match(done.details, /ENOSPC/);
  assert.equal(f.native.state().downloadDirectory, f.oldFolder);
});

test('Move: Stop writes the cancel file and the run ends by itself', async t => {
  let release;
  const f = fixture(t, { move: (from, to, options) => new Promise(resolve => { release = () => resolve({ ok: true, event: 'result', done: false, stopped: existsSync(options.cancelFile), moved: [], remaining: ['gyro-s', 'coder'], bytes_moved: 0, total_bytes: 74e9, files_moved: 0, same_drive: false }); }) });
  const job = await f.native.startModelsFolder({ folder: f.newFolder, choice: 'move' });
  await f.native.cancel(job.id);
  assert.equal(f.native.state().jobs.find(j => j.id === job.id).state, 'running', 'it ends when Control has cleaned up, not before');
  release();
  const done = await finish(f.native, job.id);
  assert.equal(done.result.stopped, true);
  assert.equal(f.native.state().downloadDirectory, f.oldFolder);
});

test('a move needs the app: the Control command line is built from the plan and the cancel file', async () => {
  const seen = [];
  const control = createControl({ control: { dir: '/c', python: '/c/py', cli: '/c/strata.py' }, run: async (args, options) => { seen.push([args, options]); return args.includes('--plan') ? { code: 0, json: { ok: true, plan: { ok: true } }, text: '', stderr: '' } : { code: 0, json: { ok: true, event: 'result', done: true }, text: '', stderr: '' }; } });
  assert.deepEqual(await control.planModelsMove('/old', '/new'), { ok: true });
  assert.deepEqual(seen[0][0], ['models', 'move', '/new', '--from', '/old', '--plan', '--output', 'json']);
  const result = await control.moveModels('/old', '/new', { installDir: '/i', cancelFile: '/c.cancel' });
  assert.equal(result.done, true);
  assert.deepEqual(seen[1][0], ['models', 'move', '/new', '--from', '/old', '--install-dir', '/i', '--cancel-file', '/c.cancel', '--output', 'jsonl']);
  const failing = createControl({ control: { dir: '/c', python: '/c/py', cli: '/c/strata.py' }, run: async () => ({ code: 5, json: { ok: false, error: { code: 'disk_full', message: 'The drive ran out of space.', details: 'ENOSPC' }, moved: [] }, text: '', stderr: '' }) });
  await assert.rejects(failing.moveModels('/o', '/n'), e => e.code === 'disk_full' && e.details === 'ENOSPC' && /ran out of space/.test(e.message));
});

test('an unfinished move is found at the next start, and Finish resumes it as a job that changes the folder only when done', async t => {
  const f = fixture(t);
  f.control.interruptedModelsMove = async from => { f.calls.push(['status', from]); return { state: 'failed', from: f.oldFolder, to: f.newFolder, bytes: 74e9 }; };
  assert.equal((await f.native.interruptedMove()).to, f.newFolder);
  assert.deepEqual(f.calls[0], ['status', f.oldFolder]);
  const job = await f.native.finishInterruptedMove({ stopRunning: true });
  const done = await finish(f.native, job.id);
  assert.equal(done.state, 'done');
  assert.equal(f.calls.find(c => c[0] === 'resume')[1], f.oldFolder);
  assert.equal(f.native.state().downloadDirectory, f.newFolder);
});

test('Leave it keeps the old folder and asks Control to remove the partial copies; nothing interrupted means nothing to do', async t => {
  const f = fixture(t);
  assert.equal(await f.native.interruptedMove(), null);
  await assert.rejects(f.native.leaveInterruptedMove(), /No move was interrupted/);
  f.control.interruptedModelsMove = async () => ({ state: 'running', from: f.oldFolder, to: f.newFolder, bytes: 1 });
  const result = await f.native.leaveInterruptedMove();
  assert.equal(result.folder, f.oldFolder);
  assert.deepEqual(f.calls.find(c => c[0] === 'leave').slice(0, 2), ['leave', f.oldFolder]);
  assert.equal(f.native.state().downloadDirectory, f.oldFolder);
});

test('the Control command lines for status, resume and leave', async () => {
  const seen = [];
  const control = createControl({ control: { dir: '/c', python: '/c/py', cli: '/c/strata.py' }, run: async args => { seen.push(args); return args.includes('--status') ? { code: 0, json: { ok: true, interrupted: { from: '/o', to: '/n' } }, text: '', stderr: '' } : args.includes('--leave') ? { code: 0, json: { ok: true, removed: 0 }, text: '', stderr: '' } : { code: 0, json: { ok: true, event: 'result', done: true }, text: '', stderr: '' }; } });
  assert.equal((await control.interruptedModelsMove('/o')).to, '/n');
  await control.resumeModelsMove('/o', { installDir: '/i', cancelFile: '/c.cancel' });
  await control.leaveModelsMove('/o', { installDir: '/i' });
  assert.deepEqual(seen[0], ['models', 'move', '--status', '--from', '/o', '--output', 'json']);
  assert.deepEqual(seen[1], ['models', 'move', '--resume', '--from', '/o', '--install-dir', '/i', '--cancel-file', '/c.cancel', '--output', 'jsonl']);
  assert.deepEqual(seen[2], ['models', 'move', '--leave', '--from', '/o', '--install-dir', '/i', '--output', 'json']);
});

test('the models folder strings exist in all 9 languages with the same placeholders', () => {
  const read = lang => JSON.parse(readFileSync(new URL(`../src/locales/${lang}.json`, import.meta.url), 'utf8'));
  const en = read('en');
  const ours = Object.keys(en).filter(k => Number(k.slice(1)) >= 8339 && Number(k.slice(1)) <= 8422);
  assert.equal(ours.length, 84);
  for (const lang of ['de', 'es', 'fr', 'ja', 'ko', 'pt', 'ru', 'zh']) {
    const text = read(lang);
    for (const key of ours) {
      assert.ok(text[key], `${lang} ${key}`);
      assert.deepEqual((text[key].match(/\{\d\}/g) ?? []).sort(), (en[key].match(/\{\d\}/g) ?? []).sort(), `${lang} ${key} placeholders`);
    }
  }
  // every string the dialog shows through tr() is in the catalogue
  const source = readFileSync(new URL('../src/components/ModelsFolderDialog.tsx', import.meta.url), 'utf8');
  const values = new Set(Object.values(en));
  for (const text of ['Models folder', 'Change folder', 'Move my models', 'Use both folders', 'Start empty', 'Stop moving', 'Your models are moved', 'Moving stopped']) {
    assert.ok(source.includes(text) && values.has(text), text);
  }
});