Adom TTS: Text to Speech

@@ -4,24 +4,78 @@   "slug": "adom-tts",   "title": "adom-tts — your AI's voice",   "brief": "Adom's shared voice service. Reads your AI's answers back to you while you drive, and renders perfectly-timed voiceover tracks for your demo videos — so you never record your own voice.",-  "version": "1.7.0",+  "version": "1.8.0",   "license": "MIT",-  "tags": ["tts", "voice", "audio", "demo", "accessibility", "open-source", "mit"],+  "tags": [+    "tts",+    "voice",+    "audio",+    "demo",+    "accessibility",+    "cli",+    "open-source",+    "mit"+  ],   "hero": {     "type": "image",     "path": "screenshots/hero-v2.png",     "thumbnail": "screenshots/hero-v2-thumb.png"   },   "discovery_pitch": "Hands-free in the car? Say 'read me your last answer, I'm driving' and adom-tts speaks it aloud. Making a demo video? Feed it your script and get a perfectly-timed narration track in the house voice — no recording booth, no retakes. One shared edge-tts service with Adom pronunciation overrides and an instant source-hash cache.",-  "discovery_triggers": ["adom-tts", "text to speech", "tts", "voiceover", "demo narration", "narration", "synthesize speech", "make audio from text", "read it to me", "read me your answer", "read that back", "read me the last prompt", "I'm driving", "hands-free", "drive mode", "narrate the answer", "play this audio"],+  "discovery_triggers": [+    "adom-tts",+    "text to speech",+    "tts",+    "voiceover",+    "demo narration",+    "narration",+    "synthesize speech",+    "make audio from text",+    "read it to me",+    "read me your answer",+    "read that back",+    "read me the last prompt",+    "I'm driving",+    "hands-free",+    "drive mode",+    "narrate the answer",+    "play this audio"+  ],   "sample_prompts": [-    { "label": "Drive mode", "prompt": "Read me your last answer, I'm driving" },-    { "label": "Demo voiceover", "prompt": "Render this script as a demo voiceover track" },-    { "label": "Synthesize and play", "prompt": "Synthesize a 30-second walkthrough of this design and play it for me" },-    { "label": "Replay last", "prompt": "Play the last TTS clip again" },-    { "label": "Add pronunciation", "prompt": "Teach the TTS service that aci is pronounced A-C-I" }+    {+      "label": "Drive mode",+      "prompt": "Read me your last answer, I'm driving"+    },+    {+      "label": "Demo voiceover",+      "prompt": "Render this script as a demo voiceover track"+    },+    {+      "label": "Synthesize and play",+      "prompt": "Synthesize a 30-second walkthrough of this design and play it for me"+    },+    {+      "label": "Replay last",+      "prompt": "Play the last TTS clip again"+    },+    {+      "label": "Add pronunciation",+      "prompt": "Teach the TTS service that aci is pronounced A-C-I"+    }   ],   "install": {     "binary_name": "adom-tts"+  },+  "description": "Adom's shared text-to-speech CLI + Playground. Reads your AI answers back to you while driving, and renders perfectly-timed voiceover tracks for demo videos.",+  "dependencies": {},+  "scripts": {+    "install": "./install.sh",+    "uninstall": "./uninstall.sh"+  },+  "needs_sudo": false,+  "org": "adom",+  "author": {+    "name": "John Lauer",+    "email": "[email protected]"   }-}+}\ No newline at end of file

