@sillybit/opencode-plugin-everynotify 0.1.1 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # 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)
+[![npm version](https://img.shields.io/npm/v/@sillybit/opencode-plugin-everynotify.svg)](https://www.npmjs.com/package/@sillybit/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.
@@ -25,15 +25,54 @@ In long-running development tasks or deep research sessions, it's common to swit
 - ✅ **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.
+- ✅ **Event Filtering**: Selectively enable or disable notifications for specific event types.
+- ✅ **Rich Content**: Notifications include the actual assistant response text for better context.
 
 ## Installation
 
 Install EveryNotify into your opencode environment using npm:
 
 ```bash
-npm install opencode-plugin-everynotify
+npm install @sillybit/opencode-plugin-everynotify
 ```
 
+## Using with opencode
+
+opencode does not auto-load npm packages; you must **register the plugin** in your opencode config so it is loaded at startup.
+
+### Option 1: Register via config (recommended)
+
+Add EveryNotify to the `plugin` array in your opencode config. opencode will install and load it automatically (using Bun) when you run opencode.
+
+**Global config** (all projects): edit `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "plugin": ["@sillybit/opencode-plugin-everynotify"]
+}
+```
+
+**Project config** (single project): add or edit `opencode.json` in your project root:
+
+```json
+{
+  "plugin": ["@sillybit/opencode-plugin-everynotify"]
+}
+```
+
+You can list multiple plugins in the same array, e.g. `["@sillybit/opencode-plugin-everynotify", "opencode-wakatime"]`.
+
+### Option 2: Local plugin directory
+
+Alternatively, place the plugin in opencode’s plugin directory so it is loaded as a local plugin:
+
+- **Project-only**: `.opencode/plugins/` (e.g. symlink or copy from `node_modules/@sillybit/opencode-plugin-everynotify`)
+- **All projects**: `~/.config/opencode/plugins/`
+
+Files in these directories are loaded automatically; no `plugin` entry in opencode config is required for them.
+
+After the plugin is loaded, configure your notification services (see [Configuration](#configuration)) and optionally add a `.everynotify.json` for per-project overrides.
+
 ## Configuration
 
 EveryNotify utilizes a simple JSON configuration file named `.everynotify.json`. The plugin aggregates configuration from two potential scopes:
@@ -67,15 +106,96 @@ Create your `.everynotify.json` with the tokens for the services you want to use
   "discord": {
     "enabled": false,
     "webhookUrl": "https://discord.com/api/webhooks/0000/XXXX"
+  },
+  "log": {
+    "enabled": true,
+    "level": "warn"
+  },
+  "events": {
+    "complete": true,
+    "subagent_complete": true,
+    "error": true,
+    "permission": false,
+    "question": true
+  }
+}
+```
+
+## Configuration Options
+
+### Event Filtering
+
+You can control which events trigger notifications by adding an `events` block to your `.everynotify.json`. All events are enabled (`true`) by default to ensure backward compatibility.
+
+| Event               | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| `complete`          | The main opencode session has finished its task and is now idle.           |
+| `subagent_complete` | A subagent has completed its specific assigned task.                       |
+| `error`             | A fatal error or crash occurred during the session.                        |
+| `permission`        | opencode is waiting for you to grant permission for a tool or file access. |
+| `question`          | The `question` tool was used to ask you for clarification.                 |
+
+### Rich Message Content
+
+EveryNotify provides rich context in its notifications by extracting the assistant's last response. Instead of generic "Task completed" messages, you receive the actual summary or answer provided by opencode.
+
+**Notification Priority:**
+
+1. **Errors**: The specific error message always takes top priority.
+2. **Assistant Text**: The actual text from the assistant's final response.
+3. **Fallback**: If no text is found, it defaults to a generic "Task completed" message.
+
+**Message Format Example:**
+
+```text
+[complete] my-project
+I've successfully implemented the authentication system with JWT tokens and refresh token rotation. The API endpoints are secured and tests are passing. (elapsed: 2m 18s)
+```
+
+### File-Based Logging
+
+EveryNotify includes an optional file-based logging system to help you troubleshoot service delivery or configuration issues without cluttering your terminal.
+
+```json
+{
+  "log": {
+    "enabled": true,
+    "level": "warn"
   }
 }
 ```
 
+**Options:**
+
+- `enabled`: Set to `true` to activate file-based logging (default: `false`).
+- `level`: The minimum severity to log.
+  - `"error"`: Only records failed service dispatches and critical system errors.
+  - `"warn"`: Records errors plus non-critical warnings like missing configuration files (default).
+
+**Log File Details:**
+
+- **Location**: `~/.config/opencode/.everynotify.log`
+- **Format**: `[ISO-8601] [LEVEL] [EveryNotify] Message`
+- **Rotation**: Logs are automatically rotated every 7 days (based on file modification time).
+- **Cleanup**: EveryNotify maintains a maximum of 4 rotated files (e.g., `.everynotify.log.2026-02-01`), automatically deleting the oldest.
+
+**Example Entry:**
+
+```text
+[2026-02-08T14:30:45.123Z] [ERROR] [EveryNotify] Service dispatch failed: Pushover: Network timeout
+[2026-02-08T14:30:45.456Z] [WARN] [EveryNotify] Config file not found at ~/.config/opencode/.everynotify.json
+```
+
 ## 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.
+EveryNotify is a "fire-and-forget" plugin. Once you have [registered it with opencode](#using-with-opencode) and [configured](#configuration) at least one service with `"enabled": true`, it runs automatically. opencode loads the plugin at startup; EveryNotify then listens for events and sends notifications in the background with no further action needed.
+
+When an event is triggered, EveryNotify builds a rich message containing the event type, project name, the actual assistant response, and the total elapsed time.
+
+Example:
+`[complete] my-project: I've finished the refactor. (elapsed: 12m 30s)`
 
-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`.
+Notifications are dispatched to all services marked as `"enabled": true`.
 
 ## Supported Services
 

package/dist/dispatcher.d.ts

@@ -7,6 +7,7 @@
  * - Error isolation: One service failing doesn't block others (Promise.allSettled)
  */
 import type { EverynotifyConfig, NotificationPayload } from "./types";
+import type { Logger } from "./logger";
 /**
  * Truncate text to max length, appending "… [truncated]" if over limit
  * Shared utility function used by all services
@@ -22,7 +23,8 @@ interface Dispatcher {
  * Create a dispatcher that sends notifications to all enabled services
  *
  * @param config - EverynotifyConfig with enabled services
+ * @param logger - Logger instance for error logging
  * @returns Dispatcher with dispatch() function
  */
-export declare function createDispatcher(config: EverynotifyConfig): Dispatcher;
+export declare function createDispatcher(config: EverynotifyConfig, logger: Logger): Dispatcher;
 export {};

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import * as path2 from "path";
+import * as path3 from "path";
 
 // src/config.ts
 import * as fs from "fs";
@@ -24,6 +24,17 @@ var DEFAULT_CONFIG = {
   discord: {
     enabled: false,
     webhookUrl: ""
+  },
+  log: {
+    enabled: false,
+    level: "warn"
+  },
+  events: {
+    complete: true,
+    subagent_complete: true,
+    error: true,
+    permission: true,
+    question: true
   }
 };
 function getConfigPath(scope, directory) {
@@ -46,6 +57,12 @@ function deepMerge(target, source) {
   if (source.discord) {
     result.discord = { ...result.discord, ...source.discord };
   }
+  if (source.log) {
+    result.log = { ...result.log, ...source.log };
+  }
+  if (source.events) {
+    result.events = { ...result.events, ...source.events };
+  }
   return result;
 }
 function loadConfigFile(filePath) {
@@ -232,7 +249,7 @@ async function send4(config, payload, signal) {
 }
 
 // src/dispatcher.ts
-function createDispatcher(config) {
+function createDispatcher(config, logger) {
   const services = [];
   if (config.pushover.enabled) {
     services.push({
@@ -285,22 +302,109 @@ function createDispatcher(config) {
     const results = await Promise.allSettled(promises);
     results.forEach((result, index) => {
       if (result.status === "rejected") {
+        const errorMsg = result.reason instanceof Error ? result.reason.message : String(result.reason);
         console.error(`[EveryNotify] ${services[index].name} failed:`, result.reason);
+        logger.error(`${services[index].name} failed: ${errorMsg}`);
       }
     });
   }
   return { dispatch };
 }
 
+// src/logger.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import * as os2 from "node:os";
+function getLogFilePath() {
+  return path2.join(os2.homedir(), ".config", "opencode", ".everynotify.log");
+}
+function createLogger(config) {
+  if (!config.log.enabled) {
+    return { error: () => {}, warn: () => {} };
+  }
+  const logFilePath = getLogFilePath();
+  const logDir = path2.dirname(logFilePath);
+  const level = config.log.level || "warn";
+  let disabled = false;
+  try {
+    fs2.mkdirSync(logDir, { recursive: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[EveryNotify] Failed to create log directory: ${message}`);
+    disabled = true;
+  }
+  function writeLog(levelStr, msg) {
+    if (disabled)
+      return;
+    try {
+      rotateIfNeeded(logFilePath);
+      const timestamp = new Date().toISOString();
+      const line = `[${timestamp}] [${levelStr}] [EveryNotify] ${msg}
+`;
+      fs2.appendFileSync(logFilePath, line, "utf-8");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[EveryNotify] Log write failed: ${message}`);
+    }
+  }
+  return {
+    error(msg) {
+      writeLog("ERROR", msg);
+    },
+    warn(msg) {
+      if (level === "error")
+        return;
+      writeLog("WARN", msg);
+    }
+  };
+}
+function rotateIfNeeded(logFilePath) {
+  try {
+    const stat = fs2.statSync(logFilePath);
+    const ageMs = Date.now() - stat.mtime.getTime();
+    const sevenDaysMs = 7 * 24 * 60 * 60 * 1000;
+    if (ageMs > sevenDaysMs) {
+      const mtimeDate = stat.mtime.toISOString().split("T")[0];
+      const rotatedPath = `${logFilePath}.${mtimeDate}`;
+      fs2.renameSync(logFilePath, rotatedPath);
+      cleanupRotatedFiles(logFilePath);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[EveryNotify] Rotation check failed: ${message}`);
+    }
+  }
+}
+function cleanupRotatedFiles(logFilePath) {
+  try {
+    const dir = path2.dirname(logFilePath);
+    const baseName = path2.basename(logFilePath);
+    const files = fs2.readdirSync(dir).filter((f) => f.startsWith(`${baseName}.`) && /\d{4}-\d{2}-\d{2}$/.test(f)).sort();
+    while (files.length > 4) {
+      const oldest = files.shift();
+      fs2.unlinkSync(path2.join(dir, oldest));
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[EveryNotify] Cleanup failed: ${message}`);
+  }
+}
+
 // src/index.ts
 var EverynotifyPlugin = async (input) => {
   const { client, directory } = input;
   const config = loadConfig(directory);
-  const { dispatch } = createDispatcher(config);
+  const logger = createLogger(config);
+  const { dispatch } = createDispatcher(config, logger);
+  function isEventEnabled(eventType) {
+    return config.events[eventType] !== false;
+  }
   async function buildPayload(eventType, sessionID, extraMessage) {
-    const projectName = directory ? path2.basename(directory) : null;
+    const projectName = directory ? path3.basename(directory) : null;
     let elapsedSeconds = null;
     let isSubagent = false;
+    let assistantText = null;
     try {
       if (sessionID) {
         const sessionResult = await client.session.get({
@@ -320,6 +424,17 @@ var EverynotifyPlugin = async (input) => {
             const now = Date.now();
             elapsedSeconds = Math.floor((now - startTime) / 1000);
           }
+          const lastAssistantMessage = [...messages].reverse().find((msg) => msg.info?.role === "assistant");
+          if (lastAssistantMessage?.parts) {
+            const textParts = lastAssistantMessage.parts.filter((part) => part.type === "text");
+            if (textParts.length > 0) {
+              const lastTextPart = textParts[textParts.length - 1];
+              const text = lastTextPart.text?.trim();
+              if (text) {
+                assistantText = text;
+              }
+            }
+          }
         }
       }
     } catch (error) {}
@@ -328,7 +443,7 @@ var EverynotifyPlugin = async (input) => {
       finalEventType = "subagent_complete";
     }
     const title = `[${finalEventType}] ${projectName || "opencode"}`;
-    let message = extraMessage || "Event occurred";
+    let message = extraMessage ?? assistantText ?? "Task completed";
     if (elapsedSeconds !== null) {
       const minutes = Math.floor(elapsedSeconds / 60);
       const seconds = elapsedSeconds % 60;
@@ -348,40 +463,63 @@ var EverynotifyPlugin = async (input) => {
     try {
       const sessionID = event.properties?.sessionID || null;
       if (event.type === "session.idle") {
+        if (!isEventEnabled("complete")) {
+          return;
+        }
         const payload = await buildPayload("complete", sessionID);
+        if (payload.eventType === "subagent_complete" && !isEventEnabled("subagent_complete")) {
+          return;
+        }
         await dispatch(payload);
       } else if (event.type === "session.error") {
+        if (!isEventEnabled("error")) {
+          return;
+        }
         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") {
+        if (!isEventEnabled("permission")) {
+          return;
+        }
         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}`);
+      logger.error(`Event hook error: ${errorMsg}`);
     }
   }
