@lumiastream/wakeword 1.0.0 → 1.0.1-alpha.10

package/bin/wakeword

@@ -17,13 +17,28 @@ const soxPath = path.join(
 	exe
 );
 
-// Forward every CLI arg → voice.mjs
-spawn(
-	process.execPath, // node executable
+const child = spawn(
+	process.execPath,
 	[
-		path.join(__dirname, "..", "lib", "voice.mjs"),
+		path.join(
+			path.dirname(fileURLToPath(import.meta.url)),
+			"..",
+			"lib",
+			"voice.js"
+		),
 		soxPath,
 		...process.argv.slice(2),
 	],
-	{ stdio: "inherit" }
+	{ stdio: ["pipe", "inherit", "inherit"] }
 );
+
+// If you want to forward user input from this process to the child:
+// if (process.stdin.isTTY) {
+// 	process.stdin.setRawMode(false);
+// }
+// process.stdin.pipe(child.stdin);
+
+// listen for hotkey events from the child process
+child.on("message", (message) => {
+	console.log("hotkey", message);
+});

package/lib/record.js

@@ -0,0 +1,119 @@
+"use strict";
+
+import assert from "assert";
+import debug from "debug";
+import { spawn } from "child_process";
+import recorders from "./recorders/index.js";
+
+class Recording {
+	constructor(options = {}) {
+		const defaults = {
+			sampleRate: 16000,
+			channels: 1,
+			compress: false,
+			threshold: 0.5,
+			thresholdStart: null,
+			thresholdEnd: null,
+			silence: "1.0",
+			recorder: "sox",
+			endOnSilence: false,
+			audioType: "wav",
+			binPath: null,
+			bufferSize: null,
+			arguments: [],
+		};
+
+		this.options = Object.assign(defaults, options);
+
+		const recorder = recorders.load(this.options.recorder);
+		const { cmd, args, spawnOptions = {} } = recorder(this.options);
+
+		this.cmd = cmd;
+		this.args = args;
+		this.cmdOptions = Object.assign(
+			{ encoding: "binary", stdio: "pipe" },
+			spawnOptions
+		);
+
+		debug(`Started recording`);
+		debug(this.options);
+
+		const command = ` ${this.cmd} ${this.args.join(" ")}`;
+		debug(command);
+
+		return this.start();
+	}
+
+	start() {
+		const { cmd, args, cmdOptions } = this;
+
+		const cp = spawn(cmd, args, cmdOptions);
+		const rec = cp.stdout;
+		const err = cp.stderr;
+
+		this.process = cp; // expose child process
+		this._stream = rec; // expose output stream
+
+		cp.on("close", (code) => {
+			if (code === 0) return;
+			rec.emit(
+				"error",
+				`${this.cmd} has exited with error code ${code}.
+
+Enable debugging with the environment variable DEBUG=record.`
+			);
+		});
+
+		err.on("data", (chunk) => {
+			debug(`STDERR: ${chunk}`);
+		});
+
+		rec.on("data", (chunk) => {
+			debug(`Recording ${chunk.length} bytes`);
+		});
+
+		rec.on("end", () => {
+			debug("Recording ended");
+		});
+
+		return this;
+	}
+
+	stop() {
+		assert(this.process, "Recording not yet started");
+
+		this.process.kill();
+	}
+
+	pause() {
+		assert(this.process, "Recording not yet started");
+
+		this.process.kill("SIGSTOP");
+		this._stream.pause();
+		debug("Paused recording");
+	}
+
+	resume() {
+		assert(this.process, "Recording not yet started");
+
+		this.process.kill("SIGCONT");
+		this._stream.resume();
+		debug("Resumed recording");
+	}
+
+	isPaused() {
+		assert(this.process, "Recording not yet started");
+
+		return this._stream.isPaused();
+	}
+
+	stream() {
+		assert(this._stream, "Recording not yet started");
+
+		return this._stream;
+	}
+}
+
+export default {
+	record: (...args) => new Recording(...args),
+};

package/lib/recorders/arecord.js

@@ -0,0 +1,27 @@
+// On some systems (RasPi), arecord is the prefered recording binary
+export default (options) => {
+	let cmd = "arecord";
+
+	if (options.binPath) {
+		cmd = options.binPath;
+	}
+
+	const args = [
+		"-q", // show no progress
+		"-r",
+		options.sampleRate, // sample rate
+		"-c",
+		options.channels, // channels
+		"-t",
+		options.audioType, // audio type
+		"-f",
+		"S16_LE", // Sample format
+		"-", // pipe
+	];
+
+	if (options.device) {
+		args.unshift("-D", options.device);
+	}
+
+	return { cmd, args };
+};

package/lib/recorders/index.js

@@ -0,0 +1,23 @@
+// import { fileURLToPath } from "node:url";
+// import path from "node:path";
+// const __dirname = path.dirname(fileURLToPath(import.meta.url));
+import rec from "./sox.js";
+
+function load(recorderName) {
+	try {
+		// const recoderPath = path.resolve(__dirname, recorderName);
+		// const module = await import(recoderPath);
+		// return module.default;
+		return rec;
+	} catch (err) {
+		if (err.code === "MODULE_NOT_FOUND") {
+			throw new Error(`No such recorder found: ${recorderName}`);
+		}
+
+		throw err;
+	}
+}
+
+export default {
+	load,
+};

package/lib/recorders/rec.js

@@ -0,0 +1,36 @@
+export default (options) => {
+	let cmd = "rec";
+
+	if (options.binPath) {
+		cmd = options.binPath;
+	}
+
+	let args = [
+		"-q", // show no progress
+		"-r",
+		options.sampleRate, // sample rate
+		"-c",
+		options.channels, // channels
+		"-e",
+		"signed-integer", // sample encoding
+		"-b",
+		"16", // precision (bits)
+		"-t",
+		options.audioType, // audio type
+		"-", // pipe
+	];
+
+	if (options.endOnSilence) {
+		args = args.concat([
+			"silence",
+			"1",
+			"0.1",
+			options.thresholdStart || options.threshold + "%",
+			"1",
+			options.silence,
+			options.thresholdEnd || options.threshold + "%",
+		]);
+	}
+
+	return { cmd, args };
+};

package/lib/recorders/sox.js

@@ -0,0 +1,51 @@
+export default (options) => {
+	let cmd = "sox";
+
+	if (options.binPath) {
+		cmd = options.binPath;
+	}
+
+	let args = [
+		"--default-device",
+		"--no-show-progress", // show no progress
+		"--rate",
+		options.sampleRate, // sample rate
+		"--channels",
+		options.channels, // channels
+		"--encoding",
+		"signed-integer", // sample encoding
+		"--bits",
+		"16", // precision (bits)
+		"--type",
+		options.audioType, // audio type
+		"-", // pipe
+	];
+
+	if (options.bufferSize) {
+		args.push("--buffer", options.bufferSize);
+	}
+
+	if (options.endOnSilence) {
+		args = args.concat([
+			"silence",
+			"1",
+			"0.1",
+			options.thresholdStart || options.threshold + "%",
+			"1",
+			options.silence,
+			options.thresholdEnd || options.threshold + "%",
+		]);
+	}
+
+	if (options.arguments) {
+		args = args.concat(options.arguments);
+	}
+
+	const spawnOptions = {};
+
+	if (options.device) {
+		spawnOptions.env = { ...process.env, AUDIODEV: options.device };
+	}
+
+	return { cmd, args, spawnOptions };
+};

package/lib/voice.js

@@ -0,0 +1,100 @@
+// voice.js  (ESM)
+import { Model, Recognizer, setLogLevel } from "vosk-koffi";
+import record from "./record.js";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync, chmodSync } from "node:fs";
+import readline from "node:readline";
+
+/* ------------------------------------------------------------------ */
+/* 0. Helpers                                                         */
+/* ------------------------------------------------------------------ */
+const here = dirname(fileURLToPath(import.meta.url));
+
+function unpacked(p) {
+	return p.includes("app.asar")
+		? p.replace("app.asar", "app.asar.unpacked")
+		: p;
+}
+
+/* ------------------------------------------------------------------ */
+/* 1. Resolve SoX binary                                              */
+/* ------------------------------------------------------------------ */
+const exeName = { win32: "sox.exe", darwin: "soxmac", linux: "soxlinux" }[
+	process.platform
+];
+
+/* Priority: argv[2]  → fallback to sibling binaries/<exe> */
+let soxPath = process.argv[2] || join(here, "..", "binaries", exeName);
+soxPath = unpacked(soxPath);
+
+if (!existsSync(soxPath)) throw new Error(`SoX not found: ${soxPath}`);
+try {
+	chmodSync(soxPath, 0o755);
+} catch {
+	/* ignore on read‐only FS */
+}
+
+/* ------------------------------------------------------------------ */
+/* 2. Resolve Vosk model                                              */
+/* ------------------------------------------------------------------ */
+let modelPath = join(here, "..", "models", "vosk-model-small-en-us-0.15");
+modelPath = unpacked(modelPath);
+
+if (!existsSync(modelPath))
+	throw new Error(`Vosk model not found: ${modelPath}`);
+
+/* ------------------------------------------------------------------ */
+/* 3. Initialise recogniser                                           */
+/* ------------------------------------------------------------------ */
+setLogLevel(0);
+
+const SAMPLE_RATE = 16_000;
+let GRAMMAR = ["blue", "[unk]"]; // seed; always keep [unk]
+
+const model = new Model(modelPath);
+let rec = new Recognizer({ model, sampleRate: SAMPLE_RATE, grammar: GRAMMAR });
+
+/* ------------------------------------------------------------------ */
+/* 4. Start the microphone                                            */
+/* ------------------------------------------------------------------ */
+const mic = record
+	.record({ sampleRate: SAMPLE_RATE, threshold: 0, binPath: soxPath })
+	.stream();
+
+mic.on("data", (buf) => {
+	if (rec.acceptWaveform(buf)) {
+		const { text } = rec.result();
+		handle(text.trim());
+	}
+});
+
+/* ------------------------------------------------------------------ */
+/* 5. Handle recognised commands                                      */
+/* ------------------------------------------------------------------ */
+function handle(word) {
+	if (!word || word.includes("[unk]")) return;
+	if (GRAMMAR.includes(word)) process.stdout.write(`voice|${word}\n`);
+}
+
+/* ------------------------------------------------------------------ */
+/* 6. Hot-reload grammar via stdin                                    */
+/* ------------------------------------------------------------------ */
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+
+rl.on("line", (line) => {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("update,")) return;
+
+	const phrases = trimmed
+		.split(",")
+		.slice(1)
+		.map((s) => s.trim())
+		.filter(Boolean);
+
+	if (!phrases.length) return;
+
+	GRAMMAR = [...phrases, "[unk]"];
+	rec = new Recognizer({ model, sampleRate: SAMPLE_RATE, grammar: GRAMMAR });
+	console.error("[wakeword] grammar updated →", GRAMMAR.join(", "));
+});

