repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by admin
quickshell/nuguland/features/noko/fixtures/scripted-engine.mjs
Raw// A scripted stand-in for `speak_to_me serve`: the JSON-RPC methods and events
// Noko uses, with the shapes the real engine emits (see the speak_to_me client
// guide and current pipeline RPC), and no audio, model or device at all.
//
// A test bundle's bin/speak_to_me is a wrapper that names its bundle and
// revision in NOKO_ENGINE_BUNDLE and NOKO_ENGINE_REVISION. What recognition and wake
// detection hear comes from the JSON file NOKO_SCENARIO names, read at each
// start: {"recognition": "speak" | "silent" | "die" | "wake-speech", "wake": "hit" | "wait",
// "finals": [first, last]}; "speak" finals default to "Hello world." and "And the rest.".
// Every request is appended to NOKO_CALLS as one JSON line. A bundle holding
// `missing` reports model assets missing until `pipeline.prepare` ran for it.
import { appendFileSync, existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { createInterface } from 'node:readline';
const bundle = process.env.NOKO_ENGINE_BUNDLE;
const revision = process.env.NOKO_ENGINE_REVISION;
const root = process.argv[process.argv.indexOf('--data-root') + 1];
const prepared = join(root, 'models', `${revision}.prepared`);
const note = record => appendFileSync(process.env.NOKO_CALLS, JSON.stringify({ revision, ...record }) + '\n');
const scenario = () => {
try { return JSON.parse(readFileSync(process.env.NOKO_SCENARIO, 'utf8')); } catch { return {}; }
};
const missing = () => existsSync(join(bundle, 'missing')) && !existsSync(prepared)
? [{ id: 'nemotron-en-160ms-int8', bytes: 463945198, output_bytes: 463945198, acquisition: 'download', description: 'Download nemotron-en-160ms-int8' }]
: [];
let seq = 0;
let next = 0;
const operations = new Map();
const send = message => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', ...message }) + '\n');
const event = (operation, method, data) => send({ method, params: { instance: 'scripted', seq: ++seq, resource: 'pipeline', epoch: 1, operation, data } });
const later = (ms, action) => setTimeout(action, ms);
function end(operation, outcome) {
const state = operations.get(operation);
if (!state || state.ended) return;
state.ended = true;
for (const timer of state.timers) clearTimeout(timer);
event(operation, 'pipeline.ended', { outcome, error: outcome === 'failed' ? { code: -32000, message: 'scripted failure' } : null, native_settled: true, wall_ms: 1 });
}
function start(kind) {
const operation = `pipeline_${++next}`;
operations.set(operation, { kind, timers: [], pending: new Set(), finishing: false, ended: false });
return operation;
}
function schedule(operation, ms, action) {
operations.get(operation).timers.push(later(ms, action));
}
function final(operation, segment, text) {
const state = operations.get(operation);
state.pending.add(segment);
event(operation, 'pipeline.final', { raw_text: text, text, segment, start_frame: 0, end_frame: 32000, input_frames: 32000, partial_count: 1 });
}
function settleIfDone(operation) {
const state = operations.get(operation);
if (state && state.finishing && state.pending.size === 0) end(operation, 'completed');
}
function recognition(operation, params) {
const plan = scenario().recognition || 'speak';
const finals = scenario().finals || ['Hello world.', 'And the rest.'];
operations.get(operation).plan = plan;
operations.get(operation).finals = finals;
note({ method: 'recognition.start', hotwords: params.hotwords, punctuation: params.punctuation, plan });
schedule(operation, 30, () => event(operation, 'pipeline.input.ready', { mode: 'transcribe', pre_roll: false, retained_input: false, sample_rate: 16000 }));
if (plan === 'speak') {
schedule(operation, 60, () => event(operation, 'pipeline.partial', { text: 'hello', segment: 'segment-1', input_frames: 4000, input_complete: false, revisable: true }));
schedule(operation, 90, () => event(operation, 'pipeline.partial', { text: 'hello wor', segment: 'segment-1', input_frames: 8000, input_complete: false, revisable: true }));
schedule(operation, 120, () => final(operation, 'segment-1', finals[0]));
schedule(operation, 150, () => event(operation, 'pipeline.partial', { text: 'and the', segment: 'segment-2', input_frames: 36000, input_complete: false, revisable: true }));
} else if (plan === 'wake-speech') {
schedule(operation, 60, () => event(operation, 'pipeline.vad', { speech: true, input_frames: 4000, meaning: 'activity evidence, not turn commitment', source: 'native_silero_vad', live_input: true }));
schedule(operation, 90, () => event(operation, 'pipeline.partial', { text: 'take a note', segment: 'segment-1', input_frames: 8000, input_complete: false, revisable: true }));
schedule(operation, 150, () => event(operation, 'pipeline.vad', { speech: false, input_frames: 9000, meaning: 'activity evidence, not turn commitment', source: 'native_silero_vad', live_input: true }));
schedule(operation, 170, () => final(operation, 'segment-1', 'Take a note.'));
} else if (plan === 'die') {
schedule(operation, 100, () => process.exit(1));
}
}
function finish(operation, params) {
const state = operations.get(operation);
note({ method: 'recognition.finish', discard: params.discard === true, plan: state.plan });
state.finishing = true;
if (state.plan === 'speak' && !params.discard) final(operation, 'segment-2', state.finals[1]);
settleIfDone(operation);
}
const methods = {
'resource.open': () => ({ resource: 'pipeline', epoch: 1, ready: true }),
'pipeline.plan': params => {
const gaps = missing();
note({ method: 'pipeline.plan', action: params.action, roles: params.roles, missing: gaps.length });
return { plan: { action: params.action, missing: gaps, download_bytes: gaps.reduce((sum, item) => sum + item.bytes, 0), optional_missing: [], roles: params.roles } };
},
'pipeline.prepare': params => {
const operation = start('prepare');
note({ method: 'pipeline.prepare', roles: params.roles });
schedule(operation, 30, () => event(operation, 'pipeline.asset', { asset: 'nemotron-en-160ms-int8', state: 'downloading', bytes: 463945198, received_bytes: 231972599, total_bytes: 463945198 }));
schedule(operation, 60, () => event(operation, 'pipeline.asset', { asset: 'nemotron-en-160ms-int8', state: 'ready', bytes: 463945198, verified: true }));
schedule(operation, 90, () => {
mkdirSync(dirname(prepared), { recursive: true });
writeFileSync(prepared, '');
end(operation, 'completed');
});
return { operation, resource: 'pipeline', epoch: 1 };
},
'recognition.start': params => {
const operation = start('recognition');
recognition(operation, params);
return { operation, resource: 'pipeline', epoch: 1 };
},
'recognition.finish': params => {
finish(params.operation, params);
return { operation: params.operation, finishing: true, native_settled: false };
},
'recognition.ack': params => {
note({ method: 'recognition.ack', segment: params.segment });
operations.get(params.operation)?.pending.delete(params.segment);
settleIfDone(params.operation);
return { acknowledged: true, operation: params.operation, segment: params.segment };
},
'wake.start': params => {
const operation = start('wake');
const plan = scenario().wake || 'wait';
note({ method: 'wake.start', phrases: params.phrases, plan });
schedule(operation, 30, () => event(operation, 'pipeline.input.ready', { mode: 'wake', pre_roll: false }));
if (plan === 'hit') {
writeFileSync(process.env.NOKO_SCENARIO, JSON.stringify({ ...scenario(), wake: 'wait' }));
schedule(operation, 120, () => event(operation, 'pipeline.keyword', { phrase: params.phrases[0], label: 'keyword_0', start_seconds: 0, policy: 'evidence only; no actions executed' }));
schedule(operation, 130, () => end(operation, 'completed'));
}
return { operation, resource: 'pipeline', epoch: 1 };
},
'operation.cancel': params => {
note({ method: 'operation.cancel', kind: operations.get(params.operation)?.kind });
end(params.operation, 'cancelled');
return { operation: params.operation, native_settled: true };
},
'service.shutdown': () => {
note({ method: 'service.shutdown' });
for (const operation of operations.keys()) end(operation, 'cancelled');
return { closed: true };
},
};
note({ method: 'serve' });
const lines = createInterface({ input: process.stdin });
// Serial admission, as the engine opens without duplex: a second operation
// while one runs is refused Busy.
const starts = new Set(['recognition.start', 'wake.start', 'pipeline.prepare']);
lines.on('line', line => {
const request = JSON.parse(line);
if (starts.has(request.method) && [...operations.values()].some(state => !state.ended)) {
note({ method: 'busy', refused: request.method });
send({ id: request.id, error: { code: -32000, message: 'Busy' } });
return;
}
const handler = methods[request.method];
if (!handler) {
send({ id: request.id, error: { code: -32601, message: `unknown method ${request.method}` } });
return;
}
send({ id: request.id, result: handler(request.params || {}) });
});
lines.on('close', () => {
note({ method: 'exit' });
process.exit(0);
});