Add utility scripts: voice tools, chunking, batch generation, space restart

README.md

@@ -24,6 +24,36 @@ FastAPI server running [kyutai/pocket-tts](https://huggingface.co/kyutai/pocket-
 | `GET /voices` | List all available voices |
 | `GET /health` | Health check |
 
+## Scripts
+
+Utility scripts for generating audio, available in `scripts/`:
+
+| Script | Purpose |
+|---|---|
+| `voice.py` | One-shot TTS: `python3 voice.py "text" [voice] [format]` or `--file input.txt` |
+| `voice.sh` | Shell wrapper for voice.py |
+| `voice-from-file.py` | Read text from file and generate TTS |
+| `voice-chunked.py` | Split long text and generate in sequence |
+| `voice-long.sh` | Shell script for long text with ffmpeg concat |
+| `chunk_giselle.py` | Split `giselle_60min.txt` into ~10K char chunks on paragraph boundaries |
+| `batch_tts.py` | Full batch generator with auto-restart on failure and ffmpeg concat |
+| `giselle_batch.sh` | Shell batch equivalent for Giselle story generation |
+| `run_giselle_batch.sh` | Sequential batch runner with retry logic |
+| `restart_space.py` | Restart the HF Space via API (requires token) |
+
+**Usage:**
+```bash
+# Quick one-shot
+python3 scripts/voice.py "Hello world" af_alloy ogg
+
+# From file
+python3 scripts/voice.py --file story.txt scarlett_johansson ogg
+
+# Chunk a long story and generate
+python3 scripts/chunk_giselle.py
+python3 scripts/run_giselle_batch.sh
+```
+
 ## Voices (78 total)
 
 ### Standard voices (from [Nymbo/Pocket-TTS](https://huggingface.co/spaces/Nymbo/Pocket-TTS))

scripts/batch_tts.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""Batch TTS generator with auto-restart on failure."""
+import subprocess, time, os, sys, glob
+
+TOKEN = os.environ.get("HF_TOKEN", "")
+CHUNK_DIR = "/tmp/tts/smchunks"
+OUT_DIR = "/tmp/tts/smout"
+VOICE = "scarlett_johansson"
+FMT = "ogg"
+SCRIPT = "/home/runner/.openclaw/workspace/scripts/voice.py"
+RESTART_SCRIPT = "/home/runner/.openclaw/workspace/scripts/restart_space.py"
+
+os.makedirs(OUT_DIR, exist_ok=True)
+
+def restart_space():
+    print("Restarting space...")
+    subprocess.run(["python3", RESTART_SCRIPT], env={**os.environ, "HF_TOKEN": TOKEN}, capture_output=True)
+    print("Waiting 95s for startup...")
+    time.sleep(95)
+    # Quick test
+    r = subprocess.run(
+        ["curl", "-s", "-o", "/dev/null", "-w", "%{http_code}",
+         "--max-time", "60", "https://hf4uwho-pocket-tts.hf.space/tts?text=x&voice=af_alloy&format=ogg"],
+        capture_output=True, text=True, timeout=70
+    )
+    ok = r.stdout.strip() == "200"
+    print(f"Space test: {'OK' if ok else 'FAIL'}")
+    return ok
+
+def generate_chunk(idx):
+    chunk_file = f"{CHUNK_DIR}/{idx:02d}"
+    outfile = f"{OUT_DIR}/chunk_{idx:02d}.{FMT}"
+    if os.path.exists(outfile) and os.path.getsize(outfile) > 1000:
+        print(f"  Chunk {idx:02d} already exists, skipping")
+        return True
+    print(f"  Generating chunk {idx:02d}...", end=" ", flush=True)
+    r = subprocess.run(
+        ["python3", SCRIPT, "--file", chunk_file, VOICE, FMT],
+        capture_output=True, text=True, timeout=600
+    )
+    # Find the output file
+    if r.returncode == 0 and r.stdout.strip():
+        gen_file = r.stdout.strip()
+        if os.path.exists(gen_file) and os.path.getsize(gen_file) > 1000:
+            os.rename(gen_file, outfile)
+            sz = os.path.getsize(outfile)
+            print(f"OK ({sz} bytes)")
+            return True
+    print(f"FAIL (exit={r.returncode})")
+    return False
+
+# Get all chunk files
+chunk_files = sorted(glob.glob(f"{CHUNK_DIR}/[0-9][0-9]"))
+total = len(chunk_files)
+print(f"Total chunks: {total}")
+
+# Restart space first
+if not restart_space():
+    print("Space not responding after restart, retrying...")
+    if not restart_space():
+        print("FATAL: Space won't start")
+        sys.exit(1)
+
+failures_in_a_row = 0
+i = 0
+
+while i < total:
+    idx = int(os.path.basename(chunk_files[i]))
+    success = generate_chunk(idx)
+    
+    if success:
+        failures_in_a_row = 0
+        i += 1
+    else:
+        failures_in_a_row += 1
+        if failures_in_a_row >= 2:
+            print(f"  {failures_in_a_row} failures, restarting space...")
+            if not restart_space():
+                print("Space won't restart, waiting 120s and retrying...")
+                time.sleep(120)
+                if not restart_space():
+                    print("FATAL: Space won't restart")
+                    sys.exit(1)
+            failures_in_a_row = 0
+        else:
+            print("  Single failure, waiting 30s and retrying chunk...")
+            time.sleep(30)
+
+print(f"\nAll {total} chunks generated!")
+
+# Concatenate
+ffmpeg_path = "/tmp/ffmpeg-master-latest-linux64-gpl/bin/ffmpeg"
+concat_list = f"{OUT_DIR}/concat.txt"
+with open(concat_list, 'w') as f:
+    for j in range(total):
+        chunk_path = f"{OUT_DIR}/chunk_{j:02d}.{FMT}"
+        if os.path.exists(chunk_path):
+            f.write(f"file '{chunk_path}'\n")
+
+final = f"{OUT_DIR}/giselle_60min_full.ogg"
+r = subprocess.run(
+    [ffmpeg_path, "-y", "-f", "concat", "-safe", "0", "-i", concat_list, "-c", "copy", final],
+    capture_output=True, text=True, timeout=60
+)
+if r.returncode == 0:
+    sz = os.path.getsize(final)
+    # Get duration
+    r2 = subprocess.run(
+        [ffmpeg_path.replace("ffmpeg", "ffprobe"), "-v", "quiet", "-show_entries", "format=duration", "-of", "csv=p=0", final],
+        capture_output=True, text=True, timeout=10
+    )
+    dur = float(r2.stdout.strip()) if r2.stdout.strip() else 0
+    print(f"FINAL: {final}")
+    print(f"SIZE: {sz} bytes")
+    print(f"DURATION: {dur/60:.1f} minutes")
+else:
+    print(f"Concat failed: {r.stderr[:500]}")

scripts/chunk_giselle.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Split giselle_60min.txt into ~10K-12K char chunks on paragraph boundaries."""
+import os
+
+SRC = "/home/runner/.openclaw/workspace/scripts/giselle_60min.txt"
+OUTDIR = "/tmp/tts_chunks"
+os.makedirs(OUTDIR, exist_ok=True)
+
+with open(SRC) as f:
+    text = f.read()
+
+# Split on paragraph breaks (double newlines or scene breaks)
+# Each paragraph is a block
+paragraphs = []
+for block in text.split("\n\n"):
+    block = block.strip()
+    if block:
+        paragraphs.append(block)
+
+# Greedy chunking: accumulate paragraphs until we hit ~10K chars
+chunks = []
+current = []
+current_size = 0
+TARGET = 10000  # ~10K per chunk
+
+for p in paragraphs:
+    if current_size + len(p) > TARGET and current:
+        chunks.append("\n\n".join(current))
+        current = [p]
+        current_size = len(p)
+    else:
+        current.append(p)
+        current_size += len(p)
+
+if current:
+    chunks.append("\n\n".join(current))
+
+# Write chunks
+manifest = []
+for i, chunk in enumerate(chunks):
+    fname = f"chunk_{i:03d}.txt"
+    path = os.path.join(OUTDIR, fname)
+    with open(path, "w") as f:
+        f.write(chunk)
+    sz = len(chunk)
+    manifest.append((fname, sz))
+    print(f"  {fname}: {sz} chars")
+
+total = sum(sz for _, sz in manifest)
+print(f"\nTotal: {len(chunks)} chunks, {total} chars")
+print(f"\nEstimated time: ~{sum(max(5, sz//2000) for _, sz in manifest)} min total")
+
+# Save manifest
+with open(os.path.join(OUTDIR, "manifest.txt"), "w") as f:
+    for fname, sz in manifest:
+        f.write(f"{fname}\t{sz}\n")

scripts/giselle_batch.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+set -e
+export PATH="/tmp/ffmpeg-master-latest-linux64-gpl/bin:$PATH"
+
+WORKSPACE="/home/runner/.openclaw/workspace"
+OUTDIR="/tmp/tts_giselle"
+mkdir -p "$OUTDIR"
+rm -f "$OUTDIR"/*.ogg
+
+# Generate each chunk sequentially
+for i in 00 01 02 03 04 05 06 07 08 09; do
+  chunk="/tmp/giselle_chunk_${i}.txt"
+  echo "=== Starting chunk $i at $(date -u +%H:%M:%S) ==="
+  echo "Chunk file: $chunk ($(wc -c < "$chunk") bytes)"
+  
+  # Read text, generate with voice.py
+  cd "$WORKSPACE"
+  python3 scripts/voice.py "$(cat "$chunk")" scarlett_johansson ogg
+  
+  # Find the newest generated file and move it with chunk index
+  newest=$(ls -t /tmp/tts/voice_*.ogg | head -1)
+  cp "$newest" "$OUTDIR/chunk_${i}.ogg"
+  size=$(stat -c%s "$OUTDIR/chunk_${i}.ogg")
+  echo "=== Finished chunk $i: ${size} bytes at $(date -u +%H:%M:%S) ==="
+  
+  # Small delay between chunks
+  sleep 2
+done
+
+echo "=== All chunks done, creating concat list ==="
+
+# Create ffmpeg concat file
+echo "" > /tmp/giselle_concat.txt
+for i in 00 01 02 03 04 05 06 07 08 09; do
+  echo "file '${OUTDIR}/chunk_${i}.ogg'" >> /tmp/giselle_concat.txt
+done
+
+echo "=== Concatenating ==="
+ffmpeg -y -f concat -safe 0 -i /tmp/giselle_concat.txt -c copy /tmp/giselle_60min_scarjo.ogg 2>&1 | tail -5
+
+echo "=== Final file ==="
+ls -lh /tmp/giselle_60min_scarjo.ogg
+echo "=== DONE ==="

scripts/restart_space.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""Restart a HuggingFace Space via API. Requires HF token with write access.
+Usage: python3 restart_space.py [OWNER/REPO_NAME]
+Default: hf4uwho/Pocket-TTS
+"""
+import sys, os
+from huggingface_hub import HfApi
+
+repo_id = sys.argv[1] if len(sys.argv) > 1 else "hf4uwho/Pocket-TTS"
+token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+
+if not token:
+    # Try reading from default token path
+    token_path = os.path.expanduser("~/.cache/huggingface/token")
+    if os.path.exists(token_path):
+        token = open(token_path).read().strip()
+
+if not token:
+    print("ERROR: No HF token found. Set HF_TOKEN env var or login with `huggingface-cli login`")
+    sys.exit(1)
+
+api = HfApi(token=token)
+try:
+    api.restart_space(repo_id=repo_id)
+    print(f"Space {repo_id} restart initiated")
+except Exception as e:
+    print(f"ERROR restarting space: {e}")
+    sys.exit(1)

scripts/run_giselle_batch.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+set -e
+export PATH="/tmp/ffmpeg-master-latest-linux64-gpl/bin:$PATH"
+WORKSPACE="/home/runner/.openclaw/workspace"
+CHUNK_DIR="/tmp/tts_chunks"
+OUT_DIR="/tmp/tts_giselle"
+mkdir -p "$OUT_DIR"
+VOICE="scarlett_johansson"
+FMT="ogg"
+LOG="$OUT_DIR/batch.log"
+
+echo "=== Batch TTS started at $(date -u +%H:%M:%S) ===" | tee "$LOG"
+
+for chunkfile in $(ls "$CHUNK_DIR"/chunk_*.txt | sort); do
+  idx=$(basename "$chunkfile" .txt | sed 's/chunk_//')
+  outfile="$OUT_DIR/chunk_${idx}.ogg"
+  
+  if [ -f "$outfile" ] && [ $(stat -c%s "$outfile") -gt 1000 ]; then
+    echo "Chunk $idx already exists ($(stat -c%s "$outfile") bytes), skipping" | tee -a "$LOG"
+    continue
+  fi
+  
+  chars=$(wc -c < "$chunkfile")
+  echo "=== Starting chunk $idx at $(date -u +%H:%M:%S) (${chars} chars) ===" | tee -a "$LOG"
+  
+  cd "$WORKSPACE"
+  result=$(python3 scripts/voice.py --file "$chunkfile" "$VOICE" "$FMT" 2>&1)
+  exitcode=$?
+  
+  if [ $exitcode -eq 0 ]; then
+    gen_file=$(echo "$result" | tail -1)
+    if [ -f "$gen_file" ] && [ $(stat -c%s "$gen_file") -gt 1000 ]; then
+      cp "$gen_file" "$outfile"
+      echo "=== Chunk $idx done: $(stat -c%s "$outfile") bytes at $(date -u +%H:%M:%S) ===" | tee -a "$LOG"
+    else
+      echo "=== Chunk $idx FAILED: file missing/small, retrying in 30s ===" | tee -a "$LOG"
+      sleep 30
+      result=$(python3 scripts/voice.py --file "$chunkfile" "$VOICE" "$FMT" 2>&1)
+      if [ $? -eq 0 ]; then
+        gen_file=$(echo "$result" | tail -1)
+        if [ -f "$gen_file" ] && [ $(stat -c%s "$gen_file") -gt 1000 ]; then
+          cp "$gen_file" "$outfile"
+          echo "=== Chunk $idx retry OK: $(stat -c%s "$outfile") bytes ===" | tee -a "$LOG"
+        fi
+      fi
+    fi
+  else
+    echo "=== Chunk $idx FAILED (exit=$exitcode), retrying in 30s ===" | tee -a "$LOG"
+    sleep 30
+    result=$(python3 scripts/voice.py --file "$chunkfile" "$VOICE" "$FMT" 2>&1)
+    if [ $? -eq 0 ]; then
+      gen_file=$(echo "$result" | tail -1)
+      if [ -f "$gen_file" ] && [ $(stat -c%s "$gen_file") -gt 1000 ]; then
+        cp "$gen_file" "$outfile"
+        echo "=== Chunk $idx retry OK: $(stat -c%s "$outfile") bytes ===" | tee -a "$LOG"
+      fi
+    fi
+  fi
+  
+  sleep 2
+done
+
+echo "=== Concatenating at $(date -u +%H:%M:%S) ===" | tee -a "$LOG"
+concat_list="$OUT_DIR/concat.txt"
+> "$concat_list"
+for chunkfile in $(ls "$CHUNK_DIR"/chunk_*.txt | sort); do
+  idx=$(basename "$chunkfile" .txt | sed 's/chunk_//')
+  f="$OUT_DIR/chunk_${idx}.ogg"
+  if [ -f "$f" ]; then
+    echo "file '$f'" >> "$concat_list"
+  fi
+done
+
+ffmpeg -y -f concat -safe 0 -i "$concat_list" -c copy "$OUT_DIR/giselle_60min_scarjo.ogg" 2>/dev/null
+final_size=$(stat -c%s "$OUT_DIR/giselle_60min_scarjo.ogg" 2>/dev/null || echo 0)
+duration=$(ffprobe -v quiet -show_entries format=duration -of csv=p=0 "$OUT_DIR/giselle_60min_scarjo.ogg" 2>/dev/null || echo "unknown")
+echo "=== FINAL: $OUT_DIR/giselle_60min_scarjo.ogg ===" | tee -a "$LOG"
+echo "=== SIZE: ${final_size} bytes ===" | tee -a "$LOG"
+echo "=== DURATION: ${duration}s ===" | tee -a "$LOG"
+echo "=== Batch complete at $(date -u +%H:%M:%S) ===" | tee -a "$LOG"

scripts/voice-chunked.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Chunked TTS with parallel fetching + retry + ffmpeg concat."""
+import sys, urllib.parse, subprocess, os, hashlib, time, re
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+TTS_URL = "https://hf4uwho-pocket-tts.hf.space/tts"
+OUTDIR = "/tmp/tts"
+os.makedirs(OUTDIR, exist_ok=True)
+
+def tts(text, voice, fmt, outfile, timeout=120, retries=2):
+    """Generate TTS for a single chunk with retry."""
+    encoded = urllib.parse.quote(text)
+    url = f"{TTS_URL}?text={encoded}&voice={voice}&format={fmt}"
+    
+    for attempt in range(retries + 1):
+        try:
+            r = subprocess.run(
+                ["curl", "-s", "-o", outfile, "-w", "%{http_code}\n%{time_total}\n%{errormsg}", 
+                 "--max-time", str(timeout), "--connect-timeout", "15", url],
+                capture_output=True, text=True, timeout=timeout+10
+            )
+            lines = r.stdout.strip().split("\n")
+            code = lines[0] if lines else "?"
+            curl_time = lines[1] if len(lines) > 1 else "?"
+            error = lines[2] if len(lines) > 2 else ""
+            
+            if code == "200":
+                mime = subprocess.run(["file", "-b", "--mime-type", outfile], capture_output=True, text=True).stdout.strip()
+                if mime.startswith("audio/") or mime == "application/ogg":
+                    return os.path.getsize(outfile)
+                else:
+                    raise RuntimeError(f"Not audio: {mime}")
+            elif code == "000":
+                if attempt < retries:
+                    time.sleep(2)
+                    continue
+                raise RuntimeError(f"Connection failed: {error[:80]}")
+            else:
+                raise RuntimeError(f"HTTP {code}")
+        except subprocess.TimeoutExpired:
+            if attempt < retries:
+                time.sleep(2)
+                continue
+            raise RuntimeError("Timeout")
+
+def chunk_text(text, max_chars=400):
+    """Split text into chunks at sentence boundaries."""
+    sentences = re.split(r'(?<=[.!?])\s+', text)
+    chunks = []
+    current = ""
+    for s in sentences:
+        if len(current) + len(s) + 1 > max_chars and current:
+            chunks.append(current.strip())
+            current = s
+        else:
+            current = (current + " " + s).strip()
+    if current.strip():
+        chunks.append(current.strip())
+    return chunks
+
+def gen_chunk(i, chunk, voice, fmt, chunkdir, timeout):
+    """Generate a single chunk, returns (i, path, size) or (i, path, None) on fail."""
+    cfile = f"{chunkdir}/c{i:03d}.{fmt}"
+    try:
+        sz = tts(chunk, voice, fmt, cfile, timeout=timeout)
+        return (i, cfile, sz)
+    except Exception as e:
+        return (i, cfile, None)
+
+def main():
+    textfile = sys.argv[1] if len(sys.argv) > 1 else None
+    voice = sys.argv[2] if len(sys.argv) > 2 else "af_alloy"
+    fmt = sys.argv[3] if len(sys.argv) > 3 else "ogg"
+    parallel = int(sys.argv[4]) if len(sys.argv) > 4 else 5  # parallel workers
+
+    if not textfile:
+        print("Usage: voice-chunked.py <textfile> [voice] [format] [parallel]", file=sys.stderr)
+        sys.exit(1)
+
+    with open(textfile, "r") as f:
+        text = f.read().strip()
+
+    chunks = chunk_text(text)
+    print(f"Split {len(text)} chars into {len(chunks)} chunks, {parallel} parallel", file=sys.stderr)
+
+    h = hashlib.md5(f"{textfile}{voice}".encode()).hexdigest()[:12]
+    chunkdir = f"{OUTDIR}/chunks_{h}"
+    os.makedirs(chunkdir, exist_ok=True)
+
+    # Estimate per-chunk timeout: 25s per 400 chars
+    per_chunk_timeout = max(60, int((len(text) / max(len(chunks), 1)) * 25 / 400 * 3))
+    total_start = time.time()
+
+    # Fire all chunks in parallel via ThreadPoolExecutor
+    chunk_files = {}  # i -> path
+    failed = 0
+    done = 0
+    n = len(chunks)
+
+    with ThreadPoolExecutor(max_workers=parallel) as pool:
+        fut_map = {pool.submit(gen_chunk, i, c, voice, fmt, chunkdir, per_chunk_timeout): i 
+                   for i, c in enumerate(chunks)}
+        
+        for fut in as_completed(fut_map):
+            i, path, sz = fut.result()
+            done += 1
+            if sz is not None:
+                chunk_files[i] = path
+                print(f"  [{done}/{n}] ok {i:3d} {sz/1024:.0f}KB", file=sys.stderr, flush=True)
+            else:
+                failed += 1
+                print(f"  [{done}/{n}] FAIL {i:3d}", file=sys.stderr, flush=True)
+
+    if not chunk_files:
+        print("ERROR: No chunks succeeded", file=sys.stderr)
+        sys.exit(1)
+
+    # Retry failed chunks serially (some may work on retry with less contention)
+    if failed > 0:
+        print(f"\nRetrying {failed} failed chunks serially...", file=sys.stderr)
+        for i, c in enumerate(chunks):
+            if i in chunk_files:
+                continue
+            cfile = f"{chunkdir}/c{i:03d}.{fmt}"
+            try:
+                sz = tts(c, voice, fmt, cfile, timeout=per_chunk_timeout*2, retries=3)
+                chunk_files[i] = cfile
+                print(f"  Retry ok {i:3d} {sz/1024:.0f}KB", file=sys.stderr, flush=True)
+                failed -= 1
+            except:
+                print(f"  Retry failed {i:3d}", file=sys.stderr, flush=True)
+
+    if failed > 0:
+        print(f"WARNING: {failed}/{n} chunks permanently failed", file=sys.stderr)
+
+    # Concatenate in order
+    ordered = [chunk_files[i] for i in sorted(chunk_files)]
+    outfile = f"{OUTDIR}/full_{h}.{fmt}"
+    
+    if len(ordered) == 1:
+        import shutil
+        shutil.copy2(ordered[0], outfile)
+    else:
+        concat_file = f"{chunkdir}/concat.txt"
+        with open(concat_file, "w") as f:
+            for cf in ordered:
+                f.write(f"file '{cf}'\n")
+        
+        r = subprocess.run(
+            ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", concat_file, "-c", "copy", outfile],
+            capture_output=True, text=True, timeout=30
+        )
+        if r.returncode != 0:
+            print(f"ffmpeg failed ({r.returncode}), using raw cat", file=sys.stderr)
+            with open(outfile, "wb") as out:
+                for cf in ordered:
+                    with open(cf, "rb") as inp:
+                        out.write(inp.read())
+
+    # Cleanup
+    import shutil
+    shutil.rmtree(chunkdir, ignore_errors=True)
+
+    total = time.time() - total_start
+    sz = os.path.getsize(outfile)
+    print(f"Done: {outfile} ({sz/1024:.0f}KB) in {total:.1f}s", file=sys.stderr)
+    print(outfile)
+
+if __name__ == "__main__":
+    main()

scripts/voice-from-file.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""Generate TTS from a text file. Handles URL encoding properly."""
+import sys, urllib.parse, subprocess, os, hashlib, time
+
+TTS_URL = "https://hf4uwho-pocket-tts.hf.space/tts"
+OUTDIR = "/tmp/tts"
+os.makedirs(OUTDIR, exist_ok=True)
+
+textfile = sys.argv[1] if len(sys.argv) > 1 else None
+voice = sys.argv[2] if len(sys.argv) > 2 else "af_alloy"
+fmt = sys.argv[3] if len(sys.argv) > 3 else "ogg"
+
+if not textfile:
+    print("Usage: voice-from-file.py <textfile> [voice] [format]", file=sys.stderr)
+    sys.exit(1)
+
+with open(textfile, "r") as f:
+    text = f.read().strip()
+
+encoded = urllib.parse.quote(text)
+url = f"{TTS_URL}?text={encoded}&voice={voice}&format={fmt}"
+h = hashlib.md5(f"{textfile}{voice}{time.time()}".encode()).hexdigest()[:12]
+outfile = f"{OUTDIR}/magi_{h}.{fmt}"
+
+print(f"Generating {len(text)} chars...", file=sys.stderr)
+start = time.time()
+
+r = subprocess.run(
+    ["curl", "-s", "-o", outfile, "-w", "%{http_code}\n%{time_total}", "--max-time", "300", url],
+    capture_output=True, text=True, timeout=310
+)
+
+elapsed = time.time() - start
+parts = r.stdout.strip().split("\n")
+code = parts[0] if parts else "?"
+curl_time = parts[1] if len(parts) > 1 else "?"
+
+print(f"HTTP {code} | curl: {curl_time}s | total: {elapsed:.1f}s", file=sys.stderr)
+
+if code != "200":
+    print(f"ERROR: HTTP {code}", file=sys.stderr)
+    if os.path.exists(outfile): os.remove(outfile)
+    sys.exit(1)
+
+sz = os.path.getsize(outfile)
+print(f"Output: {outfile} ({sz} bytes)", file=sys.stderr)
+print(outfile)

scripts/voice-long.sh

@@ -0,0 +1,101 @@
+#!/usr/bin/env bash
+# Chunked TTS for long text - splits into sentences, generates each, concatenates
+# Usage: voice-long.sh "text" [voice] [format]
+
+TTS_URL="https://hf4uwho-pocket-tts.hf.space/tts"
+TEXT="${1:?Usage: voice-long.sh 'text' [voice] [format]}"
+VOICE="${2:-af_alloy}"
+FORMAT="${3:-ogg}"
+OUTDIR="/tmp/tts"
+mkdir -p "$OUTDIR"
+
+HASH=$(echo -n "$TEXT$VOICE$(date +%s%N)" | md5sum | cut -c1-12)
+OUTFILE="$OUTDIR/voice_${HASH}.${FORMAT}"
+CHUNKDIR="$OUTDIR/chunks_${HASH}"
+mkdir -p "$CHUNKDIR"
+
+# Split text into sentences (rough but effective)
+CHUNKS=$(python3 -c "
+import re
+text = '''$TEXT'''
+# Split on sentence boundaries, group into chunks of ~200 chars
+sentences = re.split(r'(?<=[.!?])\s+', text)
+chunks = []
+current = ''
+for s in sentences:
+    if len(current) + len(s) > 300 and current:
+        chunks.append(current.strip())
+        current = s
+    else:
+        current = (current + ' ' + s).strip()
+if current.strip():
+    chunks.append(current.strip())
+for i, c in enumerate(chunks):
+    print(f'CHUNK_{i}:{c}')
+")
+
+# Generate each chunk
+INDEX=0
+CHUNK_FILES=()
+while IFS= read -r line; do
+    if [[ "$line" == CHUNK_* ]]; then
+        CHUNK_TEXT="${line#CHUNK_[0-9]*:}"
+        # Strip the index prefix
+        CHUNK_TEXT="${line#*:}"
+        ENCODED=$(python3 -c "import urllib.parse; print(urllib.parse.quote('''$CHUNK_TEXT'''))")
+        CHUNKFILE="$CHUNKDIR/chunk_${INDEX}.${FORMAT}"
+        
+        HTTP_CODE=$(curl -s -w "%{http_code}" -o "$CHUNKFILE" "${TTS_URL}?text=${ENCODED}&voice=${VOICE}&format=${FORMAT}" --max-time 60 2>/dev/null)
+        
+        if [ "$HTTP_CODE" != "200" ]; then
+            echo "ERROR: Chunk $INDEX failed with HTTP $HTTP_CODE" >&2
+            rm -rf "$CHUNKDIR"
+            exit 1
+        fi
+        
+        # Verify audio
+        MIME=$(file -b --mime-type "$CHUNKFILE" 2>/dev/null)
+        if [[ "$MIME" == audio/* ]] || [[ "$MIME" == application/ogg ]]; then
+            CHUNK_FILES+=("$CHUNKFILE")
+            INDEX=$((INDEX + 1))
+        else
+            echo "WARNING: Chunk $INDEX not audio ($MIME), skipping" >&2
+        fi
+    fi
+done <<< "$CHUNKS"
+
+if [ ${#CHUNK_FILES[@]} -eq 0 ]; then
+    echo "ERROR: No chunks generated" >&2
+    rm -rf "$CHUNKDIR"
+    exit 1
+fi
+
+# If only one chunk, just use it
+if [ ${#CHUNK_FILES[@]} -eq 1 ]; then
+    cp "${CHUNK_FILES[0]}" "$OUTFILE"
+else
+    # Concatenate Ogg files using sox or ffmpeg, fallback to simple cat
+    if command -v sox &>/dev/null; then
+        sox "${CHUNK_FILES[@]}" "$OUTFILE" 2>/dev/null
+    elif command -v ffmpeg &>/dev/null; then
+        # Create concat list
+        CONCFILE="$CHUNKDIR/concat.txt"
+        > "$CONCFILE"
+        for f in "${CHUNK_FILES[@]}"; do
+            echo "file '$f'" >> "$CONCFILE"
+        done
+        ffmpeg -y -f concat -safe 0 -i "$CONCFILE" -c copy "$OUTFILE" 2>/dev/null
+    else
+        # Simple cat (works for raw Ogg but may have glitches)
+        cat "${CHUNK_FILES[@]}" > "$OUTFILE"
+    fi
+fi
+
+rm -rf "$CHUNKDIR"
+
+if [ -f "$OUTFILE" ] && [ -s "$OUTFILE" ]; then
+    echo "$OUTFILE"
+else
+    echo "ERROR: Final file empty or missing" >&2
+    exit 1
+fi

scripts/voice.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Pocket-TTS voice generator + sender
+# Usage: voice.sh "text" [voice] [format]
+# Output: path to generated audio file (for chaining)
+
+TTS_URL="https://hf4uwho-pocket-tts.hf.space/tts"
+TEXT="${1:?Usage: voice.sh 'text' [voice] [format]}"
+VOICE="${2:-af_alloy}"
+FORMAT="${3:-ogg}"
+OUTDIR="/tmp/tts"
+mkdir -p "$OUTDIR"
+
+# Unique filename
+HASH=$(echo -n "$TEXT$VOICE$(date +%s%N)" | md5sum | cut -c1-12)
+OUTFILE="$OUTDIR/voice_${HASH}.${FORMAT}"
+
+# Generate
+HTTP_CODE=$(curl -s -w "%{http_code}" -o "$OUTFILE" "${TTS_URL}?text=$(python3 -c "import urllib.parse; print(urllib.parse.quote('''$TEXT'''))")&voice=${VOICE}&format=${FORMAT}" 2>/dev/null)
+
+if [ "$HTTP_CODE" != "200" ]; then
+  echo "ERROR: HTTP $HTTP_CODE" >&2
+  rm -f "$OUTFILE"
+  exit 1
+fi
+
+# Verify it's actual audio
+MIME=$(file -b --mime-type "$OUTFILE" 2>/dev/null)
+if [[ "$MIME" != audio/* ]] && [[ "$MIME" != application/ogg ]]; then
+  echo "ERROR: Not audio (got $MIME)" >&2
+  cat "$OUTFILE" >&2
+  rm -f "$OUTFILE"
+  exit 1
+fi
+
+echo "$OUTFILE"