opencode-plugin-boops 2.6.2 → 2.7.0

package/README.md

@@ -5,7 +5,7 @@ Sound notifications for OpenCode - plays pleasant "boop" sounds when tasks compl
 ## Features
 
 - 🎵 Soft, friendly notification sounds when AI completes tasks
-- 📡 Gentle alert when AI needs your permission or input
+- 📡 Gentle alert when AI needs your permission, input, or asks a question
 - 🌐 Works out of the box with online sounds (auto-downloaded and cached)
 - 🔄 Fully configurable - use URLs or local files
 - 🐧 Works on Linux (with `paplay` or `aplay`)
@@ -67,6 +67,7 @@ The plugin listens to OpenCode events and plays sounds based on your configurati
 
 - **`session.idle`** - AI finishes responding → soft "pristine" notification
 - **`permission.asked`** - AI needs permission → gentle "relax" chime
+- **`question.asked`** - AI asks a question → gentle "relax" chime
 - **`session.error`** - An error occurs → friendly "magic" alert
 
 **Instant config reload:** The config is reloaded on every event, so changes take effect immediately without restarting OpenCode! Edit your config, trigger an event, and hear the new sound instantly.
@@ -147,6 +148,10 @@ You can configure sounds for any of the 28 OpenCode events:
 - `permission.asked` - AI needs permission
 - `permission.replied` - Permission response given
 
+**Question events (2):**
+- `question.asked` - AI asks a multiple-choice question
+- `question.replied` - User answers a question
+
 **File events (2):**
 - `file.edited` - File is edited
 - `file.watcher.updated` - File watcher detects change

package/boops.default.toml

@@ -5,8 +5,9 @@
 
 [sounds]
 "session.idle" = "pristine"  # AI completes response
+"session.error" = "exclamation"  # Error occurs
 "permission.asked" = "relax"  # AI needs permission
-"session.error" = "magic"  # Error occurs
+"question.asked" = "relax"  # AI asks a question (falls back to permission.asked if not set)
 
 # You can use:
 # - Sound names: "pristine" (searches sounds.json by name)

package/cli/browse

@@ -34,6 +34,8 @@ const availableEvents = [
   "message.updated",
   "permission.asked",
   "permission.replied",
+  "question.asked",
+  "question.replied",
   "server.connected",
   "session.compacted",
   "session.created",

package/index.ts

@@ -52,6 +52,17 @@ export const BoopsPlugin: Plugin = async ({ client }) => {
     })
   }
 
+  // Track last error time to debounce idle sounds after errors
+  let lastErrorTime = 0
+  const ERROR_DEBOUNCE_MS = 2000
+
+  // Track pending sounds that can be cancelled
+  let pendingSoundTimeout: ReturnType<typeof setTimeout> | null = null
+  let pendingSoundCancelled = false
+
+  // Track which sessions are subagents (have parentID)
+  const subagentSessions = new Set<string>()
+
   // Cache directory for downloaded sounds
   const cacheDir = join(homedir(), ".cache", "opencode", "boops")
   
@@ -249,33 +260,54 @@ export const BoopsPlugin: Plugin = async ({ client }) => {
     return null
   }
 
