Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/features/noko/noko-service.test.mjs

Raw
import assert from 'node:assert/strict';
import { once } from 'node:events';
import { createHash } from 'node:crypto';
import { createServer } from 'node:http';
import { copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { offscreenDiagnostic } from '../../test-fixtures/offscreen.mjs';
import isolation from '../../test-fixtures/isolation.js';
const { runIsolated, spawnIsolated } = isolation;

// The production Noko service, offscreen, against a scripted engine speaking the
// real JSON-RPC protocol (fixtures/scripted-engine.mjs), noko-engine.nu, a local
// release server and a stand-in typing tool. Live partials, finals typed once,
// named failures, a dying engine, the capture limit, a wake word hit ending
// after silence, hotwords on every start, and an update that switches only
// while idle and only once its models are installed. Load evidence, not pixels
// or real audio.
const engineScript = fileURLToPath(new URL('fixtures/scripted-engine.mjs', import.meta.url));
const path = process.env.PATH.split(':').filter(entry => !entry.includes('/mise/shims')).join(':');
const revision = letter => letter.repeat(40);
const [a, b] = [revision('a'), revision('b')];

// One engine bundle as the release ships it, its executable the scripted engine.
function bundle(at, rev, { missing = false } = {}) {
    const root = join(at, 'speak_to_me');
    mkdirSync(join(root, 'bin'), { recursive: true });
    mkdirSync(join(root, 'assets'), { recursive: true });
    writeFileSync(join(root, 'assets', 'pipeline.json'), '{}');
    writeFileSync(join(root, 'manifest.json'), JSON.stringify({ schema: 1, name: 'speak_to_me', revision: rev }));
    writeFileSync(join(root, 'bin', 'speak_to_me'), `#!/bin/sh\nNOKO_ENGINE_BUNDLE='${root}' NOKO_ENGINE_REVISION='${rev}' exec '${process.execPath}' '${engineScript}' "$@"\n`, { mode: 0o755 });
    if (missing) writeFileSync(join(root, 'missing'), '');
}

const directory = mkdtempSync(join(tmpdir(), 'nuguland-noko-service-'));
const files = new Map();
let manifestRequests = 0;
const server = createServer((request, response) => {
    if (request.url.endsWith('/latest/manifest.json')) manifestRequests++;
    // The startup check finds the installed engine current; later checks find B.
    const body = request.url.endsWith('/latest/manifest.json') ? files.get(manifestRequests === 1 ? 'manifest-a' : 'manifest-b') : files.get(request.url);
    response.writeHead(body === undefined ? 404 : 200);
    response.end(body ?? '');
});
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
const release = `http://127.0.0.1:${server.address().port}/releases/speak_to_me`;
try {
    for (const file of ['Noko.qml', 'noko-engine.nu'])
        copyFileSync(new URL(file, import.meta.url), join(directory, file));
    const engine = join(directory, 'data', 'nuguland', 'noko', 'engine');
    bundle(join(engine, a), a);
    symlinkSync(a, join(engine, 'current'));
    const stage = join(directory, 'stage');
    bundle(join(stage, 'b'), b, { missing: true });
    const archive = join(directory, 'b.tar.zst');
    const tar = runIsolated('tar', ['--zstd', '--create', '--file', archive, '--directory', join(stage, 'b'), 'speak_to_me'], { encoding: 'utf8' });
    assert.equal(tar.status, 0, tar.stderr);
    const bytes = readFileSync(archive);
    const manifest = (rev, size, sha256) => JSON.stringify({ schema: 1, name: 'speak_to_me', revision: rev, built_at: '2026-11-20T10:00:00Z', target: 'x86_64-unknown-linux-gnu',
        bundle: { file: 'speak_to_me-x86_64-linux.tar.zst', url: `${release}/${rev}/speak_to_me-x86_64-linux.tar.zst`, size, sha256 } });
    files.set('manifest-a', manifest(a, 1, '0'.repeat(64)));
    files.set('manifest-b', manifest(b, bytes.length, createHash('sha256').update(bytes).digest('hex')));
    files.set(`/releases/speak_to_me/${b}/speak_to_me-x86_64-linux.tar.zst`, bytes);

    const calls = join(directory, 'calls');
    const typed = join(directory, 'typed');
    const scenario = join(directory, 'scenario.json');
    writeFileSync(calls, '');
    const bin = join(directory, 'bin');
    mkdirSync(bin);
    writeFileSync(join(bin, 'wtype'), `#!${process.execPath}
let text = '';
process.stdin.on('data', chunk => { text += chunk; });
process.stdin.on('end', () => require('node:fs').appendFileSync(${JSON.stringify(typed)}, JSON.stringify({ args: process.argv.slice(2), text }) + '\\n'));
`, { mode: 0o700 });

    const shell = body => writeFileSync(join(directory, 'shell.qml'), `import QtQuick
import Quickshell
import Quickshell.Io
ShellRoot {
    id: test
    property int phase: 0
    property double mark: 0
    property bool seenStarting: false
    property bool seenPending: false
    Noko { id: service }
    FileView { id: scenarioFile; path: Quickshell.env("NOKO_SCENARIO"); blockWrites: true; atomicWrites: true; printErrors: false }
    function hear(value) { scenarioFile.setText(JSON.stringify(value)); }
    function require(ok, message) { if (!ok) { console.error("ERROR phase", test.phase, message, service.stateJson()); Qt.quit(); } }
    function step() {
        const s = service;
        ${body}
    }
    Timer { interval: 20; running: true; repeat: true; onTriggered: test.step() }
    Timer { interval: 30000; running: true; onTriggered: { console.error("ERROR deadline in phase", test.phase, service.stateJson()); Qt.quit(); } }
}
`);
    shell(`
        if (phase === 0 && s.statusKnown && s.settingsLoaded && s.lastUpdateCheck > 0) {
            require(s.ready && s.status === "ready" && s.engineRevision === "${a}" && s.typingReady, "the installed engine readies the service");
            require(!s.wakeEnabled && !s.wakeListening && s.wakePhrase === "hello computer", "the wake word is off by default");
            s.loadHistoryText(Array.from({ length: 30 }, (_, i) => JSON.stringify({ transcript: "old " + i, duration: 1 })).join("\\n") + "\\nnot json\\n");
            require(s.historyEntries.length === 20 && s.historyEntries[0].transcript === "old 29", "history loads its newest twenty");
            s.editHotwords("Nuguland\\n niri  \\n\\nniri");
            require(s.hotwordsError === "" && JSON.stringify(s.hotwords) === '["Nuguland","niri"]', "one hotword per line, trimmed, once each");
            s.editHotwords("Nuguland\\nhome/office");
            require(s.hotwordsError === "line 2: drop / @ : #" && s.hotwords.length === 2, "an invalid hotword is named and never sent");
            s.editHotwords("Nuguland\\nniri");
            hear({ recognition: "speak" });
            s.trigger();
            require(s.starting && s.overlayState === "starting" && s.status === "listening" && s.busy, "capture starts at once and says it is starting");
            s.install();
            require(!s.installing, "capture rejects setup");
            phase = 1;
        } else if (phase === 1) {
            if (s.starting) seenStarting = true;
            if (s.listening && s.liveText === "Hello world. and the") {
                require(seenStarting && s.overlayState === "capturing", "the overlay turns from starting to capturing once the engine hears");
                require(s.stateJson().indexOf("Hello") < 0 && s.stateJson().indexOf("and the") < 0, "state never carries the partial");
                s.stopCapture();
                require(s.transcribing && s.overlayState === "transcribing", "stop turns to transcribing");
                s.startCapture();
                require(s.transcribing, "transcription rejects a new capture");
                phase = 2;
            }
        } else if (phase === 2 && !s.dictating) {
            require(s.finished && !s.failed && s.captureError === "" && s.status === "ready", "the final finishes the dictation");
            require(s.liveText === "Hello world. And the rest.", "the final replaces the partial");
            require(s.historyEntries.length === 20 && s.historyEntries[0].transcript === "Hello world. And the rest." && s.historyEntries[19].transcript === "old 11", "history takes the transcript and stays bounded");
            const state = JSON.parse(s.stateJson());
            require(s.stateJson().indexOf("Hello") < 0 && s.stateJson().indexOf("Nuguland") < 0 && state.historyCount === 20 && state.hotwordCount === 2, "state never carries what was said or listened for");
            hear({ recognition: "silent" });
            s.trigger();
            require(s.starting && !s.finished, "the next capture starts at once");
            phase = 3;
        } else if (phase === 3 && s.listening) {
            s.trigger();
            phase = 4;
        } else if (phase === 4 && !s.dictating) {
            require(!s.finished && s.failed && s.overlayState === "failed" && s.captureError === "no speech heard", "silence is a named failure, never finished");
            require(s.status === "ready" && !s.blocked && s.historyEntries[0].transcript === "Hello world. And the rest.", "a failed dictation neither blocks nor records");
            hear({ recognition: "die" });
            s.trigger();
            require(s.starting && s.captureError === "" && !s.failed, "the next capture clears the failure");
            phase = 5;
        } else if (phase === 5 && !s.dictating) {
            require(s.failed && s.captureError === "speech engine stopped" && !s.finished, "an engine that dies is a named failure");
            hear({ recognition: "speak" });
            s.captureLimitMs = 400;
            s.trigger();
            require(s.starting, "a dead engine leaves nothing stuck");
            phase = 6;
        } else if (phase === 6 && !s.dictating) {
            require(s.finished && s.historyEntries[0].transcript === "Hello world. And the rest.", "a forgotten capture stops itself and is transcribed");
            // The shortened limit proved the bound; later dictations get the real one.
            s.captureLimitMs = 300000;
            hear({ recognition: "wake-speech", wake: "hit" });
            s.wakeSilenceMs = 300;
            s.editWakePhrase("hello: computer");
            require(s.wakePhraseError === "drop / @ : #" && s.wakePhrase === "hello: computer", "an invalid wake phrase is named");
            s.editWakePhrase("  hello computer ");
            s.setWakeEnabled(true);
            require(s.wakeWanted && s.wakeListening && s.active && s.role === "ui.accent", "arming the wake word opens the microphone visibly");
            mark = s.historyEntries.length;
            phase = 7;
        } else if (phase === 7 && s.historyEntries[0].transcript === "Take a note." && !s.dictating && s.wakeListening && s.wakeOperation) {
            require(!s.failed, "a wake capture ends by itself after silence");
            s.engineLingerMs = 100;
            s.setWakeEnabled(false);
            require(!s.wakeEnabled, "the wake word turns off");
            phase = 8;
        } else if (phase === 8 && !s.wakeListening && s.engineMode === "" && !s.finished) {
            require(!s.active && s.role === "ui.focus", "off releases the microphone and the engine goes");
            hear({ recognition: "speak" });
            s.lastUpdateCheck = 0;
            s.refresh();
            s.trigger();
            phase = 9;
        } else if (phase === 9 && s.liveText.endsWith("and the") && s.pendingRevision === "${b}") {
            require(s.engineRunningRevision === "${a}" && s.engineRevision === "${a}", "an update waits for the dictation to end");
            s.stopCapture();
            phase = 10;
        } else if (phase === 10 && !s.dictating && s.pendingAssetsMissing && s.engineMode === "") {
            require(s.engineRevision === "${a}" && s.assetBytes === 463945198 && s.ready && !s.blocked, "an update missing models is held; the old engine stays");
            s.trigger();
            phase = 11;
        } else if (phase === 11 && s.liveText.endsWith("and the")) {
            require(s.engineRunningRevision === "${a}", "the held update leaves dictation on the old engine");
            s.stopCapture();
            phase = 12;
        } else if (phase === 12 && !s.dictating) {
            s.install();
            require(s.installing && s.status === "installing", "consent installs the models");
            s.trigger();
            require(!s.dictating, "installation rejects capture");
            phase = 13;
        } else if (phase === 13 && !s.installing) {
            require(s.engineRevision === "${b}" && s.ready && s.status === "ready" && s.lastError === "" && s.pendingRevision === "", "installed models switch to the update");
            s.trigger();
            phase = 14;
        } else if (phase === 14 && s.liveText.endsWith("and the")) {
            require(s.engineRunningRevision === "${b}", "dictation runs on the update");
            s.stopCapture();
            phase = 15;
        } else if (phase === 15 && !s.dictating) {
            require(s.finished, "the update dictates");
            s.clearHistory();
            require(s.historyEntries.length === 0, "history clears");
            phase = 16;
            mark = Date.now();
        } else if (phase === 16 && Date.now() - mark > 600) {
            console.log("noko service: PASS");
            Qt.quit();
        }
    `);
    const env = { NOKO_CALLS: calls, NOKO_SCENARIO: scenario, NOKO_RELEASE_URL: release, PATH: `${bin}:${path}` };
    async function offscreen(environment) {
        const child = spawnIsolated('qs', ['--no-color', '-p', join(directory, 'shell.qml')], { directory, env: environment, stdio: ['ignore', 'pipe', 'pipe'] });
        let output = '';
        child.stdout.on('data', chunk => { output += chunk; });
        child.stderr.on('data', chunk => { output += chunk; });
        const timer = setTimeout(() => child.kill('SIGKILL'), 45000);
        const [code] = await once(child, 'close');
        clearTimeout(timer);
        process.stdout.write(output);
        assert.equal(code, 0, output);
        assert.doesNotMatch(output, offscreenDiagnostic, output);
        assert.match(output, /noko service: PASS/, output);
    }
    await offscreen(env);

    const records = readFileSync(calls, 'utf8').trim().split('\n').map(line => JSON.parse(line));
    assert.deepEqual(records.filter(row => row.method === 'busy'), [], 'one engine operation at a time, never refused Busy');
    const starts = records.filter(row => row.method === 'recognition.start');
    assert(starts.length >= 9, 'every dictation and the wake priming started recognition');
    assert(starts.every(row => JSON.stringify(row.hotwords) === '["Nuguland","niri"]' && row.punctuation === false), 'hotwords on every start; finals typed as recognised');
    assert.deepEqual(records.filter(row => row.method === 'recognition.ack').map(row => row.segment).slice(0, 2), ['segment-1', 'segment-2'], 'every final is acknowledged');
    const wakes = records.filter(row => row.method === 'wake.start');
    assert(wakes.length >= 2 && wakes.every(row => JSON.stringify(row.phrases) === '["hello computer"]'), 'the wake word re-arms with the trimmed phrase');
    assert(records.some(row => row.method === 'recognition.finish' && row.discard && row.plan === 'wake-speech'), 'arming primes the recogniser once, discarded');
    assert(records.some(row => row.method === 'operation.cancel' && row.kind === 'wake'), 'turning the wake word off cancels detection');
    // The update: never served while a dictation ran on the old engine.
    const firstB = records.findIndex(row => row.method === 'serve' && row.revision === b);
    const duringDownload = records.findLastIndex((row, index) => index < firstB && row.method === 'recognition.finish' && row.revision === a);
    assert(firstB > duringDownload && duringDownload > 0, 'the update starts only after the running dictation finished');
    assert(records.some(row => row.method === 'pipeline.plan' && row.revision === b && row.missing === 1), 'the update reported missing models');
    assert.equal(records.filter(row => row.method === 'pipeline.prepare' && row.revision === b).length, 1, 'models install once, with consent');
    assert.equal(records.filter(row => row.method === 'exit').length, records.filter(row => row.method === 'serve').length - records.filter(row => row.method === 'recognition.start' && row.plan === 'die').length, 'every engine that did not die ended once idle');
    const typing = readFileSync(typed, 'utf8').trim().split('\n').map(line => JSON.parse(line));
    assert(typing.every(row => JSON.stringify(row.args) === '["-"]'), 'text reaches wtype on stdin only');
    assert.deepEqual(typing.map(row => row.text), ['Hello world. And the rest.', 'Hello world. And the rest.', 'Take a note.', 'Hello world. And the rest.', 'Hello world. And the rest.', 'Hello world. And the rest.'], 'only finals are typed, once each');
    const noko = join(directory, 'data', 'nuguland', 'noko');
    assert.equal(readlinkSync(join(noko, 'engine', 'current')), b);
    assert.deepEqual(readdirSync(join(noko, 'engine')).sort(), [b, 'current'], 'the old engine goes once the update has run');
    assert(lstatSync(join(noko, 'models')).isDirectory());
    const state = readdirSync(directory, { recursive: true }).map(String);
    const history = state.filter(file => file.endsWith('noko-history.jsonl'));
    assert.equal(history.length, 1);
    assert.equal(readFileSync(join(directory, history[0]), 'utf8'), '', 'clearing empties the stored history');
    const settings = state.filter(file => file.endsWith('noko-settings.json'));
    assert.deepEqual(JSON.parse(readFileSync(join(directory, settings[0]), 'utf8')), { hotwords: ['Nuguland', 'niri'], wakeEnabled: false, wakePhrase: 'hello computer' }, 'settings persist in the service state file');

    // Nothing installed and no release reachable: blocked, and capture asks nothing of the engine.
    rmSync(join(directory, 'data'), { recursive: true, force: true });
    files.clear();
    writeFileSync(calls, '');
    shell(`
        if (s.statusKnown && phase === 0) {
            require(!s.ready && s.status === "blocked" && s.blocked && s.strong && s.role === "warning", "no engine blocks with a warning");
            s.trigger();
            require(!s.dictating, "capture needs an engine");
            phase = 1;
            mark = Date.now();
        } else if (phase === 1 && Date.now() - mark > 300) {
            require(s.latestRevision === "" && s.engineMode === "", "an unreachable release starts nothing");
            console.log("noko service: PASS");
            Qt.quit();
        }
    `);
    await offscreen(env);
    assert.equal(readFileSync(calls, 'utf8'), '', 'no engine ran');
} finally {
    server.closeAllConnections();
    await new Promise(resolve => server.close(resolve));
    rmSync(directory, { recursive: true, force: true });
}