@mohak34/opencode-notifier 0.2.2-beta.0 → 0.2.3-beta.0

package/README.md

@@ -17,9 +17,10 @@ Restart OpenCode. Done.
 ## What it does
 
 You'll get notified when:
+
 - OpenCode needs permission to run something
 - Your session finishes
-- An error happens  
+- An error happens
 - The question tool pops up
 
 There's also `subagent_complete` for when subagents finish, and `user_cancelled` for when you press ESC to abort -- both are silent by default so you don't get spammed.
@@ -39,9 +40,22 @@ sudo pacman -S libnotify         # Arch
 For sounds, you need one of: `paplay`, `aplay`, `mpv`, or `ffplay`
 
 **Windows**: Works out of the box. But heads up:
+
 - Only `.wav` files work (not mp3)
 - Use full paths like `C:/Users/You/sounds/alert.wav` not `~/`
 
+**WSL**: It's recommeneded to set `customIconPath` pointing to a file on Windows filesystem
+due to issues with path translation (can be copied from `logos` folder from this repository).
+This path will be passed down to `snoretoast-*.exe`
+
+In `opencode-notifier.json` config:
+```json
+  "showIcon": true,
+  "customIconPath": "C:\\Users\\jhon\\Documents\\opencode-logo-dark.png",
+```
+
+- If notifications are not showing up, check out: (missing WSL notification)[https://github.com/mikaelbr/node-notifier?tab=readme-ov-file#windows-and-wsl2]
+
 ## Config file
 
 Create `~/.config/opencode/opencode-notifier.json` with the defaults:
@@ -55,12 +69,14 @@ Create `~/.config/opencode/opencode-notifier.json` with the defaults:
   "showProjectName": true,
   "showSessionTitle": false,
   "showIcon": true,
+  "customIconPath": null,
   "suppressWhenFocused": true,
   "enableOnDesktop": false,
   "notificationSystem": "osascript",
   "linux": {
     "grouping": false
   },
+  "minDuration": 0,
   "command": {
     "enabled": false,
     "path": "/path/to/command",
@@ -217,7 +233,7 @@ Messages support placeholder tokens that get replaced with actual values:
 - `{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`
 
-When `showSessionTitle` is `false`, `{sessionTitle}` is replaced with an empty string. Any trailing separators (`: `, ` - `, ` | `) are automatically cleaned up when a placeholder resolves to empty.
+When `showSessionTitle` is `false`, `{sessionTitle}` is replaced with an empty string. Any trailing separators (`: `, `-`, `|`) are automatically cleaned up when a placeholder resolves to empty.
 
 To disable session titles in messages without changing `showSessionTitle`, just remove the `{sessionTitle}` placeholder from your custom messages.
 
@@ -245,6 +261,7 @@ Use your own sound files:
 ```
 
 Platform notes:
+
 - macOS/Linux: .wav or .mp3 files work
 - Windows: Only .wav files work
 - If file doesn't exist, falls back to bundled sound
@@ -365,23 +382,37 @@ To disable this and always get notified:
 }
 ```
 
+## Minimum duration threshold
+
+You can suppress `complete` and `subagent_complete` notifications for short-lived sessions. Set `minDuration` to the number of seconds a session must exceed to trigger a done notification:
+
+```json
+{
+  "minDuration": 10
+}
+```
+
+With the above, if OpenCode finishes in under 10 seconds, no notification, sound, bell, or command is fired. Default is `0` (no threshold).
+
+This is independent of `command.minDuration`, which only controls whether the custom command runs.
+
 ### Platform support
 
-| Platform | Method | Requirements | Status |
-|----------|--------|--------------|--------|
-| 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 (river, dwl, Cosmic, etc.) | Not supported | - | Falls back to always notifying |
-| Windows | `GetForegroundWindow()` via PowerShell | None | Untested |
+| Platform                                 | Method                                   | Requirements          | Status                         |
+| ---------------------------------------- | ---------------------------------------- | --------------------- | ------------------------------ |
+| 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 | Tested                         |
+| Linux Wayland (GNOME)                    | 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, 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).
+**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. On Linux setups where window focus cannot be detected at all, tmux pane state is also used as a best-effort fallback. 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.
 
@@ -407,6 +438,15 @@ With grouping enabled, each new notification replaces the previous one so you on
 
 Works with all major notification daemons (GNOME, dunst, mako, swaync, etc.) on both X11 and Wayland.
 
+## KDE Plasma: Jump back to terminal from notification
+
+On KDE Plasma/Wayland, clicking the popup body is not consistently delivered as a notification activation event.This plugin uses an explicit notification action button instead:
+
+- **Jump to terminal** (action button on the popup card, or in notification history)
+
+When clicked, the plugin runs its terminal-focus path. On KDE with `kdotool` installed, it auto-captures the startup terminal window ID and jumps back to that pinned window.
+The action button is only enabled on Linux KDE sessions where `kdotool` is available.
+
 ## Updating
 
 If Opencode does not update the plugin or there is an issue with the cache version:
@@ -431,6 +471,7 @@ Switch back to osascript. Some users report node-notifier works for sounds but n
 
 **Linux: No notifications?**
 Install libnotify-bin:
+
 ```bash
 sudo apt install libnotify-bin  # Debian/Ubuntu
 sudo dnf install libnotify       # Fedora
@@ -442,7 +483,39 @@ Test with: `notify-send "Test" "Hello"`
 **Linux: No sounds?**
 Install one of: `paplay`, `aplay`, `mpv`, or `ffplay`
 
+**KDE Plasma: jumps to wrong terminal window or doesn't jump?**
+
+Jump back feature tested on:
+
+- KWin with default floating windows
+- KWin + Krohnkite
+- Ghostty and Konsole
+- Warp
+- OpenCode in tmux inside VS Code terminal
+
+Most terminal emulators should work fine, but there can be exceptions.
+
+Known limitations:
+
+- Kitty is currently unsupported for this jump-back path (unstable focus targeting)
+- Yakuake sessions are not supported for activity-specific jump-back behavior
+
+You can still override manually (if needed) by pinning an explicit window ID:
+
+```bash
+export OPENCODE_NOTIFIER_WINDOW_ID="$(kdotool getactivewindow)"
+opencode
+```
+
+Manual pinning bypasses heuristic window matching and should activate that exact window on notification action click.
+
+**X11 deterministic jump-back**
+
+- `xdotool` support is possible for the same startup pin behavior
+- not implemented yet
+
 **Windows: Custom sounds not working?**
+
 - Must be .wav format (not .mp3)
 - Use full Windows paths: `C:/Users/YourName/sounds/alert.wav` (not `~/`)
 - Make sure the file actually plays in Windows Media Player
@@ -485,6 +558,7 @@ This is a known Bun issue on Windows. Disable native notifications and use Power
 ```
 
 **Plugin not loading?**
+
 - Check your opencode.json syntax
 - Clear the cache (see Updating section)
 - Restart OpenCode

package/dist/index.js

@@ -1,12 +1,87 @@
 // src/index.ts
 import { basename } from "path";
-import { readFileSync as readFileSync2, writeFileSync } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 
 // src/config.ts
 import { readFileSync, existsSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { fileURLToPath } from "url";
+
+// node_modules/is-wsl/index.js
+import process2 from "node:process";
+import os from "node:os";
+import fs3 from "node:fs";
+
+// node_modules/is-inside-container/index.js
+import fs2 from "node:fs";
+
+// node_modules/is-docker/index.js
+import fs from "node:fs";
+var isDockerCached;
+function hasDockerEnv() {
+  try {
+    fs.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === undefined) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+
+// node_modules/is-inside-container/index.js
+var cachedResult;
+var hasContainerEnv = () => {
+  try {
+    fs2.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+function isInsideContainer() {
+  if (cachedResult === undefined) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+
+// node_modules/is-wsl/index.js
+var isWsl = () => {
+  if (process2.platform !== "linux") {
+    return false;
+  }
+  if (os.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    if (fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+      return !isInsideContainer();
+    }
+  } catch {}
+  if (fs3.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs3.existsSync("/run/WSL")) {
+    return !isInsideContainer();
+  }
+  return false;
+};
+var is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+
+// src/config.ts
 var DEFAULT_EVENT_CONFIG = {
   sound: true,
   notification: true,
@@ -21,12 +96,14 @@ var DEFAULT_CONFIG = {
   showProjectName: true,
   showSessionTitle: false,
   showIcon: true,
+  customIconPath: null,
   suppressWhenFocused: true,
   enableOnDesktop: false,
   notificationSystem: "osascript",
   linux: {
     grouping: false
   },
+  minDuration: 0,
   command: {
     enabled: false,
     path: "",
@@ -154,12 +231,14 @@ function loadConfig() {
       showProjectName: userConfig.showProjectName ?? DEFAULT_CONFIG.showProjectName,
       showSessionTitle: userConfig.showSessionTitle ?? DEFAULT_CONFIG.showSessionTitle,
       showIcon: userConfig.showIcon ?? DEFAULT_CONFIG.showIcon,
+      customIconPath: userConfig.customIconPath ?? DEFAULT_CONFIG.customIconPath,
       suppressWhenFocused: userConfig.suppressWhenFocused ?? DEFAULT_CONFIG.suppressWhenFocused,
       enableOnDesktop: typeof userConfig.enableOnDesktop === "boolean" ? userConfig.enableOnDesktop : DEFAULT_CONFIG.enableOnDesktop,
       notificationSystem: userConfig.notificationSystem === "node-notifier" ? "node-notifier" : userConfig.notificationSystem === "ghostty" ? "ghostty" : "osascript",
       linux: {
         grouping: typeof userConfig.linux?.grouping === "boolean" ? userConfig.linux.grouping : DEFAULT_CONFIG.linux.grouping
       },
+      minDuration: typeof userConfig.minDuration === "number" && Number.isFinite(userConfig.minDuration) && userConfig.minDuration >= 0 ? userConfig.minDuration : DEFAULT_CONFIG.minDuration,
       command: {
         enabled: typeof userCommand.enabled === "boolean" ? userCommand.enabled : DEFAULT_CONFIG.command.enabled,
         path: typeof userCommand.path === "string" ? userCommand.path : DEFAULT_CONFIG.command.path,
@@ -249,10 +328,15 @@ function getIconPath(config) {
     return;
   }
   try {
-    const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname2 = dirname(__filename2);
-    const iconPath = join(__dirname2, "..", "logos", "opencode-logo-dark.png");
-    if (existsSync(iconPath)) {
+    let iconPath;
+    if (config.customIconPath) {
+      iconPath = config.customIconPath;
+    } else {
+      const __filename2 = fileURLToPath(import.meta.url);
+      const __dirname2 = dirname(__filename2);
+      iconPath = join(__dirname2, "..", "logos", "opencode-logo-dark.png");
+    }
+    if (is_wsl_default || existsSync(iconPath)) {
       return iconPath;
     }
   } catch {}
@@ -276,21 +360,23 @@ function interpolateMessage(message, context) {
 }
 
 // src/notify.ts
-import os from "os";
-import { exec, execFile } from "child_process";
+import os2 from "os";
+import { exec, execFile, spawn } from "child_process";
 import notifier from "node-notifier";
 var DEBOUNCE_MS = 1000;
-var platform = os.type();
+var platform = os2.type();
 var platformNotifier;
-if (platform === "Linux" || platform.match(/BSD$/)) {
-  const { NotifySend } = notifier;
-  platformNotifier = new NotifySend({ withFallback: false });
-} else if (platform === "Windows_NT") {
+if (platform === "Windows_NT" || is_wsl_default) {
   const { WindowsToaster } = notifier;
   platformNotifier = new WindowsToaster({ withFallback: false });
+} else if (platform === "Linux" || platform.match(/BSD$/)) {
+  const { NotifySend } = notifier;
+  platformNotifier = new NotifySend({ withFallback: false });
 } else if (platform !== "Darwin") {
   platformNotifier = notifier;
 }
+var LINUX_FOCUS_ACTION_KEY = "focus-terminal";
+var LINUX_FOCUS_ACTION_LABEL = "Jump to terminal";
 var lastNotificationTime = {};
 var lastLinuxNotificationId = null;
 var linuxNotifySendSupportsReplace = null;
@@ -324,8 +410,12 @@ function detectNotifySendCapabilities() {
     });
   });
 }
-function sendLinuxNotificationDirect(title, message, timeout, iconPath, grouping = true) {
+function sendLinuxNotificationDirect(title, message, timeout, iconPath, grouping = true, onAction) {
   return new Promise((resolve) => {
+    if (onAction) {
+      sendLinuxNotificationWithActions(title, message, timeout, iconPath, grouping, onAction).then(() => resolve()).catch(() => resolve());
+      return;
+    }
     const args = [];
     args.push("--app-name", "opencode");
     if (iconPath) {
@@ -350,7 +440,85 @@ function sendLinuxNotificationDirect(title, message, timeout, iconPath, grouping
     });
   });
 }
-async function sendNotification(title, message, timeout, iconPath, notificationSystem = "osascript", linuxGrouping = true) {
+async function sendLinuxNotificationWithActions(title, message, timeout, iconPath, grouping = true, onAction) {
+  const args = ["--app-name", "opencode"];
+  if (iconPath) {
+    args.push("--icon", iconPath);
+  }
+  args.push("--expire-time", String(timeout * 1000));
+  if (grouping && lastLinuxNotificationId !== null) {
+    args.push("--replace-id", String(lastLinuxNotificationId));
+  }
+  args.push("--print-id");
+  args.push("--action", `${LINUX_FOCUS_ACTION_KEY}=${LINUX_FOCUS_ACTION_LABEL}`);
+  args.push("--", title, message);
+  return new Promise((resolve) => {
+    const child = spawn("notify-send", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    const consumeStdout = () => {
+      const lines = stdout.split(/\r?\n/);
+      stdout = lines.pop() ?? "";
+      for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line) {
+          continue;
+        }
+        const parsed = parseNotifySendOutputLine(line);
+        if (!parsed) {
+          continue;
+        }
+        if (parsed.type === "id") {
+          if (grouping) {
+            lastLinuxNotificationId = parsed.id;
+          }
+          continue;
+        }
+        if (onAction) {
+          if (parsed.action === "focus") {
+            onAction("focus");
+          } else if (parsed.action === "close") {
+            onAction("close");
+          }
+        }
+      }
+    };
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+      consumeStdout();
+    });
+    child.on("close", () => {
+      if (stdout.trim().length > 0) {
+        stdout += `
+`;
+        consumeStdout();
+      }
+      resolve();
+    });
+    child.on("error", () => {
+      resolve();
+    });
+  });
+}
+function parseNotifySendOutputLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const id = parseInt(trimmed, 10);
+    if (!isNaN(id)) {
+      return { type: "id", id };
+    }
+  }
+  if (trimmed === LINUX_FOCUS_ACTION_KEY) {
+    return { type: "action", action: "focus" };
+  }
+  if (trimmed === "close") {
+    return { type: "action", action: "close" };
+  }
+  return null;
+}
+async function sendNotification(title, message, timeout, iconPath, notificationSystem = "osascript", linuxGrouping = true, onClick) {
   const now = Date.now();
   if (lastNotificationTime[message] && now - lastNotificationTime[message] < DEBOUNCE_MS) {
     return;
@@ -386,7 +554,18 @@ async function sendNotification(title, message, timeout, iconPath, notificationS
       });
     });
   }
-  if (platform === "Linux" || platform.match(/BSD$/)) {
+  if ((platform === "Linux" || platform.match(/BSD$/)) && !is_wsl_default) {
+    if (onClick) {
+      if (linuxGrouping) {
+        if (linuxNotifySendSupportsReplace === null) {
+          linuxNotifySendSupportsReplace = await detectNotifySendCapabilities();
+        }
+        if (linuxNotifySendSupportsReplace) {
+          return sendLinuxNotificationDirect(title, message, timeout, iconPath, true, () => onClick());
+        }
+      }
+      return sendLinuxNotificationDirect(title, message, timeout, iconPath, false, () => onClick());
+    }
     if (linuxGrouping) {
       if (linuxNotifySendSupportsReplace === null) {
         linuxNotifySendSupportsReplace = await detectNotifySendCapabilities();
@@ -404,7 +583,10 @@ async function sendNotification(title, message, timeout, iconPath, notificationS
       icon: iconPath,
       "app-name": "opencode"
     };
-    platformNotifier.notify(notificationOptions, () => {
+    platformNotifier.notify(notificationOptions, (err, response, metadata) => {
+      if (onClick && metadata?.activationType === "default") {
+        onClick();
+      }
       resolve();
     });
   });
@@ -415,7 +597,7 @@ import { platform as platform2 } from "os";
 import { join as join2, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { existsSync as existsSync2 } from "fs";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
 var DEBOUNCE_MS2 = 1000;
 var FULL_VOLUME_PERCENT = 100;
@@ -446,7 +628,7 @@ function getSoundFilePath(event, customPath) {
 }
 async function runCommand(command, args) {
   return new Promise((resolve, reject) => {
-    const proc = spawn(command, args, {
+    const proc = spawn2(command, args, {
       stdio: "ignore",
       detached: false
     });
@@ -516,9 +698,9 @@ async function playSound(event, customPath, volume) {
   if (!soundPath) {
     return;
   }
-  const os2 = platform2();
+  const os3 = platform2();
   try {
-    switch (os2) {
+    switch (os3) {
       case "darwin":
         await playOnMac(soundPath, normalizedVolume);
         break;
@@ -553,7 +735,7 @@ function ringBell(now = Date.now()) {
 }
 
 // src/command.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 function substituteTokens(value, event, message, sessionTitle, agentName, projectName, timestamp, turn) {
   let result = value.replaceAll("{event}", event).replaceAll("{message}", message);
   result = result.replaceAll("{sessionTitle}", sessionTitle || "");
@@ -569,7 +751,7 @@ function runCommand2(config, event, message, sessionTitle, agentName, projectNam
   }
   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, {
+  const proc = spawn3(command, args, {
     stdio: "ignore",
     detached: true
   });
@@ -579,6 +761,28 @@ function runCommand2(config, event, message, sessionTitle, agentName, projectNam
 
 // src/focus.ts
 import { execFileSync, execSync } from "child_process";
+import { readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+var LINUX_TERMINAL_APPS = new Set([
+  "ghostty",
+  "konsole",
+  "gnome-terminal",
+  "xterm",
+  "urxvt",
+  "alacritty",
+  "kitty",
+  "wezterm",
+  "wezterm-gui",
+  "tilix",
+  "terminator",
+  "xfce4-terminal",
+  "lxterminal",
+  "mate-terminal",
+  "deepin-terminal",
+  "foot",
+  "footclient"
+]);
 var MAC_TERMINAL_APP_NAMES = new Set([
   "terminal",
   "iterm2",
@@ -759,6 +963,14 @@ function getActiveWindowId() {
   return null;
 }
 var cachedWindowId = getActiveWindowId();
+var cachedWindowTitleValue;
+function getCachedWindowTitle() {
+  if (cachedWindowTitleValue !== undefined) {
+    return cachedWindowTitleValue;
+  }
+  cachedWindowTitleValue = process.platform === "linux" && !!process.env.KDE_SESSION_VERSION && cachedWindowId ? getWindowTitleFromKdotool(cachedWindowId) : null;
+  return cachedWindowTitleValue;
+}
 function isTmuxPaneFocused(tmuxPane, probeResult) {
   if (!tmuxPane)
     return false;
@@ -767,6 +979,23 @@ function isTmuxPaneFocused(tmuxPane, probeResult) {
   const [sessionAttached, windowActive, paneActive] = probeResult.split(" ");
   return sessionAttached === "1" && windowActive === "1" && paneActive === "1";
 }
+function isLinuxTerminalFocused(params) {
+  const { cachedWindowId: cachedWindowId2, currentWindowId, wezTermPaneActive, tmuxPaneActive } = params;
+  if (!cachedWindowId2) {
+    if (!wezTermPaneActive)
+      return false;
+    if (tmuxPaneActive !== null)
+      return tmuxPaneActive;
+    return false;
+  }
+  if (currentWindowId !== cachedWindowId2)
+    return false;
+  if (!wezTermPaneActive)
+    return false;
+  if (tmuxPaneActive !== null)
+    return tmuxPaneActive;
+  return true;
+}
 function isTmuxPaneActive() {
   const tmuxPane = process.env.TMUX_PANE ?? null;
   const result = execFileWithTimeout("tmux", ["display-message", "-t", tmuxPane ?? "", "-p", "#{session_attached} #{window_active} #{pane_active}"]);
@@ -799,18 +1028,378 @@ function isTerminalFocused() {
       }
       return true;
     }
-    if (!cachedWindowId)
-      return false;
-    const currentId = getActiveWindowId();
-    if (currentId !== cachedWindowId)
-      return false;
-    if (!isWezTermPaneActive())
-      return false;
-    if (process.env.TMUX)
-      return isTmuxPaneActive();
-    return true;
+    const tmuxPaneActive = process.env.TMUX ? isTmuxPaneActive() : null;
+    return isLinuxTerminalFocused({
+      cachedWindowId,
+      currentWindowId: getActiveWindowId(),
+      wezTermPaneActive: isWezTermPaneActive(),
+      tmuxPaneActive
+    });
+  } catch {
+    return false;
+  }
+}
+function getWindowIdFromXdotool(searchTerm) {
+  return execWithTimeout(`xdotool search --classname "${searchTerm}" | head -1`);
+}
+function getWindowIdFromKdotool(searchTerm) {
+  return execWithTimeout(`kdotool search --classname "${searchTerm}" | head -1`);
+}
+function getWindowTitleFromKdotool(windowId) {
+  return execWithTimeout(`kdotool getwindowname ${windowId}`);
+}
+var cachedKDEJumpBackSupport = null;
+function isKDEJumpBackSupported() {
+  if (process.platform !== "linux" || !process.env.KDE_SESSION_VERSION) {
+    return false;
+  }
+  if (cachedKDEJumpBackSupport !== null) {
+    return cachedKDEJumpBackSupport;
+  }
+  cachedKDEJumpBackSupport = execFileWithTimeout("kdotool", ["--help"], 1000) !== null;
+  return cachedKDEJumpBackSupport;
+}
+function getWindowClassX11(windowId) {
+  return execWithTimeout(`xprop -id ${windowId} WM_CLASS 2>/dev/null | awk -F '"' '{print $4}'`);
+}
+function getWaylandAppId(windowId) {
+  if (process.env.HYPRLAND_INSTANCE_SIGNATURE) {
+    const output = execWithTimeout(`hyprctl clients -j`);
+    if (!output)
+      return null;
+    try {
+      const clients = JSON.parse(output);
+      for (const client of clients) {
+        if (String(client.address) === windowId) {
+          return client.class?.toLowerCase() || client.initialClass?.toLowerCase() || null;
+        }
+      }
+    } catch {
+      return null;
+    }
+  }
+  if (process.env.SWAYSOCK) {
+    const output = execWithTimeout(`swaymsg -t get_tree`, 1000);
+    if (!output)
+      return null;
+    try {
+      const tree = JSON.parse(output);
+      const findWindow = (node) => {
+        if (String(node.id) === windowId) {
+          return node.app_id?.toLowerCase() || node.window_properties?.class?.toLowerCase() || null;
+        }
+        if (Array.isArray(node.nodes)) {
+          for (const child of node.nodes) {
+            const result = findWindow(child);
+            if (result)
+              return result;
+          }
+        }
+        if (Array.isArray(node.floating_nodes)) {
+          for (const child of node.floating_nodes) {
+            const result = findWindow(child);
+            if (result)
+              return result;
+          }
+        }
+        return null;
+      };
+      return findWindow(tree);
+    } catch {
+      return null;
+    }
+  }
+  if (process.env.NIRI_SOCKET) {
+    const output = execWithTimeout(`niri msg --json windows`);
+    if (!output)
+      return null;
+    try {
+      const windows = JSON.parse(output);
+      for (const window of windows) {
+        if (String(window.id) === windowId) {
+          return window.app_id?.toLowerCase() || null;
+        }
+      }
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function getTerminalWindowId() {
+  if (process.platform !== "linux")
+    return null;
+  const term = process.env.TERM_PROGRAM?.toLowerCase() || "";
+  const desktopSession = process.env.DESKTOP_SESSION?.toLowerCase() || "";
+  const isKDE = process.env.KDE_SESSION_VERSION || desktopSession.includes("plasma");
+  if (process.env.WAYLAND_DISPLAY) {
+    const cachedId = cachedWindowId;
+    if (cachedId) {
+      const appId = getWaylandAppId(cachedId);
+      if (appId && LINUX_TERMINAL_APPS.has(appId)) {
+        return cachedId;
+      }
+    }
+    if (isKDE) {
+      return cachedId || "kde-wayland";
+    }
+    return cachedId;
+  }
+  if (process.env.DISPLAY) {
+    const cachedId = cachedWindowId;
+    if (cachedId) {
+      const windowClass = getWindowClassX11(cachedId);
+      if (windowClass && LINUX_TERMINAL_APPS.has(windowClass.toLowerCase())) {
+        return cachedId;
+      }
+    }
+    for (const app of LINUX_TERMINAL_APPS) {
+      const id = isKDE ? getWindowIdFromKdotool(app) : getWindowIdFromXdotool(app);
+      if (id)
+        return id;
+    }
+  }
+  return null;
+}
+function focusLinuxWindowX11(windowId) {
+  try {
+    execSync(`xdotool windowactivate ${windowId} 2>/dev/null`, { timeout: 1000 });
+  } catch {}
+}
+function findTerminalPid() {
+  try {
+    let currentPid = process.pid;
+    while (currentPid > 1) {
+      try {
+        const statContent = readFileSync2(`/proc/${currentPid}/stat`, "utf-8");
+        const match = statContent.match(/^\d+\s+\([^)]+\)\s+\S\s+(\d+)/);
+        if (!match)
+          break;
+        const ppid = parseInt(match[1], 10);
+        const cmdline = readFileSync2(`/proc/${ppid}/comm`, "utf-8").trim();
+        if (cmdline.match(/ghostty|konsole|gnome-terminal|xterm|alacritty|kitty|wezterm|terminator|tilix|foot/i)) {
+          return ppid;
+        }
+        currentPid = ppid;
+      } catch {
+        break;
+      }
+    }
+    return process.ppid;
   } catch {
+    return process.ppid;
+  }
+}
+function focusKDEWithKWinScript() {
+  try {
+    const pinnedWindowId = process.env.OPENCODE_NOTIFIER_WINDOW_ID?.trim() || null;
+    if (pinnedWindowId) {
+      try {
+        execSync(`kdotool windowactivate ${pinnedWindowId} 2>/dev/null`, { timeout: 1500 });
+        return;
+      } catch {}
+    }
+    if (cachedWindowId) {
+      try {
+        execSync(`kdotool windowactivate ${cachedWindowId} 2>/dev/null`, { timeout: 1500 });
+        return;
+      } catch {}
+    }
+    const terminalPid = findTerminalPid();
+    const currentPid = process.pid;
+    const termProgram = (process.env.TERM_PROGRAM || "terminal").toLowerCase();
+    const cwd = process.cwd().toLowerCase();
+    const cwdBase = cwd.split("/").filter(Boolean).pop() || "";
+    const cachedTitle = (getCachedWindowTitle() || "").toLowerCase();
+    const scriptContent = `
+function activateTargetWindow(window) {
+    // Jump to the window's desktop/activity first, then activate.
+    // This works more reliably on Plasma than moving windows between desktops.
+    try {
+        if (window.desktops && window.desktops.length > 0) {
+            workspace.currentDesktop = window.desktops[0];
+        } else if (typeof window.desktop === "number" && window.desktop > 0) {
+            workspace.currentDesktop = window.desktop;
+        }
+    } catch (e) {}
+
+    try {
+        if (window.activities && window.activities.length > 0 && typeof workspace.currentActivity !== "undefined") {
+            workspace.currentActivity = window.activities[0];
+        }
+    } catch (e) {}
+
+    try { window.minimized = false; } catch (e) {}
+
+    try { workspace.activeWindow = window; } catch (e) {}
+    try {
+        if (typeof workspace.activateWindow === "function") {
+            workspace.activateWindow(window);
+        }
+    } catch (e) {}
+    try { window.active = true; } catch (e) {}
+
+    // Nudge stacking so KWin treats this like an explicit user jump.
+    try {
+        window.keepAbove = true;
+        window.keepAbove = false;
+    } catch (e) {}
+}
+
+function isLikelyTerminal(window) {
+    var resourceClass = (window.resourceClass || "").toLowerCase();
+    var resourceName = (window.resourceName || "").toLowerCase();
+    var caption = (window.caption || "").toLowerCase();
+
+    return resourceClass.indexOf("ghostty") !== -1 ||
+           resourceName.indexOf("ghostty") !== -1 ||
+           caption.indexOf("ghostty") !== -1 ||
+           resourceClass.indexOf("konsole") !== -1 ||
+           resourceName.indexOf("konsole") !== -1 ||
+           caption.indexOf("konsole") !== -1 ||
+           resourceClass.indexOf("terminal") !== -1 ||
+           resourceName.indexOf("terminal") !== -1;
+}
+
+function findAndActivateTerminal() {
+    var allWindows = workspace.windowList();
+    var terminalPid = ${terminalPid};
+    var termProgramHint = ${JSON.stringify(termProgram)};
+    var cwdHint = ${JSON.stringify(cwd)};
+    var cwdBaseHint = ${JSON.stringify(cwdBase)};
+    var cachedTitleHint = ${JSON.stringify(cachedTitle)};
+
+    function contains(haystack, needle) {
+        return !!needle && needle.length > 0 && haystack.indexOf(needle) !== -1;
+    }
+
+    function windowScore(window) {
+        var resourceClass = (window.resourceClass || "").toLowerCase();
+        var resourceName = (window.resourceName || "").toLowerCase();
+        var caption = (window.caption || "").toLowerCase();
+        var score = 0;
+
+        if (window.pid === terminalPid) score += 30;
+        if (contains(caption, "opencode")) score += 60;
+        if (contains(caption, cachedTitleHint)) score += 50;
+        if (contains(caption, cwdBaseHint)) score += 35;
+        if (contains(caption, cwdHint)) score += 20;
+        if (contains(resourceClass, termProgramHint) || contains(resourceName, termProgramHint) || contains(caption, termProgramHint)) score += 20;
+        if (isLikelyTerminal(window)) score += 10;
+        if (window.minimized === true) score -= 5;
+
+        return score;
+    }
+
+    var bestWindow = null;
+    var bestScore = -1;
+
+    for (var i = 0; i < allWindows.length; i++) {
+        var candidate = allWindows[i];
+        var score = windowScore(candidate);
+        if (score > bestScore) {
+            bestWindow = candidate;
+            bestScore = score;
+        }
+    }
+
+    // Require enough confidence to avoid jumping to unrelated terminals.
+    if (bestWindow && bestScore >= 30) {
+        activateTargetWindow(bestWindow);
+        return true;
+    }
+
     return false;
+}
+
+findAndActivateTerminal();
+`;
+    const scriptPath = join3(tmpdir(), `opencode-focus-${currentPid}.kwinscript`);
+    const pluginName = `opencode-focus-${currentPid}`;
+    writeFileSync(scriptPath, scriptContent);
+    execSync(`qdbus org.kde.KWin /Scripting org.kde.kwin.Scripting.loadScript "${scriptPath}" "${pluginName}"`, { encoding: "utf-8", timeout: 2000 });
+    execSync(`qdbus org.kde.KWin /Scripting org.kde.kwin.Scripting.start`, { timeout: 2000 });
+    try {
+      unlinkSync(scriptPath);
+    } catch {}
+    setTimeout(() => {
+      try {
+        execSync(`qdbus org.kde.KWin /Scripting org.kde.kwin.Scripting.unloadScript "${pluginName}"`, { timeout: 500 });
+      } catch {}
+    }, 1000);
+  } catch {
+    try {
+      const cachedId = cachedWindowId;
+      if (cachedId) {
+        execSync(`xdotool windowactivate ${cachedId} 2>/dev/null`, { timeout: 1000 });
+      }
+    } catch {}
+  }
+}
+function focusLinuxWindowHyprland(windowId) {
+  try {
+    execSync(`hyprctl dispatch focuswindow address:${windowId} 2>/dev/null`, { timeout: 1000 });
+  } catch {}
+}
+function focusLinuxWindowSway(windowId) {
+  try {
+    execSync(`swaymsg "[con_id=${windowId}] focus" 2>/dev/null`, { timeout: 1000 });
+  } catch {}
+}
+function focusLinuxWindowNiri(windowId) {
+  try {
+    execSync(`niri msg action focus-window --id ${windowId} 2>/dev/null`, { timeout: 1000 });
+  } catch {}
+}
+function captureStartupWindowId() {
+  if (!isKDEJumpBackSupported()) {
+    return;
+  }
+  const existing = process.env.OPENCODE_NOTIFIER_WINDOW_ID?.trim();
+  if (existing) {
+    return;
+  }
+  const detected = execWithTimeout("kdotool getactivewindow", 1000);
+  if (detected && /^\d+$/.test(detected)) {
+    process.env.OPENCODE_NOTIFIER_WINDOW_ID = detected;
+  }
+}
+async function focusTerminal() {
+  if (process.platform === "darwin") {
+    try {
+      const frontmostAppName = getMacOSFrontmostAppName();
+      if (frontmostAppName && isMacTerminalAppFocused(frontmostAppName, process.env)) {
+        return;
+      }
+      const expectedApps = getExpectedMacTerminalAppNames(process.env);
+      for (const app of expectedApps) {
+        try {
+          execSync(`osascript -e 'tell application "${app}" to activate' 2>/dev/null`, { timeout: 1000 });
+          return;
+        } catch {}
+      }
+      execSync(`osascript -e 'tell application "Terminal" to activate' 2>/dev/null`, { timeout: 1000 });
+    } catch {}
+    return;
+  }
+  if (process.platform === "linux") {
+    const env = process.env;
+    if (env.KDE_SESSION_VERSION) {
+      focusKDEWithKWinScript();
+      return;
+    }
+    const windowId = getTerminalWindowId();
+    if (!windowId)
+      return;
+    if (env.HYPRLAND_INSTANCE_SIGNATURE) {
+      focusLinuxWindowHyprland(windowId);
+    } else if (env.SWAYSOCK) {
+      focusLinuxWindowSway(windowId);
+    } else if (env.NIRI_SOCKET) {
+      focusLinuxWindowNiri(windowId);
+    } else if (env.DISPLAY) {
+      focusLinuxWindowX11(windowId);
+    }
   }
 }
 
@@ -873,7 +1462,7 @@ function getStringField(record, key) {
 var globalTurnCount = null;
 function loadTurnCount() {
   try {
-    const content = readFileSync2(getStatePath(), "utf-8");
+    const content = readFileSync3(getStatePath(), "utf-8");
     const state = JSON.parse(content);
     if (typeof state.turn === "number" && Number.isFinite(state.turn) && state.turn >= 0) {
       return state.turn;
@@ -883,7 +1472,7 @@ function loadTurnCount() {
 }
 function saveTurnCount(count) {
   try {
-    writeFileSync(getStatePath(), JSON.stringify({ turn: count }));
+    writeFileSync2(getStatePath(), JSON.stringify({ turn: count }));
   } catch {}
 }
 function incrementTurnCount() {
@@ -950,6 +1539,9 @@ async function handleEvent(config, eventType, projectName, elapsedSeconds, sessi
   if (config.suppressWhenFocused && isTerminalFocused()) {
     return;
   }
+  if ((eventType === "complete" || eventType === "subagent_complete") && typeof elapsedSeconds === "number" && Number.isFinite(elapsedSeconds) && elapsedSeconds < config.minDuration) {
+    return;
+  }
   const promises = [];
   const timestamp = formatTimestamp();
   const turn = incrementTurnCount();
@@ -964,7 +1556,8 @@ async function handleEvent(config, eventType, projectName, elapsedSeconds, sessi
   if (isEventNotificationEnabled(config, eventType)) {
     const title = getNotificationTitle(config, projectName);
     const iconPath = getIconPath(config);
-    promises.push(sendNotification(title, message, config.timeout, iconPath, config.notificationSystem, config.linux.grouping));
+    const onNotificationClick = isKDEJumpBackSupported() ? () => void focusTerminal() : undefined;
+    promises.push(sendNotification(title, message, config.timeout, iconPath, config.notificationSystem, config.linux.grouping, onNotificationClick));
   }
   if (isEventSoundEnabled(config, eventType)) {
     const customSoundPath = getSoundPath(config, eventType);
@@ -1134,6 +1727,7 @@ async function handleEventWithElapsedTime(client, config, eventType, projectName
   await handleEvent(config, eventType, projectName, elapsedSeconds, sessionTitle, sessionID, agentName);
 }
 var NotifierPlugin = async ({ client, directory }) => {
+  captureStartupWindowId();
   const clientEnv = process.env.OPENCODE_CLIENT;
   if (clientEnv && clientEnv !== "cli") {
     const config = loadConfig();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohak34/opencode-notifier",
-  "version": "0.2.2-beta.0",
+  "version": "0.2.3-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",
@@ -34,6 +34,7 @@
     "alerts"
   ],
   "dependencies": {
+    "is-wsl": "^3.1.0",
     "node-notifier": "^10.0.1"
   },
   "devDependencies": {