@sillybit/opencode-plugin-everynotify 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sillybit
+
+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 @@
+# EveryNotify — Multi-Service Notifications for opencode
+
+[![npm version](https://img.shields.io/npm/v/opencode-plugin-everynotify.svg)](https://www.npmjs.com/package/opencode-plugin-everynotify)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+EveryNotify is a lightweight, zero-dependency notification plugin for [opencode](https://github.com/opencode-ai/plugin) designed to keep you informed about your AI-driven development sessions. It dispatches notifications to multiple services simultaneously, ensuring you stay updated on task progress, errors, and interaction requests, even when you're not actively monitoring your terminal.
+
+## Overview
+
+In long-running development tasks or deep research sessions, it's common to switch focus while opencode works in the background. EveryNotify bridges the gap between your terminal and your preferred notification device, allowing you to react quickly when opencode requires input or has finished its work.
+
+### Why EveryNotify?
+
+- **Multitasking Efficiency**: Walk away from your desk while opencode processes complex requests.
+- **Immediate Awareness**: Get notified the instant an error occurs or a permission is requested.
+- **Centralized Logs**: Use Slack, Discord, or Telegram as a secondary history of your opencode sessions.
+- **Universal Reach**: Works across desktop and mobile through native service apps.
+
+## Features
+
+- ✅ **4 Notification Services**: Native support for Pushover, Telegram, Slack, and Discord.
+- ✅ **Automatic Event Detection**: Notifies on session completion, idle states, errors, and questions.
+- ✅ **Rich Session Meta**: Notifications include the project name, session ID, and total elapsed time.
+- ✅ **Intelligent Debouncing**: Prevents notification storms by aggregating repeated events within a 1-second window.
+- ✅ **Fault Tolerance**: Isolated service calls ensure that a failure in one provider doesn't block others.
+- ✅ **Zero Runtime Dependencies**: Built entirely on standard Node.js APIs and native `fetch()`.
+- ✅ **Privacy & Control**: Completely opt-in; no notifications are sent until you enable and configure a service.
+
+## Installation
+
+Install EveryNotify into your opencode environment using npm:
+
+```bash
+npm install opencode-plugin-everynotify
+```
+
+## Configuration
+
+EveryNotify utilizes a simple JSON configuration file named `.everynotify.json`. The plugin aggregates configuration from two potential scopes:
+
+1. **Global Configuration**: `~/.config/opencode/.everynotify.json`
+   _Use this for your default tokens and webhook URLs across all projects._
+2. **Project Configuration**: `.opencode/.everynotify.json` (inside your project directory)
+   _Use this to override settings or redirect notifications for a specific repository._
+
+### Example Configuration
+
+Create your `.everynotify.json` with the tokens for the services you want to use. You can enable multiple services at once.
+
+```json
+{
+  "pushover": {
+    "enabled": true,
+    "token": "KzG789...your_app_token",
+    "userKey": "uQi678...your_user_key",
+    "priority": 0
+  },
+  "telegram": {
+    "enabled": true,
+    "botToken": "123456:ABC-DEF...your_bot_token",
+    "chatId": "987654321"
+  },
+  "slack": {
+    "enabled": false,
+    "webhookUrl": "https://hooks.slack.com/services/T000/B000/XXXX"
+  },
+  "discord": {
+    "enabled": false,
+    "webhookUrl": "https://discord.com/api/webhooks/0000/XXXX"
+  }
+}
+```
+
+## Usage
+
+EveryNotify is a "fire-and-forget" plugin. Once installed and configured, it requires no manual intervention. opencode will automatically detect and load the plugin, which then runs silently in the background.
+
+When an event is triggered, EveryNotify builds a descriptive message (e.g., `[complete] my-project (elapsed: 12m 30s)`) and dispatches it to all services marked as `"enabled": true`.
+
+## Supported Services
+
+| Service      | Requirements        | Recommended For                 | Setup Link                                                                |
+| ------------ | ------------------- | ------------------------------- | ------------------------------------------------------------------------- |
+| **Pushover** | App Token, User Key | High-priority mobile alerts     | [Pushover API](https://pushover.net/api)                                  |
+| **Telegram** | Bot Token, Chat ID  | Instant messaging & groups      | [Telegram Bots](https://core.telegram.org/bots)                           |
+| **Slack**    | Webhook URL         | Team collaboration & logging    | [Slack Webhooks](https://api.slack.com/messaging/webhooks)                |
+| **Discord**  | Webhook URL         | Community & server-based alerts | [Discord Webhooks](https://discord.com/developers/docs/resources/webhook) |
+
+## Event Types
+
+The plugin monitors several key lifecycle hooks within opencode:
+
+- **`complete`**: Dispatched when a task is finished and the session becomes idle. Also triggers when a subagent completes its assigned task.
+- **`error`**: Dispatched if the session crashes or encounters a fatal execution error. Includes the error message in the notification.
+- **`permission`**: Dispatched when opencode pauses to ask for tool execution permissions or file access.
+- **`question`**: Dispatched when opencode uses the `question` tool to seek clarification from the user.
+
+## Advanced Features
+
+### Priority Management (Pushover)
+
+For Pushover users, you can customize the `priority` level:
+
+- `-2`: Lowest priority (no notification)
+- `-1`: Quiet notification
+- `0`: Normal priority (default)
+- `1`: High priority (bypasses quiet hours)
+- `2`: Emergency priority (requires acknowledgment)
+
+### Session Enrichment
+
+EveryNotify automatically calculates the time elapsed since the first user message in a session. This duration is included in the notification text to give you context on how long the task took to complete.
+
+### Project Overrides
+
+If you are working on a sensitive or client-specific project, you can place a `.everynotify.json` file in the project's `.opencode/` directory to send notifications to a specific Slack channel or Telegram group, bypassing your global configuration.
+
+## Development
+
+Developers looking to extend EveryNotify or add new service providers should consult [AGENTS.md](./AGENTS.md).
+
+### Build & Test Workflow
+
+The project uses [Bun](https://bun.sh) for lightning-fast development:
+
+- **Install Dependencies**: `bun install`
+- **Build Plugin**: `bun run build`
+- **Run Tests**: `bun test`
+- **Type Check**: `bun run typecheck`
+
+## Contributing
+
+We welcome contributions of all kinds!
+
+1. **Bug Reports**: Open an issue describing the bug and your environment.
+2. **Feature Requests**: Propose new services or event hooks via issues.
+3. **Pull Requests**: Follow the existing code style (2-space indent, strict TypeScript) and ensure all tests pass.
+
+## License
+
+Distributed under the **MIT License**. See `LICENSE` for more information.
+
+## Credits
+
+Created by **[Sillybit](https://sillybit.io)** — Pixel Perfect Innovation.
+
+Built with ❤️ for the opencode community.

package/dist/config.d.ts

@@ -0,0 +1,29 @@
+/**
+ * EveryNotify Plugin — Configuration Loader
+ *
+ * Loads configuration from:
+ * 1. Global: ~/.config/opencode/.everynotify.json
+ * 2. Project: .opencode/.everynotify.json (in project directory)
+ *
+ * Merge order: defaults ← global ← project (project wins)
+ * All services disabled by default.
+ */
+import type { EverynotifyConfig } from "./types";
+/**
+ * Default configuration — all services disabled, empty credentials
+ */
+export declare const DEFAULT_CONFIG: EverynotifyConfig;
+/**
+ * Get config file path for a given scope
+ * @param scope "global" or "project"
+ * @param directory project directory (used for project scope)
+ * @returns full path to config file
+ */
+export declare function getConfigPath(scope: "global" | "project", directory: string): string;
+/**
+ * Load configuration from global and project scopes
+ * Merge order: defaults ← global ← project (project wins)
+ * @param directory project directory
+ * @returns merged EverynotifyConfig
+ */
+export declare function loadConfig(directory: string): EverynotifyConfig;

package/dist/dispatcher.d.ts

@@ -0,0 +1,28 @@
+/**
+ * EveryNotify Plugin — Dispatcher
+ *
+ * Dispatches notifications to all enabled services in parallel with:
+ * - Debouncing: 1000ms per event type (prevents duplicate notifications)
+ * - Timeout: 5s per service call (via AbortController)
+ * - Error isolation: One service failing doesn't block others (Promise.allSettled)
+ */
+import type { EverynotifyConfig, NotificationPayload } from "./types";
+/**
+ * Truncate text to max length, appending "… [truncated]" if over limit
+ * Shared utility function used by all services
+ */
+export declare function truncate(text: string, maxLength: number): string;
+/**
+ * Dispatcher interface returned by createDispatcher
+ */
+interface Dispatcher {
+    dispatch: (payload: NotificationPayload) => Promise<void>;
+}
+/**
+ * Create a dispatcher that sends notifications to all enabled services
+ *
+ * @param config - EverynotifyConfig with enabled services
+ * @returns Dispatcher with dispatch() function
+ */
+export declare function createDispatcher(config: EverynotifyConfig): Dispatcher;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * EveryNotify Plugin — Entry Point
+ *
+ * Implements the opencode plugin interface with three hooks:
+ * - event: Handles session.idle, session.error, permission.updated events
+ * - permission.ask: Handles permission requests (debounce handles overlap with event hook)
+ * - tool.execute.before: Detects question tool usage
+ *
+ * Session enrichment:
+ * - Calls client.session.get() to check parentID (subagent detection)
+ * - Calls client.session.messages() to calculate elapsed time
+ * - All SDK calls wrapped in try/catch with fallback to null
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+/**
+ * EveryNotify Plugin
+ *
+ * @param input - PluginInput from opencode SDK
+ * @returns Hooks object with event, permission.ask, and tool.execute.before hooks
+ */
+declare const EverynotifyPlugin: Plugin;
+export default EverynotifyPlugin;
+export { EverynotifyPlugin };

package/dist/index.js

@@ -0,0 +1,397 @@
+// src/index.ts
+import * as path2 from "path";
+
+// src/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var DEFAULT_CONFIG = {
+  pushover: {
+    enabled: false,
+    token: "",
+    userKey: "",
+    priority: 0
+  },
+  telegram: {
+    enabled: false,
+    botToken: "",
+    chatId: ""
+  },
+  slack: {
+    enabled: false,
+    webhookUrl: ""
+  },
+  discord: {
+    enabled: false,
+    webhookUrl: ""
+  }
+};
+function getConfigPath(scope, directory) {
+  if (scope === "global") {
+    return path.join(os.homedir(), ".config", "opencode", ".everynotify.json");
+  }
+  return path.join(directory, ".opencode", ".everynotify.json");
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  if (source.pushover) {
+    result.pushover = { ...result.pushover, ...source.pushover };
+  }
+  if (source.telegram) {
+    result.telegram = { ...result.telegram, ...source.telegram };
+  }
+  if (source.slack) {
+    result.slack = { ...result.slack, ...source.slack };
+  }
+  if (source.discord) {
+    result.discord = { ...result.discord, ...source.discord };
+  }
+  return result;
+}
+function loadConfigFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    return parsed;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.error(`[EveryNotify] Failed to load config from ${filePath}: ${errorMsg}`);
+    return null;
+  }
+}
+function loadConfig(directory) {
+  let config = { ...DEFAULT_CONFIG };
+  const globalPath = getConfigPath("global", directory);
+  const globalConfig = loadConfigFile(globalPath);
+  if (globalConfig) {
+    config = deepMerge(config, globalConfig);
+  }
+  const projectPath = getConfigPath("project", directory);
+  const projectConfig = loadConfigFile(projectPath);
+  if (projectConfig) {
+    config = deepMerge(config, projectConfig);
+  }
+  const allDisabled = !config.pushover.enabled && !config.telegram.enabled && !config.slack.enabled && !config.discord.enabled;
+  if (allDisabled) {
+    console.error("[EveryNotify] No services configured. Enable services in .everynotify.json");
+  }
+  return config;
+}
+
+// src/services/pushover.ts
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  const suffix = "… [truncated]";
+  return text.slice(0, maxLength - suffix.length) + suffix;
+}
+async function send(config, payload, signal) {
+  try {
+    const body = new URLSearchParams({
+      token: config.token,
+      user: config.userKey,
+      message: truncate(payload.message, 1024),
+      title: truncate(payload.title, 250),
+      priority: String(config.priority ?? 0)
+    });
+    const response = await fetch("https://api.pushover.net/1/messages.json", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body.toString(),
+      signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`[EveryNotify] Pushover error: ${response.status} ${errorText}`);
+      return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[EveryNotify] Pushover failed: ${message}`);
+  }
+}
+
+// src/services/telegram.ts
+function truncate2(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  const suffix = "… [truncated]";
+  return text.slice(0, maxLength - suffix.length) + suffix;
+}
+function formatMessage(payload) {
+  const truncatedTitle = truncate2(payload.title, 250);
+  const truncatedMessage = truncate2(payload.message, 3840);
+  return `<b>${truncatedTitle}</b>
+${truncatedMessage}`;
+}
+async function send2(config, payload, signal) {
+  try {
+    const text = formatMessage(payload);
+    const body = JSON.stringify({
+      chat_id: config.chatId,
+      text,
+      parse_mode: "HTML"
+    });
+    const response = await fetch(`https://api.telegram.org/bot${config.botToken}/sendMessage`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body,
+      signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`[EveryNotify] Telegram error: ${response.status} ${errorText}`);
+      return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[EveryNotify] Telegram failed: ${message}`);
+  }
+}
+
+// src/services/slack.ts
+function truncate3(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  const suffix = "… [truncated]";
+  return text.slice(0, maxLength - suffix.length) + suffix;
+}
+function formatSlackMessage(payload) {
+  return `*${payload.title}*
+${payload.message}`;
+}
+async function send3(config, payload, signal) {
+  try {
+    const text = truncate3(formatSlackMessage(payload), 40000);
+    const response = await fetch(config.webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ text }),
+      signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`[EveryNotify] Slack error: ${response.status} ${errorText}`);
+      return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[EveryNotify] Slack failed: ${message}`);
+  }
+}
+
+// src/services/discord.ts
+function truncate4(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  const suffix = "… [truncated]";
+  return text.slice(0, maxLength - suffix.length) + suffix;
+}
+function formatDiscordMessage(payload) {
+  return `**${payload.title}**
+${payload.message}`;
+}
+async function send4(config, payload, signal) {
+  try {
+    const content = truncate4(formatDiscordMessage(payload), 2000);
+    const response = await fetch(config.webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ content }),
+      signal
+    });
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      console.error(`[EveryNotify] Discord rate limited. Retry-After: ${retryAfter}s`);
+      return;
+    }
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`[EveryNotify] Discord error: ${response.status} ${errorText}`);
+      return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[EveryNotify] Discord failed: ${message}`);
+  }
+}
+
+// src/dispatcher.ts
+function createDispatcher(config) {
+  const services = [];
+  if (config.pushover.enabled) {
+    services.push({
+      name: "Pushover",
+      send,
+      config: config.pushover
+    });
+  }
+  if (config.telegram.enabled) {
+    services.push({
+      name: "Telegram",
+      send: send2,
+      config: config.telegram
+    });
+  }
+  if (config.slack.enabled) {
+    services.push({
+      name: "Slack",
+      send: send3,
+      config: config.slack
+    });
+  }
+  if (config.discord.enabled) {
+    services.push({
+      name: "Discord",
+      send: send4,
+      config: config.discord
+    });
+  }
+  const lastDispatchTime = new Map;
+  async function dispatch(payload) {
+    const now = Date.now();
+    const lastTime = lastDispatchTime.get(payload.eventType) ?? 0;
+    if (now - lastTime < 1000) {
+      return;
+    }
+    lastDispatchTime.set(payload.eventType, now);
+    if (services.length === 0) {
+      return;
+    }
+    const promises = services.map(async (service) => {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), 5000);
+      try {
+        await service.send(service.config, payload, controller.signal);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    });
+    const results = await Promise.allSettled(promises);
+    results.forEach((result, index) => {
+      if (result.status === "rejected") {
+        console.error(`[EveryNotify] ${services[index].name} failed:`, result.reason);
+      }
+    });
+  }
+  return { dispatch };
+}
+
+// src/index.ts
+var EverynotifyPlugin = async (input) => {
+  const { client, directory } = input;
+  const config = loadConfig(directory);
+  const { dispatch } = createDispatcher(config);
+  async function buildPayload(eventType, sessionID, extraMessage) {
+    const projectName = directory ? path2.basename(directory) : null;
+    let elapsedSeconds = null;
+    let isSubagent = false;
+    try {
+      if (sessionID) {
+        const sessionResult = await client.session.get({
+          path: { id: sessionID }
+        });
+        if (sessionResult.data?.parentID) {
+          isSubagent = true;
+        }
+        const messagesResult = await client.session.messages({
+          path: { id: sessionID }
+        });
+        const messages = messagesResult.data;
+        if (messages && messages.length > 0) {
+          const firstUserMessage = messages.find((msg) => msg.info?.role === "user");
+          if (firstUserMessage?.info?.time?.created) {
+            const startTime = new Date(firstUserMessage.info.time.created).getTime();
+            const now = Date.now();
+            elapsedSeconds = Math.floor((now - startTime) / 1000);
+          }
+        }
+      }
+    } catch (error) {}
+    let finalEventType = eventType;
+    if (eventType === "complete" && isSubagent) {
+      finalEventType = "subagent_complete";
+    }
+    const title = `[${finalEventType}] ${projectName || "opencode"}`;
+    let message = extraMessage || "Event occurred";
+    if (elapsedSeconds !== null) {
+      const minutes = Math.floor(elapsedSeconds / 60);
+      const seconds = elapsedSeconds % 60;
+      message += ` (elapsed: ${minutes}m ${seconds}s)`;
+    }
+    return {
+      eventType: finalEventType,
+      title,
+      message,
+      projectName,
+      timestamp: Date.now(),
+      sessionID,
+      elapsedSeconds
+    };
+  }
+  async function eventHook({ event }) {
+    try {
+      const sessionID = event.properties?.sessionID || null;
+      if (event.type === "session.idle") {
+        const payload = await buildPayload("complete", sessionID);
+        await dispatch(payload);
+      } else if (event.type === "session.error") {
+        const rawError = event.properties?.error;
+        const errorMessage = rawError?.data?.message ?? rawError?.name ?? "Unknown error";
+        const payload = await buildPayload("error", sessionID, errorMessage);
+        await dispatch(payload);
+      } else if (event.type === "permission.updated") {
+        const payload = await buildPayload("permission", sessionID);
+        await dispatch(payload);
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[EveryNotify] Event hook error: ${errorMsg}`);
+    }
+  }
+  async function permissionAskHook(_input, _output) {
+    try {
+      const payload = await buildPayload("permission", null);
+      await dispatch(payload);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[EveryNotify] Permission.ask hook error: ${errorMsg}`);
+    }
+  }
+  async function toolExecuteBeforeHook(input2, _output) {
+    try {
+      if (input2.tool === "question") {
+        const payload = await buildPayload("question", null);
+        await dispatch(payload);
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[EveryNotify] Tool.execute.before hook error: ${errorMsg}`);
+    }
+  }
+  return {
+    event: eventHook,
+    "permission.ask": permissionAskHook,
+    "tool.execute.before": toolExecuteBeforeHook
+  };
+};
+var src_default = EverynotifyPlugin;
+export {
+  src_default as default,
+  EverynotifyPlugin
+};

