agentvibes 5.13.0 → 5.14.0

package/templates/agentvibes-receiver.ps1

@@ -0,0 +1,311 @@
+#
+# File: agentvibes-receiver.ps1
+# Location: Install to $env:USERPROFILE\.agentvibes\play-remote.ps1
+#
+# AgentVibes Windows TTS Receiver
+# Receives base64 JSON payload via stdin (from SSH ForceCommand),
+# decodes it, configures voice/music, and delegates to play-tts.ps1.
+#
+# Payload format (same as Linux receiver):
+#   Base64-encoded JSON: { text, voice, effects, music, volume, project, pretext, speed, provider }
+#
+# Usage (SSH ForceCommand in sshd_config):
+#   ForceCommand powershell -NoProfile -ExecutionPolicy Bypass -File C:\Users\Paul\.agentvibes\play-remote.ps1
+#
+
+param(
+    [Parameter(Position = 0)]
+    [string]$EncodedPayload = ""
+)
+
+# Paths - __OWNER_HOME__ is replaced at install time by setup-ssh-receiver.ps1
+# with the installing user's home directory (e.g. C:\Users\Paul).
+# This is necessary because sshd runs the ForceCommand as the SSH user
+# (e.g. agentvibes-receiver), whose $env:USERPROFILE is a different directory.
+$OwnerHome = "__OWNER_HOME__"
+if (-not (Test-Path "$OwnerHome\.agentvibes")) {
+    Write-Output "Error: Receiver not installed properly - run setup-ssh-receiver.ps1"
+    exit 1
+}
+$AgentVibesDir = "$OwnerHome\.agentvibes"
+$ClaudeDir = "$OwnerHome\.claude"
+$HooksDir = "$ClaudeDir\hooks-windows"
+$ConfigDir = "$ClaudeDir\config"
+$LogFile = "$AgentVibesDir\receiver.log"
+$PlayTtsScript = "$HooksDir\play-tts.ps1"
+
+# Ensure directories exist
+foreach ($dir in @($AgentVibesDir, $ConfigDir)) {
+    if (-not (Test-Path $dir)) {
+        New-Item -ItemType Directory -Path $dir -Force | Out-Null
+    }
+}
+
+# Generate log ID
+$LogId = '{0:x4}' -f (Get-Random -Maximum 65536)
+
+function Write-Log {
+    param([string]$Status, [string]$Detail = "")
+    $timestamp = Get-Date -Format 'yyyy-MM-ddTHH:mm:ss'
+    $senderIp = if ($env:SSH_CLIENT) { ($env:SSH_CLIENT -split ' ')[0] } else { "local" }
+    $preview = if ($script:Text.Length -gt 200) { $script:Text.Substring(0, 200) } else { $script:Text }
+    $logLine = "$timestamp|$Status|$($script:Project)|$($script:Voice)|$preview|$Detail|$senderIp|$LogId"
+    Add-Content -Path $LogFile -Value $logLine -ErrorAction SilentlyContinue
+}
+
+# ---------------------------------------------------------------------------
+# Read payload from stdin or argument
+# ---------------------------------------------------------------------------
+
+if (-not $EncodedPayload) {
+    # SSH ForceCommand stores the client's requested command in SSH_ORIGINAL_COMMAND
+    $EncodedPayload = if ($env:SSH_ORIGINAL_COMMAND) { $env:SSH_ORIGINAL_COMMAND.Trim() } else { "" }
+}
+if (-not $EncodedPayload) {
+    # Fallback: read from stdin (direct invocation or piped input)
+    $EncodedPayload = [Console]::In.ReadToEnd().Trim()
+}
+
+if (-not $EncodedPayload) {
+    Write-Output "Error: No payload provided"
+    exit 1
+}
+
+# Validate base64 format
+if ($EncodedPayload -notmatch '^[A-Za-z0-9+/=]+$') {
+    Write-Output "Error: Payload must be base64-encoded"
+    exit 1
+}
+
+# Decode base64
+try {
+    $decoded = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($EncodedPayload))
+} catch {
+    Write-Output "Error: Failed to decode base64 payload"
+    exit 1
+}
+
+# ---------------------------------------------------------------------------
+# Parse JSON payload
+# ---------------------------------------------------------------------------
+
+$script:Text = ""
+$script:Voice = "en_US-lessac-medium"
+$SoxEffects = ""
+$BgFile = ""
+# TODO(AVI-S8.6): generate this constant from the shared JSON source of truth.
+$BgVolume = "0.20"
+$script:Project = "unknown"
+# Sender's absolute project path — forwarded to the watcher so the avatar can
+# show/learn the real remote folder (paired with $script:Project).
+$ProjectPath = ""
+$Pretext = ""
+$Speed = ""
+$Provider = "piper"
+$Llm = "default"
+$Mute = "false"
+$Language = ""
+# kind: "speak" (default — synthesize text) or "music" (play a standalone
+# background-music track, no speech). Set by the Music-tab remote preview.
+$Kind = "speak"
+
+if ($decoded.TrimStart().StartsWith('{')) {
+    # JSON payload
+    try {
+        $json = $decoded | ConvertFrom-Json
+        if ($json.text)     { $script:Text = $json.text }
+        if ($json.voice)    { $script:Voice = $json.voice }
+        if ($json.effects)  { $SoxEffects = $json.effects }
+        if ($json.music)    { $BgFile = $json.music }
+        if ($json.volume)   { $BgVolume = $json.volume }
+        if ($json.project)  { $script:Project = $json.project }
+        if ($json.projectPath) { $ProjectPath = $json.projectPath }
+        if ($json.pretext)  { $Pretext = $json.pretext }
+        if ($json.speed)    { $Speed = $json.speed }
+        if ($json.provider) { $Provider = $json.provider }
+        if ($json.llm)      { $Llm = $json.llm }
+        # Forwarded as strings by the sender ("true"/"false"); ConvertFrom-Json
+        # may hand back a real boolean, so stringify defensively.
+        if ($null -ne $json.mute) { $Mute = ([string]$json.mute).ToLower() }
+        if ($json.language) { $Language = $json.language }
+        if ($json.kind)     { $Kind = ([string]$json.kind).ToLower() }
+    } catch {
+        Write-Output "Error: Failed to parse JSON payload"
+        exit 1
+    }
+} else {
+    # Legacy plain text
+    $script:Text = $decoded
+}
+
+# Validate text. Music-only previews carry no speech — they require a track
+# (the "music" field) instead of text.
+if ($Kind -eq 'music') {
+    if (-not $BgFile) {
+        Write-Output "Error: music payload has no track"
+        exit 1
+    }
+} elseif ($Kind -eq 'music-stop') {
+    # Stop request carries neither text nor a track — nothing to validate.
+} elseif (-not $script:Text) {
+    Write-Output "Error: No text in payload"
+    exit 1
+}
+
+# Validate voice format
+if ($script:Voice -notmatch '^[a-zA-Z0-9_\-\. ]+$' -and $script:Voice -notmatch '^[a-zA-Z0-9_\-\. ]+::[a-zA-Z0-9_\-\. ]+$') {
+    $script:Voice = "en_US-lessac-medium"
+}
+
+# Validate provider
+if ($Provider -notin @("piper", "soprano", "kokoro", "windows-sapi", "windows-piper", "macos")) {
+    $Provider = "piper"
+}
+
+# Validate LLM name - only safe identifier chars (mirrors play-tts.ps1 check)
+if ($Llm -and $Llm -notmatch '^[a-zA-Z0-9][a-zA-Z0-9_-]*$') {
+    $Llm = "default"
+}
+
+# Music-only preview: the track must be a bare .mp3 filename (no path parts) —
+# the watcher resolves it against ~/.claude/audio/tracks/ with a containment check.
+if ($Kind -eq 'music' -and $BgFile -notmatch '^[A-Za-z0-9._][A-Za-z0-9._ \-]*\.mp3$') {
+    Write-Output "Error: invalid music track name"
+    exit 1
+}
+
+# Validate volume is numeric
+if ($BgVolume -notmatch '^\d+\.?\d*$') {
+    $BgVolume = "0.20"
+}
+
+# Prepend pretext
+if ($Pretext) {
+    $script:Text = "$Pretext. $($script:Text)"
+}
+
+# ---------------------------------------------------------------------------
+# RECEIVER-AUTHORITATIVE: mute safety-OR (map §C, R17)
+# ---------------------------------------------------------------------------
+# effective_mute = receiver_local_mute OR forwarded_mute. If EITHER the sender
+# (forwarded $Mute -eq "true") or THIS receiver host is muted, stay silent. A
+# receiver-local mute always vetoes; the forwarded mute is a subordinate DEFAULT
+# that can also veto. We NEVER force-unmute a muted receiver.
+$ReceiverMuteFile = "$ClaudeDir\tts-muted.txt"
+$ReceiverLocalMuted = $false
+if (Test-Path $ReceiverMuteFile) {
+    if ((Get-Content $ReceiverMuteFile -Raw -ErrorAction SilentlyContinue).Trim() -eq "true") {
+        $ReceiverLocalMuted = $true
+    }
+}
+$EffectiveMute = ($Mute -eq "true") -or $ReceiverLocalMuted
+
+# ---------------------------------------------------------------------------
+# RECEIVER-AUTHORITATIVE: language fallback (map §D, R18)
+# ---------------------------------------------------------------------------
+# The receiver's OWN language config wins; otherwise use the forwarded language
+# as the default. Non-destructive: we do NOT overwrite the receiver's own
+# tts-language.txt — the effective value only rides along in the queue JSON.
+$EffectiveLanguage = $Language
+foreach ($lf in @("$ClaudeDir\tts-language.txt", "$ConfigDir\tts-language.txt")) {
+    if (Test-Path $lf) {
+        $rl = (Get-Content $lf -Raw -ErrorAction SilentlyContinue)
+        if ($rl) { $rl = $rl.Trim() }
+        if ($rl) { $EffectiveLanguage = $rl; break }  # receiver's own config wins
+    }
+}
+
+Write-Log "RECEIVED" "provider=$Provider effects=$SoxEffects music=$BgFile mute=$Mute/$EffectiveMute lang=$EffectiveLanguage"
+
+# RECEIVER-AUTHORITATIVE mute veto: if either side muted, do not queue/play.
+if ($EffectiveMute) {
+    Write-Log "MUTED" "forwarded=$Mute receiverLocal=$ReceiverLocalMuted"
+    Write-Output "Muted (forwarded=$Mute, receiver-local=$ReceiverLocalMuted) - not playing"
+    exit 0
+}
+
+# ---------------------------------------------------------------------------
+# Readiness bling — a short cue on the RECEIVER, played BEFORE we generate/play,
+# so a listener knows audio is incoming (kokoro synth + track load have latency).
+# Standardizes the UX across voice AND music: bling first, then the audio. A
+# music-stop carries no audio, so it gets no cue. Best-effort + synchronous (the
+# cue is ~0.7s and must finish before the track so they don't overlap); a missing
+# wav or player failure must NEVER block or fail the actual playback.
+# ---------------------------------------------------------------------------
+if ($Kind -eq 'music') {
+    $blingWav = "$ClaudeDir\audio\ui\bling-success.wav"
+    if (-not (Test-Path $blingWav)) { $blingWav = "$env:USERPROFILE\.agentvibes\bling-success.wav" }
+    if (Test-Path $blingWav) {
+        try {
+            $ffb = Get-Command ffplay -ErrorAction SilentlyContinue
+            if ($ffb) { & $ffb.Source -autoexit -nodisp -loglevel quiet "$blingWav" 2>$null }
+            else { (New-Object System.Media.SoundPlayer "$blingWav").PlaySync() }
+        } catch { Write-Log "WARN" "readiness bling failed: $($_.Exception.Message)" }
+    }
+}
+
+# ---------------------------------------------------------------------------
+# Configure voice for play-tts.ps1
+# ---------------------------------------------------------------------------
+
+# Write voice to tts-voice.txt so play-tts-piper.ps1 picks it up
+# Format: "voiceId" or "voiceId::SpeakerName-ID"
+$voiceFile = "$ClaudeDir\tts-voice.txt"
+Set-Content -Path $voiceFile -Value $script:Voice -NoNewline -ErrorAction SilentlyContinue
+
+# Background music and effects are now forwarded through the queue JSON
+# (music/volume/effects fields) and applied via AGENTVIBES_OVERRIDE_*
+# env vars in the watcher.  No need to mutate audio-effects.cfg here.
+
+# Set speed if specified
+if ($Speed -and $Speed -match '^\d+\.?\d*$') {
+    Set-Content -Path "$ConfigDir\tts-speed.txt" -Value $Speed -NoNewline -ErrorAction SilentlyContinue
+}
+
+# ---------------------------------------------------------------------------
+# Drop into queue for the user-session watcher to play
+# ---------------------------------------------------------------------------
+#
+# CRITICAL: SSH receiver runs in Windows session 0 (sshd service), which has
+# NO access to audio devices.  Calling play-tts.ps1 directly here would run
+# silently - synthesis succeeds, but PlaySync writes to a null audio sink.
+#
+# Instead, write a JSON request to ~/.agentvibes/tts-queue/.  The watcher
+# (tts-watcher.ps1, started by start-watcher.vbs in the user session via the
+# Startup folder shortcut) polls this dir and runs play-tts.ps1 with audio
+# device access.
+
+$QueueDir = "$OwnerHome\.agentvibes\tts-queue"
+if (-not (Test-Path $QueueDir)) {
+    New-Item -ItemType Directory -Path $QueueDir -Force | Out-Null
+}
+
+$ReqId = [Guid]::NewGuid().ToString().Substring(0, 8)
+$ReqFile = "$QueueDir\req-$ReqId.json"
+# Pass ALL per-call overrides through the queue so the watcher applies
+# them without mutating audio-effects.cfg (avoids race conditions).
+$ReqJson = @{
+    id       = $ReqId
+    text     = $script:Text
+    voice    = $script:Voice
+    music    = $BgFile
+    volume   = $BgVolume
+    effects  = $SoxEffects
+    speed    = $Speed
+    provider = $Provider
+    llm      = $Llm
+    language = $EffectiveLanguage
+    kind     = $Kind
+    project     = $script:Project
+    projectPath = $ProjectPath
+} | ConvertTo-Json -Compress
+
+try {
+    [System.IO.File]::WriteAllText($ReqFile, $ReqJson, [System.Text.UTF8Encoding]::new($false))
+    Write-Log "QUEUED" "id=$ReqId voice=$($script:Voice)"
+    Write-Output "Queued for playback: $ReqId"
+} catch {
+    Write-Log "ERROR" "Queue write failed: $_"
+    Write-Output "Error: failed to queue TTS request: $_"
+    exit 1
+}