opencode-smart-voice-notify 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-smart-voice-notify",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Smart voice notification plugin for OpenCode with multiple TTS engines (ElevenLabs, Edge TTS, Windows SAPI) and intelligent reminder system",
   "main": "index.js",
   "type": "module",
@@ -44,4 +44,4 @@
   "peerDependencies": {
     "@opencode-ai/plugin": "^1.0.0"
   }
-}
+}

package/util/linux.js

@@ -0,0 +1,468 @@
+/**
+ * Linux Platform Compatibility Module
+ * 
+ * Provides Linux-specific implementations for:
+ * - Wake monitor from sleep (X11 and Wayland)
+ * - Get current system volume (PulseAudio/PipeWire and ALSA)
+ * - Force system volume up (PulseAudio/PipeWire and ALSA)
+ * - Play audio files (PulseAudio and ALSA)
+ * 
+ * Dependencies (optional - graceful fallback if missing):
+ * - x11-xserver-utils (for xset on X11)
+ * - pulseaudio-utils or pipewire-pulse (for pactl)
+ * - alsa-utils (for amixer, aplay, paplay)
+ * 
+ * @module util/linux
+ */
+
+/**
+ * Creates a Linux platform utilities instance
+ * @param {object} params - { $: shell runner, debugLog: logging function }
+ * @returns {object} Linux platform API
+ */
+export const createLinuxPlatform = ({ $, debugLog = () => {} }) => {
+  
+  // ============================================================
+  // DISPLAY SESSION DETECTION
+  // ============================================================
+  
+  /**
+   * Detect if running under Wayland
+   * @returns {boolean}
+   */
+  const isWayland = () => {
+    return !!process.env.WAYLAND_DISPLAY;
+  };
+
+  /**
+   * Detect if running under X11
+   * @returns {boolean}
+   */
+  const isX11 = () => {
+    return !!process.env.DISPLAY && !isWayland();
+  };
+
+  /**
+   * Get the current session type
+   * @returns {'x11' | 'wayland' | 'tty' | 'unknown'}
+   */
+  const getSessionType = () => {
+    const sessionType = process.env.XDG_SESSION_TYPE;
+    if (sessionType === 'x11' || sessionType === 'wayland' || sessionType === 'tty') {
+      return sessionType;
+    }
+    if (isWayland()) return 'wayland';
+    if (isX11()) return 'x11';
+    return 'unknown';
+  };
+
+  // ============================================================
+  // WAKE MONITOR
+  // ============================================================
+
+  /**
+   * Wake monitor using X11 DPMS (works on X11 and often XWayland)
+   * @returns {Promise<boolean>} Success status
+   */
+  const wakeMonitorX11 = async () => {
+    if (!$) return false;
+    try {
+      await $`xset dpms force on`.quiet();
+      debugLog('wakeMonitor: X11 xset dpms force on succeeded');
+      return true;
+    } catch (e) {
+      debugLog(`wakeMonitor: X11 xset failed: ${e.message}`);
+      return false;
+    }
+  };
+
+  /**
+   * Wake monitor using GNOME D-Bus (for GNOME on Wayland)
+   * Triggers a brightness step which wakes the display
+   * @returns {Promise<boolean>} Success status
+   */
+  const wakeMonitorGnomeDBus = async () => {
+    if (!$) return false;
+    try {
+      await $`gdbus call --session --dest org.gnome.SettingsDaemon.Power --object-path /org/gnome/SettingsDaemon/Power --method org.gnome.SettingsDaemon.Power.Screen.StepUp`.quiet();
+      debugLog('wakeMonitor: GNOME D-Bus StepUp succeeded');
+      return true;
+    } catch (e) {
+      debugLog(`wakeMonitor: GNOME D-Bus failed: ${e.message}`);
+      return false;
+    }
+  };
+
+  /**
+   * Wake monitor from sleep/DPMS standby
+   * Tries multiple methods with graceful fallback:
+   * 1. X11 xset (works on X11 and XWayland)
+   * 2. GNOME D-Bus (works on GNOME Wayland)
+   * 
+   * @returns {Promise<boolean>} True if any method succeeded
+   */
+  const wakeMonitor = async () => {
+    // Try X11 method first (most compatible, works on XWayland too)
+    if (await wakeMonitorX11()) return true;
+    
+    // Try GNOME Wayland D-Bus method
+    if (await wakeMonitorGnomeDBus()) return true;
+    
+    debugLog('wakeMonitor: all methods failed');
+    return false;
+  };
+
+  // ============================================================
+  // VOLUME CONTROL - PULSEAUDIO / PIPEWIRE
+  // ============================================================
+
+  /**
+   * Get current volume using PulseAudio/PipeWire (pactl)
+   * @returns {Promise<number>} Volume percentage (0-100) or -1 if failed
+   */
+  const getVolumePulse = async () => {
+    if (!$) return -1;
+    try {
+      const result = await $`pactl get-sink-volume @DEFAULT_SINK@`.quiet();
+      const output = result.stdout?.toString() || '';
+      // Parse output like: "Volume: front-left: 65536 / 100% / 0.00 dB, ..."
+      const match = output.match(/(\d+)%/);
+      if (match) {
+        const volume = parseInt(match[1], 10);
+        debugLog(`getVolume: pactl returned ${volume}%`);
+        return volume;
+      }
+    } catch (e) {
+      debugLog(`getVolume: pactl failed: ${e.message}`);
+    }
+    return -1;
+  };
+
+  /**
+   * Set volume using PulseAudio/PipeWire (pactl)
+   * @param {number} volume - Volume percentage (0-100)
+   * @returns {Promise<boolean>} Success status
+   */
+  const setVolumePulse = async (volume) => {
+    if (!$) return false;
+    try {
+      const clampedVolume = Math.max(0, Math.min(100, volume));
+      await $`pactl set-sink-volume @DEFAULT_SINK@ ${clampedVolume}%`.quiet();
+      debugLog(`setVolume: pactl set to ${clampedVolume}%`);
+      return true;
+    } catch (e) {
+      debugLog(`setVolume: pactl failed: ${e.message}`);
+      return false;
+    }
+  };
+
+  /**
+   * Unmute using PulseAudio/PipeWire (pactl)
+   * @returns {Promise<boolean>} Success status
+   */
+  const unmutePulse = async () => {
+    if (!$) return false;
+    try {
+      await $`pactl set-sink-mute @DEFAULT_SINK@ 0`.quiet();
+      debugLog('unmute: pactl succeeded');
+      return true;
+    } catch (e) {
+      debugLog(`unmute: pactl failed: ${e.message}`);
+      return false;
+    }
+  };
+
+  /**
+   * Check if muted using PulseAudio/PipeWire
+   * @returns {Promise<boolean|null>} True if muted, false if not, null if failed
+   */
+  const isMutedPulse = async () => {
+    if (!$) return null;
+    try {
+      const result = await $`pactl get-sink-mute @DEFAULT_SINK@`.quiet();
+      const output = result.stdout?.toString() || '';
+      // Output: "Mute: yes" or "Mute: no"
+      return /yes|true/i.test(output);
+    } catch (e) {
+      debugLog(`isMuted: pactl failed: ${e.message}`);
+      return null;
+    }
+  };
+
+  // ============================================================
+  // VOLUME CONTROL - ALSA (FALLBACK)
+  // ============================================================
+
+  /**
+   * Get current volume using ALSA (amixer)
+   * @returns {Promise<number>} Volume percentage (0-100) or -1 if failed
+   */
+  const getVolumeAlsa = async () => {
+    if (!$) return -1;
+    try {
+      const result = await $`amixer get Master`.quiet();
+      const output = result.stdout?.toString() || '';
+      // Parse output like: "Front Left: Playback 65536 [75%] [on]"
+      const match = output.match(/\[(\d+)%\]/);
+      if (match) {
+        const volume = parseInt(match[1], 10);
+        debugLog(`getVolume: amixer returned ${volume}%`);
+        return volume;
+      }
+    } catch (e) {
+      debugLog(`getVolume: amixer failed: ${e.message}`);
+    }
+    return -1;
+  };
+
+  /**
+   * Set volume using ALSA (amixer)
+   * @param {number} volume - Volume percentage (0-100)
+   * @returns {Promise<boolean>} Success status
+   */
+  const setVolumeAlsa = async (volume) => {
+    if (!$) return false;
+    try {
+      const clampedVolume = Math.max(0, Math.min(100, volume));
+      await $`amixer set Master ${clampedVolume}%`.quiet();
+      debugLog(`setVolume: amixer set to ${clampedVolume}%`);
+      return true;
+    } catch (e) {
+      debugLog(`setVolume: amixer failed: ${e.message}`);
+      return false;
+    }
+  };
+
+  /**
+   * Unmute using ALSA (amixer)
+   * @returns {Promise<boolean>} Success status
+   */
+  const unmuteAlsa = async () => {
+    if (!$) return false;
+    try {
+      await $`amixer set Master unmute`.quiet();
+      debugLog('unmute: amixer succeeded');
+      return true;
+    } catch (e) {
+      debugLog(`unmute: amixer failed: ${e.message}`);
+      return false;
+    }
+  };
+
+  /**
+   * Check if muted using ALSA
+   * @returns {Promise<boolean|null>} True if muted, false if not, null if failed
+   */
+  const isMutedAlsa = async () => {
+    if (!$) return null;
+    try {
+      const result = await $`amixer get Master`.quiet();
+      const output = result.stdout?.toString() || '';
+      // Look for [off] or [mute] in output
+      return /\[off\]|\[mute\]/i.test(output);
+    } catch (e) {
+      debugLog(`isMuted: amixer failed: ${e.message}`);
+      return null;
+    }
+  };
+
+  // ============================================================
+  // UNIFIED VOLUME CONTROL (AUTO-DETECT BACKEND)
+  // ============================================================
+
+  /**
+   * Get current system volume
+   * Tries PulseAudio first, then falls back to ALSA
+   * @returns {Promise<number>} Volume percentage (0-100) or -1 if failed
+   */
+  const getCurrentVolume = async () => {
+    // Try PulseAudio/PipeWire first (most common on desktop Linux)
+    let volume = await getVolumePulse();
+    if (volume >= 0) return volume;
+    
+    // Fallback to ALSA
+    volume = await getVolumeAlsa();
+    return volume;
+  };
+
+  /**
+   * Set system volume
+   * Tries PulseAudio first, then falls back to ALSA
+   * @param {number} volume - Volume percentage (0-100)
+   * @returns {Promise<boolean>} Success status
+   */
+  const setVolume = async (volume) => {
+    // Try PulseAudio/PipeWire first
+    if (await setVolumePulse(volume)) return true;
+    
+    // Fallback to ALSA
+    return await setVolumeAlsa(volume);
+  };
+
+  /**
+   * Unmute system audio
+   * Tries PulseAudio first, then falls back to ALSA
+   * @returns {Promise<boolean>} Success status
+   */
+  const unmute = async () => {
+    // Try PulseAudio/PipeWire first
+    if (await unmutePulse()) return true;
+    
+    // Fallback to ALSA
+    return await unmuteAlsa();
+  };
+
+  /**
+   * Check if system audio is muted
+   * Tries PulseAudio first, then falls back to ALSA
+   * @returns {Promise<boolean|null>} True if muted, false if not, null if detection failed
+   */
+  const isMuted = async () => {
+    // Try PulseAudio/PipeWire first
+    let muted = await isMutedPulse();
+    if (muted !== null) return muted;
+    
+    // Fallback to ALSA
+    return await isMutedAlsa();
+  };
+
+  /**
+   * Force volume to maximum (unmute + set to 100%)
+   * Used to ensure notifications are audible
+   * @returns {Promise<boolean>} Success status
+   */
+  const forceVolume = async () => {
+    const unmuted = await unmute();
+    const volumeSet = await setVolume(100);
+    return unmuted || volumeSet;
+  };
+
+  /**
+   * Force volume if below threshold
+   * @param {number} threshold - Minimum volume threshold (0-100)
+   * @returns {Promise<boolean>} True if volume was forced, false if already adequate
+   */
+  const forceVolumeIfNeeded = async (threshold = 50) => {
+    const currentVolume = await getCurrentVolume();
+    
+    // If we couldn't detect volume, force it to be safe
+    if (currentVolume < 0) {
+      debugLog('forceVolumeIfNeeded: could not detect volume, forcing');
+      return await forceVolume();
+    }
+    
+    // Check if already above threshold
+    if (currentVolume >= threshold) {
+      debugLog(`forceVolumeIfNeeded: volume ${currentVolume}% >= ${threshold}%, no action needed`);
+      return false;
+    }
+    
+    // Force volume up
+    debugLog(`forceVolumeIfNeeded: volume ${currentVolume}% < ${threshold}%, forcing to 100%`);
+    return await forceVolume();
+  };
+
+  // ============================================================
+  // AUDIO PLAYBACK
+  // ============================================================
+
+  /**
+   * Play an audio file using PulseAudio (paplay)
+   * @param {string} filePath - Path to audio file
+   * @returns {Promise<boolean>} Success status
+   */
+  const playAudioPulse = async (filePath) => {
+    if (!$) return false;
+    try {
+      await $`paplay ${filePath}`.quiet();
+      debugLog(`playAudio: paplay succeeded for ${filePath}`);
+      return true;
+    } catch (e) {
+      debugLog(`playAudio: paplay failed: ${e.message}`);
+      return false;
+    }
+  };
+
+  /**
+   * Play an audio file using ALSA (aplay)
+   * Note: aplay only supports WAV files natively
+   * @param {string} filePath - Path to audio file
+   * @returns {Promise<boolean>} Success status
+   */
+  const playAudioAlsa = async (filePath) => {
+    if (!$) return false;
+    try {
+      await $`aplay ${filePath}`.quiet();
+      debugLog(`playAudio: aplay succeeded for ${filePath}`);
+      return true;
+    } catch (e) {
+      debugLog(`playAudio: aplay failed: ${e.message}`);
+      return false;
+    }
+  };
+
+  /**
+   * Play an audio file
+   * Tries PulseAudio (paplay) first, then falls back to ALSA (aplay)
+   * @param {string} filePath - Path to audio file
+   * @param {number} loops - Number of times to play (default: 1)
+   * @returns {Promise<boolean>} Success status
+   */
+  const playAudioFile = async (filePath, loops = 1) => {
+    for (let i = 0; i < loops; i++) {
+      // Try PulseAudio first (supports more formats including MP3)
+      if (await playAudioPulse(filePath)) continue;
+      
+      // Fallback to ALSA
+      if (await playAudioAlsa(filePath)) continue;
+      
+      // Both failed
+      debugLog(`playAudioFile: all methods failed for ${filePath}`);
+      return false;
+    }
+    return true;
+  };
+
+  // ============================================================
+  // PUBLIC API
+  // ============================================================
+
+  return {
+    // Session detection
+    isWayland,
+    isX11,
+    getSessionType,
+    
+    // Wake monitor
+    wakeMonitor,
+    wakeMonitorX11,
+    wakeMonitorGnomeDBus,
+    
+    // Volume control (unified)
+    getCurrentVolume,
+    setVolume,
+    unmute,
+    isMuted,
+    forceVolume,
+    forceVolumeIfNeeded,
+    
+    // Volume control (specific backends)
+    pulse: {
+      getVolume: getVolumePulse,
+      setVolume: setVolumePulse,
+      unmute: unmutePulse,
+      isMuted: isMutedPulse,
+    },
+    alsa: {
+      getVolume: getVolumeAlsa,
+      setVolume: setVolumeAlsa,
+      unmute: unmuteAlsa,
+      isMuted: isMutedAlsa,
+    },
+    
+    // Audio playback
+    playAudioFile,
+    playAudioPulse,
+    playAudioAlsa,
+  };
+};