package/dist/services/discord.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Discord notification service
+ * API: https://discord.com/developers/docs/resources/webhook#execute-webhook
+ *
+ * CRITICAL: Uses application/json
+ * Message limit: 2000 chars (Discord webhook content field limit)
+ * Rate limit: 10 requests per 10 seconds per webhook
+ */
+import type { DiscordConfig, NotificationPayload } from "../types";
+/**
+ * Send notification via Discord webhook API
+ *
+ * @param config - Discord configuration (webhookUrl)
+ * @param payload - Notification payload (title, message, etc.)
+ * @param signal - AbortSignal for timeout control
+ */
+export declare function send(config: DiscordConfig, payload: NotificationPayload, signal: AbortSignal): Promise<void>;

package/dist/services/pushover.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Pushover notification service
+ * API: https://pushover.net/api
+ *
+ * CRITICAL: Uses application/x-www-form-urlencoded (NOT JSON)
+ * Message limit: 1024 chars
+ * Title limit: 250 chars
+ */
+import type { PushoverConfig, NotificationPayload } from "../types";
+/**
+ * Send notification via Pushover API
+ *
+ * @param config - Pushover configuration (token, userKey, priority)
+ * @param payload - Notification payload (title, message, etc.)
+ * @param signal - AbortSignal for timeout control
+ */
+export declare function send(config: PushoverConfig, payload: NotificationPayload, signal: AbortSignal): Promise<void>;