-  async function permissionAskHook(_input, _output) {
+  async function permissionAskHook(input2, _output) {
     try {
-      const payload = await buildPayload("permission", null);
+      if (!isEventEnabled("permission")) {
+        return;
+      }
+      const sessionID = input2?.sessionID ?? null;
+      const payload = await buildPayload("permission", sessionID);
       await dispatch(payload);
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       console.error(`[EveryNotify] Permission.ask hook error: ${errorMsg}`);
+      logger.error(`Permission.ask hook error: ${errorMsg}`);
     }
   }
   async function toolExecuteBeforeHook(input2, _output) {
     try {
+      if (!isEventEnabled("question")) {
+        return;
+      }
       if (input2.tool === "question") {
-        const payload = await buildPayload("question", null);
+        const sessionID = input2?.sessionID ?? null;
+        const payload = await buildPayload("question", sessionID);
         await dispatch(payload);
       }
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       console.error(`[EveryNotify] Tool.execute.before hook error: ${errorMsg}`);
+      logger.error(`Tool.execute.before hook error: ${errorMsg}`);
     }
   }
   return {

package/dist/logger.d.ts

@@ -0,0 +1,25 @@
+/**
+ * EveryNotify Plugin — File-Based Logger
+ *
+ * Provides a simple file-based logger with 7-day rotation.
+ * Writes to ~/.config/opencode/.everynotify.log with automatic cleanup.
+ */
+import type { EverynotifyConfig } from "./types";
+/**
+ * Logger interface with error and warn methods
+ */
+export interface Logger {
+    error(msg: string): void;
+    warn(msg: string): void;
+}
+/**
+ * Returns the absolute path to the log file
+ * @returns Log file path: ~/.config/opencode/.everynotify.log
+ */
+export declare function getLogFilePath(): string;
+/**
+ * Creates a logger instance based on configuration
+ * @param config - EveryNotify configuration object
+ * @returns Logger instance (no-op if logging disabled)
+ */
+export declare function createLogger(config: EverynotifyConfig): Logger;

package/dist/types.d.ts

@@ -62,6 +62,32 @@ export interface DiscordConfig {
     enabled: boolean;
     webhookUrl: string;
 }
+/**
+ * Logging configuration
+ * Controls debug output and error logging behavior
+ * - enabled: whether logging is active
+ * - level: minimum log level to output ("error" or "warn")
+ */
+export interface LogConfig {
+    enabled: boolean;
+    level?: "error" | "warn";
+}
+/**
+ * Events configuration
+ * Controls which event types trigger notifications
+ * - complete: main session completion events
+ * - subagent_complete: subagent task completion events
+ * - error: session error events
+ * - permission: permission request events
+ * - question: question tool usage events
+ */
+export interface EventsConfig {
+    complete: boolean;
+    subagent_complete: boolean;
+    error: boolean;
+    permission: boolean;
+    question: boolean;
+}
 /**
  * Top-level configuration object containing all service configs
  */
@@ -70,6 +96,8 @@ export interface EverynotifyConfig {
     telegram: TelegramConfig;
     slack: SlackConfig;
     discord: DiscordConfig;
+    log: LogConfig;
+    events: EventsConfig;
 }
 /**
  * Function signature for service send functions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sillybit/opencode-plugin-everynotify",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Multi-service notification plugin for opencode — Pushover, Telegram, Slack, Discord",
   "author": "Sillybit <https://sillybit.io>",
   "repository": {