@mohak34/opencode-notifier 0.1.29 → 0.1.30-beta.0

package/README.md

@@ -54,6 +54,7 @@ Create `~/.config/opencode/opencode-notifier.json` with the defaults:
   "showProjectName": true,
   "showSessionTitle": false,
   "showIcon": true,
+  "suppressWhenFocused": true,
   "notificationSystem": "osascript",
   "linux": {
     "grouping": false
@@ -121,6 +122,7 @@ Create `~/.config/opencode/opencode-notifier.json` with the defaults:
 - `showProjectName` - Show folder name in notification title (default: true)
 - `showSessionTitle` - Include the session title in notification messages via `{sessionTitle}` placeholder (default: true)
 - `showIcon` - Show OpenCode icon, Windows/Linux only (default: true)
+- `suppressWhenFocused` - Skip notifications and sounds when the terminal is the active window (default: true). See [Focus detection](#focus-detection) for platform details
 - `notificationSystem` - macOS only: `"osascript"` or `"node-notifier"` (default: "osascript")
 - `linux.grouping` - Linux only: replace notifications in-place instead of stacking (default: false). Requires `notify-send` 0.8+
 
@@ -277,6 +279,32 @@ Run your own script when something happens. Use `{event}`, `{message}`, and `{se
 
 **NOTE:** If you go with node-notifier and start missing notifications, just switch back or remove the option from the config. Users have reported issues with using node-notifier for receiving only sounds and no notification popups.
 
+## 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.
+
+To disable this and always get notified:
+
+```json
+{
+  "suppressWhenFocused": false
+}
+```
+
+### Platform support
+
+| Platform | Method | Requirements |
+|----------|--------|--------------|
+| macOS | AppleScript (`System Events`) | None |
+| Linux X11 | `xdotool` | `xdotool` installed |
+| Linux Wayland (Hyprland) | `hyprctl activewindow` | None |
+| Linux Wayland (Sway) | `swaymsg -t get_tree` | None |
+| Linux Wayland (KDE) | `kdotool` | `kdotool` installed |
+| Linux Wayland (GNOME) | Not supported | Falls back to always notifying |
+| Windows | `GetForegroundWindow()` via PowerShell | None |
+
+If detection fails for any reason (missing tools, unknown compositor, permissions), it falls back to always notifying. It never silently eats your notifications.
+
 ## Linux: Notification Grouping
 
 By default, each notification appears as a separate entry. During active sessions this can create noise when multiple events fire quickly (e.g. permission + complete + question).

package/dist/index.js

@@ -3745,6 +3745,7 @@ var DEFAULT_CONFIG = {
   showProjectName: true,
   showSessionTitle: false,
   showIcon: true,
+  suppressWhenFocused: true,
   notificationSystem: "osascript",
   linux: {
     grouping: false
@@ -3848,6 +3849,7 @@ function loadConfig() {
       showProjectName: userConfig.showProjectName ?? DEFAULT_CONFIG.showProjectName,
       showSessionTitle: userConfig.showSessionTitle ?? DEFAULT_CONFIG.showSessionTitle,
       showIcon: userConfig.showIcon ?? DEFAULT_CONFIG.showIcon,
+      suppressWhenFocused: userConfig.suppressWhenFocused ?? DEFAULT_CONFIG.suppressWhenFocused,
       notificationSystem: userConfig.notificationSystem === "node-notifier" ? "node-notifier" : "osascript",
       linux: {
         grouping: typeof userConfig.linux?.grouping === "boolean" ? userConfig.linux.grouping : DEFAULT_CONFIG.linux.grouping
@@ -4198,6 +4200,228 @@ function runCommand2(config, event, message, sessionTitle, projectName) {
   proc.unref();
 }
 
+// src/focus.ts
+import { execSync } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+var TERMINAL_MAP = {
+  ghostty: { name: "Ghostty", macProcessNames: ["Ghostty", "ghostty"] },
+  kitty: { name: "kitty", macProcessNames: ["kitty"] },
+  alacritty: { name: "Alacritty", macProcessNames: ["Alacritty", "alacritty"] },
+  wezterm: { name: "WezTerm", macProcessNames: ["WezTerm", "wezterm-gui"] },
+  apple_terminal: { name: "Terminal", macProcessNames: ["Terminal"] },
+  iterm: { name: "iTerm2", macProcessNames: ["iTerm2", "iTerm"] },
+  warp: { name: "Warp", macProcessNames: ["Warp"] },
+  vscode: { name: "VS Code", macProcessNames: ["Code", "Code - Insiders", "Cursor", "cursor"] },
+  windows_terminal: { name: "Windows Terminal", macProcessNames: [] },
+  tmux: { name: "tmux", macProcessNames: [] }
+};
+var cachedTerminal = undefined;
+function detectTerminal() {
+  if (cachedTerminal !== undefined)
+    return cachedTerminal;
+  const env = process.env;
+  let result = null;
+  if (env.GHOSTTY_RESOURCES_DIR) {
+    result = TERMINAL_MAP.ghostty;
+  } else if (env.KITTY_PID) {
+    result = TERMINAL_MAP.kitty;
+  } else if (env.ALACRITTY_SOCKET || env.ALACRITTY_LOG) {
+    result = TERMINAL_MAP.alacritty;
+  } else if (env.WEZTERM_EXECUTABLE) {
+    result = TERMINAL_MAP.wezterm;
+  } else if (env.WT_SESSION) {
+    result = TERMINAL_MAP.windows_terminal;
+  } else if (env.VSCODE_PID || env.TERM_PROGRAM === "vscode") {
+    result = TERMINAL_MAP.vscode;
+  } else if (env.TERM_PROGRAM === "Apple_Terminal") {
+    result = TERMINAL_MAP.apple_terminal;
+  } else if (env.TERM_PROGRAM === "iTerm.app") {
+    result = TERMINAL_MAP.iterm;
+  } else if (env.TERM_PROGRAM === "WarpTerminal") {
+    result = TERMINAL_MAP.warp;
+  } else if (env.TMUX || env.TERM_PROGRAM === "tmux") {
+    result = TERMINAL_MAP.tmux;
+  }
+  cachedTerminal = result;
+  return result;
+}
+function execWithTimeout(command, timeoutMs = 500) {
+  try {
+    return execSync(command, { timeout: timeoutMs, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+function isMacOSFocused(terminal) {
+  const frontApp = execWithTimeout(`osascript -e 'tell application "System Events" to get name of first application process whose frontmost is true'`);
+  if (!frontApp)
+    return false;
+  return terminal.macProcessNames.some((name) => name.toLowerCase() === frontApp.toLowerCase());
+}
+function isPidAncestorOfCurrentProcess(pid) {
+  let currentPid = process.pid;
+  for (let depth = 0;depth < 20; depth++) {
+    if (currentPid === pid)
+      return true;
+    if (currentPid <= 1)
+      return false;
+    try {
+      const stat = readFileSync2(`/proc/${currentPid}/stat`, "utf-8");
+      const match = stat.match(/^\d+\s+\(.*?\)\s+\S+\s+(\d+)/);
+      if (!match)
+        return false;
+      currentPid = parseInt(match[1], 10);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function isLinuxX11Focused() {
+  const pidStr = execWithTimeout("xdotool getactivewindow getwindowpid");
+  if (!pidStr)
+    return false;
+  const pid = parseInt(pidStr, 10);
+  if (!Number.isFinite(pid) || pid <= 0)
+    return false;
+  return isPidAncestorOfCurrentProcess(pid);
+}
+function isHyprlandFocused() {
+  const output = execWithTimeout("hyprctl activewindow -j");
+  if (!output)
+    return false;
+  try {
+    const data = JSON.parse(output);
+    const pid = data?.pid;
+    if (typeof pid !== "number" || pid <= 0)
+      return false;
+    return isPidAncestorOfCurrentProcess(pid);
+  } catch {
+    return false;
+  }
+}
+function isSwayFocused() {
+  const output = execWithTimeout("swaymsg -t get_tree", 1000);
+  if (!output)
+    return false;
+  try {
+    const tree = JSON.parse(output);
+    const pid = findFocusedPid(tree);
+    if (pid === null)
+      return false;
+    return isPidAncestorOfCurrentProcess(pid);
+  } catch {
+    return false;
+  }
+}
+function findFocusedPid(node) {
+  if (node.focused === true && typeof node.pid === "number") {
+    return node.pid;
+  }
+  if (Array.isArray(node.nodes)) {
+    for (const child of node.nodes) {
+      const pid = findFocusedPid(child);
+      if (pid !== null)
+        return pid;
+    }
+  }
+  if (Array.isArray(node.floating_nodes)) {
+    for (const child of node.floating_nodes) {
+      const pid = findFocusedPid(child);
+      if (pid !== null)
+        return pid;
+    }
+  }
+  return null;
+}
+function isKDEWaylandFocused() {
+  const windowId = execWithTimeout("kdotool getactivewindow");
+  if (!windowId)
+    return false;
+  const pidStr = execWithTimeout(`kdotool getwindowpid ${windowId}`);
+  if (!pidStr)
+    return false;
+  const pid = parseInt(pidStr, 10);
+  if (!Number.isFinite(pid) || pid <= 0)
+    return false;
+  return isPidAncestorOfCurrentProcess(pid);
+}
+function isLinuxWaylandFocused() {
+  const env = process.env;
+  if (env.HYPRLAND_INSTANCE_SIGNATURE) {
+    return isHyprlandFocused();
+  }
+  if (env.SWAYSOCK) {
+    return isSwayFocused();
+  }
+  if (env.KDE_SESSION_VERSION) {
+    return isKDEWaylandFocused();
+  }
+  return false;
+}
+function isWindowsFocused() {
+  const script = `
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class FocusHelper {
+  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint pid);
+}
+"@
+$hwnd = [FocusHelper]::GetForegroundWindow()
+$pid = 0
+[void][FocusHelper]::GetWindowThreadProcessId($hwnd, [ref]$pid)
+Write-Output $pid
+`.trim().replace(/\n/g, "; ");
+  const pidStr = execWithTimeout(`powershell -NoProfile -Command "${script}"`, 1000);
+  if (!pidStr)
+    return false;
+  const pid = parseInt(pidStr, 10);
+  if (!Number.isFinite(pid) || pid <= 0)
+    return false;
+  let currentPid = process.pid;
+  for (let depth = 0;depth < 20; depth++) {
+    if (currentPid === pid)
+      return true;
+    if (currentPid <= 1)
+      return false;
+    const parentPidStr = execWithTimeout(`powershell -NoProfile -Command "(Get-Process -Id ${currentPid}).Parent.Id"`, 500);
+    if (!parentPidStr)
+      return false;
+    currentPid = parseInt(parentPidStr, 10);
+    if (!Number.isFinite(currentPid))
+      return false;
+  }
+  return false;
+}
+function isTerminalFocused() {
+  try {
+    const platform3 = process.platform;
+    if (platform3 === "darwin") {
+      const terminal = detectTerminal();
+      if (!terminal || terminal.macProcessNames.length === 0)
+        return false;
+      return isMacOSFocused(terminal);
+    }
+    if (platform3 === "linux") {
+      if (process.env.WAYLAND_DISPLAY) {
+        return isLinuxWaylandFocused();
+      }
+      if (process.env.DISPLAY) {
+        return isLinuxX11Focused();
+      }
+      return false;
+    }
+    if (platform3 === "win32") {
+      return isWindowsFocused();
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
 // src/index.ts
 var IDLE_COMPLETE_DELAY_MS = 350;
 var pendingIdleTimers = new Map;
@@ -4229,6 +4453,9 @@ function getNotificationTitle(config, projectName) {
   return "OpenCode";
 }
 async function handleEvent(config, eventType, projectName, elapsedSeconds, sessionTitle) {
+  if (config.suppressWhenFocused && isTerminalFocused()) {
+    return;
+  }
   const promises = [];
   const rawMessage = getMessage(config, eventType);
   const message = interpolateMessage(rawMessage, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohak34/opencode-notifier",
-  "version": "0.1.29",
+  "version": "0.1.30-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",