@mohak34/opencode-notifier 0.2.8 → 0.2.9-beta.1

package/README.md

@@ -4,13 +4,15 @@ OpenCode plugin that plays sounds and sends system notifications when permission
 
 ## Quick Start
 
-Add this to your `opencode.json`:
+Install the plugin via the CLI: `opencode plug -g @mohak34/opencode-notifier`.
 
-```json
-{
-  "plugin": ["@mohak34/opencode-notifier@latest"]
-}
-```
+Or add manually to your `opencode.json`:
+
+  ```json
+  {
+    "plugin": ["@mohak34/opencode-notifier@latest"]
+  }
+  ```
 
 Restart OpenCode. Done.
 
@@ -319,6 +321,13 @@ Run your own script when something happens. Use `{event}`, `{message}`, `{sessio
 - `args` - Arguments to pass, can use `{event}`, `{message}`, `{sessionTitle}`, `{agentName}`, `{projectName}`, `{timestamp}`, and `{turn}` tokens
 - `minDuration` - Skip if response was quick, avoids spam (seconds)
 
+Token values are passed as argv values and are not shell-escaped for use inside
+script source. Do not put `{message}`, `{sessionTitle}`, or other dynamic tokens
+inside a `sh -c`, `bash -c`, `powershell -Command`, or similar script string.
+Use a wrapper script and pass the tokens as separate arguments instead.
+Custom commands run with the same user permissions as OpenCode, so only enable
+scripts you trust.
+
 #### Example: Log events to a file
 
 ```json
@@ -328,7 +337,10 @@ Run your own script when something happens. Use `{event}`, `{message}`, `{sessio
     "path": "/bin/bash",
     "args": [
       "-c",
-      "echo '[{event}] {message}' >> /tmp/opencode.log"
+      "printf '[%s] %s\\n' \"$1\" \"$2\" >> /tmp/opencode.log",
+      "opencode-notifier",
+      "{event}",
+      "{message}"
     ]
   }
 }
@@ -425,11 +437,13 @@ This is independent of `command.minDuration`, which only controls whether the cu
 | 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 (GNOME)                    | AT-SPI (`gdbus` on the `org.a11y.Bus`) | `gdbus` installed   | Tested (Ubuntu 26.04.1 LTS + GNOME Shell 50.1 + Ghostty 1.3.0) |
 | 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.
+**GNOME Wayland**: GNOME exposes no compositor API for the focused window (`Introspect.GetWindows` and `Eval` are access-denied) and XWayland tools like `xdotool` cannot see native Wayland windows, so focus is read from the accessibility bus instead: the active terminal window is the one whose AT-SPI `ACTIVE` state bit is set. Ghostty is matched by its `/com/mitchellh/ghostty` AT-SPI path, other terminals by app name (including the `gnome-terminal-server` AT-SPI alias). Window identity is `bus@path` since AT-SPI paths repeat across processes. Implemented and verified on Ubuntu 26.04.1 LTS + GNOME Shell 50.1 + Ghostty 1.3.0. With several terminal windows open, suppression compares against the window that was active at startup. Set `OPENCODE_NOTIFIER_DEBUG=1` to log the focus backend decision.
+
+**Unsupported compositors**: Wayland has no standard protocol for querying the focused window. Each compositor has its own IPC. Compositors without a backend (river, dwl, Cosmic, etc.) 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. 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).
 
@@ -468,25 +482,49 @@ The action button is only enabled on Linux KDE sessions where `kdotool` is avail
 
 ## Updating
 
-If Opencode does not update the plugin or there is an issue with the cache version:
+OpenCode caches plugin packages under `~/.cache/opencode`. If you switch between `latest`, `beta`, or a pinned version and OpenCode still uses the old plugin, close OpenCode and remove the cached package.
+
+Linux/macOS:
 
 ```bash
-# Linux/macOS
-rm -rf ~/.cache/opencode/packages/@mohak34/opencode-notifier@beta
+rm -rf ~/.cache/opencode/packages/@mohak34/opencode-notifier*
 rm -rf ~/.cache/opencode/node_modules/@mohak34/opencode-notifier
+rm -f ~/.cache/opencode/bun.lock
+```
+
+Windows PowerShell:
+
+```powershell
+Remove-Item -Recurse -Force "$env:USERPROFILE\.cache\opencode\packages\@mohak34\opencode-notifier*" -ErrorAction SilentlyContinue
+Remove-Item -Recurse -Force "$env:USERPROFILE\.cache\opencode\node_modules\@mohak34\opencode-notifier" -ErrorAction SilentlyContinue
+Remove-Item -Force "$env:USERPROFILE\.cache\opencode\bun.lock" -ErrorAction SilentlyContinue
+```
 
-# Windows
-Remove-Item -Recurse -Force "$env:USERPROFILE\.cache\opencode\packages\@mohak34\opencode-notifier@beta"
-Remove-Item -Recurse -Force "$env:USERPROFILE\.cache\opencode\node_modules\@mohak34\opencode-notifier"
+Then reopen OpenCode. It will download the plugin again.
+
+To avoid cache confusion while testing, pin the exact version in `opencode.json` instead of using a moving tag:
+
+```json
+{
+  "plugin": ["@mohak34/opencode-notifier@x.y.z"]
+}
+```
+
+Check the version published under a tag:
+
+```bash
+npm view @mohak34/opencode-notifier@latest version
+npm view @mohak34/opencode-notifier@beta version
 ```
 
-Then restart OpenCode.
+Check the version OpenCode cached:
 
-Verify installation:
 ```bash