package/package.json

@@ -1,23 +1,21 @@
 {
 	"name": "@lumiastream/wakeword",
-	"version": "1.0.0",
+	"version": "1.0.1-alpha.10",
 	"type": "module",
-	"main": "lib/voice.mjs",
+	"main": "lib/voice.js",
 	"bin": {
 		"wakeword": "bin/wakeword"
 	},
 	"files": [
 		"bin/",
 		"lib/",
-		"binaries/",
-		"models/"
+		"models/",
+		"binaries/"
 	],
 	"scripts": {
-		"postinstall": "chmod +x binaries/soxmac binaries/soxlinux || true"
+		"postinstall": "chmod +x binaries/soxmac binaries/soxlinux binaries/sox.exe || true"
 	},
-	"optionalDependencies": {
-		"@lumiastream/wakeword-darwin": "file:./binaries/soxmac",
-		"@lumiastream/wakeword-linux": "file:./binaries/soxlinux",
-		"@lumiastream/wakeword-win32": "file:./binaries/sox.exe"
+	"dependencies": {
+		"vosk-koffi": "^1.1.1"
 	}
 }

package/lib/voice.mjs

@@ -1,88 +0,0 @@
-import { Model, Recognizer, setLogLevel } from "vosk";
-import record from "@lumiastream/record";
-import { join } from "node:path";
-
-const binPath = join(
-	"binaries",
-	process.platform === "win32"
-		? "sox.exe"
-		: process.platform === "darwin"
-		? "soxmac"
-		: "soxlinux"
-);
-
-console.log(binPath);
-
-let COMMANDS = [
-	"open settings",
-	"mute audio",
-	"start recording",
-	"[unk]", // always keep an [unk] fallback!
-];
-
-const SAMPLE_RATE = 16_000;
-setLogLevel(0); // silence Kaldi logs
-
-// 1. load model once
-const model = new Model("./models/vosk-model-small-en-us-0.15");
-
-// 2. build a grammar recognizer
-let rec = new Recognizer({
-	model,
-	sampleRate: SAMPLE_RATE,
-	grammar: COMMANDS,
-});
-
-// 3. open the mic (16-kHz, 16-bit, mono)
-const mic = record
-	.record({
-		sampleRate: SAMPLE_RATE,
-		threshold: 0,
-		binPath,
-	})
-	.stream();
-
-mic.on("data", (buf) => {
-	// accept 0.1-sec chunks for low latency
-	if (rec.acceptWaveform(buf)) {
-		const result = rec.result();
-		handle(result?.text?.trim());
-	} else {
-		// optional: JSON.parse(rec.partialResult()).partial for live captions
-	}
-});
-
-// 4. map recognised phrase ➜ action
-function handle(phrase) {
-	console.log(phrase);
-	if (phrase && COMMANDS.includes(phrase)) {
-		console.log("found", phrase);
-	}
-	// switch (phrase) {
-	// 	case "open settings":
-	// 		process.send?.({ hotkey: "settings" });
-	// 		break;
-	// 	case "mute audio":
-	// 		process.send?.({ hotkey: "mute" });
-	// 		break;
-	// 	case "start recording":
-	// 		process.send?.({ hotkey: "record" });
-	// 		break;
-	// }
-}
-
-const updateGrammar = (grammar) => {
-	COMMANDS = grammar;
-	rec = new Recognizer({
-		model,
-		sampleRate: SAMPLE_RATE,
-		grammar: [...COMMANDS, "[unk]"],
-	});
-	console.log(COMMANDS);
-};
-
-setTimeout(() => {
-	updateGrammar(["red", "blue", "green"]);
-}, 5000);
-
-export { updateGrammar };