@lumiastream/wakeword 1.1.2 → 1.1.5-alpha.1

package/lib/list-devices.js

@@ -31,9 +31,60 @@ export function listAudioDevices() {
 			return;
 		}
 
-		// Windows: Use PowerShell to get audio devices
-		const psCommand = `Get-WmiObject Win32_SoundDevice | Select-Object -Property Name, DeviceID | ConvertTo-Json`;
-		const proc = spawn("powershell", ["-Command", psCommand], {
+		// Windows: Use PowerShell to enumerate capture endpoints so names match Sound settings
+		const psCommand = `
+$devices = @()
+$defaultName = $null
+
+# Try to read the current default recording device
+try {
+  $defaultKey = 'HKCU:\\SOFTWARE\\Microsoft\\Multimedia\\Sound Mapper'
+  if (Test-Path $defaultKey) {
+    $defaultName = (Get-ItemProperty -Path $defaultKey -ErrorAction SilentlyContinue).Record
+  }
+} catch {}
+
+# First pass: registry-backed capture endpoints (matches Sound control panel)
+try {
+  $captureRoot = 'HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\MMDevices\\Audio\\Capture'
+  if (Test-Path $captureRoot) {
+    foreach ($dev in Get-ChildItem $captureRoot) {
+      $props = Get-ItemProperty $dev.PSPath
+      $name = $props.FriendlyName
+      $state = $props.DeviceState
+
+      # Only include active/available devices with names
+      if ([string]::IsNullOrWhiteSpace($name)) { continue }
+      if (($state -band 1) -ne 1) { continue }
+
+      $displayName = $name
+      if ($defaultName -and $name -eq $defaultName) {
+        $displayName = "$name (Default)"
+      }
+
+      $devices += [PSCustomObject]@{
+        name = $displayName
+        id   = $name  # SoX expects the friendly name
+      }
+    }
+  }
+} catch {}
+
+# Fallback: PnP endpoints filtered to likely inputs
+if (-not $devices.Count) {
+  try {
+    $pnp = Get-CimInstance -ClassName Win32_PnPEntity -Filter "PNPClass='AudioEndpoint'" -ErrorAction Stop
+    foreach ($d in $pnp) {
+      if (-not $d.Name) { continue }
+      if ($d.Name -notmatch '(?i)microphone|mic|input|line in|array|webcam|stereo mix') { continue }
+      $devices += [PSCustomObject]@{ name = $d.Name; id = $d.Name }
+    }
+  } catch {}
+}
+
+$devices | ConvertTo-Json -Depth 3
+		`;
+		const proc = spawn("powershell", ["-NoProfile", "-NonInteractive", "-Command", psCommand], {
 			encoding: "utf8",
 			windowsHide: true,
 		});
@@ -59,10 +110,12 @@ export function listAudioDevices() {
 					const deviceArray = Array.isArray(psDevices) ? psDevices : [psDevices];
 					
 					deviceArray.forEach((device, index) => {
-						if (device && device.Name) {
+						const name = device?.name || device?.Name;
+						const id = device?.id || device?.Id || device?.ID;
+						if (name) {
 							devices.push({
-								id: index.toString(),
-								name: device.Name,
+								id: (id ?? name).toString(),
+								name,
 							});
 						}
 					});
@@ -117,4 +170,4 @@ if (process.argv[1] && import.meta.url.endsWith(process.argv[1].replace(/\\/g, '
 			console.error("Error listing devices:", err);
 			process.exit(1);
 		});
-}
+}

package/lib/recorders/sox.js

@@ -46,7 +46,9 @@ export default (options) => {
   // Prepend input spec based on platform
   const platform = process.platform;
   if (platform === "win32") {
-    const dev = options.device ?? "default";
+    const rawDev = options.device;
+    const dev =
+      rawDev && `${rawDev}`.trim().length ? `${rawDev}`.trim() : "default";
     args.unshift("-t", "waveaudio", dev);
     // AUDIODEV sometimes respected on Windows; keep for compatibility
     spawnOptions.env = { ...process.env, AUDIODEV: dev };

package/lib/voice.js

@@ -1,10 +1,37 @@
-import { Model, Recognizer, setLogLevel } from "vosk-koffi";
 import record from "./record.js";
-import { dirname, join } from "node:path";
+import koffi from "koffi";
+import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { existsSync, chmodSync } from "node:fs";
 import readline from "node:readline";
 
+// Ensure native libs can load from app.asar.unpacked when packaged
+const maybeUnpackedPath = (libPath) => {
+	if (typeof libPath !== "string") return libPath;
+	if (!libPath.includes("app.asar")) return libPath;
+	const unpacked = libPath.replace("app.asar", "app.asar.unpacked");
+	return existsSync(unpacked) ? unpacked : libPath;
+};
+const ensureWinBinOnPath = (libPath) => {
+	if (process.platform !== "win32") return;
+	const dir = dirname(libPath);
+	const current = process.env.Path || process.env.PATH || "";
+	const parts = current.split(delimiter).filter(Boolean);
+	if (!parts.includes(dir)) {
+		process.env.Path = [dir, ...parts].join(delimiter);
+	}
+};
+const originalKoffiLoad = koffi.load.bind(koffi);
+koffi.load = (libPath, ...rest) => {
+	const resolved = maybeUnpackedPath(libPath);
+	if (resolved !== libPath && typeof resolved === "string") {
+		ensureWinBinOnPath(resolved);
+	}
+	return originalKoffiLoad(resolved, ...rest);
+};
+
+const { Model, Recognizer, setLogLevel } = await import("vosk-koffi");
+
 /* ------------------------------------------------------------------ */
 /* 0. Helpers                                                         */
 /* ------------------------------------------------------------------ */
@@ -16,12 +43,21 @@ function unpacked(p) {
 		: p;
 }
 
+const UNKNOWN_TOKEN = "[unk]";
+const normalizePhrase = (phrase = "") => phrase.trim().toLowerCase();
+const toBool = (v = "") =>
+	["1", "true", "yes", "y"].includes(`${v}`.trim().toLowerCase());
+
 /* ------------------------------------------------------------------ */
 /* 1. Resolve SoX binary and audio device                            */
 /* ------------------------------------------------------------------ */
-const exeName = { win32: "sox.exe", darwin: "soxmac", linux: "soxlinux" }[
-	process.platform
-];
+const defaultExeName = {
+	win32: "sox.exe",
+	darwin: "soxmac",
+	linux: "soxlinux",
+}[process.platform];
+const exeName = defaultExeName;
+const MATCH_SENTENCE = toBool(process.env.LUMIA_VOICE_MATCH_SENTENCE);
 
 /* Priority for sox path: argv[2] → fallback to sibling binaries/<exe> */
 /* Priority for device: argv[3] → env var → default */
@@ -32,7 +68,14 @@ if (!soxPath || soxPath === "") {
 soxPath = unpacked(soxPath);
 
 // Parse device from argv[3] or environment variable
-let audioDevice = process.argv[3] || process.env.AUDIO_DEVICE || null;
+let audioDeviceRaw = process.argv[3] ?? process.env.AUDIO_DEVICE ?? null;
+let audioDevice =
+	typeof audioDeviceRaw === "string" ? audioDeviceRaw.trim() : audioDeviceRaw;
+if (!audioDevice) audioDevice = null;
+// Normalize Windows numeric "0" to SoX's "default" alias
+if (process.platform === "win32" && audioDevice === "0") {
+	audioDevice = "default";
+}
 
 if (!existsSync(soxPath)) throw new Error(`SoX not found: ${soxPath}`);
 try {
@@ -56,26 +99,36 @@ if (!existsSync(modelPath))
 setLogLevel(0);
 
 const SAMPLE_RATE = Number(process.env.SAMPLE_RATE || 16_000);
-let GRAMMAR = ["[unk]"]; // seed; always keep [unk]
+let GRAMMAR = [UNKNOWN_TOKEN]; // seed; always keep [unk]
+let COMMANDS = [];
 
 const model = new Model(modelPath);
-let rec = new Recognizer({ model, sampleRate: SAMPLE_RATE, grammar: GRAMMAR });
-rec.setWords(true);
+const buildRecognizer = () => {
+	const recognizer = MATCH_SENTENCE
+		? new Recognizer({ model, sampleRate: SAMPLE_RATE })
+		: new Recognizer({ model, sampleRate: SAMPLE_RATE, grammar: GRAMMAR });
+	recognizer.setWords(true);
+	return recognizer;
+};
+let rec = buildRecognizer();
 
 /* ------------------------------------------------------------------ */
 /* 4. Start the microphone                                            */
 /* ------------------------------------------------------------------ */
 const recArgs = { sampleRate: SAMPLE_RATE, threshold: 0, binPath: soxPath };
+// Feed raw PCM to Vosk for consistent parsing across platforms
+recArgs.audioType = "raw";
+recArgs.channels = 1;
 
 // Set device based on platform and configuration
 if (audioDevice !== null) {
 	// User specified a device explicitly
 	recArgs.device = audioDevice;
-	console.error(`Using audio device: ${audioDevice}`);
+	console.error(`Using audio device: ${audioDevice || "default"}`);
 } else if (process.platform === "win32") {
-	// Windows: default to device 0 if not specified
-	recArgs.device = "0";
-	console.error("Using default Windows audio device: 0");
+	// Windows: use default alias for reliability
+	recArgs.device = "default";
+	console.error("Using default Windows audio device: default");
 	console.error(
 		"To specify a different device, use: AUDIO_DEVICE=<device_id> or pass as 3rd argument"
 	);
@@ -91,8 +144,36 @@ mic.on("error", (err) => {
 // Define a confidence threshold for individual words.
 // You might need to adjust this value based on your specific use case.
 let WORD_CONFIDENCE_THRESHOLD = 0.7;
+const DEBUG_AUDIO = ["1", "true", "yes"].includes(
+	(process.env.WAKEWORD_DEBUG || "").toLowerCase()
+);
+const LOG_PARTIAL =
+	DEBUG_AUDIO ||
+	["1", "true", "yes"].includes(
+		(process.env.WAKEWORD_LOG_PARTIAL || "").toLowerCase()
+	);
+let lastLevelLog = 0;
+
+function logAudioLevel(buf) {
+	const now = Date.now();
+	if (now - lastLevelLog < 1000) return;
+	lastLevelLog = now;
+
+	// Expect 16-bit little-endian PCM
+	const samples = buf.length / 2;
+	if (!samples) return;
+	let sumSquares = 0;
+	for (let i = 0; i < buf.length; i += 2) {
+		const sample = buf.readInt16LE(i);
+		sumSquares += sample * sample;
+	}
+	const rms = Math.sqrt(sumSquares / samples);
+	console.error(`[wakeword] audio rms=${rms.toFixed(1)} (0-32768)`);
+}
 
 mic.on("data", (buf) => {
+	if (DEBUG_AUDIO) logAudioLevel(buf);
+
 	if (rec.acceptWaveform(buf)) {
 		const fullResult = rec.result();
 
@@ -126,18 +207,39 @@ mic.on("data", (buf) => {
 			// Fallback for cases where setWords(true) might not fully apply or for partial results
 			handle(fullResult.text.trim(), 1.0, fullResult.text); // Assume high confidence if no word-level details
 		}
+	} else if (LOG_PARTIAL) {
+		const partial = rec.partialResult();
+		if (partial?.partial) {
+			console.error(`[wakeword] partial: "${partial.partial}"`);
+		}
 	}
 });
 
 function handle(processedWord, averageConfidence, originalText) {
-	if (!processedWord) return;
+	if (!processedWord && !originalText) return;
+
+	const normalizedProcessed = normalizePhrase(processedWord);
+	const normalizedOriginal = normalizePhrase(originalText);
+	const matches = new Set();
+
+	const findMatches = (text) => {
+		if (!text || text.includes(UNKNOWN_TOKEN)) return;
+		const hits = MATCH_SENTENCE
+			? COMMANDS.filter((command) => text.includes(command))
+			: COMMANDS.filter((command) => text === command);
+		hits.forEach((hit) => matches.add(hit));
+	};
 
-	if (processedWord.includes("[unk]")) return;
+	// Try the filtered text first, then fall back to the raw sentence for sentence matching
+	findMatches(normalizedProcessed);
+	findMatches(normalizedOriginal);
 
-	if (GRAMMAR.includes(processedWord)) {
-		process.stdout?.write(`voice|${processedWord}\n`);
+	if (!matches.size) return;
+
+	matches.forEach((match) => {
+		process.stdout?.write(`voice|${match}\n`);
 		process.stdout?.write(`confidence|${averageConfidence}\n`);
-	}
+	});
 }
 /* ------------------------------------------------------------------ */
 /* 6. Hot-reload grammar via stdin                                    */
@@ -157,11 +259,15 @@ rl.on("line", (line) => {
 	const phrases = trimmed
 		.split(",")
 		.slice(1)
-		.map((s) => s.trim())
+		.map((s) => normalizePhrase(s))
 		.filter(Boolean);
 
 	if (!phrases.length) return;
 
-	GRAMMAR = [...phrases, "[unk]"];
-	rec = new Recognizer({ model, sampleRate: SAMPLE_RATE, grammar: GRAMMAR });
+	COMMANDS = phrases;
+	GRAMMAR = [...phrases, UNKNOWN_TOKEN];
+	console.error(
+		`[wakeword] grammar updated (${phrases.length}): ${phrases.join(", ")}`
+	);
+	rec = buildRecognizer();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lumiastream/wakeword",
-	"version": "1.1.2",
+	"version": "1.1.5-alpha.1",
 	"type": "module",
 	"main": "lib/index.js",
 	"files": [
@@ -15,6 +15,7 @@
 		"start": "node lib/voice.js"
 	},
 	"dependencies": {
+		"koffi": "^2.8.6",
 		"vosk-koffi": "^1.1.1"
 	}
 }