@mohak34/opencode-notifier 0.1.12 → 0.1.14

package/README.md

@@ -18,7 +18,7 @@ To pin a specific version:
 
 ```json
 {
-  "plugin": ["@mohak34/opencode-notifier@0.1.10"]
+  "plugin": ["@mohak34/opencode-notifier@0.1.14"]
 }
 ```
 
@@ -46,13 +46,13 @@ Remove-Item -Recurse -Force "$env:USERPROFILE\.cache\opencode\node_modules\@moha
 
 Then restart OpenCode - it will download the latest version automatically.
 
-### If you use a pinned version (e.g., `@0.1.10`)
+### If you use a pinned version (e.g., `@0.1.14`)
 
 1. Update the version in your `opencode.json`:
 
    ```json
    {
-     "plugin": ["@mohak34/opencode-notifier@0.1.10"]
+     "plugin": ["@mohak34/opencode-notifier@0.1.14"]
    }
    ```
 
@@ -91,21 +91,31 @@ To customize the plugin, create `~/.config/opencode/opencode-notifier.json`:
   "sound": true,
   "notification": true,
   "timeout": 5,
+  "showProjectName": true,
+  "command": {
+    "enabled": false,
+    "path": "/path/to/command",
+    "args": ["--event", "{event}", "--message", "{message}"],
+    "minDuration": 0
+  },
   "events": {
     "permission": { "sound": true, "notification": true },
     "complete": { "sound": true, "notification": true },
+    "subagent_complete": { "sound": false, "notification": false },
     "error": { "sound": true, "notification": true },
     "question": { "sound": true, "notification": true }
   },
   "messages": {
-    "permission": "OpenCode needs permission",
-    "complete": "OpenCode has finished",
-    "error": "OpenCode encountered an error",
-    "question": "OpenCode has a question"
+    "permission": "Session needs permission",
+    "complete": "Session has finished",
+    "subagent_complete": "Subagent has finished",
+    "error": "Session encountered an error",
+    "question": "Session has a question"
   },
   "sounds": {
     "permission": "/path/to/custom/sound.wav",
     "complete": "/path/to/custom/sound.wav",
+    "subagent_complete": "/path/to/custom/sound.wav",
     "error": "/path/to/custom/sound.wav",
     "question": "/path/to/custom/sound.wav"
   }
@@ -119,6 +129,8 @@ To customize the plugin, create `~/.config/opencode/opencode-notifier.json`:
 | `sound` | boolean | `true` | Global toggle for all sounds |
 | `notification` | boolean | `true` | Global toggle for all notifications |
 | `timeout` | number | `5` | Notification duration in seconds (Linux only) |
+| `showProjectName` | boolean | `true` | Show project folder name in notification title |
+| `command` | object | — | Command execution settings (enabled/path/args/minDuration) |
 
 ### Events
 
@@ -129,6 +141,7 @@ Control sound and notification separately for each event:
   "events": {
     "permission": { "sound": true, "notification": true },
     "complete": { "sound": false, "notification": true },
+    "subagent_complete": { "sound": true, "notification": false },
     "error": { "sound": true, "notification": false },
     "question": { "sound": true, "notification": true }
   }
@@ -142,12 +155,15 @@ Or use a boolean to toggle both:
   "events": {
     "permission": true,
     "complete": false,
+    "subagent_complete": true,
     "error": true,
     "question": true
   }
 }
 ```
 
+Note: `complete` fires for primary (main) session completion, while `subagent_complete` fires for subagent completion. `subagent_complete` defaults to disabled (both sound and notification are false).
+
 ### Messages
 
 Customize notification text:
@@ -157,12 +173,33 @@ Customize notification text:
   "messages": {
     "permission": "Action required",
     "complete": "Done!",
+    "subagent_complete": "Subagent finished",
     "error": "Something went wrong",
     "question": "Input needed"
   }
 }
 ```
 
+### Command
+
+Run a custom command when events fire. Use `{event}` and `{message}` tokens in `path` or `args` to inject the event name and message.
+
+`command.minDuration` (optional, seconds) gates command execution based on the time elapsed since the last user prompt.
+- Applies to all events for the custom command.
+- If elapsed time is known and is below `minDuration`, the command is skipped.
+- If elapsed time cannot be determined for an event, the command still runs.
+
+```json
+{
+  "command": {
+    "enabled": true,
+    "path": "/path/to/command",
+    "args": ["--event", "{event}", "--message", "{message}"],
+    "minDuration": 10
+  }
+}
+```
+
 ### Custom Sounds
 
 Use your own sound files:
