@mohak34/opencode-notifier 0.1.14 → 0.1.16

package/README.md

@@ -92,6 +92,7 @@ To customize the plugin, create `~/.config/opencode/opencode-notifier.json`:
   "notification": true,
   "timeout": 5,
   "showProjectName": true,
+  "suppressWhenFocused": false,
   "command": {
     "enabled": false,
     "path": "/path/to/command",
@@ -108,7 +109,7 @@ To customize the plugin, create `~/.config/opencode/opencode-notifier.json`:
   "messages": {
     "permission": "Session needs permission",
     "complete": "Session has finished",
-    "subagent_complete": "Subagent has finished",
+    "subagent_complete": "Subagent task completed",
     "error": "Session encountered an error",
     "question": "Session has a question"
   },
@@ -130,6 +131,7 @@ To customize the plugin, create `~/.config/opencode/opencode-notifier.json`:
 | `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 |
+| `suppressWhenFocused` | boolean | `false` | Suppress notifications when terminal is focused |
 | `command` | object | — | Command execution settings (enabled/path/args/minDuration) |
 
 ### Events
@@ -164,6 +166,14 @@ Or use a boolean to toggle both:
 
 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).
 
+### Suppress when focused
+
+When `suppressWhenFocused` is enabled, notifications are skipped if your terminal is the frontmost window.
+
+- macOS: works out of the box
+- Windows: uses PowerShell to detect the foreground app
+- Linux: requires one of `xdotool`, `wmctrl`, or `xprop` (install via your package manager). If none are installed, suppression is skipped.
+
 ### Messages
 
 Customize notification text:

package/dist/index.js

@@ -18,6 +18,231 @@ var __toESM = (mod, isNodeMode, target) => {
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// node_modules/detect-terminal/dist/index.js
+var require_dist = __commonJS((exports, module) => {
+  var __create2 = Object.create;
+  var __defProp2 = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames2 = Object.getOwnPropertyNames;
+  var __getProtoOf2 = Object.getPrototypeOf;
+  var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp2(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames2(from))
+        if (!__hasOwnProp2.call(to, key) && key !== except)
+          __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target, mod));
+  var __toCommonJS = (mod) => __copyProps(__defProp2({}, "__esModule", { value: true }), mod);
+  var detect_terminal_exports = {};
+  __export(detect_terminal_exports, {
+    default: () => detect_terminal_default,
+    detectFromEnv: () => detectFromEnv,
+    detectFromProcessTitle: () => detectFromProcessTitle,
+    detectFromShell: () => detectFromShell,
+    detectTerminal: () => detectTerminal
+  });
+  module.exports = __toCommonJS(detect_terminal_exports);
+  var import_node_child_process = __require("child_process");
+  var import_node_path = __toESM2(__require("path"));
+  var detectFromEnv = /* @__PURE__ */ __name(() => {
+    const platform = process.platform;
+    if (platform === "android" && process.env.TERMUX_VERSION) {
+      return "termux";
+    }
+    let termProgram = process.env.TERM_PROGRAM?.trim()?.toLowerCase();
+    if (platform === "darwin" && termProgram) {
+      termProgram = import_node_path.default.parse(termProgram).name;
+    }
+    if (termProgram) {
+      switch (termProgram) {
+        case "apple_terminal":
+          return "terminal";
+        case "eterm":
+          return "eterm";
+        case "gnome-terminal":
+          return "gnome_terminal";
+        case "gnome-terminal-server":
+          return "gnome_terminal";
+        case "hyper":
+          return "hyper";
+        case "iterm.app":
+          return "iterm";
+        case "iterm":
+          return "iterm";
+        case "iterm2":
+          return "iterm";
+        case "kitty":
+          return "kitty";
+        case "konsole":
+          return "konsole";
+        case "mate-terminal":
+          return "mate_terminal";
+        case "powershell":
+          return "powershell";
+        case "putty":
+          return "putty";
+        case "qterminal":
+          return "qterminal";
+        case "rxvt":
+          return "rxvt";
+        case "terminal.app":
+          return "terminal_app";
+        case "terminal":
+          return "terminal";
+        case "terminator":
+          return "terminator";
+        case "termux":
+          return "termux";
+        case "vscode":
+          return "vscode";
+        case "warp":
+          return "warp";
+        case "wezterm":
+          return "wezterm";
+        case "xfce4-terminal":
+          return "xfce4_terminal";
+        case "alacritty":
+          return "alacritty";
+        default:
+          break;
+      }
+      return termProgram.replace(/[^a-z0-9]+/g, "_");
+    }
+    if (typeof process.env.VSCODE_PID !== "undefined" || typeof process.env.TERM_PROGRAM_VERSION !== "undefined" && /vscode/i.test(process.env.TERM_PROGRAM_VERSION)) {
+      return "vscode";
+    }
+    const term = process.env.TERM?.trim()?.toLowerCase();
+    if (term && term !== "unknown") {
+      if (term === "xterm" || term === "xterm-256color") {
+        if (process.env.VTE_VERSION) {
+          const vteVersion = parseInt(process.env.VTE_VERSION, 10);
+          if (vteVersion >= 3803) {
+            return "gnome_terminal";
+          }
+        }
+        for (const [key] of Object.entries(process.env)) {
+          if (/konsole/i.test(key)) {
+            return "konsole";
+          }
+        }
+        if (platform === "darwin") {
+          return "terminal";
+        }
+        return "xterm";
+      }
+      if (/screen/.test(term))
+        return "screen";
+      if (/tmux/.test(term))
+        return "tmux";
+      if (/rxvt/.test(term))
+        return "rxvt";
+      if (/vt100/.test(term))
+        return "vt100";
+      if (/linux/.test(term))
+        return "linux_console";
+      if (/alacritty/.test(term))
+        return "alacritty";
+      if (/dopamine/.test(term))
+        return "dopamine";
+      if (/kitty/.test(term))
+        return "kitty";
+      if (/ghostty/.test(term))
+        return "ghostty";
+      return term.replace(/[^a-z0-9]+/g, "_");
+    }
+    const colorTerm = process.env.COLORTERM?.trim()?.toLowerCase();
+    if (colorTerm === "truecolor" || colorTerm === "24bit") {
+      return "truecolor_terminal";
+    }
+    if (colorTerm) {
+      return colorTerm.replace(/[^a-z0-9]+/g, "_");
+    }
+    return null;
+  }, "detectFromEnv");
+  var detectFromShell = /* @__PURE__ */ __name(() => {
+    try {
+      const isWindows = process.platform === "win32";
+      if (isWindows) {
+        if (process.env.WT_SESSION)
+          return "windows_terminal";
+        const shell = process.env.COMSPEC?.toLowerCase() || "";
+        if (/powershell/i.test(shell))
+          return "powershell";
+        if (/pwsh/i.test(shell))
+          return "powershell";
+        if (/cmd\.exe/i.test(shell))
+          return "cmd";
+        if (/wt\.exe/i.test(shell))
+          return "windows_terminal";
+        if (/conhost\.exe/i.test(shell))
+          return "conhost";
+        return "windows_cmd";
+      }
+      const terminal = (0, import_node_child_process.execSync)("echo $TERM", {
+        encoding: "utf8",
+        timeout: 1000,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim().toLowerCase();
+      return terminal ? terminal.replace(/[^a-z0-9]+/g, "_") : null;
+    } catch {
+      return null;
+    }
+  }, "detectFromShell");
+  var detectFromProcessTitle = /* @__PURE__ */ __name(() => {
+    const processTitle = process.title?.toLowerCase() ?? "";
+    if (/^alacritty/.test(processTitle))
+      return "alacritty";
+    if (/^kitty/.test(processTitle))
+      return "kitty";
+    if (/^wezterm/.test(processTitle))
+      return "wezterm";
+    if (/^hyper/.test(processTitle))
+      return "hyper";
+    if (/bash/.test(processTitle))
+      return "bash";
+    if (/zsh/.test(processTitle))
+      return "zsh";
+    if (/ksh/.test(processTitle))
+      return "ksh";
+    if (/fish/.test(processTitle))
+      return "fish";
+    if (/csh/.test(processTitle))
+      return "csh";
+    if (/tcsh/.test(processTitle))
+      return "tcsh";
+    if (/pwsh/.test(processTitle))
+      return "powershell";
+    if (/powershell/.test(processTitle))
+      return "powershell";
+    if (/cmd/.test(processTitle))
+      return "cmd";
+    if (/sh$/.test(processTitle))
+      return "sh";
+    if (/^node/.test(processTitle))
+      return "node";
+    return null;
+  }, "detectFromProcessTitle");
+  var detectTerminal = /* @__PURE__ */ __name(() => {
+    let terminal = detectFromEnv();
+    if (!terminal) {
+      terminal = detectFromShell();
+    }
+    if (!terminal) {
+      terminal = detectFromProcessTitle();
+    }
+    return terminal || "unknown";
+  }, "detectTerminal");
+  var detect_terminal_default = detectTerminal;
+});
+
 // node_modules/shellwords/lib/shellwords.js
 var require_shellwords = __commonJS((exports) => {
   (function() {
@@ -3502,7 +3727,7 @@ var require_version = __commonJS((exports) => {
 });
 
 // node_modules/uuid/dist/index.js
-var require_dist = __commonJS((exports) => {
+var require_dist2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", {
     value: true
   });
@@ -3582,7 +3807,7 @@ var require_toaster = __commonJS((exports, module) => {
   var utils = require_utils();
   var Balloon = require_balloon();
   var os = __require("os");
-  var { v4: uuid } = require_dist();
+  var { v4: uuid } = require_dist2();
   var EventEmitter = __require("events").EventEmitter;
   var util = __require("util");
   var fallback;
@@ -3742,6 +3967,7 @@ var DEFAULT_CONFIG = {
   notification: true,
   timeout: 5,
   showProjectName: true,
+  suppressWhenFocused: false,
   command: {
     enabled: false,
     path: "",
@@ -3809,6 +4035,7 @@ function loadConfig() {
       notification: globalNotification,
       timeout: typeof userConfig.timeout === "number" && userConfig.timeout > 0 ? userConfig.timeout : DEFAULT_CONFIG.timeout,
       showProjectName: userConfig.showProjectName ?? DEFAULT_CONFIG.showProjectName,
+      suppressWhenFocused: typeof userConfig.suppressWhenFocused === "boolean" ? userConfig.suppressWhenFocused : DEFAULT_CONFIG.suppressWhenFocused,
       command: {
         enabled: typeof userCommand.enabled === "boolean" ? userCommand.enabled : DEFAULT_CONFIG.command.enabled,
         path: typeof userCommand.path === "string" ? userCommand.path : DEFAULT_CONFIG.command.path,
@@ -3854,6 +4081,10 @@ function getSoundPath(config, event) {
   return config.sounds[event];
 }
 
+// src/index.ts
+var import_detect_terminal = __toESM(require_dist(), 1);
+import { execFile } from "child_process";
+
 // src/notify.ts
 var import_node_notifier = __toESM(require_node_notifier(), 1);
 import os from "os";
@@ -4030,6 +4261,12 @@ async function handleEvent(config, eventType, projectName, elapsedSeconds) {
   const promises = [];
   const message = getMessage(config, eventType);
   if (isEventNotificationEnabled(config, eventType)) {
+    if (config.suppressWhenFocused) {
+      const shouldSuppress = await isTerminalFocused();
+      if (shouldSuppress) {
+        return;
+      }
+    }
     const title = getNotificationTitle(config, projectName);
     promises.push(sendNotification(title, message, config.timeout));
   }
@@ -4044,6 +4281,99 @@ async function handleEvent(config, eventType, projectName, elapsedSeconds) {
   }
   await Promise.allSettled(promises);
 }
+async function runExecCommand(command, args) {
+  return new Promise((resolve) => {
+    execFile(command, args, (error, stdout) => {
+      if (error) {
+        resolve(null);
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
+}
+async function runOsascript(script) {
+  if (process.platform !== "darwin")
+    return null;
+  return runExecCommand("osascript", ["-e", script]);
+}
+async function getFrontmostAppMac() {
+  return runOsascript('tell application "System Events" to get name of first application process whose frontmost is true');
+}
+async function getFrontmostProcessWindows() {
+  if (process.platform !== "win32")
+    return null;
+  const script = [
+    'Add-Type @"',
+    "using System;",
+    "using System.Runtime.InteropServices;",
+    "public class Win32 {",
+    '  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();',
+    '  [DllImport("user32.dll")] public static extern int GetWindowThreadProcessId(IntPtr hWnd, out int processId);',
+    "}",
+    '"@',
+    "$hwnd = [Win32]::GetForegroundWindow()",
+    "$pid = 0",
+    "[Win32]::GetWindowThreadProcessId($hwnd, [ref]$pid) | Out-Null",
+    "(Get-Process -Id $pid).ProcessName"
+  ].join(`
+`);
+  return runExecCommand("powershell", ["-NoProfile", "-Command", script]);
+}
+function extractQuotedStrings(input) {
+  const matches = input.match(/"([^"]+)"/g);
+  if (!matches)
+    return [];
+  return matches.map((value) => value.replace(/"/g, ""));
+}
+async function getActiveWindowClassLinux() {
+  if (process.platform !== "linux")
+    return null;
+  const xdotoolClass = await runExecCommand("xdotool", ["getactivewindow", "getwindowclassname"]);
+  if (xdotoolClass)
+    return xdotoolClass;
+  const activeWindow = await runExecCommand("xprop", ["-root", "_NET_ACTIVE_WINDOW"]);
+  if (!activeWindow)
+    return null;
+  const idMatch = activeWindow.match(/0x[0-9a-fA-F]+/);
+  if (!idMatch)
+    return null;
+  const wmClass = await runExecCommand("xprop", ["-id", idMatch[0], "WM_CLASS"]);
+  if (!wmClass)
+    return null;
+  const names = extractQuotedStrings(wmClass);
+  if (names.length === 0)
+    return null;
+  return names[names.length - 1];
+}
+function normalizeAppName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function matchesTerminal(frontmost, terminal) {
+  const frontNormalized = normalizeAppName(frontmost);
+  const terminalNormalized = normalizeAppName(terminal);
+  if (!frontNormalized || !terminalNormalized)
+    return false;
+  return frontNormalized.includes(terminalNormalized) || terminalNormalized.includes(frontNormalized);
+}
+async function isTerminalFocused() {
+  const terminalName = import_detect_terminal.default({ preferOuter: true });
+  if (!terminalName)
+    return false;
+  if (process.platform === "darwin") {
+    const frontmost = await getFrontmostAppMac();
+    return frontmost ? matchesTerminal(frontmost, terminalName) : false;
+  }
+  if (process.platform === "win32") {
+    const frontmostProcess = await getFrontmostProcessWindows();
+    return frontmostProcess ? matchesTerminal(frontmostProcess, terminalName) : false;
+  }
+  if (process.platform === "linux") {
+    const frontmostClass = await getActiveWindowClassLinux();
+    return frontmostClass ? matchesTerminal(frontmostClass, terminalName) : false;
+  }
+  return false;
+}
 function getSessionIDFromEvent(event) {
   const sessionID = event?.properties?.sessionID;
   if (typeof sessionID === "string" && sessionID.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohak34/opencode-notifier",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "OpenCode plugin that sends system notifications and plays sounds when permission is needed, generation completes, or errors occur",
   "author": "mohak34",
   "license": "MIT",
@@ -32,6 +32,7 @@
     "alerts"
   ],
   "dependencies": {
+    "detect-terminal": "^2.0.0",
     "node-notifier": "^10.0.1"
   },
   "devDependencies": {