-  // Play sound with fallback mechanism
-  const playSound = async (soundFile: string, eventName: string) => {
+  // Play sound with fallback mechanism (supports cancellation)
+  const playSound = async (soundFile: string, eventName: string, canCancel = false) => {
     if (player === "echo") return // Skip if no player
 
-    try {
-      // Resolve the sound file (download if URL, check if local path exists)
-      const resolvedPath = await resolveSoundPath(soundFile, eventName)
-      
-      if (resolvedPath) {
-        await Bun.$`${player} ${resolvedPath}`.quiet()
-        return
-      }
-
-      // Try fallback
-      const fallback = config.fallbacks?.default
-      if (fallback) {
-        const fallbackPath = await resolveSoundPath(fallback, "fallback")
-        if (fallbackPath) {
-          await Bun.$`${player} ${fallbackPath}`.quiet()
+    const play = async () => {
+      try {
+        // Resolve the sound file (download if URL, check if local path exists)
+        const resolvedPath = await resolveSoundPath(soundFile, eventName)
+        
+        if (resolvedPath) {
+          await Bun.$`${player} ${resolvedPath}`.quiet()
           return
         }
+
+        // Try fallback
+        const fallback = config.fallbacks?.default
+        if (fallback) {
+          const fallbackPath = await resolveSoundPath(fallback, "fallback")
+          if (fallbackPath) {
+            await Bun.$`${player} ${fallbackPath}`.quiet()
+            return
+          }
+        }
+
+        // Last resort: terminal bell
+        await Bun.$`echo -e "\a"`.quiet()
+      } catch (error) {
+        // Silently fail - don't spam logs for sound errors
       }
+    }
 
-      // Last resort: terminal bell
-      await Bun.$`echo -e "\a"`.quiet()
-    } catch (error) {
-      // Silently fail - don't spam logs for sound errors
+    if (canCancel) {
+      // Clear any pending sound
+      if (pendingSoundTimeout) {
+        clearTimeout(pendingSoundTimeout)
+        pendingSoundTimeout = null
+      }
+      pendingSoundCancelled = false
+      
+      // Delay slightly to allow error to cancel it
+      pendingSoundTimeout = setTimeout(() => {
+        pendingSoundTimeout = null
+        if (!pendingSoundCancelled) {
+          play()
+        }
+      }, 100)
+    } else {
+      await play()
     }
   }
 
@@ -312,12 +344,41 @@ export const BoopsPlugin: Plugin = async ({ client }) => {
       // Reload config on every event for instant updates (no restart needed!)
       config = await loadConfig()
       
-      // Log session.idle events for debugging (helpful for users configuring filters)
-      if (event.type === "session.idle") {
-        await log(`session.idle event received`, { 
-          properties: event,
-          configuredSound: config.sounds["session.idle"]
-        })
+      // Track subagent sessions (sessions with parentID)
+      if (event.type === "session.updated") {
+        const sessionInfo = event.properties?.info
+        if (sessionInfo?.parentID) {
+          subagentSessions.add(sessionInfo.id)
+        }
+      }
+      
+      // Cancel any pending sounds on error
+      if (event.type === "session.error") {
+        lastErrorTime = Date.now()
+        if (pendingSoundTimeout) {
+          pendingSoundCancelled = true
+          clearTimeout(pendingSoundTimeout)
+          pendingSoundTimeout = null
+        }
+      }
+       
+      // Skip idle sound if error recently fired (for events that bypass cancellation)
+      if (event.type === "session.idle" && Date.now() - lastErrorTime < ERROR_DEBOUNCE_MS) {
+        return // Don't play idle sound after error
+      }
+      
+      // Skip idle for subagent sessions
+      const sessionID = event.properties?.sessionID
+      if ((event.type === "session.idle" || event.type === "session.status") && sessionID && subagentSessions.has(sessionID)) {
+        return // Don't play sound for subagent completions
+      }
+      
+      // Handle question.asked -> play permission sound as a fallback
+      if (event.type === "question.asked") {
+        const questionSound = config.sounds["question.asked"] || config.sounds["permission.asked"]
+        if (questionSound) {
+          await playSound(questionSound, "question.asked")
+        }
       }
 
       const soundConfig = config.sounds[event.type]
@@ -325,13 +386,16 @@ export const BoopsPlugin: Plugin = async ({ client }) => {
 
       // Handle simple string (just a sound file path/URL)
       if (typeof soundConfig === "string") {
-        await playSound(soundConfig, event.type)
+        // Use cancellable sound for idle
+        const canCancel = event.type === "session.idle" || event.type === "session.error"
+        await playSound(soundConfig, event.type, canCancel)
         return
       }
 
       // Handle filter object
       if (matchesFilter(event, soundConfig)) {
-        await playSound(soundConfig.sound, event.type)
+        const canCancel = event.type === "session.idle" || event.type === "session.error"
+        await playSound(soundConfig.sound, event.type, canCancel)
       }
     },
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-plugin-boops",
-  "version": "2.6.2",
+  "version": "2.7.0",
   "description": "Sound notifications for OpenCode - plays pleasant sounds when tasks complete or input is needed",
   "main": "index.ts",
   "type": "module",