@@ -172,6 +209,7 @@ Use your own sound files:
   "sounds": {
     "permission": "/home/user/sounds/alert.wav",
     "complete": "/home/user/sounds/done.wav",
+    "subagent_complete": "/home/user/sounds/subagent-done.wav",
     "error": "/home/user/sounds/error.wav",
     "question": "/home/user/sounds/question.wav"
   }
@@ -180,6 +218,30 @@ Use your own sound files:
 
 If a custom sound file path is provided but the file doesn't exist, the plugin will fall back to the bundled sound.
 
+### Example: Different behaviors for main and subagent completion
+
+You may want different notification behaviors for primary sessions versus subagent sessions. For example:
+
+- **Main session completion**: Play a sound and show a system notification
+- **Subagent completion**: Play a different sound, but no system notification
+
+```json
+{
+  "events": {
+    "complete": { "sound": true, "notification": true },
+    "subagent_complete": { "sound": true, "notification": false }
+  },
+  "messages": {
+    "complete": "Session has finished",
+    "subagent_complete": "Subagent task completed"
+  },
+  "sounds": {
+    "complete": "/home/user/sounds/main-done.wav",
+    "subagent_complete": "/home/user/sounds/subagent-chime.wav"
+  }
+}
+```
+
 ## Troubleshooting
 
 ### macOS: Notifications not showing (only sound works)
@@ -188,17 +250,10 @@ If a custom sound file path is provided but the file doesn't exist, the plugin w
 
 If notifications still don't work after updating:
 
-1. **Install terminal-notifier via Homebrew:**
-
-   ```bash
-   brew install terminal-notifier
-   ```
-
-2. **Check notification permissions:**
+1. **Check notification permissions:**
    - Open **System Settings > Notifications**
-   - Find your terminal app (e.g., Ghostty, iTerm2, Terminal)
+   - Find **Script Editor** in the list
    - Make sure notifications are set to **Banners** or **Alerts**
-   - Also enable notifications for **terminal-notifier** if it appears in the list
 
 ### Linux: Notifications not showing
 

package/dist/index.js

@@ -3726,6 +3726,9 @@ var require_node_notifier = __commonJS((exports, module) => {
   module.exports.Growl = Growl;
 });
 
+// src/index.ts
+import { basename } from "path";
+
 // src/config.ts
 import { readFileSync, existsSync } from "fs";
 import { join } from "path";