-cat ~/.cache/opencode/packages/@mohak34/opencode-notifier@beta/node_modules/@mohak34/opencode-notifier/package.json | grep version
+cat ~/.cache/opencode/packages/@mohak34/opencode-notifier@latest/node_modules/@mohak34/opencode-notifier/package.json | grep version
 ```
 
+If you use `@beta` or a pinned version, replace `latest` in the path with `beta` or the exact version, for example `0.2.9-beta.0`.
+
 ## Troubleshooting
 
 **macOS: Not seeing notifications?**
@@ -550,6 +588,18 @@ Manual pinning bypasses heuristic window matching and should activate that exact
 **Windows WSL notifications not working?**
 WSL doesn't have a native notification daemon. Use PowerShell commands instead:
 
+Save this wrapper as `C:\Users\YourName\bin\opencode-notifier-popup.ps1`:
+
+```powershell
+param(
+  [string]$Message,
+  [string]$Event
+)
+
+$wshell = New-Object -ComObject Wscript.Shell
+$wshell.Popup($Message, 5, ("OpenCode - {0}" -f $Event), 0+64)
+```
+
 ```json
 {
   "notification": false,
@@ -558,8 +608,11 @@ WSL doesn't have a native notification daemon. Use PowerShell commands instead:
     "enabled": true,
     "path": "powershell.exe",
     "args": [
-      "-Command",
-      "$wshell = New-Object -ComObject Wscript.Shell; $wshell.Popup('{message}', 5, 'OpenCode - {event}', 0+64)"
+      "-NoProfile",
+      "-File",
+      "C:\\Users\\YourName\\bin\\opencode-notifier-popup.ps1",
+      "{message}",
+      "{event}"
     ]
   }
 }
@@ -576,8 +629,11 @@ This is a known Bun issue on Windows. Disable native notifications and use Power
     "enabled": true,
     "path": "powershell.exe",
     "args": [
-      "-Command",
-      "$wshell = New-Object -ComObject Wscript.Shell; $wshell.Popup('{message}', 5, 'OpenCode - {event}', 0+64)"
+      "-NoProfile",
+      "-File",
+      "C:\\Users\\YourName\\bin\\opencode-notifier-popup.ps1",
+      "{message}",
+      "{event}"
     ]
   }
 }
@@ -593,10 +649,11 @@ This is a known Bun issue on Windows. Disable native notifications and use Power
 
 - Check `suppressWhenFocused`: when `true` (default), notifications are skipped while OpenCode terminal is focused. Set to `false` to always notify.
 - Check `enableOnDesktop`: defaults to `false`, so the plugin won't run on Desktop/Web clients. Set to `true` if you need it there.
-- Verify the package is actually cached:
+- Verify the package version OpenCode cached:
   ```bash
-  cat ~/.cache/opencode/packages/@mohak34/opencode-notifier@beta/node_modules/@mohak34/opencode-notifier/package.json | grep version
+  cat ~/.cache/opencode/packages/@mohak34/opencode-notifier@latest/node_modules/@mohak34/opencode-notifier/package.json | grep version
   ```
+  If you use `@beta` or a pinned version, replace `latest` in the path with `beta` or the exact version.
 
 ## Changelog
 

package/dist/index.js