package/dist/services/slack.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Slack notification service
+ * API: https://api.slack.com/messaging/webhooks
+ *
+ * Uses Incoming Webhooks with JSON POST
+ * Message limit: 40000 chars (Slack text field limit)
+ * Formatting: mrkdwn (Slack markdown)
+ */
+import type { SlackConfig, NotificationPayload } from "../types";
+/**
+ * Send notification via Slack Incoming Webhook
+ *
+ * @param config - Slack configuration (webhookUrl)
+ * @param payload - Notification payload (title, message, etc.)
+ * @param signal - AbortSignal for timeout control
+ */
+export declare function send(config: SlackConfig, payload: NotificationPayload, signal: AbortSignal): Promise<void>;

package/dist/services/telegram.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Telegram notification service
+ * API: https://core.telegram.org/bots/api#sendmessage
+ *
+ * CRITICAL: Uses application/json (JSON body)
+ * Message limit: 4096 chars
+ * Supports HTML formatting via parse_mode: "HTML"
+ */
+import type { TelegramConfig, NotificationPayload } from "../types";
+/**
+ * Send notification via Telegram Bot API
+ *
+ * @param config - Telegram configuration (botToken, chatId)
+ * @param payload - Notification payload (title, message, etc.)
+ * @param signal - AbortSignal for timeout control
+ */
+export declare function send(config: TelegramConfig, payload: NotificationPayload, signal: AbortSignal): Promise<void>;

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * EveryNotify Plugin — Shared Type Definitions
+ *
+ * All types for notification payloads, service configurations, and dispatch functions.
+ * No validation logic here — types only.
+ */
+/**
+ * Event types that trigger notifications
+ */
+export type EventType = "complete" | "subagent_complete" | "error" | "permission" | "question";
+/**
+ * Notification payload sent to all enabled services
+ */
+export interface NotificationPayload {
+    eventType: EventType;
+    title: string;
+    message: string;
+    projectName: string | null;
+    timestamp: number;
+    sessionID: string | null;
+    elapsedSeconds: number | null;
+}
+/**
+ * Pushover service configuration
+ * API: https://pushover.net/api
+ * - token: 30-character app token
+ * - userKey: 30-character user key
+ * - priority: optional priority level (-2 to 2)
+ */
+export interface PushoverConfig {
+    enabled: boolean;
+    token: string;
+    userKey: string;
+    priority?: number;
+}
+/**
+ * Telegram service configuration
+ * API: https://core.telegram.org/bots/api#sendmessage
+ * - botToken: bot token from BotFather
+ * - chatId: target chat ID
+ */
+export interface TelegramConfig {
+    enabled: boolean;
+    botToken: string;
+    chatId: string;
+}
+/**
+ * Slack service configuration
+ * API: https://api.slack.com/messaging/webhooks
+ * - webhookUrl: incoming webhook URL
+ */
+export interface SlackConfig {
+    enabled: boolean;
+    webhookUrl: string;
+}
+/**
+ * Discord service configuration
+ * API: https://discord.com/developers/docs/resources/webhook#execute-webhook
+ * - webhookUrl: webhook URL
+ */
+export interface DiscordConfig {
+    enabled: boolean;
+    webhookUrl: string;
+}
+/**
+ * Top-level configuration object containing all service configs
+ */
+export interface EverynotifyConfig {
+    pushover: PushoverConfig;
+    telegram: TelegramConfig;
+    slack: SlackConfig;
+    discord: DiscordConfig;
+}
+/**
+ * Function signature for service send functions
+ * Each service implements this interface
+ */
+export type ServiceSendFunction = (config: any, payload: NotificationPayload, signal: AbortSignal) => Promise<void>;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@sillybit/opencode-plugin-everynotify",
+  "version": "0.1.1",
+  "description": "Multi-service notification plugin for opencode — Pushover, Telegram, Slack, Discord",
+  "author": "Sillybit <https://sillybit.io>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sillybit-io/opencode-plugin-everynotify.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sillybit-io/opencode-plugin-everynotify/issues"
+  },
+  "homepage": "https://github.com/sillybit-io/opencode-plugin-everynotify#readme",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node && tsc --emitDeclarationOnly",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.1.53",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.1.53"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "notification",
+    "pushover",
+    "telegram",
+    "slack",
+    "discord"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}