opencode-plugin-apprise 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 opencode-plugin-apprise contributors
+
+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,186 @@
+# opencode-plugin-apprise
+
+OpenCode plugin for multi-service notifications via Apprise.
+
+## Features
+
+- Multi-service support for 128+ notification services via Apprise.
+- Automatic notifications when sessions go idle.
+- Delayed notifications for Question tool prompts (30-second grace period).
+- Alerts when sessions transition to idle after activity.
+- Notifications for permission requests with dual-mechanism reliability.
+
+## Prerequisites
+
+- OpenCode
+- Python 3.x
+- Apprise (`pip install apprise`)
+
+## Quick Start
+
+1. Install the plugin by adding it to your `opencode.json` plugin array:
+
+    ```json
+    "plugins": ["opencode-plugin-apprise"]
+    ```
+
+    Or use the CLI:
+    `opencode plugins add opencode-plugin-apprise`
+
+2. Configure Apprise with your notification URLs in a default Apprise config file such as `~/.apprise`, `~/.apprise.yml`, or `~/.config/apprise/apprise.yml`.
+
+    Example:
+
+    ```yaml
+    # ~/.config/apprise/apprise.yml
+    urls:
+      - slack://TokenA/TokenB/TokenC
+      - discord://webhook_id/webhook_token
+      - tgram://bottoken/ChatID
+    ```
+
+3. Restart OpenCode — the plugin will automatically detect Apprise and use your configured services.
+
+## Configuration
+
+The plugin relies on Apprise's default configuration file behavior.
+
+### Apprise Config File Locations
+
+Apprise automatically looks for config files in these locations (in order):
+
+- `~/.apprise`
+- `~/.apprise.yml`
+- `~/.config/apprise/apprise.yml`
+
+For complete configuration options, see: https://github.com/caronc/apprise#configuration-file
+
+### Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `OPENCODE_NOTIFY_TAG` | No | Apprise tag for filtering which configured services receive notifications. When set, only services matching this tag in your Apprise config will be notified. |
+
+### Behavior Defaults
+
+| Setting | Value |
+|---------|:------|
+| Maximum message length | 1,500 characters |
+| Deduplication TTL | 5 minutes (max 100 entries) |
+| Question notification delay | 30 seconds |
+| Apprise CLI timeout | 30 seconds |
+
+## Notification Triggers
+
+### Idle
+
+Fires immediately when OpenCode emits a `session.idle` event. Includes the last user request, agent response, and todo status.
+
+**Severity**: info
+
+```
+📢 OpenCode Attention Required
+📝 Request: Build a REST API
+🤖 Response: I've created the Express server...
+📋 Todo: ✅ 3 done | ▶️ 1 in_progress | ⚪ 2 pending
+```
+
+### Question
+
+Fires 30 seconds after the Question tool is invoked. If the user answers within 30 seconds, the notification is cancelled. This prevents spam for quick interactions.
+
+**Severity**: warning
+
+```
+❓ OpenCode Question
+❓ Question: Deploy to production?
+Options:
+  1. yes
+  2. no
+  3. cancel
+```
+
+### Background
+
+Fires when a session's status transitions to `idle` after being active. This indicates the agent has finished working and the session is waiting.
+
+**Severity**: success
+
+```
+✅ Background Task Complete
+Task: Session ses_abc123
+```
+
+### Permission
+
+Fires when a tool requires explicit user permission. Uses two mechanisms for reliability: the primary `permission.ask` hook and a fallback `permission.updated` event listener. Permissions are deduplicated by ID to prevent double notifications.
+
+**Severity**: warning
+
+```
+🔐 OpenCode Permission Required
+🔧 Tool: bash
+⚡ Action: execute rm -rf node_modules
+```
+
+## Supported Services
+
+Apprise supports many services. Use these URL formats:
+
+- **Slack**: `slack://TokenA/TokenB/TokenC`
+- **Discord**: `discord://webhook_id/webhook_token`
+- **Telegram**: `tgram://bottoken/ChatID`
+- **Email**: `mailto://user:pass@gmail.com`
+
+For a complete list, see: https://github.com/caronc/apprise#supported-notifications
+
+## How It Works
+
+### Message Truncation
+
+Messages exceeding 1,500 characters are truncated. For messages with more than 10 lines, the first 5 and last 5 lines are preserved with a `...(truncated)` marker. Otherwise, a simple character truncation is applied.
+
+### Deduplication
+
+Identical notifications are suppressed for 5 minutes. Duplicates are identified by a hash of the notification type, title, user request, and question text. The cache holds a maximum of 100 entries with LRU eviction.
+
+### Notification Severity Mapping
+
+| Event | Apprise Type |
+|-------|:-------------|
+| Idle | info |
+| Question | warning |
+| Background | success |
+| Permission | warning |
+
+## Troubleshooting
+
+- **apprise CLI not found**: Run `pip install apprise` to install the required dependency.
+- **No notifications received**: Check your Apprise config file (`~/.apprise`, `~/.apprise.yml`, or `~/.config/apprise/apprise.yml`) and test with `apprise -t test -b test`.
+- **Notifications not reaching a specific service**: Set `OPENCODE_NOTIFY_TAG` to match the tag assigned to that service in your Apprise config.
+- **Too many notifications**: Deduplication suppresses identical notifications for 5 minutes.
+- **Notifications cut off**: Messages are truncated at 1,500 characters.
+- **Apprise command hangs**: The CLI timeout is 30 seconds. If Apprise doesn't respond in time, the notification fails silently.
+
+## Contributing
+
+Contributions are welcome! Please:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feat/my-feature`)
+3. Write tests first (TDD)
+4. Ensure all tests pass (`bun test`)
+5. Submit a pull request
+
+**Development setup:**
+```bash
+git clone https://github.com/or1is1/opencode-plugin-apprise.git
+cd opencode-plugin-apprise
+bun install
+pip install apprise
+bun test
+```
+
+## License
+
+MIT

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+import type { PluginConfig } from "./types.js";
+/**
+ * Load minimal plugin configuration.
+ * All behavior handled by Apprise defaults — no environment variables.
+ */
+export declare function loadConfig(): PluginConfig;
+/**
+ * Validate plugin configuration (no-op — no required fields).
+ */
+export declare function validateConfig(_config: PluginConfig): void;

package/dist/dedup.d.ts

@@ -0,0 +1,6 @@
+import type { NotificationPayload } from "./types.js";
+export interface DedupChecker {
+    isDuplicate(payload: NotificationPayload): boolean;
+    clear(): void;
+}
+export declare function createDedupChecker(): DedupChecker;

package/dist/formatter.d.ts

@@ -0,0 +1,8 @@
+import type { FormattedNotification, NotificationPayload } from "./types.js";
+export declare const DEFAULT_TRUNCATE_LENGTH = 1500;
+export declare function truncateText(text: string, maxLength: number): string;
+export declare function formatTodoStatus(todos: Array<{
+    status: string;
+    content: string;
+}>): string;
+export declare function formatNotification(payload: NotificationPayload, truncateLength?: number): FormattedNotification;

package/dist/hooks/background.d.ts

@@ -0,0 +1,4 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { DedupChecker } from "../dedup.js";
+import type { PluginConfig } from "../types.js";
+export declare function createBackgroundHook(config: PluginConfig, dedup: DedupChecker): NonNullable<Hooks["event"]>;

package/dist/hooks/idle.d.ts

@@ -0,0 +1,4 @@
+import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+import type { DedupChecker } from "../dedup.js";
+import type { PluginConfig } from "../types.js";
+export declare function createIdleHook(ctx: PluginInput, config: PluginConfig, dedup: DedupChecker): NonNullable<Hooks["event"]>;

package/dist/hooks/permission.d.ts

@@ -0,0 +1,10 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { DedupChecker } from "../dedup.js";
+import type { PluginConfig } from "../types.js";
+export interface PermissionHooks {
+    /** Primary: permission.ask hook */
+    permissionAsk: NonNullable<Hooks["permission.ask"]>;
+    /** Fallback: event hook watching permission.updated */
+    eventFallback: NonNullable<Hooks["event"]>;
+}
+export declare function createPermissionHooks(config: PluginConfig, dedup: DedupChecker): PermissionHooks;

package/dist/hooks/question.d.ts

@@ -0,0 +1,8 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { DedupChecker } from "../dedup.js";
+import type { PluginConfig } from "../types.js";
+export interface QuestionHooks {
+    before: NonNullable<Hooks["tool.execute.before"]>;
+    after: NonNullable<Hooks["tool.execute.after"]>;
+}
+export declare function createQuestionHooks(config: PluginConfig, dedup: DedupChecker, delayMs?: number): QuestionHooks;

package/dist/hooks/shared.d.ts

@@ -0,0 +1,4 @@
+import type { DedupChecker } from "../dedup.js";
+import type { HookEventType, NotificationContext, NotificationPayload, PluginConfig } from "../types.js";
+export declare function createPayload(type: HookEventType, title: string, context?: Partial<NotificationContext>): NotificationPayload;
+export declare function sendHookNotification(hookName: string, config: PluginConfig, dedup: DedupChecker, payload: NotificationPayload): Promise<void>;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const plugin: Plugin;
+export default plugin;

package/dist/notifier.d.ts

@@ -0,0 +1,8 @@
+import type { FormattedNotification, PluginConfig } from "./types.js";
+export interface NotifierResult {
+    success: boolean;
+    exitCode: number;
+    stderr: string;
+}
+export declare function checkAppriseInstalled(): Promise<boolean>;
+export declare function sendNotification(config: PluginConfig, notification: FormattedNotification): Promise<NotifierResult>;

package/dist/opencode-plugin-apprise.js

@@ -0,0 +1,421 @@
+// src/config.ts
+function loadConfig() {
+  return {
+    tag: process.env.OPENCODE_NOTIFY_TAG
+  };
+}
+function validateConfig(_config) {}
+
+// src/dedup.ts
+function createDedupChecker() {
+  const TTL_MS = 5 * 60 * 1000;
+  const MAX_SIZE = 100;
+  const seen = new Map;
+  function hashPayload(payload) {
+    const key = `${payload.type}:${payload.title}:${payload.context.userRequest ?? ""}:${payload.context.question ?? ""}`;
+    let hash = 5381;
+    for (let i = 0;i < key.length; i++) {
+      hash = (hash << 5) + hash ^ key.charCodeAt(i);
+      hash = hash >>> 0;
+    }
+    return hash.toString(16);
+  }
+  function evictExpired() {
+    const now = Date.now();
+    for (const [hash, ts] of seen) {
+      if (now - ts > TTL_MS)
+        seen.delete(hash);
+    }
+  }
+  function evictOldestIfFull() {
+    if (seen.size >= MAX_SIZE) {
+      const firstKey = seen.keys().next().value;
+      if (firstKey !== undefined)
+        seen.delete(firstKey);
+    }
+  }
+  return {
+    isDuplicate(payload) {
+      evictExpired();
+      const hash = hashPayload(payload);
+      if (seen.has(hash))
+        return true;
+      evictOldestIfFull();
+      seen.set(hash, Date.now());
+      return false;
+    },
+    clear() {
+      seen.clear();
+    }
+  };
+}
+
+// src/formatter.ts
+var TYPE_MAP = {
+  idle: "info",
+  question: "warning",
+  background: "success",
+  permission: "warning"
+};
+var DEFAULT_TRUNCATE_LENGTH = 1500;
+var TRUNCATE_LINE_THRESHOLD = 10;
+var TRUNCATE_HEAD_LINES = 5;
+var TRUNCATE_TAIL_LINES = 5;
+var TRUNCATE_MARKER = `
+...(truncated)`;
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  const lines = text.split(`
+`);
+  if (lines.length <= TRUNCATE_LINE_THRESHOLD) {
+    const keepLength = maxLength - TRUNCATE_MARKER.length;
+    return text.slice(0, keepLength) + TRUNCATE_MARKER;
+  }
+  const head = lines.slice(0, TRUNCATE_HEAD_LINES).join(`
+`);
+  const tail = lines.slice(-TRUNCATE_TAIL_LINES).join(`
+`);
+  const result = head + TRUNCATE_MARKER + `
+` + tail;
+  if (result.length > maxLength) {
+    return text.slice(0, maxLength - TRUNCATE_MARKER.length) + TRUNCATE_MARKER;
+  }
+  return result;
+}
+function formatTodoStatus(todos) {
+  const done = todos.filter((todo) => todo.status === "completed").length;
+  const inProgress = todos.filter((todo) => todo.status === "in_progress").length;
+  const pending = todos.filter((todo) => todo.status === "pending").length;
+  const parts = [];
+  if (done > 0)
+    parts.push(`✅ ${done} done`);
+  if (inProgress > 0)
+    parts.push(`▶️ ${inProgress} in_progress`);
+  if (pending > 0)
+    parts.push(`⚪ ${pending} pending`);
+  return parts.length > 0 ? parts.join(" | ") : "No todos";
+}
+function formatNotification(payload, truncateLength = DEFAULT_TRUNCATE_LENGTH) {
+  const { type, title, context } = payload;
+  const notificationType = TYPE_MAP[type] ?? "info";
+  let body;
+  switch (type) {
+    case "idle": {
+      const parts = [];
+      if (context.userRequest)
+        parts.push(`\uD83D\uDCDD Request: ${context.userRequest}`);
+      if (context.agentResponse)
+        parts.push(`\uD83E\uDD16 Response: ${context.agentResponse}`);
+      if (context.todoStatus)
+        parts.push(`\uD83D\uDCCB Todo: ${context.todoStatus}`);
+      body = parts.join(`
+
+`);
+      break;
+    }
+    case "question": {
+      const parts = [];
+      if (context.userRequest)
+        parts.push(`\uD83D\uDCDD Request: ${context.userRequest}`);
+      if (context.question)
+        parts.push(`❓ Question: ${context.question}`);
+      if (context.options && context.options.length > 0) {
+        parts.push(`Options:
+${context.options.map((option, index) => `  ${index + 1}. ${option}`).join(`
+`)}`);
+      }
+      body = parts.join(`
+
+`);
+      break;
+    }
+    case "background": {
+      const parts = [];
+      if (context.taskName)
+        parts.push(`Task: ${context.taskName}`);
+      if (context.agentResponse)
+        parts.push(`Result: ${context.agentResponse}`);
+      body = parts.join(`
+
+`);
+      break;
+    }
+    case "permission": {
+      const parts = [];
+      if (context.toolName)
+        parts.push(`\uD83D\uDD27 Tool: ${context.toolName}`);
+      if (context.action)
+        parts.push(`⚡ Action: ${context.action}`);
+      body = parts.join(`
+
+`);
+      break;
+    }
+    default:
+      body = "";
+  }
+  body = truncateText(body, truncateLength);
+  return { title, body, notificationType };
+}
+
+// src/notifier.ts
+var APPRISE_TIMEOUT_MS = 30000;
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function checkAppriseInstalled() {
+  try {
+    const proc = Bun.spawn(["apprise", "--version"], {
+      timeout: APPRISE_TIMEOUT_MS,
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function sendNotification(config, notification) {
+  const args = [
+    "apprise",
+    "-t",
+    notification.title,
+    "-b",
+    notification.body,
+    "--notification-type",
+    notification.notificationType
+  ];
+  if (config.tag) {
+    args.push("--tag", config.tag);
+  }
+  try {
+    const proc = Bun.spawn(args, {
+      timeout: APPRISE_TIMEOUT_MS,
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    const stderr = await new Response(proc.stderr).text();
+    return {
+      success: exitCode === 0,
+      exitCode,
+      stderr
+    };
+  } catch (error) {
+    return {
+      success: false,
+      exitCode: -1,
+      stderr: getErrorMessage(error)
+    };
+  }
+}
+
+// src/hooks/shared.ts
+var EMPTY_CONTEXT = {
+  userRequest: undefined,
+  agentResponse: undefined,
+  question: undefined,
+  options: undefined,
+  todoStatus: undefined,
+  taskName: undefined,
+  toolName: undefined,
+  action: undefined
+};
+function createPayload(type, title, context = {}) {
+  return {
+    type,
+    title,
+    context: { ...EMPTY_CONTEXT, ...context }
+  };
+}
+async function sendHookNotification(hookName, config, dedup, payload) {
+  if (dedup.isDuplicate(payload))
+    return;
+  try {
+    const formatted = formatNotification(payload, DEFAULT_TRUNCATE_LENGTH);
+    await sendNotification(config, formatted);
+  } catch (err) {
+    console.warn(`[opencode-plugin-apprise] ${hookName} hook error:`, err);
+  }
+}
+
+// src/hooks/background.ts
+function createBackgroundHook(config, dedup) {
+  return async ({ event }) => {
+    if (event.type !== "session.status")
+      return;
+    const props = event.properties;
+    if (props.status.type !== "idle")
+      return;
+    const payload = createPayload("background", "✅ Background Task Complete", {
+      taskName: `Session ${props.sessionID}`
+    });
+    await sendHookNotification("background", config, dedup, payload);
+  };
+}
+
+// src/hooks/idle.ts
+function extractText(message) {
+  if (!message || typeof message !== "object") {
+    return;
+  }
+  const parts = Array.isArray(message) ? message.map((p) => typeof p === "string" ? p : p.text || "") : [];
+  return parts.join(`
+`).trim() || undefined;
+}
+function createIdleHook(ctx, config, dedup) {
+  return async ({ event }) => {
+    if (event.type !== "session.idle")
+      return;
+    const props = event.properties;
+    if (!props.sessionID)
+      return;
+    let userRequest = undefined;
+    let agentResponse = undefined;
+    let todoStatus = undefined;
+    try {
+      const messagesResponse = await ctx.client.session.messages({
+        path: { id: props.sessionID }
+      });
+      const messages = messagesResponse.data ?? [];
+      for (let i = messages.length - 1;i >= 0; i--) {
+        const msg = messages[i];
+        if (msg?.role === "user") {
+          userRequest = extractText(msg.content);
+          break;
+        }
+      }
+      if (userRequest) {
+        for (let i = messages.length - 1;i >= 0; i--) {
+          const msg = messages[i];
+          if (msg?.role === "assistant") {
+            agentResponse = extractText(msg.content);
+            break;
+          }
+        }
+      }
+      try {
+        const todosResponse = await ctx.client.session.todo({
+          path: { id: props.sessionID }
+        });
+        if (todosResponse.data) {
+          todoStatus = formatTodoStatus(todosResponse.data);
+        }
+      } catch {}
+    } catch (err) {
+      console.warn("[opencode-plugin-apprise] failed to fetch session data:", err);
+    }
+    const payload = createPayload("idle", "\uD83D\uDCE2 OpenCode Attention Required", {
+      userRequest,
+      agentResponse,
+      todoStatus
+    });
+    await sendHookNotification("idle", config, dedup, payload);
+  };
+}
+
+// src/hooks/permission.ts
+function createPermissionHooks(config, dedup) {
+  const notifiedPermissions = new Set;
+  async function notifyPermission(permission) {
+    const permId = permission.id ?? "unknown";
+    if (notifiedPermissions.has(permId))
+      return;
+    notifiedPermissions.add(permId);
+    const toolName = permission.toolName ?? "Unknown Tool";
+    const action = permission.action ?? "Unknown Action";
+    const payload = createPayload("permission", "\uD83D\uDD10 OpenCode Permission Required", {
+      toolName,
+      action
+    });
+    await sendHookNotification("permission", config, dedup, payload);
+  }
+  const permissionAsk = async (input, _output) => {
+    await notifyPermission(input);
+  };
+  const eventFallback = async ({ event }) => {
+    if (event.type !== "permission.updated")
+      return;
+    const permission = event.properties;
+    await notifyPermission(permission);
+  };
+  return { permissionAsk, eventFallback };
+}
+
+// src/hooks/question.ts
+function createQuestionHooks(config, dedup, delayMs = 30000) {
+  const timers = new Map;
+  const before = async ({ tool, callID }, input) => {
+    if (tool.toLowerCase() !== "question")
+      return;
+    const args = input?.args;
+    const question = typeof args?.question === "string" ? args.question : undefined;
+    const options = Array.isArray(args?.options) ? args.options.filter((option) => typeof option === "string") : undefined;
+    const timer = setTimeout(async () => {
+      if (!question)
+        return;
+      const payload = createPayload("question", "❓ OpenCode Question", {
+        question,
+        options,
+        toolName: "Question"
+      });
+      await sendHookNotification("question", config, dedup, payload);
+    }, delayMs);
+    timers.set(callID, timer);
+  };
+  const after = async ({
+    tool,
+    callID
+  }) => {
+    if (tool.toLowerCase() !== "question")
+      return;
+    const timer = timers.get(callID);
+    if (timer) {
+      clearTimeout(timer);
+      timers.delete(callID);
+    }
+  };
+  return { before, after };
+}
+
+// src/index.ts
+var plugin = async (input) => {
+  let config;
+  try {
+    config = loadConfig();
+    validateConfig(config);
+  } catch (err) {
+    console.warn("[opencode-plugin-apprise] Configuration error:", err instanceof Error ? err.message : err);
+    console.warn("[opencode-plugin-apprise] Plugin disabled due to configuration error.");
+    return {};
+  }
+  const appriseInstalled = await checkAppriseInstalled();
+  if (!appriseInstalled) {
+    console.warn("[opencode-plugin-apprise] apprise CLI not found. Install with: pip install apprise");
+    console.warn("[opencode-plugin-apprise] Plugin disabled.");
+    return {};
+  }
+  const dedup = createDedupChecker();
+  const idleHook = createIdleHook(input, config, dedup);
+  const questionHooks = createQuestionHooks(config, dedup);
+  const backgroundHook = createBackgroundHook(config, dedup);
+  const permissionHooks = createPermissionHooks(config, dedup);
+  const combinedEventHook = async ({ event }) => {
+    await idleHook({ event });
+    await backgroundHook({ event });
+    await permissionHooks.eventFallback({ event });
+  };
+  return {
+    event: combinedEventHook,
+    "tool.execute.before": questionHooks.before,
+    "tool.execute.after": questionHooks.after,
+    "permission.ask": permissionHooks.permissionAsk
+  };
+};
+var src_default = plugin;
+export {
+  src_default as default
+};

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+export interface PluginConfig {
+    tag?: string;
+}
+export type HookEventType = "idle" | "question" | "background" | "permission";
+export type AppriseNotificationType = "info" | "warning" | "success" | "failure";
+export interface NotificationContext {
+    userRequest: string | undefined;
+    agentResponse: string | undefined;
+    question: string | undefined;
+    options: string[] | undefined;
+    todoStatus: string | undefined;
+    taskName: string | undefined;
+    toolName: string | undefined;
+    action: string | undefined;
+}
+export interface NotificationPayload {
+    type: HookEventType;
+    title: string;
+    context: NotificationContext;
+}
+export interface FormattedNotification {
+    title: string;
+    body: string;
+    notificationType: AppriseNotificationType;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "opencode-plugin-apprise",
+  "version": "1.0.0",
+  "description": "OpenCode plugin that sends rich notifications via Apprise CLI when the agent needs your attention",
+  "type": "module",
+  "main": "dist/opencode-plugin-apprise.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/opencode-plugin-apprise.js",
+      "default": "./dist/opencode-plugin-apprise.js"
+    }
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "bun build src/index.ts --outfile dist/opencode-plugin-apprise.js --target node --format esm && tsc --emitDeclarationOnly",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": ["opencode", "plugin", "apprise", "notification", "slack", "discord", "telegram", "attention"],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/or1is1/opencode-plugin-apprise.git"
+  },
+  "homepage": "https://github.com/or1is1/opencode-plugin-apprise#readme",
+  "bugs": {
+    "url": "https://github.com/or1is1/opencode-plugin-apprise/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.2.15",
+    "@types/bun": "latest",
+    "typescript": "^5.9.3"
+  }
+}