@lumiastream/wakeword 1.1.1 → 1.1.4

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

@@ -1,53 +1,73 @@
 export default (options) => {
-	let cmd = "sox";
-
-	if (options.binPath) {
-		cmd = options.binPath;
-	}
-
-	let args = [
-		"--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) {
-		args.unshift("-t", "waveaudio", options.device);
-		spawnOptions.env = { ...process.env, AUDIODEV: options.device };
-	} else {
-		args.unshift("--default-device");
-	}
-
-	return { cmd, args, spawnOptions };
+  let cmd = "sox";
+
+  if (options.binPath) {
+    cmd = options.binPath;
+  }
+
+  // Build common output/encoding args
+  let args = [
+    "--no-show-progress",
+    "--rate",
+    options.sampleRate,
+    "--channels",
+    options.channels,
+    "--encoding",
+    "signed-integer",
+    "--bits",
+    "16",
+    "--type",
+    options.audioType,
+    "-", // write to stdout
+  ];
+
+  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 = {};
+
+  // Prepend input spec based on platform
+  const platform = process.platform;
+  if (platform === "win32") {
+    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 };
+  } else if (platform === "darwin") {
+    // CoreAudio input
+    if (options.device) {
+      args.unshift("-t", "coreaudio", options.device);
+    } else {
+      // Explicitly select CoreAudio default device for reliability
+      args.unshift("-t", "coreaudio", "default");
+    }
+  } else {
+    // Linux: ALSA default or specified
+    if (options.device) {
+      args.unshift("-t", "alsa", options.device);
+    } else {
+      args.unshift("-d");
+    }
+  }
+
+  return { cmd, args, spawnOptions };
 };

package/lib/voice.js

@@ -16,12 +16,26 @@ 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 envExeOverride =
+	process.platform === "win32" && process.env.LUMIA_WIN_MIC_ALIAS_NAME
+		? process.env.LUMIA_WIN_MIC_ALIAS_NAME.trim()
+		: null;
+const exeName =
+	envExeOverride && envExeOverride.length ? envExeOverride : 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 +46,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,35 +77,81 @@ 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");
-	console.error("To specify a different device, use: AUDIO_DEVICE=<device_id> or pass as 3rd argument");
+	// 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"
+	);
 }
 
 const mic = record.record(recArgs).stream();
+// Handle recorder (SoX) errors to avoid unhandled 'error' events
+mic.on("error", (err) => {
+	const msg = typeof err === "string" ? err : err?.message || String(err);
+	console.error(`[wakeword] audio stream error: ${msg}`);
+	process.exit(2);
+});
 // 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();
 
@@ -118,18 +185,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                                    */
@@ -149,11 +237,15 @@ rl.on("line", (line) => {
 	const phrases = trimmed
 		.split(",")
 		.slice(1)
-		.map((s) => s.trim())
-		.filter(Boolean);
+		.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.1",
+	"version": "1.1.4",
 	"type": "module",
 	"main": "lib/index.js",
 	"files": [