@@ -105,6 +105,9 @@ var DEFAULT_CONFIG = {
   linux: {
     grouping: false
   },
+  windows: {
+    appID: "opencode"
+  },
   minDuration: 0,
   command: {
     enabled: false,
@@ -242,6 +245,9 @@ function loadConfig() {
       linux: {
         grouping: typeof userConfig.linux?.grouping === "boolean" ? userConfig.linux.grouping : DEFAULT_CONFIG.linux.grouping
       },
+      windows: {
+        appID: typeof userConfig.windows?.appID === "string" && userConfig.windows.appID.length > 0 ? userConfig.windows.appID : DEFAULT_CONFIG.windows.appID
+      },
       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,
@@ -365,7 +371,7 @@ function interpolateMessage(message, context) {
 
 // src/notify.ts
 import os2 from "os";
-import { exec, execFile, spawn } from "child_process";
+import { execFile, spawn } from "child_process";
 import notifier from "node-notifier";
 var DEBOUNCE_MS = 1000;
 var platform = os2.type();
@@ -385,7 +391,7 @@ var lastNotificationTime = {};
 var lastLinuxNotificationId = null;
 var linuxNotifySendSupportsReplace = null;
 function sanitizeGhosttyField(value) {
-  return value.replace(/[;\x07\x1b\n\r]/g, "");
+  return value.replace(/[;\u0000-\u001f\u007f-\u009f]/g, "");
 }
 function formatGhosttyNotificationSequence(title, message, env = process.env) {
   const escapedTitle = sanitizeGhosttyField(title);
@@ -522,7 +528,17 @@ function parseNotifySendOutputLine(line) {
   }
   return null;
 }
-async function sendNotification(title, message, timeout, iconPath, notificationSystem = "osascript", linuxGrouping = true, onClick) {
+function buildOsascriptNotificationArgs(title, message) {
+  return [
+    "-e",
+    `on run argv
+ display notification (item 1 of argv) with title (item 2 of argv)
+end run`,
+    message,
+    title
+  ];
+}
+async function sendNotification(title, message, timeout, iconPath, notificationSystem = "osascript", linuxGrouping = true, onClick, windowsAppID) {
   const now = Date.now();
   if (lastNotificationTime[message] && now - lastNotificationTime[message] < DEBOUNCE_MS) {
     return;
@@ -551,9 +567,7 @@ async function sendNotification(title, message, timeout, iconPath, notificationS
       });
     }
     return new Promise((resolve) => {
-      const escapedMessage = message.replace(/"/g, "\\\"");
-      const escapedTitle = title.replace(/"/g, "\\\"");
-      exec(`osascript -e 'display notification "${escapedMessage}" with title "${escapedTitle}"'`, () => {
+      execFile("osascript", buildOsascriptNotificationArgs(title, message), () => {
         resolve();
       });
     });
@@ -587,7 +601,7 @@ async function sendNotification(title, message, timeout, iconPath, notificationS
       message,
       timeout,
       icon: iconPath,
-      "app-name": "opencode"
+      appName: windowsAppID ?? "opencode"
     };
     platformNotifier.notify(notificationOptions, (err, response, metadata) => {
       if (onClick && metadata?.activationType === "default") {
@@ -636,7 +650,8 @@ async function runCommand(command, args) {
   return new Promise((resolve, reject) => {
     const proc = spawn2(command, args, {
       stdio: "ignore",
-      detached: false
+      detached: false,
+      windowsHide: true
     });
     proc.on("error", (err) => {
       reject(err);
@@ -674,7 +689,18 @@ async function playOnLinux(soundPath, volume) {
   const players = [
     { command: "paplay", args: [`--volume=${pulseVolume}`, soundPath] },
     { command: "aplay", args: [soundPath] },
-    { command: "mpv", args: ["--no-video", "--no-terminal", "--script-opts=autoload-disabled=yes", `--volume=${percentVolume}`, soundPath] },
+    {
+      command: "mpv",
+      args: [
+        "--no-video",
+        "--no-terminal",
+        "--script-opts=autoload-disabled=yes",
+        "--keep-open=no",
+        "--idle=no",
+        `--volume=${percentVolume}`,
+        soundPath
+      ]
+    },
     { command: "ffplay", args: ["-nodisp", "-autoexit", "-loglevel", "quiet", "-volume", `${percentVolume}`, soundPath] }
   ];
   for (const player of players) {
@@ -690,8 +716,9 @@ async function playOnMac(soundPath, volume) {
   await runCommand("afplay", ["-v", `${volume}`, soundPath]);
 }
 async function playOnWindows(soundPath) {
-  const script = `& { (New-Object Media.SoundPlayer $args[0]).PlaySync() }`;
-  await runCommand("powershell", ["-c", script, soundPath]);
+  const script = `(New-Object Media.SoundPlayer '${soundPath.replace(/'/g, "''")}').PlaySync()`;
+  const encoded = Buffer.from(script, "utf16le").toString("base64");
+  await runCommand("powershell", ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded]);
 }
 async function playSound(event, customPath, volume) {
   const now = Date.now();
@@ -704,9 +731,9 @@ async function playSound(event, customPath, volume) {
   if (!soundPath) {
     return;
   }
-  const os3 = platform2();
+  const os = platform2();
   try {
-    switch (os3) {
+    switch (os) {
       case "darwin":
         await playOnMac(soundPath, normalizedVolume);
         break;
@@ -758,8 +785,10 @@ 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 = spawn3(command, args, {
+    shell: false,
     stdio: "ignore",
-    detached: true
+    detached: true,
+    windowsHide: true
   });
   proc.on("error", () => {});
   proc.unref();
@@ -767,9 +796,9 @@ 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 { accessSync, constants, mkdtempSync, readFileSync as readFileSync2, rmSync, statSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { delimiter, join as join3 } from "path";
 var LINUX_TERMINAL_APPS = new Set([
   "ghostty",
   "konsole",
@@ -820,13 +849,25 @@ function execFileWithTimeout(command, args, timeoutMs = 500) {
     return null;
   }
 }
+function isNumericWindowId(value) {
+  return /^\d+$/.test(value);
+}
+function isSafeCompositorWindowId(value) {
+  return /^[A-Za-z0-9._:-]+$/.test(value);
+}
+function firstNumericWindowId(output) {
+  if (!output)
+    return null;
+  const value = output.split(/\s+/).find((part) => isNumericWindowId(part));
+  return value ?? null;
+}
 function getHyprlandActiveWindowId() {
   const output = execWithTimeout("hyprctl activewindow -j");
   if (!output)
     return null;
   try {
     const data = JSON.parse(output);
-    return typeof data?.address === "string" ? data.address : null;
+    return typeof data?.address === "string" && isSafeCompositorWindowId(data.address) ? data.address : null;
   } catch {
     return null;
   }
@@ -897,15 +938,213 @@ function getLinuxWaylandActiveWindowId() {
   if (env.SWAYSOCK)
     return getSwayActiveWindowId();
   if (env.KDE_SESSION_VERSION)
-    return execWithTimeout("kdotool getactivewindow");
+    return firstNumericWindowId(execWithTimeout("kdotool getactivewindow"));
+  if (isGnomeLikeSession(env))
+    return getGnomeAtspiActiveWindowKey();
   return null;
 }
-function getWindowsActiveWindowId() {
-  const script = `$type=Add-Type -Name FocusHelper -Namespace OpenCodeNotifier -MemberDefinition '[DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();' -PassThru; $type::GetForegroundWindow()`;
-  let windowId = execFileWithTimeout("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], 1000);
-  if (!windowId)
-    windowId = execFileWithTimeout("pwsh", ["-NoProfile", "-NonInteractive", "-Command", script], 1000);
-  return windowId;
+var ATSPI_ACTIVE_BIT_INDEX = 1;
+var ATSPI_TERMINAL_PATH_MARKERS = ["mitchellh/ghostty"];
+var ATSPI_TERMINAL_APP_ALIASES = new Set([
+  "gnome-terminal-server"
+]);
+var GNOME_LIKE_DESKTOPS = new Set(["gnome", "ubuntu", "pop"]);
+function isGnomeLikeSession(env = process.env) {
+  const desktop = `${env.XDG_CURRENT_DESKTOP ?? ""} ${env.DESKTOP_SESSION ?? ""}`.toLowerCase();
+  return desktop.split(/[:;\s]+/).some((token) => GNOME_LIKE_DESKTOPS.has(token));
+}
+function getLinuxFocusBackendName(env = process.env) {
+  if (env.HYPRLAND_INSTANCE_SIGNATURE)
+    return "hyprland";
+  if (env.NIRI_SOCKET)
+    return "niri";
+  if (env.SWAYSOCK)
+    return "sway";
+  if (env.KDE_SESSION_VERSION)
+    return "kde";
+  if (isGnomeLikeSession(env))
+    return "gnome-atspi";
+  if (env.DISPLAY)
+    return "x11";
+  if (env.WAYLAND_DISPLAY)
+    return "wayland-unsupported";
+  return "none";
+}
+function parseAtspiString(output) {
+  if (!output)
+    return null;
+  const match = output.match(/'((?:[^'\\]|\\.)*)'/);
+  if (!match)
+    return null;
+  try {
+    return JSON.parse(`"${match[1].replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`);
+  } catch {
+    return match[1];
+  }
+}
+function parseAtspiObjectRefs(output) {
+  if (!output)
+    return [];
+  const refs = [];
+  const re = /\('([^']+)',\s*(?:objectpath\s+)?'([^']+)'\)/g;
+  let match;
+  while ((match = re.exec(output)) !== null) {
+    refs.push({ bus: match[1], path: match[2] });
+  }
+  return refs;
+}
+function parseAtspiStateActive(output) {
+  if (!output)
+    return null;
+  const match = output.match(/uint32\s+(\d+)/);
+  if (!match)
+    return null;
+  const firstWord = Number(match[1]) >>> 0;
+  return (firstWord >>> ATSPI_ACTIVE_BIT_INDEX & 1) === 1;
+}
+function isAtspiTerminalWindow(appName, windowPath) {
+  if (ATSPI_TERMINAL_PATH_MARKERS.some((marker) => windowPath.toLowerCase().includes(marker))) {
+    return true;
+  }
+  if (!appName)
+    return false;
+  const normalized = appName.trim().toLowerCase();
+  return LINUX_TERMINAL_APPS.has(normalized) || ATSPI_TERMINAL_APP_ALIASES.has(normalized);
+}
+var ATSPI_ROLES = new Set(["window", "frame", "dialog"]);
+function isAtspiWindowRoleAccepted(role) {
+  return role !== null && ATSPI_ROLES.has(role);
+}
+function callAtspi(address, dest, path, method, args = [], timeoutMs = 500) {
+  return execFileWithTimeout("gdbus", [
+    "call",
+    "--address",
+    address,
+    "--dest",
+    dest,
+    "--object-path",
+    path,
+    "--method",
+    method,
+    ...args
+  ], timeoutMs);
+}
+var cachedAtspiAddress = null;
+var ATSPI_ADDRESS_CACHE_TTL_MS = 1e4;
+function getAtspiBusAddress() {
+  const now = Date.now();
+  if (cachedAtspiAddress && now - cachedAtspiAddress.at < ATSPI_ADDRESS_CACHE_TTL_MS) {
+    return cachedAtspiAddress.address;
+  }
+  cachedAtspiAddress = null;
+  const output = execFileWithTimeout("gdbus", [
+    "call",
+    "--session",
+    "--dest",
+    "org.a11y.Bus",
+    "--object-path",
+    "/org/a11y/bus",
+    "--method",
+    "org.a11y.Bus.GetAddress"
+  ], 1000);
+  const address = parseAtspiString(output);
+  if (address) {
+    cachedAtspiAddress = { address, at: now };
+  }
+  return address;
+}
+function getAtspiWindowRole(address, ref) {
+  const output = callAtspi(address, ref.bus, ref.path, "org.a11y.atspi.Accessible.GetRoleName");
+  return parseAtspiString(output);
+}
+function isAtspiWindowActive(address, ref) {
+  const output = callAtspi(address, ref.bus, ref.path, "org.a11y.atspi.Accessible.GetState");
+  return parseAtspiStateActive(output);
+}
+function getAtspiTerminalWindowRefs(address) {
+  const refs = [];
+  const rootOutput = callAtspi(address, "org.a11y.atspi.Registry", "/org/a11y/atspi/accessible/root", "org.a11y.atspi.Accessible.GetChildren", [], 1000);
+  for (const app of parseAtspiObjectRefs(rootOutput)) {
+    const appName = parseAtspiString(callAtspi(address, app.bus, "/org/a11y/atspi/accessible/root", "org.freedesktop.DBus.Properties.Get", ["org.a11y.atspi.Accessible", "Name"]));
+    const childrenOutput = callAtspi(address, app.bus, app.path, "org.a11y.atspi.Accessible.GetChildren");
+    for (const child of parseAtspiObjectRefs(childrenOutput)) {
+      if (!isAtspiTerminalWindow(appName, child.path))
+        continue;
+      const role = getAtspiWindowRole(address, child)?.toLowerCase() ?? null;
+      if (isAtspiWindowRoleAccepted(role)) {
+        refs.push(child);
+      }
+    }
+  }
+  return refs;
+}
+function getGnomeAtspiActiveWindowKey() {
+  try {
+    const address = getAtspiBusAddress();
+    if (!address)
+      return null;
+    for (const ref of getAtspiTerminalWindowRefs(address)) {
+      if (isAtspiWindowActive(address, ref) === true) {
+        return `atspi:${ref.bus}@${ref.path}`;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function debugFocusState(message) {
+  if (process.env.OPENCODE_NOTIFIER_DEBUG) {
+    console.error(`[opencode-notifier] ${message}`);
+  }
+}
+var WINDOWS_TERMINAL_WINDOW_CLASSES = new Set([
+  "cascadia_hosting_window_class",
+  "consolewindowclass",
+  "windowsterminalwindowclass"
+]);
+var WINDOWS_TERMINAL_PROCESS_NAMES = new Set([
+  "windowsterminal",
+  "windowsterminalpreview",
+  "conhost",
+  "alacritty",
+  "wezterm",
+  "wezterm-gui",
+  "kitty",
+  "hyper",
+  "cursor",
+  "code",
+  "code - insiders"
+]);
+function getWindowsActiveWindowInfo() {
+  const script = `
+$p=Add-Type -Name NFI -Namespace OpenCodeNotifier -MemberDefinition '[DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();[DllImport("user32.dll", CharSet=CharSet.Auto)] public static extern int GetClassName(IntPtr h,System.Text.StringBuilder b,int n);[DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr h,out uint p);' -PassThru;
+$h=$p::GetForegroundWindow();
+if(!$h){return}
+$sb=New-Object System.Text.StringBuilder 256;
+$p::GetClassName($h,$sb,256)|Out-Null;
+$c=$sb.ToString();
+$procId=0;
+$p::GetWindowThreadProcessId($h,[ref]$procId)|Out-Null;
+$pn='';
+try{$pn=(Get-Process -Id $procId -ErrorAction SilentlyContinue).ProcessName}catch{}
+Write-Output "$c|$pn"
+`.trim().replace(/\n/g, "; ");
+  let output = execFileWithTimeout("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], 5000);
+  if (!output)
+    output = execFileWithTimeout("pwsh", ["-NoProfile", "-NonInteractive", "-Command", script], 1000);
+  if (!output)
+    return null;
+  const line = output.split(`
+`).map((l) => l.trim()).find((l) => l.length > 0 && !l.startsWith("#<"));
+  if (!line)
+    return null;
+  const sep = line.indexOf("|");
+  if (sep === -1)
+    return null;
+  const className = line.substring(0, sep) || null;
+  const processName = line.substring(sep + 1) || null;
+  return { className, processName };
 }
 function getMacOSActiveWindowId() {
   return execWithTimeout(`osascript -e 'tell application "System Events" to return id of window 1 of (first application process whose frontmost is true)'`);
@@ -945,6 +1184,13 @@ function getExpectedMacTerminalAppNames(env) {
   }
   return new Set(MAC_TERMINAL_APP_NAMES);
 }
+function buildOsascriptActivateAppArgs(appName) {
+  const escapedAppName = appName.replace(/[\u0000-\u001f\u007f-\u009f]/g, "").replaceAll("\\", "\\\\").replaceAll('"', "\\\"");
+  return [
+    "-e",
+    `tell application "${escapedAppName}" to activate`
+  ];
+}
 function isMacTerminalAppFocused(frontmostAppName, env = process.env) {
   if (!frontmostAppName) {
     return false;
@@ -957,18 +1203,18 @@ function isMacTerminalAppFocused(frontmostAppName, env = process.env) {
   return expectedApps.has(normalizedFrontmost);
 }
 function getActiveWindowId() {
-  const platform3 = process.platform;
-  if (platform3 === "darwin")
+  const platform = process.platform;
+  if (platform === "darwin")
     return getMacOSActiveWindowId();
-  if (platform3 === "linux") {
+  if (platform === "linux") {
     if (process.env.WAYLAND_DISPLAY)
       return getLinuxWaylandActiveWindowId();
     if (process.env.DISPLAY)
-      return execWithTimeout("xdotool getactivewindow");
+      return firstNumericWindowId(execWithTimeout("xdotool getactivewindow"));
     return null;
   }
-  if (platform3 === "win32")
-    return getWindowsActiveWindowId();
+  if (platform === "win32")
+    return null;
   return null;
 }
 var cachedWindowId = getActiveWindowId();
@@ -989,15 +1235,15 @@ function isTmuxPaneFocused(tmuxPane, probeResult) {
   return Number(sessionAttached) > 0 && windowActive === "1" && paneActive === "1";
 }
 function isLinuxTerminalFocused(params) {
-  const { cachedWindowId: cachedWindowId2, currentWindowId, wezTermPaneActive, tmuxPaneActive } = params;
-  if (!cachedWindowId2) {
+  const { cachedWindowId, currentWindowId, wezTermPaneActive, tmuxPaneActive } = params;
+  if (!cachedWindowId) {
     if (!wezTermPaneActive)
       return false;
     if (tmuxPaneActive !== null)
       return tmuxPaneActive;
     return false;
   }
-  if (currentWindowId !== cachedWindowId2)
+  if (currentWindowId !== cachedWindowId)
     return false;
   if (!wezTermPaneActive)
     return false;
@@ -1005,6 +1251,12 @@ function isLinuxTerminalFocused(params) {
     return tmuxPaneActive;
   return true;
 }
+function isWindowsTerminalFocused(params) {
+  const { className, processName } = params;
+  const classLower = className?.toLowerCase() ?? "";
+  const processLower = processName?.toLowerCase() ?? "";
+  return WINDOWS_TERMINAL_WINDOW_CLASSES.has(classLower) || WINDOWS_TERMINAL_PROCESS_NAMES.has(processLower);
+}
 function isTmuxPaneActive() {
   const tmuxPane = process.env.TMUX_PANE ?? null;
   const result = execFileWithTimeout("tmux", ["display-message", "-t", tmuxPane ?? "", "-p", "#{session_attached} #{window_active} #{pane_active}"]);
@@ -1037,25 +1289,37 @@ function isTerminalFocused() {
       }
       return true;
     }
+    if (process.platform === "win32") {
+      const info = getWindowsActiveWindowInfo();
+      return isWindowsTerminalFocused({
+        className: info?.className ?? null,
+        processName: info?.processName ?? null
+      });
+    }
     const tmuxPaneActive = process.env.TMUX ? isTmuxPaneActive() : null;
-    return isLinuxTerminalFocused({
+    const currentWindowId = getActiveWindowId();
+    const focused = isLinuxTerminalFocused({
       cachedWindowId,
-      currentWindowId: getActiveWindowId(),
+      currentWindowId,
       wezTermPaneActive: isWezTermPaneActive(),
       tmuxPaneActive
     });
+    debugFocusState(`linux focus: backend=${getLinuxFocusBackendName()} session=${process.env.XDG_SESSION_TYPE ?? "?"} desktop=${process.env.XDG_CURRENT_DESKTOP ?? process.env.DESKTOP_SESSION ?? "?"} cached=${cachedWindowId ?? "null"} current=${currentWindowId ?? "null"} tmux=${String(tmuxPaneActive)} focused=${focused}`);
+    return focused;
   } catch {
     return false;
   }
 }
 function getWindowIdFromXdotool(searchTerm) {
-  return execWithTimeout(`xdotool search --classname "${searchTerm}" | head -1`);
+  return firstNumericWindowId(execFileWithTimeout("xdotool", ["search", "--classname", searchTerm]));
 }
 function getWindowIdFromKdotool(searchTerm) {
-  return execWithTimeout(`kdotool search --classname "${searchTerm}" | head -1`);
+  return firstNumericWindowId(execFileWithTimeout("kdotool", ["search", "--classname", searchTerm]));
 }
 function getWindowTitleFromKdotool(windowId) {
-  return execWithTimeout(`kdotool getwindowname ${windowId}`);
+  if (!isNumericWindowId(windowId))
+    return null;
+  return execFileWithTimeout("kdotool", ["getwindowname", windowId]);
 }
 var cachedKDEJumpBackSupport = null;
 function isKDEJumpBackSupported() {
@@ -1069,7 +1333,13 @@ function isKDEJumpBackSupported() {
   return cachedKDEJumpBackSupport;
 }
 function getWindowClassX11(windowId) {
-  return execWithTimeout(`xprop -id ${windowId} WM_CLASS 2>/dev/null | awk -F '"' '{print $4}'`);
+  if (!isNumericWindowId(windowId))
+    return null;
+  const output = execFileWithTimeout("xprop", ["-id", windowId, "WM_CLASS"]);
+  if (!output)
+    return null;
+  const matches = [...output.matchAll(/"([^"]*)"/g)].map((match) => match[1]);
+  return matches[1] ?? matches[0] ?? null;
 }
 function getWaylandAppId(windowId) {
   if (process.env.HYPRLAND_INSTANCE_SIGNATURE) {
@@ -1171,8 +1441,10 @@ function getTerminalWindowId() {
   return null;
 }
 function focusLinuxWindowX11(windowId) {
+  if (!isNumericWindowId(windowId))
+    return;
   try {
-    execSync(`xdotool windowactivate ${windowId} 2>/dev/null`, { timeout: 1000 });
+    execFileSync("xdotool", ["windowactivate", windowId], { timeout: 1000, stdio: "ignore" });
   } catch {}
 }
 function findTerminalPid() {
@@ -1199,18 +1471,49 @@ function findTerminalPid() {
     return process.ppid;
   }
 }
+var cachedQdbusBinary;
+var QDBUS_CANDIDATES = ["qdbus-qt6", "qdbus6", "qdbus-qt5", "qdbus5", "qdbus"];
+function isExecutableOnPath(name) {
+  const pathEnv = process.env.PATH ?? "";
+  for (const dir of pathEnv.split(delimiter)) {
+    if (!dir)
+      continue;
+    const full = join3(dir, name);
+    try {
+      accessSync(full, constants.X_OK);
+      if (statSync(full).isFile())
+        return true;
+    } catch {}
+  }
+  return false;
+}
+function findQdbusBinary(candidates = QDBUS_CANDIDATES, isExecutable = isExecutableOnPath) {
+  for (const candidate of candidates) {
+    if (isExecutable(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveQdbusBinary() {
+  if (cachedQdbusBinary !== undefined) {
+    return cachedQdbusBinary;
+  }
+  cachedQdbusBinary = findQdbusBinary();
+  return cachedQdbusBinary;
+}
 function focusKDEWithKWinScript() {
   try {
     const pinnedWindowId = process.env.OPENCODE_NOTIFIER_WINDOW_ID?.trim() || null;
-    if (pinnedWindowId) {
+    if (pinnedWindowId && isNumericWindowId(pinnedWindowId)) {
       try {
-        execSync(`kdotool windowactivate ${pinnedWindowId} 2>/dev/null`, { timeout: 1500 });
+        execFileSync("kdotool", ["windowactivate", pinnedWindowId], { timeout: 1500, stdio: "ignore" });
         return;
       } catch {}
     }
-    if (cachedWindowId) {
+    if (cachedWindowId && isNumericWindowId(cachedWindowId)) {
       try {
-        execSync(`kdotool windowactivate ${cachedWindowId} 2>/dev/null`, { timeout: 1500 });
+        execFileSync("kdotool", ["windowactivate", cachedWindowId], { timeout: 1500, stdio: "ignore" });
         return;
       } catch {}
     }
@@ -1323,41 +1626,83 @@ function findAndActivateTerminal() {
 
 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(() => {
+    let scriptDirectory = null;
+    let scriptPath = null;
+    let scriptLoaded = false;
+    const cleanupScript = () => {
+      if (!scriptPath || !scriptDirectory)
+        return;
+      try {
+        rmSync(scriptPath, { force: true });
+      } catch {}
       try {
-        execSync(`qdbus org.kde.KWin /Scripting org.kde.kwin.Scripting.unloadScript "${pluginName}"`, { timeout: 500 });
+        rmSync(scriptDirectory, { recursive: true, force: true });
       } catch {}
-    }, 1000);
+    };
+    const qdbus = resolveQdbusBinary();
+    if (!qdbus) {
+      throw new Error("qdbus not found");
+    }
+    try {
+      scriptDirectory = mkdtempSync(join3(tmpdir(), "opencode-focus-"));
+      scriptPath = join3(scriptDirectory, "script.kwinscript");
+      writeFileSync(scriptPath, scriptContent, { encoding: "utf-8", mode: 384, flag: "wx" });
+      execFileSync(qdbus, ["org.kde.KWin", "/Scripting", "org.kde.kwin.Scripting.loadScript", scriptPath, pluginName], { encoding: "utf-8", timeout: 2000, stdio: "ignore" });
+      scriptLoaded = true;
+      execFileSync(qdbus, ["org.kde.KWin", "/Scripting", "org.kde.kwin.Scripting.start"], {
+        timeout: 2000,
+        stdio: "ignore"
+      });
+      cleanupScript();
+      setTimeout(() => {
+        try {
+          execFileSync(qdbus, ["org.kde.KWin", "/Scripting", "org.kde.kwin.Scripting.unloadScript", pluginName], {
+            timeout: 500,
+            stdio: "ignore"
+          });
+        } catch {}
+      }, 1000);
+    } catch {
+      if (scriptLoaded) {
+        try {
+          execFileSync(qdbus, ["org.kde.KWin", "/Scripting", "org.kde.kwin.Scripting.unloadScript", pluginName], {
+            timeout: 500,
+            stdio: "ignore"
+          });
+        } catch {}
+      }
+      cleanupScript();
+      throw new Error("Unable to activate the terminal through KWin");
+    }
   } catch {
     try {
       const cachedId = cachedWindowId;
-      if (cachedId) {
-        execSync(`xdotool windowactivate ${cachedId} 2>/dev/null`, { timeout: 1000 });
+      if (cachedId && isNumericWindowId(cachedId)) {
+        execFileSync("xdotool", ["windowactivate", cachedId], { timeout: 1000, stdio: "ignore" });
       }
     } catch {}
   }
 }
 function focusLinuxWindowHyprland(windowId) {
+  if (!isSafeCompositorWindowId(windowId))
+    return;
   try {
-    execSync(`hyprctl dispatch focuswindow address:${windowId} 2>/dev/null`, { timeout: 1000 });
+    execFileSync("hyprctl", ["dispatch", "focuswindow", `address:${windowId}`], { timeout: 1000, stdio: "ignore" });
   } catch {}
 }
 function focusLinuxWindowSway(windowId) {
+  if (!isNumericWindowId(windowId))
+    return;
   try {
-    execSync(`swaymsg "[con_id=${windowId}] focus" 2>/dev/null`, { timeout: 1000 });
+    execFileSync("swaymsg", [`[con_id=${windowId}] focus`], { timeout: 1000, stdio: "ignore" });
   } catch {}
 }
 function focusLinuxWindowNiri(windowId) {
+  if (!isNumericWindowId(windowId))
+    return;
   try {
-    execSync(`niri msg action focus-window --id ${windowId} 2>/dev/null`, { timeout: 1000 });
+    execFileSync("niri", ["msg", "action", "focus-window", "--id", windowId], { timeout: 1000, stdio: "ignore" });
   } catch {}
 }
 function captureStartupWindowId() {
@@ -1383,11 +1728,11 @@ async function focusTerminal() {
       const expectedApps = getExpectedMacTerminalAppNames(process.env);
       for (const app of expectedApps) {
         try {
-          execSync(`osascript -e 'tell application "${app}" to activate' 2>/dev/null`, { timeout: 1000 });
+          execFileSync("osascript", buildOsascriptActivateAppArgs(app), { timeout: 1000, stdio: "ignore" });
           return;
         } catch {}
       }
-      execSync(`osascript -e 'tell application "Terminal" to activate' 2>/dev/null`, { timeout: 1000 });
+      execFileSync("osascript", buildOsascriptActivateAppArgs("Terminal"), { timeout: 1000, stdio: "ignore" });
     } catch {}
     return;
   }
@@ -1442,6 +1787,9 @@ function prunePermissionAlertState(cutoffMs) {
 
 // src/index.ts
 var IDLE_COMPLETE_DELAY_MS = 350;
+function isCLIClient(clientEnv) {
+  return !clientEnv || clientEnv === "cli";
+}
 var pendingIdleTimers = new Map;
 var sessionIdleSequence = new Map;
 var sessionErrorSuppressionAt = new Map;
@@ -1492,7 +1840,7 @@ function incrementTurnCount() {
   saveTurnCount(globalTurnCount);
   return globalTurnCount;
 }
-setInterval(() => {
+var cleanupInterval = setInterval(() => {
   const cutoff = Date.now() - 5 * 60 * 1000;
   for (const [sessionID] of sessionIdleSequence) {
     if (!pendingIdleTimers.has(sessionID)) {
@@ -1512,6 +1860,7 @@ setInterval(() => {
   }
   prunePermissionAlertState(cutoff);
 }, 5 * 60 * 1000);
+cleanupInterval.unref();
 function getNotificationTitle(config, projectName) {
   if (config.showProjectName && projectName) {
     return `OpenCode (${projectName})`;
@@ -1567,7 +1916,7 @@ async function handleEvent(config, eventType, projectName, elapsedSeconds, sessi
     const title = getNotificationTitle(config, projectName);
     const iconPath = getIconPath(config);
     const onNotificationClick = isKDEJumpBackSupported() ? () => void focusTerminal() : undefined;
-    promises.push(sendNotification(title, message, config.timeout, iconPath, config.notificationSystem, config.linux.grouping, onNotificationClick));
+    promises.push(sendNotification(title, message, config.timeout, iconPath, config.notificationSystem, config.linux.grouping, onNotificationClick, config.windows.appID));
   }
   if (isEventSoundEnabled(config, eventType)) {
     const customSoundPath = getSoundPath(config, eventType);
@@ -1591,6 +1940,33 @@ function getSessionIDFromEvent(event) {
   const properties = getNestedRecord(event, "properties");
   return getStringField(properties, "sessionID");
 }
+function getPermissionIDFromEvent(event) {
+  const properties = getNestedRecord(event, "properties");
+  const id = getStringField(properties, "id");
+  if (id) {
+    return id;
+  }
+  const request = getNestedRecord(event, "properties", "request");
+  return getStringField(request, "id");
+}
+var PERMISSION_PENDING_GRACE_MS = 300;
+async function isPermissionStillPending(client, permissionID) {
+  try {
+    const inner = client?._client || client?.session?._client;
+    if (!inner || typeof inner.get !== "function") {
+      return true;
+    }
+    const listResponse = await inner.get({ url: "/permission" });
+    const body = listResponse?.data ?? listResponse;
+    const pendingList = Array.isArray(body) ? body : Array.isArray(body?.data) ? body.data : null;
+    if (!pendingList) {
+      return true;
+    }
+    return pendingList.some((p) => p?.id === permissionID);
+  } catch {
+    return true;
+  }
+}
 function getSessionLifecycleInfo(event) {
   const info = getNestedRecord(event, "properties", "info");
   return {
@@ -1751,9 +2127,14 @@ var NotifierPlugin = async ({ client, directory }) => {
   }
   const getConfig = () => loadConfig();
   const projectName = directory ? getConfig().showFullPath ? directory : basename(directory) : null;
-  setTimeout(() => {
+  const isCLI = isCLIClient(clientEnv);
+  if (isCLI) {
     handleEvent(getConfig(), "client_connected", projectName, null);
-  }, 100);
+  } else {
+    setTimeout(() => {
+      handleEvent(getConfig(), "client_connected", projectName, null);
+    }, 100);
+  }
   return {
     event: async ({ event }) => {
       const config = getConfig();
@@ -1779,14 +2160,26 @@ var NotifierPlugin = async ({ client, directory }) => {
       }
       if (event.type === "permission.asked") {
         const sessionID = getSessionIDFromEvent(event);
-        if (!shouldSuppressPermissionAlert(sessionID)) {
+        const permissionID = getPermissionIDFromEvent(event);
+        let stillPending = true;
+        if (permissionID) {
+          await new Promise((resolve) => setTimeout(resolve, PERMISSION_PENDING_GRACE_MS));
+          stillPending = await isPermissionStillPending(client, permissionID);
+        }
+        if (stillPending && !shouldSuppressPermissionAlert(sessionID)) {
           await handleEventWithElapsedTime(client, config, "permission", projectName, event);
         }
       }
       if (event.type === "session.idle") {
         const sessionID = getSessionIDFromEvent(event);
         if (sessionID) {
-          scheduleSessionIdle(client, config, projectName, event, sessionID);
+          if (isCLI) {
+            const idleReceivedAtMs = Date.now();
+            const sequence = bumpSessionIdleSequence(sessionID);
+            await processSessionIdle(client, config, projectName, event, sessionID, sequence, idleReceivedAtMs);
+          } else {
+            scheduleSessionIdle(client, config, projectName, event, sessionID);
+          }
         } else {
           await handleEventWithElapsedTime(client, config, "complete", projectName, event);
         }
@@ -1832,9 +2225,17 @@ var NotifierPlugin = async ({ client, directory }) => {
     }
   };
 };
-var src_default = NotifierPlugin;
+var pluginModule = {
+  id: "opencode-notifier",
+  server: NotifierPlugin
+};
+var src_default = pluginModule;
 export {
-  extractAgentNameFromSessionTitle,
+  NotifierPlugin,
+  PERMISSION_PENDING_GRACE_MS,
   src_default as default,
-  NotifierPlugin
+  extractAgentNameFromSessionTitle,
+  getPermissionIDFromEvent,
+  isCLIClient,
+  isPermissionStillPending
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohak34/opencode-notifier",
-  "version": "0.2.8",
+  "version": "0.2.9-beta.1",
   "description": "OpenCode plugin that sends system notifications and plays sounds when permission is needed, generation completes, or errors occur",
   "author": "mohak34",
   "license": "MIT",
@@ -38,12 +38,12 @@
     "node-notifier": "^10.0.1"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.0.224",
+    "@opencode-ai/plugin": "^1.18.25",
     "@types/node": "^22.0.0",
     "@types/node-notifier": "^8.0.5",
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.0.0"
+    "@opencode-ai/plugin": ">=1.17.0"
   }
 }