opencode-notifications 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,147 @@
+# opencode-notifications
+
+Smart desktop notifications for [OpenCode](https://opencode.ai) - **only notifies when the terminal is not in focus**.
+
+This is the key differentiator from other notification plugins: if you're already looking at OpenCode, you won't be bothered with redundant notifications.
+
+## Features
+
+- **Smart focus detection** - Only sends notifications when you're NOT looking at the terminal
+- **X11 support** - Focus detection via `xdotool`
+- **Tmux support** - Detects active tmux window/pane, works with multiple sessions
+- **Configurable events** - Enable/disable notifications for specific event types
+- **Lightweight** - No sound files, no complex dependencies
+
+## Installation
+
+Add the plugin to your `opencode.json` or `opencode.jsonc`:
+
+```json
+{
+  "plugin": ["opencode-notifications"]
+}
+```
+
+Restart OpenCode. The plugin will be automatically installed and loaded.
+
+## Requirements
+
+### X11
+
+- `xdotool` - For window focus detection
+- `notify-send` - For desktop notifications (usually from `libnotify-bin`)
+
+```bash
+# Debian/Ubuntu
+sudo apt install xdotool libnotify-bin
+
+# Fedora
+sudo dnf install xdotool libnotify
+
+# Arch
+sudo pacman -S xdotool libnotify
+```
+
+### Tmux
+
+Tmux support works automatically when running OpenCode inside a tmux session. No additional setup is required.
+
+When running inside tmux, notifications are suppressed only when **both**:
+1. The terminal window is focused (X11 level)
+2. The tmux window containing the OpenCode pane is active
+
+This means you'll still receive notifications if:
+- You switch to a different tmux window
+- You're in a different tmux session
+- The terminal itself is not focused
+
+## Platform Support
+
+Focus detection is supported on:
+- Linux with X11
+- Tmux (works with X11 for window and pane-level detection)
+
+## Events
+
+The plugin notifies on these OpenCode events:
+
+| Event | Description |
+|-------|-------------|
+| `complete` | Generation/task completed (`session.idle`) |
+| `error` | An error occurred (`session.error`) |
+| `permission` | Permission needed (`permission.asked`) |
+
+## Configuration
+
+Create `~/.config/opencode/opencode-notifications.json` to customize:
+
+```json
+{
+  "events": {
+    "complete": true,
+    "error": true,
+    "permission": true
+  }
+}
+```
+
+### Disable specific events
+
+```json
+{
+  "events": {
+    "complete": true,
+    "error": false,
+    "permission": true
+  }
+}
+```
+
+## How It Works
+
+1. When the plugin loads, it captures the window ID of the terminal running OpenCode
+2. Before sending any notification, it checks if that window is still focused
+3. If the terminal IS focused, the notification is skipped (you're already looking at it!)
+4. If the terminal is NOT focused, the notification is sent
+
+This simple approach ensures you're only notified when you need to be.
+
+## Troubleshooting
+
+### Notifications not appearing
+
+1. **Check if `notify-send` is installed:**
+   ```bash
+   notify-send "Test" "Hello"
+   ```
+
+2. **Check your notification daemon:**
+    - GNOME: Notifications should work out of the box
+    - KDE: Notifications should work out of the box
+
+### Focus detection not working
+
+**X11 - Check if `xdotool` works:**
+```bash
+xdotool getactivewindow
+```
+
+If this returns an error, make sure `xdotool` is installed.
+
+### Notifications always showing (even when terminal is focused)
+
+Make sure `xdotool` is installed and working on X11.
+
+### Tmux: Notifications showing when pane is visible
+
+If you're getting notifications even when the tmux pane running OpenCode is visible:
+- Make sure the tmux window is **active** (not just visible in a split)
+- Check that `TMUX_PANE` environment variable is set (it should be automatic)
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+import type { NotificationConfig } from "./types";
+/**
+ * Load and parse the configuration file
+ * Falls back to default config if file doesn't exist or is invalid
+ */
+export declare function loadConfig(): NotificationConfig;
+/**
+ * Check if a specific event type is enabled
+ */
+export declare function isEventEnabled(config: NotificationConfig, eventType: "complete" | "error" | "permission" | "question"): boolean;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AA6BjD;;;GAGG;AACH,wBAAgB,UAAU,IAAI,kBAAkB,CA2B/C;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,SAAS,EAAE,UAAU,GAAG,OAAO,GAAG,YAAY,GAAG,UAAU,GAC1D,OAAO,CAET"}

package/dist/focus.d.ts

@@ -0,0 +1,15 @@
+import type { FocusDetector } from "./types";
+/**
+ * Detect the display server and return the appropriate focus detector
+ * If running inside tmux, wraps the detector with tmux window-level checking
+ */
+export declare function createFocusDetector(): FocusDetector;
+/**
+ * Initialize focus detection and return a function to check if terminal is focused
+ * Returns null if focus detection is not available
+ */
+export declare function initFocusDetection(): Promise<{
+    detector: FocusDetector;
+    terminalId: string | null;
+}>;
+//# sourceMappingURL=focus.d.ts.map

package/dist/focus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus.d.ts","sourceRoot":"","sources":["../src/focus.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAkH5C;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAkBnD;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC;IAClD,QAAQ,EAAE,aAAa,CAAA;IACvB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B,CAAC,CAKD"}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "@opencode-ai/plugin";
+/**
+ * OpenCode Notifications Plugin
+ *
+ * Sends desktop notifications for meaningful events, but ONLY when the
+ * terminal running OpenCode is not in focus. This prevents unnecessary
+ * notifications when you're already looking at the terminal.
+ *
+ * Supports:
+ * - X11 (via xdotool)
+ * - Sway (via swaymsg)
+ * - Hyprland (via hyprctl)
+ * - Fallback for other Wayland compositors (always notify)
+ */
+export declare const NotificationsPlugin: Plugin;
+export default NotificationsPlugin;
+export type { NotificationConfig, EventType } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAWjD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,EAAE,MA+FjC,CAAA;AAGD,eAAe,mBAAmB,CAAA;AAGlC,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,290 @@
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_CONFIG = {
+  events: {
+    complete: true,
+    error: true,
+    permission: true,
+    question: true
+  },
+  sound: {
+    enabled: true
+  }
+};
+var CONFIG_FILENAME = "opencode-notifications.json";
+function getConfigPath() {
+  return join(homedir(), ".config", "opencode", CONFIG_FILENAME);
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return {
+      events: {
+        complete: parsed?.events?.complete ?? DEFAULT_CONFIG.events.complete,
+        error: parsed?.events?.error ?? DEFAULT_CONFIG.events.error,
+        permission: parsed?.events?.permission ?? DEFAULT_CONFIG.events.permission,
+        question: parsed?.events?.question ?? DEFAULT_CONFIG.events.question
+      },
+      sound: {
+        enabled: parsed?.sound?.enabled ?? DEFAULT_CONFIG.sound.enabled
+      }
+    };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+function isEventEnabled(config, eventType) {
+  return config.events[eventType];
+}
+
+// src/focus.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function runCommand(command) {
+  try {
+    const { stdout } = await execAsync(command, { timeout: 5000 });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function commandExists(cmd) {
+  const result = await runCommand(`which ${cmd}`);
+  return result !== null && result.length > 0;
+}
+
+class X11FocusDetector {
+  name = "X11 (xdotool)";
+  async init() {
+    if (!await commandExists("xdotool")) {
+      return null;
+    }
+    return runCommand("xdotool getactivewindow");
+  }
+  async isTerminalFocused(terminalId) {
+    const currentWindow = await runCommand("xdotool getactivewindow");
+    return currentWindow === terminalId;
+  }
+}
+
+class TmuxFocusDetector {
+  name = "Tmux";
+  innerDetector;
+  paneId;
+  constructor(paneId, innerDetector) {
+    this.paneId = paneId;
+    this.innerDetector = innerDetector;
+  }
+  async init() {
+    if (!await commandExists("tmux")) {
+      return this.innerDetector.init();
+    }
+    return this.innerDetector.init();
+  }
+  async isTerminalFocused(terminalId) {
+    const terminalFocused = await this.innerDetector.isTerminalFocused(terminalId);
+    if (!terminalFocused) {
+      return false;
+    }
+    const sessionAttached = await runCommand(`tmux display-message -t ${this.paneId} -p '#{session_attached}'`);
+    if (sessionAttached !== "1") {
+      return false;
+    }
+    const windowActive = await runCommand(`tmux display-message -t ${this.paneId} -p '#{window_active}'`);
+    return windowActive === "1";
+  }
+}
+
+class AlwaysNotifyDetector {
+  name = "Fallback (always notify)";
+  async init() {
+    return "unsupported";
+  }
+  async isTerminalFocused(_terminalId) {
+    return false;
+  }
+}
+function createFocusDetector() {
+  const sessionType = process.env.XDG_SESSION_TYPE;
+  const tmuxPane = process.env.TMUX_PANE;
+  let baseDetector;
+  if (sessionType === "x11" || process.env.DISPLAY) {
+    baseDetector = new X11FocusDetector;
+  } else {
+    baseDetector = new AlwaysNotifyDetector;
+  }
+  if (tmuxPane) {
+    return new TmuxFocusDetector(tmuxPane, baseDetector);
+  }
+  return baseDetector;
+}
+async function initFocusDetection() {
+  const detector = createFocusDetector();
+  const terminalId = await detector.init();
+  return { detector, terminalId };
+}
+
+// src/notify.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+var NOTIFICATION_DEFAULTS = {
+  complete: {
+    title: "OpenCode Ready",
+    body: "Task completed",
+    icon: "dialog-information"
+  },
+  error: {
+    title: "OpenCode Error",
+    body: "An error occurred",
+    icon: "dialog-error"
+  },
+  permission: {
+    title: "OpenCode Permission",
+    body: "Action requires approval",
+    icon: "dialog-password"
+  },
+  question: {
+    title: "OpenCode Question",
+    body: "Your input is needed",
+    icon: "dialog-question"
+  }
+};
+var EVENT_SOUNDS = {
+  complete: "dialog-information",
+  error: "dialog-error",
+  permission: "dialog-warning",
+  question: "dialog-question"
+};
+function getNotificationContent(eventType, context) {
+  const defaults = NOTIFICATION_DEFAULTS[eventType];
+  if (!context) {
+    return defaults;
+  }
+  let body = defaults.body;
+  switch (eventType) {
+    case "error":
+      if (context.errorMessage) {
+        body = truncate(context.errorMessage, 100);
+      }
+      break;
+    case "permission":
+      if (context.permissionName) {
+        const pattern = context.permissionPatterns?.[0];
+        body = pattern ? `${context.permissionName}: ${truncate(pattern, 60)}` : `${context.permissionName} requested`;
+      }
+      break;
+    case "question":
+      if (context.questionText) {
+        body = truncate(context.questionText, 100);
+      } else if (context.questionHeader) {
+        body = truncate(context.questionHeader, 100);
+      }
+      break;
+  }
+  return {
+    ...defaults,
+    body
+  };
+}
+function getEventSound(eventType) {
+  return EVENT_SOUNDS[eventType];
+}
+async function playSound(soundId) {
+  try {
+    await execAsync2(`canberra-gtk-play -i "${soundId}"`, { timeout: 5000 });
+  } catch {
+  }
+}
+async function sendNotification(title, body, options) {
+  const promises = [];
+  const iconArg = options?.icon ? `-i "${escapeShellArg(options.icon)}"` : "";
+  const cmd = `notify-send -a "OpenCode" -u normal ${iconArg} "${escapeShellArg(title)}" "${escapeShellArg(body)}"`;
+  promises.push(execAsync2(cmd, { timeout: 5000 }).then(() => {
+  }).catch(() => {
+  }));
+  if (options?.playSound && options?.soundId) {
+    promises.push(playSound(options.soundId));
+  }
+  await Promise.all(promises);
+}
+function escapeShellArg(arg) {
+  return arg.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function truncate(str, maxLength) {
+  const cleaned = str.replace(/\s+/g, " ").trim();
+  if (cleaned.length <= maxLength) {
+    return cleaned;
+  }
+  return cleaned.slice(0, maxLength - 1) + "…";
+}
+
+// src/index.ts
+var NotificationsPlugin = async () => {
+  const config = loadConfig();
+  const { detector, terminalId } = await initFocusDetection();
+  async function maybeNotify(eventType, context) {
+    if (!isEventEnabled(config, eventType)) {
+      return;
+    }
+    if (terminalId && await detector.isTerminalFocused(terminalId)) {
+      return;
+    }
+    const { title, body, icon } = getNotificationContent(eventType, context);
+    await sendNotification(title, body, {
+      icon,
+      playSound: config.sound.enabled,
+      soundId: getEventSound(eventType)
+    });
+  }
+  return {
+    event: async ({ event }) => {
+      if (event.type === "session.idle") {
+        await maybeNotify("complete");
+      }
+      if (event.type === "session.error") {
+        const props = event.properties;
+        const errorMessage = props.error?.data?.message || props.error?.name || undefined;
+        await maybeNotify("error", { errorMessage });
+      }
+      if (event.type === "permission.updated") {
+        await maybeNotify("permission");
+      }
+      if (event.type === "permission.asked") {
+        const props = event.properties;
+        await maybeNotify("permission", {
+          permissionName: props.permission,
+          permissionPatterns: props.patterns
+        });
+      }
+      if (event.type === "question.asked") {
+        const props = event.properties;
+        const firstQuestion = props.questions?.[0];
+        await maybeNotify("question", {
+          questionText: firstQuestion?.question,
+          questionHeader: firstQuestion?.header
+        });
+      }
+    },
+    "permission.ask": async (input) => {
+      const props = input;
+      await maybeNotify("permission", {
+        permissionName: props.permission,
+        permissionPatterns: props.patterns
+      });
+    }
+  };
+};
+var src_default = NotificationsPlugin;
+export {
+  src_default as default,
+  NotificationsPlugin
+};

package/dist/notify.d.ts

@@ -0,0 +1,40 @@
+import type { EventType, NotificationContent } from "./types";
+/**
+ * Event context passed from OpenCode events
+ */
+export interface EventContext {
+    /** Error message for error events */
+    errorMessage?: string;
+    /** Permission name for permission events */
+    permissionName?: string;
+    /** File patterns for permission events */
+    permissionPatterns?: string[];
+    /** Question text for question events */
+    questionText?: string;
+    /** Question header for question events */
+    questionHeader?: string;
+}
+/**
+ * Get the notification content for an event type, optionally enhanced with context
+ */
+export declare function getNotificationContent(eventType: EventType, context?: EventContext): NotificationContent;
+/**
+ * Get the sound ID for an event type
+ */
+export declare function getEventSound(eventType: EventType): string;
+/**
+ * Send a desktop notification using notify-send
+ *
+ * @param title - Notification title
+ * @param body - Notification body text
+ * @param options - Additional options
+ * @param options.icon - Icon name (freedesktop icon theme)
+ * @param options.playSound - Whether to play a sound effect
+ * @param options.soundId - The freedesktop sound theme ID to play
+ */
+export declare function sendNotification(title: string, body: string, options?: {
+    icon?: string;
+    playSound?: boolean;
+    soundId?: string;
+}): Promise<void>;
+//# sourceMappingURL=notify.d.ts.map

package/dist/notify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notify.d.ts","sourceRoot":"","sources":["../src/notify.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAyC7D;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,qCAAqC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,4CAA4C;IAC5C,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,0CAA0C;IAC1C,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC7B,wCAAwC;IACxC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,0CAA0C;IAC1C,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,SAAS,EACpB,OAAO,CAAC,EAAE,YAAY,GACrB,mBAAmB,CAwCrB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAE1D;AAgBD;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GACjE,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/dist/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Configuration for notification events
+ */
+export interface EventsConfig {
+    /** Notify when generation completes (session.idle) */
+    complete: boolean;
+    /** Notify when an error occurs (session.error) */
+    error: boolean;
+    /** Notify when permission is needed (permission.asked) */
+    permission: boolean;
+    /** Notify when a question is asked (question.asked) */
+    question: boolean;
+}
+/**
+ * Sound configuration
+ */
+export interface SoundConfig {
+    /** Enable sound effects for notifications */
+    enabled: boolean;
+}
+/**
+ * Plugin configuration
+ */
+export interface NotificationConfig {
+    events: EventsConfig;
+    sound: SoundConfig;
+}
+/**
+ * Event types that trigger notifications
+ */
+export type EventType = "complete" | "error" | "permission" | "question";
+/**
+ * Notification content
+ */
+export interface NotificationContent {
+    title: string;
+    body: string;
+    icon: string;
+}
+/**
+ * Focus detector interface for different display servers
+ */
+export interface FocusDetector {
+    /** Get the name of the display server/compositor */
+    readonly name: string;
+    /**
+     * Initialize the detector and capture the terminal window ID
+     * @returns The terminal window/container ID, or null if detection is not supported
+     */
+    init(): Promise<string | null>;
+    /**
+     * Check if the terminal window is currently focused
+     * @param terminalId The terminal ID captured during init
+     * @returns true if the terminal is focused, false otherwise
+     */
+    isTerminalFocused(terminalId: string): Promise<boolean>;
+}
+/**
+ * Result of running a shell command
+ */
+export interface CommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,sDAAsD;IACtD,QAAQ,EAAE,OAAO,CAAA;IACjB,kDAAkD;IAClD,KAAK,EAAE,OAAO,CAAA;IACd,0DAA0D;IAC1D,UAAU,EAAE,OAAO,CAAA;IACnB,uDAAuD;IACvD,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,6CAA6C;IAC7C,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,YAAY,CAAA;IACpB,KAAK,EAAE,WAAW,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,OAAO,GAAG,YAAY,GAAG,UAAU,CAAA;AAExE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;;OAGG;IACH,IAAI,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAE9B;;;;OAIG;IACH,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CACxD;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;CACjB"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "opencode-notifications",
+  "version": "0.1.0",
+  "description": "Smart desktop notifications for OpenCode - only notifies when terminal is not focused (Linux)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node && tsc --emitDeclarationOnly --declaration --outDir ./dist",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "notifications",
+    "linux",
+    "desktop",
+    "x11"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YOUR_USERNAME/opencode-notifications.git"
+  },
+  "bugs": {
+    "url": "https://github.com/YOUR_USERNAME/opencode-notifications/issues"
+  },
+  "homepage": "https://github.com/YOUR_USERNAME/opencode-notifications#readme",
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=0.0.1"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "latest",
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  }
+}