package/util/tts.js

@@ -2,6 +2,7 @@ import path from 'path';
 import os from 'os';
 import fs from 'fs';
 import { loadConfig } from './config.js';
+import { createLinuxPlatform } from './linux.js';
 
 const platform = os.platform();
 const configDir = process.env.OPENCODE_CONFIG_DIR || path.join(os.homedir(), '.config', 'opencode');
@@ -121,6 +122,18 @@ export const createTTS = ({ $, client }) => {
   const config = getTTSConfig();
   const logFile = path.join(configDir, 'smart-voice-notify-debug.log');
 
+  // Debug logging function (defined early so it can be passed to Linux platform)
+  const debugLog = (message) => {
+    if (!config.debugLog) return;
+    try {
+      const timestamp = new Date().toISOString();
+      fs.appendFileSync(logFile, `[${timestamp}] ${message}\n`);
+    } catch (e) {}
+  };
+
+  // Initialize Linux platform utilities (only used on Linux)
+  const linux = platform === 'linux' ? createLinuxPlatform({ $, debugLog }) : null;
+
   const showToast = async (message, variant = 'info') => {
     if (!config.enableToast) return;
     try {
@@ -136,14 +149,6 @@ export const createTTS = ({ $, client }) => {
     } catch (e) {}
   };
 
-  const debugLog = (message) => {
-    if (!config.debugLog) return;
-    try {
-      const timestamp = new Date().toISOString();
-      fs.appendFileSync(logFile, `[${timestamp}] ${message}\n`);
-    } catch (e) {}
-  };
-
   /**
    * Play an audio file using system media player
    */
@@ -173,7 +178,11 @@ export const createTTS = ({ $, client }) => {
         for (let i = 0; i < loops; i++) {
           await $`afplay ${filePath}`.quiet();
         }
+      } else if (platform === 'linux' && linux) {
+        // Use the Linux platform module for audio playback
+        await linux.playAudioFile(filePath, loops);
       } else {
+        // Generic fallback for other Unix-like systems
         for (let i = 0; i < loops; i++) {
           try {
             await $`paplay ${filePath}`.quiet();
@@ -337,8 +346,15 @@ ${ssml}
 
   /**
    * Check if the system has been idle long enough that the monitor might be asleep.
+   * On Linux, we always return true (assume monitor might be asleep) since idle detection
+   * varies significantly across desktop environments.
    */
   const isMonitorLikelyAsleep = async () => {
+    if (platform === 'linux') {
+      // On Linux, we can't reliably detect idle time across all DEs
+      // Return true to always attempt wake (it's a no-op if already awake)
+      return true;
+    }
     if (platform !== 'win32' || !$) return true;
     try {
       const idleThreshold = config.idleThresholdSeconds || 60;
@@ -378,6 +394,10 @@ public static class IdleCheck {
    * Get the current system volume level (0-100).
    */
   const getCurrentVolume = async () => {
+    // Use Linux platform module
+    if (platform === 'linux' && linux) {
+      return await linux.getCurrentVolume();
+    }
     if (platform !== 'win32' || !$) return -1;
     try {
       const cmd = `
@@ -416,6 +436,9 @@ public static extern int waveOutGetVolume(IntPtr hwo, out uint dwVolume);
         await $`powershell.exe -NoProfile -ExecutionPolicy Bypass -Command ${cmd}`.quiet();
       } else if (platform === 'darwin') {
         await $`caffeinate -u -t 1`.quiet();
+      } else if (platform === 'linux' && linux) {
+        // Use the Linux platform module for wake monitor
+        await linux.wakeMonitor();
       }
     } catch (e) {
       debugLog(`wakeMonitor error: ${e.message}`);
@@ -439,6 +462,9 @@ public static extern int waveOutGetVolume(IntPtr hwo, out uint dwVolume);
         await $`powershell.exe -NoProfile -ExecutionPolicy Bypass -Command ${cmd}`.quiet();
       } else if (platform === 'darwin') {
         await $`osascript -e "set volume output volume 100"`.quiet();
+      } else if (platform === 'linux' && linux) {
+        // Use the Linux platform module for force volume
+        await linux.forceVolume();
       }
     } catch (e) {
       debugLog(`forceVolume error: ${e.message}`);