@@ -150,6 +150,119 @@ pub fn show_logs(tail: usize) -> Result<()> { /// Current epoch millis (for callers to stamp a "wait for events after now"). pub fn now_ms() -> u64 { now_millis() as u64 } +/// Show the shared player's live status so any thread can QUERY the queue+/// (is a player active, what's playing, how many clips are waiting and their+/// order). Lets parallel threads coordinate politely instead of guessing.+pub fn show_status() -> Result<()> {+    let dir = tts_home()?.join(QUEUE_SUBDIR);+    let mut entries: Vec<PathBuf> = std::fs::read_dir(&dir).into_iter().flatten()+        .filter_map(|e| e.ok()).map(|e| e.path())+        .filter(|p| p.extension().and_then(|x| x.to_str()) == Some("json"))+        .collect();+    entries.sort();+    let drainer_alive = drainer_alive();+    // Is the live player's server up, and how far into the current clip?+    let mut playing_line = String::from("  (idle — no clip playing)");+    if let Some(port) = read_player_port() {+        if let Ok(r) = reqwest::blocking::Client::new()+            .get(format!("http://127.0.0.1:{port}/state"))+            .timeout(Duration::from_millis(600)).send() {+            if let Ok(v) = r.json::<serde_json::Value>() {+                let dur = v.get("dur_ms").and_then(|x| x.as_f64()).unwrap_or(0.0) / 1000.0;+                let reached = v.get("last_ms").and_then(|x| x.as_f64()).unwrap_or(0.0) / 1000.0;+                playing_line = format!("  ▶ now playing on :{port} — {reached:.0}s / {dur:.0}s");+            }+        }+    }+    println!("=== adom-tts shared player status ===");+    println!("  player/drainer: {}", if drainer_alive { "ACTIVE" } else { "idle (next clip will start one)" });+    println!("{playing_line}");+    println!("  queue: {} clip(s)", entries.len());+    for (i, e) in entries.iter().enumerate() {+        let (mp3, label) = std::fs::read_to_string(e).ok()+            .and_then(|r| serde_json::from_str::<serde_json::Value>(&r).ok())+            .and_then(|v| v.get("mp3").and_then(|m| m.as_str()).map(|m| {+                let p = PathBuf::from(m);+                let base = p.file_name().and_then(|s| s.to_str()).unwrap_or("clip").to_string();+                (base, sidecar_label(&p))+            })).unwrap_or_else(|| ("?".into(), String::new()));+        let who = if label.is_empty() { String::new() } else { format!("  [{label}]") };+        let tag = if i == 0 { "playing/next" } else { &format!("waiting #{i}") };+        println!("  {}. {mp3}{who}  ({tag})", i + 1);+    }+    if !entries.is_empty() {+        println!("# hint: clips play oldest-first in one shared player. Your `say --play` already appended to");+        println!("#       this queue and returned immediately — you don't block others. Poll `adom-tts status`");+        println!("#       to watch it drain, or `adom-tts say ... --play --confirm` to block until YOURS plays.");+    }+    Ok(())+}++/// Non-blocking per-clip query: "did MY clip play?" A thread that fired+/// `say --play` (which returns immediately) calls this later to learn whether+/// its clip is still queued, playing, played-ok, or failed — WITHOUT blocking+/// the way `--confirm` does. Prints a verdict + a next-step hint and, on a+/// confirmed failure, exits non-zero so scripts/agents can branch on it.+pub fn check_clip(clip: &str) -> Result<()> {+    // Latest recorded outcome for this clip from the event log.+    let path = tts_home()?.join(".adom/tts/events.jsonl");+    let raw = std::fs::read_to_string(&path).unwrap_or_default();+    let (mut end_verdict, mut started) = (None::<String>, false);+    for l in raw.lines() {+        let Ok(v) = serde_json::from_str::<serde_json::Value>(l) else { continue };+        if v.get("clip").and_then(|x| x.as_str()) != Some(clip) { continue; }+        match v.get("kind").and_then(|x| x.as_str()) {+            Some("clip_end") => end_verdict = Some(v.get("verdict").and_then(|x| x.as_str()).unwrap_or("?").to_string()),+            Some("clip_start") => started = true,+            _ => {}+        }+    }+    // Is it still in the shared queue (and where)?+    let dir = tts_home()?.join(QUEUE_SUBDIR);+    let mut entries: Vec<PathBuf> = std::fs::read_dir(&dir).into_iter().flatten()+        .filter_map(|e| e.ok()).map(|e| e.path())+        .filter(|p| p.extension().and_then(|x| x.to_str()) == Some("json")).collect();+    entries.sort();+    let pos = entries.iter().position(|e| std::fs::read_to_string(e).ok()+        .and_then(|r| serde_json::from_str::<serde_json::Value>(&r).ok())+        .and_then(|v| v.get("mp3").and_then(|m| m.as_str())+            .and_then(|m| PathBuf::from(m).file_name().and_then(|s| s.to_str()).map(str::to_string)))+        == Some(clip.to_string()));++    if let Some(p) = pos {+        if p == 0 {+            println!("▶ PLAYING — \"{clip}\" is at the front of the shared player now.");+        } else {+            println!("… QUEUED — \"{clip}\" has {p} clip(s) ahead of it in the shared player.");+        }+        println!("# hint: not done yet. Poll `adom-tts check {clip}` again, or next time pass `--confirm`");+        println!("#       to BLOCK until it plays. Do NOT tell the human it played until this says PLAYED.");+        return Ok(());+    }+    match end_verdict.as_deref() {+        Some("ok") => {+            println!("✓ PLAYED — \"{clip}\" played fully to the human. Safe to tell them you spoke it.");+            Ok(())+        }+        Some(v) => {+            println!("✗ FAILED — \"{clip}\" did NOT fully play (verdict={v}).");+            println!("# hint: do NOT tell the human it played. Re-queue it, or run `adom-tts logs` to see where");+            println!("#       playback died. NEVER install a local TTS fallback — report the outage instead.");+            std::process::exit(5);+        }+        None if started => {+            println!("▶ PLAYING — \"{clip}\" has started but no completion is logged yet.");+            println!("# hint: poll `adom-tts check {clip}` again in a few seconds.");+            Ok(())+        }+        None => {+            println!("? UNKNOWN — no record of \"{clip}\". Did you `say --play` it? The name must match --out.");+            println!("# hint: run `adom-tts status` to see the live queue, or `adom-tts logs` for recent events.");+            std::process::exit(5);+        }+    }+}+ /// Block until the shared player logs that THIS clip actually played to the /// human (a `clip_end` event for `clip` stamped at/after `since_ms`), then /// report the verdict. This is the GUARANTEE: `say --play` only *queues* a clip@@ -204,13 +317,21 @@ fn enqueue(mp3: &Path) -> Result<()> {     let depth = std::fs::read_dir(&dir).map(|rd| rd.filter_map(|e| e.ok())         .filter(|e| e.path().extension().and_then(|x| x.to_str()) == Some("json")).count()).unwrap_or(1);     log_event("enqueue", serde_json::json!({ "mp3": abs.to_string_lossy(), "depth": depth }));+    let clip = mp3.file_name().and_then(|s| s.to_str()).unwrap_or("clip");     if std::env::var("ADOM_TTS_NO_HINTS").is_err() {+        // Broker-style acknowledgement: tell the calling thread exactly where+        // its clip landed and how to find out when it actually played.         if depth > 1 {-            eprintln!("# queued behind {} clip(s) — one shared player plays them in order, no overlap", depth - 1);+            eprintln!("# ACCEPTED \"{clip}\" — position {} in the shared player ({} ahead). One player plays", depth, depth - 1);+            eprintln!("#          all threads' clips in order, no overlap; your call returned without blocking others.");+        } else {+            eprintln!("# ACCEPTED \"{clip}\" — next up in the shared player.");         }-        eprintln!("# hint: clips from ALL your Claude threads share this one player. START your narration by");-        eprintln!("#       saying which thread you are (e.g. \"This is the <thread name> thread —\") so the");-        eprintln!("#       listener knows who's speaking. Tag it with `--thread \"<name>\"` to label the player too.");+        eprintln!("# to KNOW it played: `adom-tts check {clip}` (non-blocking: QUEUED/PLAYING/PLAYED/FAILED), or");+        eprintln!("#   `adom-tts status` (whole queue), or re-run `say ... --play --confirm` to BLOCK until done.");+        eprintln!("#   Do NOT tell the human you spoke it until check says PLAYED / --confirm says CONFIRMED.");+        eprintln!("# etiquette: clips from ALL Claude threads share this one player — START your narration with");+        eprintln!("#   which thread you are (or pass `--thread \"<name>\"`) so the listener knows who's speaking.");     }     Ok(()) }