agentvibes 5.12.0-alpha.0 → 5.12.0

package/src/console/tabs/music-tab.js

@@ -12,16 +12,43 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { buildAudioEnv, spawnMp3Player } from '../audio-env.js';
 import { t } from '../../i18n/strings.js';
 
+const _MUSIC_TAB_DIR = path.dirname(fileURLToPath(import.meta.url));
+
 // Package-relative tracks dir — used as fallback when cwd has no .claude/audio/tracks/
 const _PKG_TRACKS_DIR = path.resolve(
-  path.dirname(fileURLToPath(import.meta.url)),
-  '..', '..', '..', '.claude', 'audio', 'tracks'
+  _MUSIC_TAB_DIR, '..', '..', '..', '.claude', 'audio', 'tracks'
 );
 
+// Transport providers route audio to a remote receiver; local MP3 playback is
+// silent on a headless/remote box, so track previews must be forwarded instead.
+const _REMOTE_PROVIDERS = ['ssh-remote', 'agentvibes-receiver'];
+
+/**
+ * Resolve the active provider and the project dir it was read from, using the
+ * same search order as the voice pickers (CLAUDE_PROJECT_DIR → cwd → package →
+ * home). Returns { remote, projectDir } so a remote preview can forward the
+ * track to the receiver and tell the sender which .claude dir to resolve.
+ */
+function _resolveMusicProvider() {
+  const projectRoot = path.resolve(_MUSIC_TAB_DIR, '..', '..', '..');
+  const dirs = [process.env.CLAUDE_PROJECT_DIR, process.cwd(), projectRoot, os.homedir()].filter(Boolean);
+  for (const d of dirs) {
+    const p = path.join(d, '.claude', 'tts-provider.txt');
+    try {
+      if (fs.existsSync(p)) {
+        const provider = fs.readFileSync(p, 'utf8').trim();
+        return { remote: _REMOTE_PROVIDERS.includes(provider), projectDir: d };
+      }
+    } catch { /* next */ }
+  }
+  return { remote: false, projectDir: '' };
+}
+
 const IS_TEST = process.env.AGENTVIBES_TEST_MODE === 'true';
 
 let blessed;
@@ -540,6 +567,10 @@ export function createMusicTab(screen, services) {
 
   let _playingProcess = null;
   let _playingTrackId = null;
+  // Remote playback is fire-and-forget (the local sender exits in ms while the
+  // receiver keeps playing), so the on/off toggle tracks the intended remote
+  // track here rather than relying on a live local process.
+  let _remotePlayingTrackId = null;
 
   function _killPlayingProcess() {
     if (_playingProcess) {
@@ -550,6 +581,51 @@ export function createMusicTab(screen, services) {
 
   const _spawnEnv = buildAudioEnv();
 
+  /**
+   * Spawn the SSH sender to play a music track on the receiver, or stop the
+   * current one. Fire-and-forget (the sender exits after handing the payload to
+   * SSH; the receiver plays/stops asynchronously). Returns true if the send was
+   * launched. On a play error the remote-playing state is cleared so the toggle
+   * doesn't get stuck "on".
+   * @param {{remote:boolean, projectDir:string}} mp
+   * @param {{track?:string, stop?:boolean}} opts
+   */
+  function _sendMusicRemote(mp, { track = null, stop = false } = {}) {
+    const _pkgSender = path.resolve(_MUSIC_TAB_DIR, '..', '..', '..', '.claude', 'hooks', 'play-tts-ssh-remote.sh');
+    const senderPath = fs.existsSync(_pkgSender)
+      ? _pkgSender
+      : path.join(mp.projectDir, '.claude', 'hooks', 'play-tts-ssh-remote.sh');
+    const env = { ..._spawnEnv, CLAUDE_PROJECT_DIR: mp.projectDir };
+    if (stop) env.AGENTVIBES_MUSIC_STOP = '1';
+    else env.AGENTVIBES_MUSIC_ONLY = track;
+    let rproc;
+    try {
+      rproc = spawn('bash', [senderPath, '', ''], { stdio: ['ignore', 'ignore', 'pipe'], detached: true, env }); // NOSONAR
+    } catch {
+      previewLine.setContent('{red-fg}Remote music preview failed{/red-fg}');
+      screen.render();
+      setTimeout(() => { previewLine.setContent(_listFocused ? _hintText() : ''); screen.render(); }, 4000);
+      return false;
+    }
+    let _rerr = '';
+    if (rproc.stderr) rproc.stderr.on('data', d => { _rerr += d.toString(); });
+    rproc.on('exit', (code) => {
+      if (stop || code === 0) return;
+      if (_remotePlayingTrackId === track) _remotePlayingTrackId = null;
+      const msg = _rerr.trim().split('\n').pop() || 'Remote preview failed';
+      previewLine.setContent(`{red-fg}♪ ${msg}{/red-fg}`);
+      screen.render();
+      setTimeout(() => { previewLine.setContent(_listFocused ? _hintText() : ''); screen.render(); }, 4000);
+    });
+    rproc.on('error', () => {
+      if (stop) return;
+      if (_remotePlayingTrackId === track) _remotePlayingTrackId = null;
+      previewLine.setContent('{red-fg}Remote music preview failed{/red-fg}');
+      screen.render();
+    });
+    return true;
+  }
+
   process.on('exit', () => { _killPlayingProcess(); });
 
   /**
@@ -566,6 +642,29 @@ export function createMusicTab(screen, services) {
       return;
     }
 
+    // Remote provider: forward to the receiver instead of local playback (which
+    // is silent on a headless box). The receiver auto-stops any prior track when
+    // a new one arrives; pressing Space on the currently-playing track sends an
+    // explicit stop (toggle off).
+    const _mp = _resolveMusicProvider();
+    if (_mp.remote) {
+      if (_remotePlayingTrackId === trackId) {
+        _sendMusicRemote(_mp, { stop: true });
+        _remotePlayingTrackId = null;
+        previewLine.setContent(_listFocused ? _hintText() : '');
+        screen.render();
+        return;
+      }
+      const rlabel = _allTracks.find(t => t.id === trackId)?.label ?? formatTrackLabel(trackId);
+      if (_sendMusicRemote(_mp, { track: trackId })) {
+        _remotePlayingTrackId = trackId;
+        previewLine.setContent(`{${COLORS.playingFg}-fg}♪ Playing on receiver: ${rlabel}  (Space to stop){/${COLORS.playingFg}-fg}`);
+      }
+      screen.render();
+      return;
+    }
+
+    // ── Local playback ──────────────────────────────────────────────────────
     // Toggle: second press on the same track → stop
     if (_playingTrackId === trackId) {
       _killPlayingProcess();

package/src/console/tabs/placeholder-tab.js

@@ -38,7 +38,6 @@ export function createPlaceholderTab(contentArea, label) {
 /** Map of tabId → display label for all tabs */
 export const TAB_DISPLAY_LABELS = {
   settings:        'Settings',
-  voices:          'Voices',
   music:           'Music',
   agents:          'BMad',
   receiver:        'Receiver',
@@ -66,7 +65,6 @@ export function getTabLabel(id, lang = 'en') {
   const keyMap = {
     setup:           'tabSetup',
     settings:        'tabSettings',
-    voices:          'tabVoices',
     music:           'tabMusic',
     agents:          'tabBmad',
     receiver:        'tabReceiver',