pi-friday 0.1.0

package/voice.ts

@@ -0,0 +1,400 @@
+/**
+ * Friday Extension - Voice/TTS Module
+ * Everything TTS: speakText, voice queue, voice helpers, and daemon interaction
+ */
+
+import { spawn, type ChildProcess } from "node:child_process";
+import { promisify } from "node:util";
+import { exec as execCb } from "node:child_process";
+const execAsync = promisify(execCb);
+import { join } from "node:path";
+import { writeFileSync, existsSync, rmSync } from "node:fs";
+import type { FridaySettings } from "./settings.js";
+
+export function getVoiceModelPath(settings: FridaySettings): string {
+	return join(
+		process.env.HOME ?? "~",
+		".local/share/piper-voices",
+		settings.voice.model + ".onnx",
+	);
+}
+
+export let currentPiper: ChildProcess | null = null;
+export let currentPlayer: ChildProcess | null = null;
+export let voiceForceKilled = false;
+export const voiceQueue: { text: string; speed?: number }[] = [];
+export let voicePlaying = false;
+
+// Resolve function for the active speakText promise — lets killCurrentVoice
+// instantly resolve it instead of waiting for the 30s safety timer
+let activeSpeakResolve: (() => void) | null = null;
+
+/** Kill any currently playing TTS immediately */
+export function killCurrentVoice() {
+	try {
+		voiceQueue.length = 0;
+		// Only set voiceForceKilled if there are actual processes to kill
+		// Otherwise the stale flag poisons the next speakText cleanup
+		if (currentPlayer || currentPiper) {
+			voiceForceKilled = true;
+			// Destroy stdio streams first so they don't hold the event loop
+			try { currentPiper?.stdout?.destroy(); } catch {}
+			try { currentPiper?.stdin?.destroy(); } catch {}
+			try { currentPlayer?.stdin?.destroy(); } catch {}
+			// SIGKILL for instant death — SIGTERM can leave processes lingering
+			try { currentPlayer?.kill("SIGKILL"); } catch {}
+			try { currentPiper?.kill("SIGKILL"); } catch {}
+		}
+		currentPlayer = null;
+		currentPiper = null;
+		voicePlaying = false;
+		// Immediately resolve any pending speakText promise so nothing hangs
+		if (activeSpeakResolve) {
+			const r = activeSpeakResolve;
+			activeSpeakResolve = null;
+			r();
+		}
+	} catch (e) { 
+		logError("killCurrentVoice", e); 
+	}
+}
+
+/** Kill any orphaned piper/play processes from crashed sessions */
+export async function killOrphanTTS() {
+	try {
+		const { stdout } = await execAsync(
+			"ps aux | grep -E 'piper.*jenny|play.*raw.*22050' | grep -v grep",
+			{ encoding: "utf8", timeout: 5000 },
+		);
+		const result = stdout.trim();
+		if (!result) return;
+		for (const line of result.split("\n")) {
+			const parts = line.trim().split(/\s+/);
+			const pid = parseInt(parts[1]!, 10);
+			if (!pid || isNaN(pid)) continue;
+			try { 
+				process.kill(pid, "SIGTERM"); 
+				log(`Killed orphan TTS process (PID ${pid})`); 
+			} catch {}
+		}
+	} catch { /* no orphans */ }
+}
+
+export function muteDaemon(commsDir: string) {
+	const muteFile = join(commsDir, "tts_playing");
+	try { writeFileSync(muteFile, String(Date.now())); } catch {}
+}
+
+export function tryUnmuteDaemon(commsDir: string) {
+	const muteFile = join(commsDir, "tts_playing");
+	try { if (existsSync(muteFile)) rmSync(muteFile, { force: true }); } catch {}
+}
+
+export function triggerDaemonListen(
+	commsDir: string, 
+	wakeDaemon: ChildProcess | null, 
+	waitForSpeechSec = 5, 
+	maxRecordSec = 10
+) {
+	try {
+		if (!wakeDaemon) return;
+		const listenNowFile = join(commsDir, "listen_now");
+		const payload = JSON.stringify({
+			timestamp: Date.now(),
+			waitForSpeech: waitForSpeechSec,
+			maxRecord: maxRecordSec,
+		});
+		writeFileSync(listenNowFile, payload);
+	} catch (e) { 
+		logError("triggerDaemonListen", e); 
+	}
+}
+
+export function estimateReadingTimeSec(text: string): number {
+	try { return text.trim().split(/\s+/).length / 3.5; } catch { return 2; }
+}
+
+export function isQuestion(text: string): boolean {
+	try {
+		const trimmed = text.trim();
+		if (trimmed.endsWith("?")) return true;
+		const questionPatterns = /\b(what do you think|which do you prefer|want me to|should I|shall I|sound good|ready to|let me know|your call|up to you)\b/i;
+		return questionPatterns.test(trimmed);
+	} catch { return false; }
+}
+
+export function estimateQuestionTiming(question: string): { waitSec: number; maxRecordSec: number } {
+	try {
+		const q = question.trim().toLowerCase();
+		const yesNo = /\b(is it|are you|do you|did you|will you|can you|have you|was it|were you|is that|does it|right\??|correct\??|ready\??|sure\??)\b/i;
+		const choiceAB = /\b(or )\b/i;
+		const oneWord = /\b(what color|what colour|what is the capital|what year|how many|how old|what number|which one|what day|what month)\b/i;
+
+		if (yesNo.test(q)) return { waitSec: 4, maxRecordSec: 5 };
+		if (choiceAB.test(q) || oneWord.test(q)) return { waitSec: 5, maxRecordSec: 6 };
+
+		const shortFactual = /^(what|who|where|when|which)\b/i;
+		if (shortFactual.test(q)) return { waitSec: 5, maxRecordSec: 8 };
+
+		const openEnded = /^(how|why|explain|describe|tell me about|what do you think)\b/i;
+		if (openEnded.test(q)) return { waitSec: 6, maxRecordSec: 15 };
+	} catch {}
+	return { waitSec: 5, maxRecordSec: 10 };
+}
+
+let voiceMessageCount = 0;
+
+export function deriveVoiceText(message: string, voiceSummary?: string): string {
+	voiceMessageCount++;
+	if (voiceSummary) return voiceSummary;
+
+	const plain = message.replace(/[\n\r]+/g, " ").trim();
+	if (plain.length <= 200) return plain;
+
+	const sentences = plain.match(/[^.!?]+[.!?]+/g) ?? [plain];
+	let spoken = "";
+	for (const s of sentences) {
+		if (spoken.length + s.length > 200 && spoken.length > 0) break;
+		spoken += s;
+	}
+
+	const PANEL_PHRASES = [
+		`Full details in the panel.`,
+		`More in the panel if you need it.`,
+		`Rest is on screen.`,
+		`Details on your screen.`,
+	];
+
+	const nudge = voiceMessageCount === 1 ? 
+		` ${PANEL_PHRASES[Math.floor(Math.random() * PANEL_PHRASES.length)]!}` : "";
+	return `${spoken.trim()}${nudge}`;
+}
+
+/** Speaks text via piper TTS. Fully hardened — never throws, always resolves. */
+export function speakText(
+	text: string,
+	settings: FridaySettings,
+	commsDir: string,
+	wakeDaemon: ChildProcess | null,
+	lastFullMessageText: string,
+	lastSpokenText: string,
+	lastMessageWasQuestion: boolean,
+	log: (msg: string) => void,
+	logError: (context: string, err: unknown) => void,
+	onPlaybackStart?: () => void, 
+	speed?: number
+): Promise<void> {
+	return new Promise((resolve) => {
+		try {
+			// Kill any active playback first — never two voices at once
+			if (currentPlayer || currentPiper) {
+				try { currentPlayer?.kill(); } catch {}
+				try { currentPiper?.kill(); } catch {}
+				currentPlayer = null;
+				currentPiper = null;
+			}
+
+			// Register resolve so killCurrentVoice can settle this promise instantly
+			activeSpeakResolve = resolve;
+
+			const modelPath = getVoiceModelPath(settings);
+			const effectiveSpeed = speed ?? 1.0;
+			const lengthScale = String(1.0 / effectiveSpeed);
+
+			muteDaemon(commsDir);
+
+			const piper = spawn(
+				"piper",
+				["--model", modelPath, "--output-raw", "--length-scale", lengthScale],
+				{ stdio: ["pipe", "pipe", "ignore"] },
+			);
+
+			const player = spawn(
+				"play",
+				["-q", "-t", "raw", "-r", "22050", "-e", "signed", "-b", "16", "-c", "1", "-"],
+				{ stdio: ["pipe", "ignore", "ignore"] },
+			);
+
+			// Unref so these processes don't keep the event loop alive on shutdown
+			piper.unref();
+			player.unref();
+
+			currentPiper = piper;
+			currentPlayer = player;
+
+			// CRITICAL: handle 'error' events on stdin streams to prevent
+			// unhandled EPIPE crashes when processes die mid-stream
+			piper.stdin.on("error", (e) => logError("piper.stdin", e));
+			player.stdin.on("error", (e) => logError("player.stdin", e));
+
+			let started = false;
+			let resolved = false;
+			const safeResolve = () => {
+				if (!resolved) {
+					resolved = true;
+					if (activeSpeakResolve === resolve) activeSpeakResolve = null;
+					resolve();
+				}
+			};
+
+			piper.stdout.on("data", (chunk: Buffer) => {
+				try {
+					if (!started) {
+						started = true;
+						try { onPlaybackStart?.(); } catch (e) { logError("onPlaybackStart", e); }
+					}
+					player.stdin.write(chunk);
+				} catch {}
+			});
+			piper.stdout.on("end", () => {
+				try { player.stdin.end(); } catch {}
+			});
+
+			try { piper.stdin.write(text); piper.stdin.end(); } catch (e) { logError("piper.stdin.write", e); }
+
+			const cleanup = () => {
+				try {
+					// Only null refs if they still point to OUR processes
+					if (currentPiper === piper) currentPiper = null;
+					if (currentPlayer === player) currentPlayer = null;
+
+					// If force-killed, skip all daemon interaction
+					if (voiceForceKilled) {
+						voiceForceKilled = false;
+						safeResolve();
+						return;
+					}
+
+					// Natural end — unmute daemon and maybe auto-listen
+					// CRITICAL FIX: Add .unref() to background timer
+					setTimeout(() => {
+						try {
+							tryUnmuteDaemon(commsDir);
+							if (wakeDaemon && isQuestion(text)) {
+								lastMessageWasQuestion = true;
+								const fullReadTime = estimateReadingTimeSec(lastFullMessageText);
+								const spokenTime = estimateReadingTimeSec(lastSpokenText);
+								const extraReadMs = Math.max(0, (fullReadTime - spokenTime)) * 1000;
+								const baseDelayMs = 500;
+								const totalDelay = baseDelayMs + extraReadMs;
+								const timing = estimateQuestionTiming(text);
+								// CRITICAL FIX: Add .unref() to background timer
+								setTimeout(() => {
+									try { triggerDaemonListen(commsDir, wakeDaemon, timing.waitSec, timing.maxRecordSec); }
+									catch (e) { logError("triggerDaemonListen.timer", e); }
+								}, totalDelay).unref();
+							} else {
+								lastMessageWasQuestion = false;
+							}
+						} catch (e) { logError("speakText.cleanup.timer", e); }
+					}, 500).unref();
+				} catch (e) { logError("speakText.cleanup", e); }
+				safeResolve();
+			};
+
+			player.on("close", cleanup);
+			player.on("error", () => { try { cleanup(); } catch {} });
+			piper.on("error", () => { try { player.kill(); } catch {} try { cleanup(); } catch {} });
+
+			// Safety net — 5s is plenty, the old 30s was causing /reload to hang
+			setTimeout(() => safeResolve(), 5000).unref();
+		} catch (e) {
+			logError("speakText", e);
+			resolve(); // always resolve — never leave a dangling promise
+		}
+	});
+}
+
+export function enqueueVoiceWithMessage(
+	text: string, 
+	log: (msg: string) => void,
+	logError: (context: string, err: unknown) => void,
+	speed?: number
+) {
+	try {
+		// Kill anything currently playing — never allow two voices at once
+		if (voicePlaying || currentPlayer || currentPiper) {
+			killCurrentVoice();
+		}
+		voiceQueue.push({ text, speed });
+		if (!voicePlaying) {
+			// processVoiceQueueSynced will be called by the main module
+		}
+	} catch (e) { 
+		logError("enqueueVoice", e); 
+	}
+}
+
+export function processVoiceQueueSynced(
+	ensurePanelOpen: () => Promise<boolean>,
+	writeMessage: (text: string) => void,
+	settings: FridaySettings,
+	commsDir: string,
+	wakeDaemon: ChildProcess | null,
+	lastFullMessageText: string,
+	lastSpokenText: string,
+	lastMessageWasQuestion: boolean,
+	log: (msg: string) => void,
+	logError: (context: string, err: unknown) => void,
+): void {
+	try {
+		if (voiceQueue.length === 0) {
+			voicePlaying = false;
+			return;
+		}
+		voicePlaying = true;
+		const item = voiceQueue.shift()!;
+		ensurePanelOpen().then((ok) => {
+			speakText(
+				item.text, 
+				settings, 
+				commsDir, 
+				wakeDaemon, 
+				lastFullMessageText, 
+				lastSpokenText, 
+				lastMessageWasQuestion, 
+				log, 
+				logError,
+				() => {
+					try { if (ok) writeMessage(item.text); } catch (e) { logError("voiceQueue.writeMessage", e); }
+				}, 
+				item.speed
+			).finally(() => {
+				try { 
+					processVoiceQueueSynced(
+						ensurePanelOpen, 
+						writeMessage, 
+						settings, 
+						commsDir, 
+						wakeDaemon, 
+						lastFullMessageText, 
+						lastSpokenText, 
+						lastMessageWasQuestion, 
+						log, 
+						logError
+					); 
+				} catch (e) { 
+					logError("voiceQueue.next", e); 
+				}
+			});
+		}).catch((e) => {
+			logError("voiceQueue.ensurePanel", e);
+			voicePlaying = false;
+		});
+	} catch (e) {
+		logError("processVoiceQueueSynced", e);
+		voicePlaying = false;
+	}
+}
+
+// Helper functions that need to be exported for other modules to use
+let log: (msg: string) => void = () => {};
+let logError: (context: string, err: unknown) => void = () => {};
+
+export function setLogFunctions(
+	logFn: (msg: string) => void, 
+	logErrorFn: (context: string, err: unknown) => void
+) {
+	log = logFn;
+	logError = logErrorFn;
+}