@@ -3738,21 +3741,30 @@ var DEFAULT_CONFIG = {
   sound: true,
   notification: true,
   timeout: 5,
+  showProjectName: true,
+  command: {
+    enabled: false,
+    path: "",
+    minDuration: 0
+  },
   events: {
     permission: { ...DEFAULT_EVENT_CONFIG },
     complete: { ...DEFAULT_EVENT_CONFIG },
+    subagent_complete: { sound: false, notification: false },
     error: { ...DEFAULT_EVENT_CONFIG },
     question: { ...DEFAULT_EVENT_CONFIG }
   },
   messages: {
-    permission: "OpenCode needs permission",
-    complete: "OpenCode has finished",
-    error: "OpenCode encountered an error",
-    question: "OpenCode has a question"
+    permission: "Session needs permission",
+    complete: "Session has finished",
+    subagent_complete: "Subagent task completed",
+    error: "Session encountered an error",
+    question: "Session has a question"
   },
   sounds: {
     permission: null,
     complete: null,
+    subagent_complete: null,
     error: null,
     question: null
   }
@@ -3789,25 +3801,38 @@ function loadConfig() {
       sound: globalSound,
       notification: globalNotification
     };
+    const userCommand = userConfig.command ?? {};
+    const commandArgs = Array.isArray(userCommand.args) ? userCommand.args.filter((arg) => typeof arg === "string") : undefined;
+    const commandMinDuration = typeof userCommand.minDuration === "number" && Number.isFinite(userCommand.minDuration) && userCommand.minDuration > 0 ? userCommand.minDuration : 0;
     return {
       sound: globalSound,
       notification: globalNotification,
       timeout: typeof userConfig.timeout === "number" && userConfig.timeout > 0 ? userConfig.timeout : DEFAULT_CONFIG.timeout,
+      showProjectName: userConfig.showProjectName ?? DEFAULT_CONFIG.showProjectName,
+      command: {
+        enabled: typeof userCommand.enabled === "boolean" ? userCommand.enabled : DEFAULT_CONFIG.command.enabled,
+        path: typeof userCommand.path === "string" ? userCommand.path : DEFAULT_CONFIG.command.path,
+        args: commandArgs,
+        minDuration: commandMinDuration
+      },
       events: {
         permission: parseEventConfig(userConfig.events?.permission ?? userConfig.permission, defaultWithGlobal),
         complete: parseEventConfig(userConfig.events?.complete ?? userConfig.complete, defaultWithGlobal),
+        subagent_complete: parseEventConfig(userConfig.events?.subagent_complete ?? userConfig.subagent_complete, { sound: false, notification: false }),
         error: parseEventConfig(userConfig.events?.error ?? userConfig.error, defaultWithGlobal),
-        question: parseEventConfig(userConfig.events?.question, defaultWithGlobal)
+        question: parseEventConfig(userConfig.events?.question ?? userConfig.question, defaultWithGlobal)
       },
       messages: {
         permission: userConfig.messages?.permission ?? DEFAULT_CONFIG.messages.permission,
         complete: userConfig.messages?.complete ?? DEFAULT_CONFIG.messages.complete,
+        subagent_complete: userConfig.messages?.subagent_complete ?? DEFAULT_CONFIG.messages.subagent_complete,
         error: userConfig.messages?.error ?? DEFAULT_CONFIG.messages.error,
         question: userConfig.messages?.question ?? DEFAULT_CONFIG.messages.question
       },
       sounds: {
         permission: userConfig.sounds?.permission ?? DEFAULT_CONFIG.sounds.permission,
         complete: userConfig.sounds?.complete ?? DEFAULT_CONFIG.sounds.complete,
+        subagent_complete: userConfig.sounds?.subagent_complete ?? DEFAULT_CONFIG.sounds.subagent_complete,
         error: userConfig.sounds?.error ?? DEFAULT_CONFIG.sounds.error,
         question: userConfig.sounds?.question ?? DEFAULT_CONFIG.sounds.question
       }
@@ -3833,7 +3858,6 @@ function getSoundPath(config, event) {
 var import_node_notifier = __toESM(require_node_notifier(), 1);
 import os from "os";
 import { exec } from "child_process";
-var NOTIFICATION_TITLE = "OpenCode";
 var DEBOUNCE_MS = 1000;
 var platform = os.type();
 var platformNotifier;
@@ -3847,7 +3871,7 @@ if (platform === "Linux" || platform.match(/BSD$/)) {
   platformNotifier = import_node_notifier.default;
 }
 var lastNotificationTime = {};
-async function sendNotification(message, timeout) {
+async function sendNotification(title, message, timeout) {
   const now = Date.now();
   if (lastNotificationTime[message] && now - lastNotificationTime[message] < DEBOUNCE_MS) {
     return;
@@ -3856,7 +3880,7 @@ async function sendNotification(message, timeout) {
   if (platform === "Darwin") {
     return new Promise((resolve) => {
       const escapedMessage = message.replace(/"/g, "\\\"");
-      const escapedTitle = NOTIFICATION_TITLE.replace(/"/g, "\\\"");
+      const escapedTitle = title.replace(/"/g, "\\\"");
       exec(`osascript -e 'display notification "${escapedMessage}" with title "${escapedTitle}"'`, () => {
         resolve();
       });
@@ -3864,7 +3888,7 @@ async function sendNotification(message, timeout) {
   }
   return new Promise((resolve) => {
     const notificationOptions = {
-      title: NOTIFICATION_TITLE,
+      title,
       message,
       timeout,
       icon: undefined
@@ -3976,42 +4000,131 @@ async function playSound(event, customPath) {
   } catch {}
 }
 
+// src/command.ts
+import { spawn as spawn2 } from "child_process";
+function substituteTokens(value, event, message) {
+  return value.replaceAll("{event}", event).replaceAll("{message}", message);
+}
+function runCommand2(config, event, message) {
+  if (!config.command.enabled || !config.command.path) {
+    return;
+  }
+  const args = (config.command.args ?? []).map((arg) => substituteTokens(arg, event, message));
+  const command = substituteTokens(config.command.path, event, message);
+  const proc = spawn2(command, args, {
+    stdio: "ignore",
+    detached: true
+  });
+  proc.on("error", () => {});
+  proc.unref();
+}
+
 // src/index.ts
-async function handleEvent(config, eventType) {
+function getNotificationTitle(config, projectName) {
+  if (config.showProjectName && projectName) {
+    return `OpenCode (${projectName})`;
+  }
+  return "OpenCode";
+}
+async function handleEvent(config, eventType, projectName, elapsedSeconds) {
   const promises = [];
+  const message = getMessage(config, eventType);
   if (isEventNotificationEnabled(config, eventType)) {
-    const message = getMessage(config, eventType);
-    promises.push(sendNotification(message, config.timeout));
+    const title = getNotificationTitle(config, projectName);
+    promises.push(sendNotification(title, message, config.timeout));
   }
   if (isEventSoundEnabled(config, eventType)) {
     const customSoundPath = getSoundPath(config, eventType);
     promises.push(playSound(eventType, customSoundPath));
   }
+  const minDuration = config.command?.minDuration;
+  const shouldSkipCommand = typeof minDuration === "number" && Number.isFinite(minDuration) && minDuration > 0 && typeof elapsedSeconds === "number" && Number.isFinite(elapsedSeconds) && elapsedSeconds < minDuration;
+  if (!shouldSkipCommand) {
+    runCommand2(config, eventType, message);
+  }
   await Promise.allSettled(promises);
 }
-var NotifierPlugin = async ({ project, client, $, directory, worktree }) => {
+function getSessionIDFromEvent(event) {
+  const sessionID = event?.properties?.sessionID;
+  if (typeof sessionID === "string" && sessionID.length > 0) {
+    return sessionID;
+  }
+  return null;
+}
+async function getElapsedSinceLastPrompt(client, sessionID) {
+  try {
+    const response = await client.session.messages({ path: { id: sessionID } });
+    const messages = response.data ?? [];
+    let lastUserMessageTime = null;
+    for (const msg of messages) {
+      const info = msg.info;
+      if (info.role === "user" && typeof info.time?.created === "number") {
+        if (lastUserMessageTime === null || info.time.created > lastUserMessageTime) {
+          lastUserMessageTime = info.time.created;
+        }
+      }
+    }
+    if (lastUserMessageTime !== null) {
+      return (Date.now() - lastUserMessageTime) / 1000;
+    }
+  } catch {}
+  return null;
+}
+async function isChildSession(client, sessionID) {
+  try {
+    const response = await client.session.get({ path: { id: sessionID } });
+    const parentID = response.data?.parentID;
+    return !!parentID;
+  } catch {
+    return false;
+  }
+}
+async function handleEventWithElapsedTime(client, config, eventType, projectName, event) {
+  const minDuration = config.command?.minDuration;
+  const shouldLookupElapsed = !!config.command?.enabled && typeof config.command?.path === "string" && config.command.path.length > 0 && typeof minDuration === "number" && Number.isFinite(minDuration) && minDuration > 0;
+  let elapsedSeconds = null;
+  if (shouldLookupElapsed) {
+    const sessionID = getSessionIDFromEvent(event);
+    if (sessionID) {
+      elapsedSeconds = await getElapsedSinceLastPrompt(client, sessionID);
+    }
+  }
+  await handleEvent(config, eventType, projectName, elapsedSeconds);
+}
+var NotifierPlugin = async ({ client, directory }) => {
   const config = loadConfig();
+  const projectName = directory ? basename(directory) : null;
   return {
     event: async ({ event }) => {
       if (event.type === "permission.updated") {
-        await handleEvent(config, "permission");
+        await handleEventWithElapsedTime(client, config, "permission", projectName, event);
       }
       if (event.type === "permission.asked") {
-        await handleEvent(config, "permission");
+        await handleEventWithElapsedTime(client, config, "permission", projectName, event);
       }
       if (event.type === "session.idle") {
-        await handleEvent(config, "complete");
+        const sessionID = getSessionIDFromEvent(event);
+        if (sessionID) {
+          const isChild = await isChildSession(client, sessionID);
+          if (!isChild) {
+            await handleEventWithElapsedTime(client, config, "complete", projectName, event);
+          } else {
+            await handleEventWithElapsedTime(client, config, "subagent_complete", projectName, event);
+          }
+        } else {
+          await handleEventWithElapsedTime(client, config, "complete", projectName, event);
+        }
       }
       if (event.type === "session.error") {
-        await handleEvent(config, "error");
+        await handleEventWithElapsedTime(client, config, "error", projectName, event);
       }
     },
     "permission.ask": async () => {
-      await handleEvent(config, "permission");
+      await handleEvent(config, "permission", projectName, null);
     },
-    "tool.execute.before": async (input, output) => {
+    "tool.execute.before": async (input) => {
       if (input.tool === "question") {
-        await handleEvent(config, "question");
+        await handleEvent(config, "question", projectName, null);
       }
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohak34/opencode-notifier",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "OpenCode plugin that sends system notifications and plays sounds when permission is needed, generation completes, or errors occur",
   "author": "mohak34",
   "license": "MIT",