@mohak34/opencode-notifier 0.1.36 → 0.2.0-beta.0

package/README.md

@@ -181,6 +181,7 @@ Customize the notification text:
 Messages support placeholder tokens that get replaced with actual values:
 
 - `{sessionTitle}` - The title/summary of the current session (e.g. "Fix login bug")
+- `{agentName}` - Subagent name extracted from session titles with `(@name subagent)` suffix (e.g. `builder`, `codebase-researcher`), empty for non-subagent sessions
 - `{projectName}` - The project folder name
 - `{timestamp}` - Current time in `HH:MM:SS` format (e.g. "14:30:05")
 - `{turn}` - Global notification counter that persists across restarts (e.g. 1, 2, 3). Stored in `~/.config/opencode/opencode-notifier-state.json`
@@ -236,7 +237,7 @@ Set per-event volume from `0` to `1`:
 
 ### Custom commands
 
-Run your own script when something happens. Use `{event}`, `{message}`, `{sessionTitle}`, `{projectName}`, `{timestamp}`, and `{turn}` as placeholders:
+Run your own script when something happens. Use `{event}`, `{message}`, `{sessionTitle}`, `{agentName}`, `{projectName}`, `{timestamp}`, and `{turn}` as placeholders:
 
 ```json
 {
@@ -251,7 +252,7 @@ Run your own script when something happens. Use `{event}`, `{message}`, `{sessio
 
 - `enabled` - Turn command on/off
 - `path` - Path to your script/executable
-- `args` - Arguments to pass, can use `{event}`, `{message}`, `{sessionTitle}`, `{projectName}`, `{timestamp}`, and `{turn}` tokens
+- `args` - Arguments to pass, can use `{event}`, `{message}`, `{sessionTitle}`, `{agentName}`, `{projectName}`, `{timestamp}`, and `{turn}` tokens
 - `minDuration` - Skip if response was quick, avoids spam (seconds)
 
 #### Example: Log events to a file
@@ -301,6 +302,18 @@ If you're using [Ghostty](https://ghostty.org/) terminal, you can use its native
 
 This sends notifications directly through the terminal instead of using system notification tools. Works on any platform where Ghostty is running.
 
+If you're using Ghostty inside tmux, enable passthrough in your tmux config so OSC 9 notifications can pass through:
+
+```tmux
+set -g allow-passthrough on
+```
+
+Then reload tmux config:
+
+```bash
+tmux source-file ~/.tmux.conf
+```
+
 ## Focus detection
 
 When `suppressWhenFocused` is `true` (the default), notifications and sounds are skipped if the terminal running OpenCode is the active/focused window. The idea is simple: if you're already looking at it, you don't need an alert.
@@ -320,15 +333,18 @@ To disable this and always get notified:
 | macOS | AppleScript (`System Events`) | None | Untested |
 | Linux X11 | `xdotool` | `xdotool` installed | Untested |
 | Linux Wayland (Hyprland) | `hyprctl activewindow` | None | Tested |
+| Linux Wayland (Niri) | `niri msg --json focused-window` | None | Tested |
 | Linux Wayland (Sway) | `swaymsg -t get_tree` | None | Untested |
 | Linux Wayland (KDE) | `kdotool` | `kdotool` installed | Untested |
 | Linux Wayland (GNOME) | Not supported | - | Falls back to always notifying |
-| Linux Wayland (Niri, river, dwl, Cosmic, etc.) | Not supported | - | Falls back to always notifying |
+| Linux Wayland (river, dwl, Cosmic, etc.) | Not supported | - | Falls back to always notifying |
 | Windows | `GetForegroundWindow()` via PowerShell | None | Untested |
 
 **Unsupported compositors**: Wayland has no standard protocol for querying the focused window. Each compositor has its own IPC, and GNOME intentionally doesn't expose focus information. Unsupported compositors fall back to always notifying.
 
-**tmux/screen**: When running inside tmux, the tmux server daemonizes and detaches from the terminal's process tree. The plugin handles this by querying the tmux client PID and walking from there. GNU Screen has the same issue but is not currently handled (falls back to always notifying).
+**tmux/screen**: When running inside tmux, focus detection uses tmux pane state (`session_attached`, `window_active`, `pane_active`) via `tmux display-message`. This keeps suppression accurate when switching panes/windows/sessions. GNU Screen is not currently handled (falls back to always notifying).
+
+**WezTerm panes**: When running in WezTerm with `WEZTERM_PANE` set, focus suppression is pane-aware via `wezterm cli list-clients --format json`. This means notifications are shown when you switch to a different WezTerm pane/tab.
 
 **Fail-open design**: If detection fails for any reason (missing tools, unknown compositor, permissions), it falls back to always notifying. It never silently eats your notifications.
 

package/dist/index.js

@@ -220,6 +220,8 @@ function interpolateMessage(message, context) {
   let result = message;
   const sessionTitle = context.sessionTitle || "";
   result = result.replaceAll("{sessionTitle}", sessionTitle);
+  const agentName = context.agentName || "";
+  result = result.replaceAll("{agentName}", agentName);
   const projectName = context.projectName || "";
   result = result.replaceAll("{projectName}", projectName);
   const timestamp = context.timestamp || "";
@@ -250,6 +252,18 @@ if (platform === "Linux" || platform.match(/BSD$/)) {
 var lastNotificationTime = {};
 var lastLinuxNotificationId = null;
 var linuxNotifySendSupportsReplace = null;
+function sanitizeGhosttyField(value) {
+  return value.replace(/[;\x07\x1b\n\r]/g, "");
+}
+function formatGhosttyNotificationSequence(title, message, env = process.env) {
+  const escapedTitle = sanitizeGhosttyField(title);
+  const escapedMessage = sanitizeGhosttyField(message);
+  const payload = `\x1B]9;${escapedTitle}: ${escapedMessage}\x07`;
+  if (env.TMUX) {
+    return `\x1BPtmux;\x1B${payload}\x1B\\`;
+  }
+  return payload;
+}
 function detectNotifySendCapabilities() {
   return new Promise((resolve) => {
     execFile("notify-send", ["--version"], (error, stdout) => {
@@ -302,9 +316,8 @@ async function sendNotification(title, message, timeout, iconPath, notificationS
   lastNotificationTime[message] = now;
   if (notificationSystem === "ghostty") {
     return new Promise((resolve) => {
-      const escapedTitle = title.replace(/[;\x07\x1b\n\r]/g, "");
-      const escapedMessage = message.replace(/[;\x07\x1b\n\r]/g, "");
-      process.stdout.write(`\x1B]9;${escapedTitle}: ${escapedMessage}\x07`, () => {
+      const sequence = formatGhosttyNotificationSequence(title, message);
+      process.stdout.write(sequence, () => {
         resolve();
       });
     });
@@ -481,20 +494,21 @@ async function playSound(event, customPath, volume) {
 
 // src/command.ts
 import { spawn as spawn2 } from "child_process";
-function substituteTokens(value, event, message, sessionTitle, projectName, timestamp, turn) {
+function substituteTokens(value, event, message, sessionTitle, agentName, projectName, timestamp, turn) {
   let result = value.replaceAll("{event}", event).replaceAll("{message}", message);
   result = result.replaceAll("{sessionTitle}", sessionTitle || "");
+  result = result.replaceAll("{agentName}", agentName || "");
   result = result.replaceAll("{projectName}", projectName || "");
   result = result.replaceAll("{timestamp}", timestamp || "");
   result = result.replaceAll("{turn}", turn != null ? String(turn) : "");
   return result;
 }
-function runCommand2(config, event, message, sessionTitle, projectName, timestamp, turn) {
+function runCommand2(config, event, message, sessionTitle, agentName, projectName, timestamp, turn) {
   if (!config.command.enabled || !config.command.path) {
     return;
   }
-  const args = (config.command.args ?? []).map((arg) => substituteTokens(arg, event, message, sessionTitle, projectName, timestamp, turn));
-  const command = substituteTokens(config.command.path, event, message, sessionTitle, projectName, timestamp, turn);
+  const args = (config.command.args ?? []).map((arg) => substituteTokens(arg, event, message, sessionTitle, agentName, projectName, timestamp, turn));
+  const command = substituteTokens(config.command.path, event, message, sessionTitle, agentName, projectName, timestamp, turn);
   const proc = spawn2(command, args, {
     stdio: "ignore",
     detached: true
@@ -578,10 +592,38 @@ function getSwayActiveWindowId() {
     return null;
   }
 }
+function getNiriActiveWindowId() {
+  const output = execWithTimeout("niri msg --json focused-window", 1000);
+  if (!output)
+    return null;
+  try {
+    const data = JSON.parse(output);
+    return typeof data?.id === "number" ? String(data.id) : null;
+  } catch {
+    return null;
+  }
+}
+function parseWezTermFocusedPaneId(output) {
+  try {
+    const data = JSON.parse(output);
+    if (!Array.isArray(data))
+      return null;
+    for (const client of data) {
+      if (typeof client?.focused_pane_id === "number") {
+        return String(client.focused_pane_id);
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 function getLinuxWaylandActiveWindowId() {
   const env = process.env;
   if (env.HYPRLAND_INSTANCE_SIGNATURE)
     return getHyprlandActiveWindowId();
+  if (env.NIRI_SOCKET)
+    return getNiriActiveWindowId();
   if (env.SWAYSOCK)
     return getSwayActiveWindowId();
   if (env.KDE_SESSION_VERSION)
@@ -607,6 +649,9 @@ function normalizeMacAppName(value) {
 function getExpectedMacTerminalAppNames(env) {
   const expected = new Set;
   const termProgram = typeof env.TERM_PROGRAM === "string" ? normalizeMacAppName(env.TERM_PROGRAM) : "";
+  if (env.TMUX && (termProgram === "tmux" || termProgram === "screen" || termProgram.length === 0)) {
+    return new Set(MAC_TERMINAL_APP_NAMES);
+  }
   if (termProgram === "apple_terminal") {
     expected.add("terminal");
   } else if (termProgram === "iterm" || termProgram === "iterm2") {
@@ -652,16 +697,31 @@ function getActiveWindowId() {
   return null;
 }
 var cachedWindowId = getActiveWindowId();
-var tmuxPane = process.env.TMUX_PANE ?? null;
-function isTmuxPaneActive() {
+function isTmuxPaneFocused(tmuxPane, probeResult) {
   if (!tmuxPane)
-    return true;
-  const result = execWithTimeout(`tmux display-message -t ${tmuxPane} -p '#{session_attached} #{window_active} #{pane_active}'`);
-  if (!result)
     return false;
-  const [sessionAttached, windowActive, paneActive] = result.split(" ");
+  if (!probeResult)
+    return false;
+  const [sessionAttached, windowActive, paneActive] = probeResult.split(" ");
   return sessionAttached === "1" && windowActive === "1" && paneActive === "1";
 }
+function isTmuxPaneActive() {
+  const tmuxPane = process.env.TMUX_PANE ?? null;
+  const result = execFileWithTimeout("tmux", ["display-message", "-t", tmuxPane ?? "", "-p", "#{session_attached} #{window_active} #{pane_active}"]);
+  return isTmuxPaneFocused(tmuxPane, result);
+}
+function isWezTermPaneActive() {
+  const weztermPane = process.env.WEZTERM_PANE ?? null;
+  if (!weztermPane)
+    return true;
+  const output = execFileWithTimeout("wezterm", ["cli", "list-clients", "--format", "json"], 1000);
+  if (!output)
+    return false;
+  const focusedPaneId = parseWezTermFocusedPaneId(output);
+  if (!focusedPaneId)
+    return false;
+  return focusedPaneId === weztermPane;
+}
 function isTerminalFocused() {
   try {
     if (process.platform === "darwin") {
@@ -669,6 +729,9 @@ function isTerminalFocused() {
       if (!isMacTerminalAppFocused(frontmostAppName, process.env)) {
         return false;
       }
+      if (!isWezTermPaneActive()) {
+        return false;
+      }
       if (process.env.TMUX) {
         return isTmuxPaneActive();
       }
@@ -679,6 +742,8 @@ function isTerminalFocused() {
     const currentId = getActiveWindowId();
     if (currentId !== cachedWindowId)
       return false;
+    if (!isWezTermPaneActive())
+      return false;
     if (process.env.TMUX)
       return isTmuxPaneActive();
     return true;
@@ -687,6 +752,34 @@ function isTerminalFocused() {
   }
 }
 
+// src/permission-dedupe.ts
+var PERMISSION_DEDUPE_WINDOW_MS = 1000;
+var sessionLastPermissionAt = new Map;
+var globalLastPermissionAt = 0;
+function shouldSuppressPermissionAlert(sessionID, now = Date.now()) {
+  const sessionLastAt = sessionID ? sessionLastPermissionAt.get(sessionID) : undefined;
+  const latestSeen = Math.max(globalLastPermissionAt, sessionLastAt ?? 0);
+  const isDuplicate = latestSeen > 0 && now - latestSeen < PERMISSION_DEDUPE_WINDOW_MS;
+  if (isDuplicate) {
+    return true;
+  }
+  globalLastPermissionAt = now;
+  if (sessionID) {
+    sessionLastPermissionAt.set(sessionID, now);
+  }
+  return false;
+}
+function prunePermissionAlertState(cutoffMs) {
+  for (const [sessionID, timestamp] of sessionLastPermissionAt) {
+    if (timestamp < cutoffMs) {
+      sessionLastPermissionAt.delete(sessionID);
+    }
+  }
+  if (globalLastPermissionAt < cutoffMs) {
+    globalLastPermissionAt = 0;
+  }
+}
+
 // src/index.ts
 var IDLE_COMPLETE_DELAY_MS = 350;
 var pendingIdleTimers = new Map;
@@ -734,6 +827,7 @@ setInterval(() => {
       sessionLastBusyAt.delete(sessionID);
     }
   }
+  prunePermissionAlertState(cutoff);
 }, 5 * 60 * 1000);
 function getNotificationTitle(config, projectName) {
   if (config.showProjectName && projectName) {
@@ -748,7 +842,26 @@ function formatTimestamp() {
   const s = String(now.getSeconds()).padStart(2, "0");
   return `${h}:${m}:${s}`;
 }
-async function handleEvent(config, eventType, projectName, elapsedSeconds, sessionTitle, sessionID) {
+function extractAgentNameFromSessionTitle(sessionTitle) {
+  if (!sessionTitle) {
+    return "";
+  }
+  const match = sessionTitle.match(/\s*\(@([^\s)]+)\s+subagent\)\s*$/);
+  return match ? match[1] : "";
+}
+function shouldResolveAgentNameForEvent(config, eventType) {
+  if (getMessage(config, eventType).includes("{agentName}")) {
+    return true;
+  }
+  if (!config.command.enabled || !isEventCommandEnabled(config, eventType)) {
+    return false;
+  }
+  if (config.command.path.includes("{agentName}")) {
+    return true;
+  }
+  return (config.command.args ?? []).some((arg) => arg.includes("{agentName}"));
+}
+async function handleEvent(config, eventType, projectName, elapsedSeconds, sessionTitle, sessionID, agentName) {
   if (config.suppressWhenFocused && isTerminalFocused()) {
     return;
   }
@@ -758,6 +871,7 @@ async function handleEvent(config, eventType, projectName, elapsedSeconds, sessi
   const rawMessage = getMessage(config, eventType);
   const message = interpolateMessage(rawMessage, {
     sessionTitle: config.showSessionTitle ? sessionTitle : null,
+    agentName,
     projectName,
     timestamp,
     turn
@@ -775,7 +889,7 @@ async function handleEvent(config, eventType, projectName, elapsedSeconds, sessi
   const minDuration = config.command?.minDuration;
   const shouldSkipCommand = !isEventCommandEnabled(config, eventType) || typeof minDuration === "number" && Number.isFinite(minDuration) && minDuration > 0 && typeof elapsedSeconds === "number" && Number.isFinite(elapsedSeconds) && elapsedSeconds < minDuration;
   if (!shouldSkipCommand) {
-    runCommand2(config, eventType, message, sessionTitle, projectName, timestamp, turn);
+    runCommand2(config, eventType, message, sessionTitle, agentName, projectName, timestamp, turn);
   }
   await Promise.allSettled(promises);
 }
@@ -905,11 +1019,13 @@ async function handleEventWithElapsedTime(client, config, eventType, projectName
     }
   }
   let sessionTitle = preloadedSessionTitle ?? null;
-  if (sessionID && !sessionTitle && config.showSessionTitle) {
+  const shouldLookupSessionInfo = sessionID && !sessionTitle && (config.showSessionTitle || shouldResolveAgentNameForEvent(config, eventType));
+  if (shouldLookupSessionInfo) {
     const info = await getSessionInfo(client, sessionID);
     sessionTitle = info.title;
   }
-  await handleEvent(config, eventType, projectName, elapsedSeconds, sessionTitle, sessionID);
+  const agentName = extractAgentNameFromSessionTitle(sessionTitle);
+  await handleEvent(config, eventType, projectName, elapsedSeconds, sessionTitle, sessionID, agentName);
 }
 var NotifierPlugin = async ({ client, directory }) => {
   const clientEnv = process.env.OPENCODE_CLIENT;
@@ -924,7 +1040,10 @@ var NotifierPlugin = async ({ client, directory }) => {
     event: async ({ event }) => {
       const config = getConfig();
       if (event.type === "permission.asked") {
-        await handleEventWithElapsedTime(client, config, "permission", projectName, event);
+        const sessionID = getSessionIDFromEvent(event);
+        if (!shouldSuppressPermissionAlert(sessionID)) {
+          await handleEventWithElapsedTime(client, config, "permission", projectName, event);
+        }
       }
       if (event.type === "session.idle") {
         const sessionID = getSessionIDFromEvent(event);
@@ -951,7 +1070,9 @@ var NotifierPlugin = async ({ client, directory }) => {
     },
     "permission.ask": async () => {
       const config = getConfig();
-      await handleEvent(config, "permission", projectName, null);
+      if (!shouldSuppressPermissionAlert(null)) {
+        await handleEvent(config, "permission", projectName, null);
+      }
     },
     "tool.execute.before": async (input) => {
       const config = getConfig();
@@ -963,6 +1084,7 @@ var NotifierPlugin = async ({ client, directory }) => {
 };
 var src_default = NotifierPlugin;
 export {
+  extractAgentNameFromSessionTitle,
   src_default as default,
   NotifierPlugin
 };

package/package.json

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