repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by admin
quickshell/nuguland/features/noko/Noko.qml
Rawpragma ComponentBehavior: Bound
import QtQuick
import Quickshell
import Quickshell.Io
// Dictation through the speak_to_me engine: one engine process while needed,
// JSON-RPC lines over its stdin and stdout. The engine captures the microphone;
// noko types finished text with `wtype -`. noko-engine.nu owns every engine path,
// release URL and command line; this file owns the protocol (methods below).
Item {
id: root
// Engine protocol: profile, model roles and recognition options in one place.
readonly property string engineScript: Qt.resolvedUrl("noko-engine.nu").toString().replace(/^file:\/\//, "")
readonly property string engineProfile: "high"
readonly property var engineRoles: ["stt", "vad", "kws"]
// Nemotron punctuates and capitalises by itself; the extra punctuation model
// doubles commas, so finals are typed as recognised.
readonly property var recognitionOptions: ({
"punctuation": false,
"enhancement": false
})
property string status: "checking"
property string lastError: ""
property string lastChecked: ""
// Why the last dictation produced no text, in words; cleared by the next capture.
property string captureError: ""
property string lastInsertError: ""
// Newest first, at most historyLimit; transcripts never leave through stateJson().
property var historyEntries: []
// Installed engine and its update, as noko-engine.nu reports them.
property bool statusKnown: false
property string engineRevision: ""
property bool typingReady: true
property string latestRevision: ""
property real latestSize: 0
// An unpacked newer revision; switched to while no dictation runs.
property string pendingRevision: ""
// Model bytes the engine still needs: the current engine's (first install)
// or the pending revision's (an update held until they are installed).
property real assetBytes: 0
property bool currentAssetsMissing: false
property bool pendingAssetsMissing: false
property bool updating: false
property string updateError: ""
property double lastUpdateCheck: 0
// Consented work: the first engine download or a model download.
property bool installing: false
property real installProgress: 0
property string installLabel: ""
// Dictation.
property bool starting: false
property bool listening: false
property bool transcribing: false
property bool finished: false
property bool failed: false
// Committed finals and the revisable partial of the running dictation.
property var finals: []
property string partialText: ""
// What the overlay shows: the newest words of the running dictation, or the
// finished text while "finished" shows; never part of stateJson().
property string liveText: ""
// Wake word and hotwords: drafts as typed, persisted once valid.
property bool settingsLoaded: false
property bool wakeEnabled: false
property string wakePhrase: "hello computer"
property string wakePhraseError: ""
property string hotwordsText: ""
property var hotwords: []
property string hotwordsError: ""
property string wakeError: ""
readonly property bool ready: statusKnown && engineRevision.length > 0 && !currentAssetsMissing
readonly property bool dictating: starting || listening || transcribing
readonly property bool blocked: status === "blocked" || status === "error"
// The microphone is open for the wake word: from arming until it is released.
readonly property bool wakeListening: wakeOperation.length > 0 || wakePriming
readonly property bool active: blocked || dictating || installing || wakeListening
readonly property bool strong: blocked || installing
readonly property string role: blocked || installing ? "warning" : (dictating || finished || wakeListening ? "ui.accent" : "ui.focus")
readonly property string overlayState: starting ? "starting" : (listening ? "capturing" : (transcribing ? "transcribing" : (finished ? "finished" : (failed ? "failed" : ""))))
readonly property bool busy: installing || dictating || maintenance
readonly property bool wakeWanted: wakeEnabled && wakePhraseError === "" && wakePhrase.trim().length > 0 && ready && settingsLoaded && !installing
readonly property string historyPath: Quickshell.statePath("noko-history.jsonl")
readonly property string settingsPath: Quickshell.statePath("noko-settings.json")
readonly property int historyLimit: 20
// A forgotten capture ends itself; the engine lingers this long for the next one.
property int captureLimitMs: 300000
property int engineLingerMs: 60000
// A capture the wake word started ends after this much silence, not the first pause.
property int wakeSilenceMs: 2500
readonly property int updateIntervalMs: 86400000
// Engine process state.
property string engineMode: ""
property string engineRunningRevision: ""
property bool engineOpen: false
property bool engineStopping: false
property var nextEngine: null
property var rpcCallbacks: ({})
property int rpcId: 0
property string dictationOperation: ""
property bool recognitionRequested: false
property bool inputReady: false
property bool stopRequested: false
property bool wakeCapture: false
property int speechFrames: 0
property string wakeOperation: ""
property bool wakeHit: false
property bool wakeCancelling: false
property bool wakePriming: false
property string primeOperation: ""
property bool primed: false
property string armedPhrase: ""
property bool maintenance: false
property string maintenanceOperation: ""
property real maintenanceBytes: 0
property var assetProgress: ({})
property bool unconfirmed: false
property bool updateFailed: false
// Setup is checked at startup, on every popup opening and on entering Config;
// updates are looked for at startup and at most daily on opening, never while
// closed. Opening also retries a wake word that stopped.
function refresh(): string {
if (!statusKnown && !busy)
status = "checking";
if (!statusProc.running)
statusProc.exec(["nu", "--no-config-file", engineScript, "status"]);
if (Date.now() - lastUpdateCheck >= updateIntervalMs)
checkForUpdate();
if (wakeError) {
wakeError = "";
Qt.callLater(settle);
}
return stateJson();
}
function checkForUpdate(): void {
if (checkProc.running || installProc.running)
return;
lastUpdateCheck = Date.now();
checkProc.exec(["nu", "--no-config-file", engineScript, "check"]);
}
// Consent: the first engine download, or the models an engine still needs.
function install(): string {
if (busy || installProc.running)
return stateJson();
lastError = "";
if (engineRevision === "" && pendingRevision === "") {
installing = true;
installProgress = 0;
installLabel = "downloading";
status = "installing";
installProc.exec(["nu", "--no-config-file", engineScript, "install"]);
return stateJson();
}
const target = pendingAssetsMissing ? pendingRevision : (currentAssetsMissing ? engineRevision : "");
if (!target)
return stateJson();
installing = true;
maintenance = true;
installProgress = 0;
installLabel = "downloading";
status = "installing";
assetProgress = ({});
maintenanceBytes = assetBytes;
if (engineOpen && engineRunningRevision === target && !engineStopping)
prepareAssets();
else
startEngine(target, target === engineRevision ? "current" : "candidate");
return stateJson();
}
function trigger(): string {
return starting || listening ? stopCapture() : startCapture();
}
function startCapture(): string {
return beginDictation(false);
}
function beginDictation(fromWake: bool): string {
if (busy)
return stateJson();
if (!ready)
return refresh();
starting = true;
listening = false;
transcribing = false;
finished = false;
failed = false;
captureError = "";
lastInsertError = "";
finals = [];
partialText = "";
liveText = "";
speechFrames = 0;
inputReady = false;
stopRequested = false;
recognitionRequested = false;
wakeCapture = fromWake;
status = "listening";
captureLimit.restart();
engineLinger.stop();
if (engineOpen && engineMode === "current" && !engineStopping)
settle();
else
startEngine(engineRevision, "current");
return stateJson();
}
function stopCapture(): string {
if (!starting && !listening)
return stateJson();
starting = false;
listening = false;
transcribing = true;
status = "transcribing";
captureLimit.stop();
wakeSilence.stop();
if (dictationOperation)
rpc("recognition.finish", {
"operation": dictationOperation
});
else
stopRequested = true;
return stateJson();
}
// The seam between the final transcript and typing: a later cleanup step
// rewrites the text here. Today it is typed as recognised.
function refineTranscript(text: string): string {
return text;
}
// The single decision point once the engine is open or an operation ended:
// a waiting dictation starts, a staged update switches while idle, the wake
// word re-arms, or the engine lingers and goes.
function settle(): void {
if (!engineOpen || engineStopping)
return;
if (engineMode === "candidate")
return;
// A wake request in flight has no operation to cancel yet: its answer settles again.
if (wakePriming && !wakeOperation && !primeOperation)
return;
if (dictating) {
if (wakeOperation || primeOperation) {
cancelWake();
return;
}
if (!dictationOperation && !recognitionRequested)
sendRecognitionStart();
return;
}
if (maintenance)
return;
if (pendingRevision && !pendingAssetsMissing && !updateFailed) {
if (wakeOperation || primeOperation) {
cancelWake();
return;
}
startEngine(pendingRevision, "candidate");
return;
}
if (wakeWanted && !wakeError) {
if (!wakeOperation && !primeOperation)
armWake();
engineLinger.stop();
return;
}
if (wakeOperation || primeOperation) {
cancelWake();
return;
}
engineLinger.restart();
}
function sendRecognitionStart(): void {
recognitionRequested = true;
rpc("recognition.start", Object.assign({
"hotwords": hotwords
}, recognitionOptions), (result, error) => {
if (!dictating)
return;
if (!result || !result.operation) {
failDictation(starting ? "microphone unavailable" : "transcription failed");
settle();
return;
}
dictationOperation = String(result.operation);
if (stopRequested)
rpc("recognition.finish", {
"operation": dictationOperation
});
});
}
// A fresh engine loads its recogniser on first use, which is slow; before
// waiting for the wake word it runs one discarded recognition so a hit
// captures at once.
function armWake(): void {
wakeHit = false;
if (!primed) {
wakePriming = true;
rpc("recognition.start", Object.assign({
"hotwords": hotwords
}, recognitionOptions), result => {
if (result && result.operation)
primeOperation = String(result.operation);
else {
wakePriming = false;
wakeError = "wake word stopped";
}
// Wanted no longer, e.g. a dictation began meanwhile: cancel it.
if (dictating || !wakeWanted)
settle();
});
return;
}
wakePriming = true;
armedPhrase = wakePhrase.trim();
rpc("wake.start", {
"phrases": [armedPhrase]
}, result => {
wakePriming = false;
if (result && result.operation)
wakeOperation = String(result.operation);
else
wakeError = "wake phrase not recognised";
settle();
});
}
function cancelWake(): void {
if (wakeCancelling)
return;
const operation = wakeOperation || primeOperation;
if (!operation)
return;
wakeCancelling = true;
rpc("operation.cancel", {
"operation": operation
});
}
function startEngine(revision: string, mode: string): void {
engineLinger.stop();
if (engineProc.running) {
nextEngine = {
"revision": revision,
"mode": mode
};
stopEngine();
return;
}
nextEngine = null;
engineMode = mode;
engineRunningRevision = revision;
engineOpen = false;
engineStopping = false;
primed = false;
rpcCallbacks = ({});
engineProc.stdinEnabled = true;
engineProc.exec(["nu", "--no-config-file", engineScript, "serve", revision]);
}
// Closing its input ends the engine; it settles its operations first.
function stopEngine(): void {
if (!engineProc.running || engineStopping)
return;
engineStopping = true;
if (engineOpen)
rpc("service.shutdown", {});
engineProc.stdinEnabled = false;
}
function rpc(method: string, params: var, done: var): void {
if (!engineProc.running)
return;
rpcId++;
if (done)
rpcCallbacks[rpcId] = done;
engineProc.write(JSON.stringify({
"jsonrpc": "2.0",
"id": rpcId,
"method": method,
"params": params
}) + "\n");
}
function engineStarted(): void {
rpc("resource.open", {
"profile": engineProfile
}, result => {
if (!result) {
stopEngine();
return;
}
engineOpen = true;
rpc("pipeline.plan", {
"action": "warm",
"roles": engineRoles
}, plan => applyPlan(plan && plan.plan));
});
}
function applyPlan(plan: var): void {
const missing = plan && Array.isArray(plan.missing) ? plan.missing : null;
if (!missing) {
stopEngine();
return;
}
const bytes = Number(plan.download_bytes || 0);
if (engineMode === "candidate") {
if (missing.length === 0) {
switchProc.exec(["nu", "--no-config-file", engineScript, "switch", engineRunningRevision]);
return;
}
pendingAssetsMissing = true;
assetBytes = bytes;
if (maintenance) {
prepareAssets();
return;
}
// Held: the old engine keeps dictating until the models are installed.
if (engineRevision && (dictating || wakeWanted))
startEngine(engineRevision, "current");
else
stopEngine();
return;
}
currentAssetsMissing = missing.length > 0;
if (currentAssetsMissing) {
assetBytes = bytes;
if (maintenance) {
prepareAssets();
return;
}
if (dictating)
failDictation("speech model missing");
status = "blocked";
} else if (!dictating && !installing)
status = "ready";
settle();
}
// Consented model download through the engine's own verified installer.
function prepareAssets(): void {
rpc("pipeline.prepare", {
"roles": engineRoles
}, result => {
if (result && result.operation)
maintenanceOperation = String(result.operation);
else
failInstall("speech model download failed");
});
}
function applySwitch(revision: string): void {
engineRevision = revision;
pendingRevision = "";
pendingAssetsMissing = false;
currentAssetsMissing = false;
assetBytes = 0;
unconfirmed = true;
engineMode = "current";
if (installing) {
installing = false;
maintenance = false;
installProgress = 1;
}
if (!dictating)
status = "ready";
settle();
}
function applyEngineLine(line: string): void {
const message = parseJson(line);
if (!message)
return;
if (message.id !== undefined && !message.method) {
const done = rpcCallbacks[message.id];
delete rpcCallbacks[message.id];
if (done)
done(message.result || null, message.error || null);
return;
}
const params = message.params || {};
const operation = String(params.operation || "");
const data = params.data || {};
if (operation && operation === dictationOperation)
applyDictationEvent(String(message.method), data);
else if (operation && operation === wakeOperation)
applyWakeEvent(String(message.method), data);
else if (operation && operation === primeOperation)
applyPrimeEvent(String(message.method), data);
else if (operation && operation === maintenanceOperation)
applyMaintenanceEvent(String(message.method), data);
}
function applyDictationEvent(method: string, data: var): void {
if (method === "pipeline.input.ready") {
inputReady = true;
if (starting) {
starting = false;
listening = true;
if (wakeCapture)
wakeSilence.restart();
}
} else if (method === "pipeline.partial") {
partialText = String(data.text || "");
showLive();
} else if (method === "pipeline.vad") {
if (wakeCapture && listening) {
if (data.speech === true)
wakeSilence.stop();
else
wakeSilence.restart();
}
} else if (method === "pipeline.final") {
const text = String(data.text || "").trim();
if (text)
finals = finals.concat([text]);
speechFrames = Math.max(speechFrames, Number(data.end_frame || data.input_frames || 0));
partialText = "";
showLive();
if (data.segment)
rpc("recognition.ack", {
"operation": dictationOperation,
"segment": String(data.segment)
});
} else if (method === "pipeline.ended") {
endDictation(String(data.outcome || "failed"));
}
}
function showLive(): void {
liveText = finals.concat(partialText ? [partialText] : []).join(" ").slice(-400);
}
function applyWakeEvent(method: string, data: var): void {
if (method === "pipeline.keyword")
wakeHit = true;
else if (method === "pipeline.ended") {
const hit = wakeHit && data.outcome === "completed";
const cancelled = wakeCancelling;
wakeOperation = "";
wakeCancelling = false;
wakeHit = false;
// Live wake detection ends only on a hit or when told to.
if (!hit && !cancelled)
wakeError = "wake word stopped";
if (hit && !dictating)
beginDictation(true);
else
settle();
}
}
function applyPrimeEvent(method: string, data: var): void {
if (method === "pipeline.input.ready" && !wakeCancelling)
rpc("recognition.finish", {
"operation": primeOperation,
"discard": true
});
else if (method === "pipeline.final" && data.segment)
rpc("recognition.ack", {
"operation": primeOperation,
"segment": String(data.segment)
});
else if (method === "pipeline.ended") {
primeOperation = "";
wakePriming = false;
const cancelled = wakeCancelling;
wakeCancelling = false;
if (data.outcome === "completed" && !cancelled)
primed = true;
else if (data.outcome === "failed")
wakeError = "wake word stopped";
settle();
}
}
function applyMaintenanceEvent(method: string, data: var): void {
if (method === "pipeline.asset") {
const asset = String(data.asset || "");
const total = Number(data.total_bytes || data.bytes || 0);
const received = data.state === "ready" ? total : Number(data.received_bytes || 0);
assetProgress[asset] = Math.min(received, total);
let sum = 0;
for (const key in assetProgress)
sum += assetProgress[key];
installProgress = maintenanceBytes > 0 ? Math.max(0, Math.min(1, sum / maintenanceBytes)) : 0;
installLabel = data.state === "verifying" ? "verifying" : "downloading";
} else if (method === "pipeline.ended") {
maintenanceOperation = "";
if (data.outcome !== "completed") {
failInstall("speech model download failed");
return;
}
installProgress = 1;
rpc("pipeline.plan", {
"action": "warm",
"roles": engineRoles
}, plan => {
const missing = plan && plan.plan && Array.isArray(plan.plan.missing) ? plan.plan.missing : null;
if (!missing || missing.length > 0) {
failInstall("speech model download failed");
return;
}
// The switch ends the installation (applySwitch).
if (engineMode === "candidate")
switchProc.exec(["nu", "--no-config-file", engineScript, "switch", engineRunningRevision]);
else {
maintenance = false;
installing = false;
currentAssetsMissing = false;
assetBytes = 0;
status = "ready";
settle();
}
});
}
}
function endDictation(outcome: string): void {
const text = finals.join(" ").replace(/\s+/g, " ").trim();
const wasReady = inputReady;
dictationOperation = "";
recognitionRequested = false;
if (outcome === "completed" && text) {
deliver(refineTranscript(text));
if (unconfirmed) {
unconfirmed = false;
confirmProc.exec(["nu", "--no-config-file", engineScript, "confirm"]);
}
} else if (outcome === "completed")
failDictation("no speech heard");
else
failDictation(!wasReady ? "microphone unavailable" : (transcribing ? "transcription failed" : "microphone stopped"));
settle();
}
function deliver(text: string): void {
starting = false;
listening = false;
transcribing = false;
captureLimit.stop();
wakeSilence.stop();
status = "ready";
partialText = "";
liveText = text.slice(-400);
insertProcess.createObject(root, {
"payload": text
});
historyEntries = [
{
"timestamp": new Date().toISOString(),
"transcript": text,
"duration": Math.round(speechFrames / 160) / 100
}
].concat(historyEntries).slice(0, historyLimit);
saveHistory();
finished = true;
finishedTimer.restart();
}
// A dictation that produced no text: said in the overlay and the panel, and
// never dressed as finished.
function failDictation(message: string): void {
starting = false;
listening = false;
transcribing = false;
finished = false;
dictationOperation = "";
recognitionRequested = false;
captureLimit.stop();
wakeSilence.stop();
partialText = "";
liveText = "";
captureError = message;
failed = true;
failedTimer.restart();
status = ready ? "ready" : "blocked";
}
function failInstall(message: string): void {
installing = false;
maintenance = false;
maintenanceOperation = "";
lastError = message;
status = "error";
settle();
}
function engineExited(): void {
const intentional = engineStopping;
const opened = engineOpen;
const mode = engineMode;
engineOpen = false;
engineStopping = false;
engineMode = "";
rpcCallbacks = ({});
wakeOperation = "";
primeOperation = "";
wakePriming = false;
wakeCancelling = false;
// An engine stopped to make way for the next one served neither.
const replaced = nextEngine !== null;
if (dictating && (dictationOperation || recognitionRequested || !replaced))
failDictation("speech engine stopped");
if (maintenance && (maintenanceOperation || !replaced))
failInstall("speech model download stopped");
if (!intentional && wakeWanted)
wakeError = "wake word stopped";
if (mode === "candidate" && !opened && !replaced) {
// An update that cannot even start stays unused this session.
updateFailed = true;
lastError = "update failed to start";
}
if (mode === "current" && !opened && unconfirmed && !intentional) {
unconfirmed = false;
rollbackProc.exec(["nu", "--no-config-file", engineScript, "rollback"]);
return;
}
if (replaced) {
const next = nextEngine;
startEngine(next.revision, next.mode);
} else if (dictating || (wakeWanted && !wakeError))
startEngine(engineRevision, "current");
}
function applyStatus(text: string): void {
const report = parseJson(text.trim().split("\n").pop());
lastChecked = new Date().toISOString();
if (!report) {
statusKnown = false;
lastError = "speech engine check did not run";
if (!busy)
status = "error";
return;
}
statusKnown = true;
const installed = report.installed ? String(report.installed) : "";
if (installed !== engineRevision && !dictating)
engineRevision = installed;
typingReady = report.typing === true;
const staged = Array.isArray(report.staged) ? report.staged.map(String) : [];
if (!pendingRevision && staged.length > 0)
pendingRevision = staged[staged.length - 1];
if (!busy)
status = engineRevision && !currentAssetsMissing ? "ready" : "blocked";
if (status === "ready" && lastError === "speech engine check did not run")
lastError = "";
settle();
if (!engineProc.running && (wakeWanted && !wakeError || pendingRevision && !pendingAssetsMissing && !updateFailed))
startEngine(engineRevision || pendingRevision, engineRevision ? "current" : "candidate");
}
function applyCheck(text: string): void {
const report = parseJson(text.trim().split("\n").pop());
if (!report || report.event !== "latest")
return;
latestRevision = String(report.revision || "");
latestSize = Number(report.size || 0);
// Updates come by themselves; a first install waits for consent.
if (engineRevision && latestRevision && latestRevision !== engineRevision && latestRevision !== pendingRevision && !report.rejected && !installProc.running) {
updating = true;
installProc.exec(["nu", "--no-config-file", engineScript, "install"]);
}
}
function applyInstallEvent(text: string): void {
const event = parseJson(text);
if (!event)
return;
if (installing && !maintenance) {
if (event.label)
installLabel = String(event.label);
if (event.progress !== undefined)
installProgress = Math.max(0, Math.min(1, Number(event.progress)));
}
if (event.event === "done" && event.revision)
staged(String(event.revision));
}
// A downloaded revision: checked by running it while no dictation runs.
function staged(revision: string): void {
updating = false;
updateError = "";
if (revision === engineRevision)
return;
pendingRevision = revision;
pendingAssetsMissing = false;
updateFailed = false;
if (installing && !maintenance) {
// First install: the engine says which models it still needs.
installing = false;
installProgress = 1;
}
if (engineProc.running)
settle();
else if (!dictating)
startEngine(revision, "candidate");
}
function failEngineInstall(text: string): void {
updating = false;
if (!installing || maintenance) {
updateError = "update failed";
return;
}
installing = false;
lastError = text.trim().replace(/^noko-engine: /, "") || "speech engine download interrupted; retry";
status = "error";
}
// Settings: one term per line, as the engine accepts them.
function phraseProblem(term: string): string {
if (/[\/@:#\u0000]/.test(term))
return "drop / @ : #";
let bytes = 0;
for (const character of term) {
const code = character.codePointAt(0);
bytes += code < 0x80 ? 1 : (code < 0x800 ? 2 : (code < 0x10000 ? 3 : 4));
}
if (bytes > 200)
return "too long";
return "";
}
function editHotwords(text: string): void {
hotwordsText = String(text);
const terms = [];
let problem = "";
hotwordsText.split("\n").forEach((line, index) => {
const term = line.trim().replace(/\s+/g, " ");
if (!term || terms.indexOf(term) >= 0)
return;
const found = phraseProblem(term);
if (found && !problem)
problem = `line ${index + 1}: ${found}`;
terms.push(term);
});
if (!problem && terms.length > 64)
problem = "at most 64 terms";
hotwordsError = problem;
if (!problem) {
hotwords = terms;
saveSettingsTimer.restart();
}
}
function editWakePhrase(text: string): void {
wakePhrase = String(text);
const phrase = wakePhrase.trim();
wakePhraseError = !phrase ? "type a phrase to listen for" : phraseProblem(phrase);
if (!wakePhraseError) {
wakeError = "";
saveSettingsTimer.restart();
}
// Typing re-arms once, after a pause, not on every key.
wakePhraseSettle.restart();
}
function setWakeEnabled(enabled: bool): void {
wakeEnabled = !!enabled;
wakeError = "";
saveSettingsTimer.restart();
restartWake();
}
// A changed phrase or switch re-arms with it; off releases the microphone.
function restartWake(): void {
if (wakeOperation || primeOperation)
cancelWake();
else if (engineProc.running)
settle();
else if (wakeWanted)
startEngine(engineRevision, "current");
}
function saveSettings(): void {
settingsFile.setText(JSON.stringify({
"hotwords": hotwords,
"wakeEnabled": wakeEnabled,
"wakePhrase": wakePhrase.trim()
}) + "\n");
}
function loadSettingsText(text: string): void {
const settings = parseJson(text) || ({});
if (Array.isArray(settings.hotwords))
editHotwords(settings.hotwords.map(String).join("\n"));
if (typeof settings.wakePhrase === "string" && settings.wakePhrase.trim())
wakePhrase = settings.wakePhrase;
wakeEnabled = settings.wakeEnabled === true;
saveSettingsTimer.stop();
settingsLoaded = true;
restartWake();
}
function saveHistory(): void {
historyFile.setText(historyEntries.slice().reverse().map(row => JSON.stringify(row) + "\n").join(""));
}
function clearHistory(): void {
historyEntries = [];
saveHistory();
}
function loadHistoryText(text: string): void {
const rows = [];
for (const line of text.split("\n")) {
const row = parseJson(line);
if (row && row.transcript)
rows.unshift(row);
}
historyEntries = rows.slice(0, historyLimit);
}
function copyTranscript(text): void {
copyProcess.createObject(root, {
"payload": String(text)
});
}
function parseJson(text): var {
try {
const value = JSON.parse(String(text));
return value !== null && typeof value === "object" ? value : null;
} catch (error) {
return null;
}
}
// IPC and diagnostics: state only, never what was said, typed or listened for.
function stateJson(): string {
return JSON.stringify({
"status": status,
"ready": ready,
"active": active,
"strong": strong,
"role": role,
"overlayState": overlayState,
"lastError": lastError,
"lastChecked": lastChecked,
"captureError": captureError,
"historyCount": historyEntries.length,
"installing": installing,
"installProgress": installProgress,
"installLabel": installLabel,
"engineInstalled": engineRevision.length > 0,
"updatePending": pendingRevision.length > 0,
"updating": updating,
"assetBytes": assetBytes,
"wakeEnabled": wakeEnabled,
"wakeListening": wakeListening,
"hotwordCount": hotwords.length
});
}
Component.onCompleted: refresh()
FileView {
id: historyFile
path: root.historyPath
blockWrites: true
atomicWrites: true
printErrors: false
onLoaded: root.loadHistoryText(historyFile.text())
onLoadFailed: root.historyEntries = []
}
FileView {
id: settingsFile
path: root.settingsPath
blockWrites: true
atomicWrites: true
printErrors: false
onLoaded: root.loadSettingsText(settingsFile.text())
onLoadFailed: root.loadSettingsText("")
}
Timer {
id: saveSettingsTimer
interval: 400
onTriggered: root.saveSettings()
}
Timer {
id: wakePhraseSettle
interval: 600
// The same phrase stays armed: no needless release and reopening.
onTriggered: if (!(root.wakeOperation && root.wakeWanted && root.armedPhrase === root.wakePhrase.trim()))
root.restartWake()
}
Timer {
id: finishedTimer
interval: 1800
onTriggered: {
root.finished = false;
if (!root.dictating)
root.liveText = "";
}
}
Timer {
id: failedTimer
interval: 2400
onTriggered: root.failed = false
}
Timer {
id: captureLimit
interval: root.captureLimitMs
onTriggered: root.stopCapture()
}
Timer {
id: wakeSilence
interval: root.wakeSilenceMs
onTriggered: root.stopCapture()
}
Timer {
id: engineLinger
interval: root.engineLingerMs
onTriggered: if (!root.dictating && !root.wakeListening && !root.maintenance)
root.stopEngine()
}
Process {
id: statusProc
running: false
stdout: StdioCollector {
waitForEnd: true
onStreamFinished: root.applyStatus(this.text)
}
}
Process {
id: checkProc
running: false
stdout: StdioCollector {
waitForEnd: true
onStreamFinished: root.applyCheck(this.text)
}
}
Process {
id: installProc
running: false
onExited: (code, exitStatus) => {
if (code !== 0 || exitStatus !== 0)
root.failEngineInstall(installErrors.text);
}
stdout: SplitParser {
onRead: data => root.applyInstallEvent(data)
}
stderr: StdioCollector {
id: installErrors
waitForEnd: true
}
}
Process {
id: switchProc
running: false
stdout: StdioCollector {
waitForEnd: true
onStreamFinished: {
const event = root.parseJson(this.text.trim());
if (event && event.event === "switched")
root.applySwitch(String(event.revision));
else {
root.updateFailed = true;
root.failInstall("update could not switch");
}
}
}
}
Process {
id: confirmProc
running: false
}
Process {
id: rollbackProc
running: false
onExited: root.refresh()
}
Process {
id: engineProc
running: false
stdinEnabled: true
onStarted: root.engineStarted()
onRunningChanged: if (!running)
root.engineExited()
stdout: SplitParser {
onRead: data => root.applyEngineLine(data)
}
}
Component {
id: copyProcess
Process {
property string payload
command: ["wl-copy"]
stdinEnabled: true
running: true
onStarted: {
write(payload);
stdinEnabled = false;
payload = "";
}
onRunningChanged: if (!running)
destroy()
}
}
Component {
id: insertProcess
Process {
property string payload
command: ["wtype", "-"]
stdinEnabled: true
running: true
onStarted: {
write(payload);
stdinEnabled = false;
payload = "";
}
onRunningChanged: if (!running)
destroy()
stderr: StdioCollector {
waitForEnd: true
onStreamFinished: if (this.text.trim().length > 0)
root.lastInsertError = this.text.trim()
}
}
}
}