@sillybit/opencode-plugin-everynotify 0.1.1 → 0.3.4

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,55 @@ 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.
+- ✅ **Truncation Direction**: Choose whether to keep the beginning or end of long messages when they exceed service limits.
 
 ## 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 +107,132 @@ 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
+  },
+  "truncateFrom": "end"
+}
+```
+
+## 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.                 |
+
+### Message Truncation
+
+Each notification service has a maximum message length (e.g., Pushover: 1024 chars, Discord: 2000 chars). When a message exceeds the limit, EveryNotify truncates it and adds `...` as an indicator.
+
+The `truncateFrom` option controls which part of the message is kept:
+
+| Value     | Behavior                           | Best For                                      |
+| --------- | ---------------------------------- | --------------------------------------------- |
+| `"end"`   | Keep beginning, trim end (default) | When the start of the message has the context |
+| `"start"` | Keep end, trim beginning           | When the conclusion/result at the end matters |
+
+**Global setting** applies to all services:
+
+```json
+{
+  "truncateFrom": "start"
+}
+```
+
+**Per-service override** — for example, keep message endings on Pushover but beginnings on Slack:
+
+```json
+{
+  "truncateFrom": "end",
+  "pushover": {
+    "enabled": true,
+    "token": "...",
+    "userKey": "...",
+    "truncateFrom": "start"
+  }
+}
+```
+
+Service-level `truncateFrom` takes priority over the global setting.
+
+### 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 descriptive message (e.g., `[complete] my-project (elapsed: 12m 30s)`) and dispatches it to all services marked as `"enabled": true`.
+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)`
+
+Notifications are dispatched to all services marked as `"enabled": true`.
 
 ## Supported Services
 
@@ -107,6 +264,10 @@ For Pushover users, you can customize the `priority` level:
 - `1`: High priority (bypasses quiet hours)
 - `2`: Emergency priority (requires acknowledgment)
 
+### Message Truncation Direction
+
+See [Message Truncation](#message-truncation) under Configuration Options for details on the `truncateFrom` setting. This is especially useful for services with tight message limits like Pushover (1024 chars), where the end of a message often contains the most important information (the result or conclusion).
+
 ### 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.

package/dist/config.d.ts

@@ -20,10 +20,14 @@ export declare const DEFAULT_CONFIG: EverynotifyConfig;
  * @returns full path to config file
  */
 export declare function getConfigPath(scope: "global" | "project", directory: string): string;
+export interface LoadConfigResult {
+    config: EverynotifyConfig;
+    warnings: string[];
+}
 /**
  * Load configuration from global and project scopes
  * Merge order: defaults ← global ← project (project wins)
  * @param directory project directory
- * @returns merged EverynotifyConfig
+ * @returns config and any warnings encountered during loading
  */
-export declare function loadConfig(directory: string): EverynotifyConfig;
+export declare function loadConfig(directory: string): LoadConfigResult;

package/dist/dispatcher.d.ts

@@ -6,12 +6,9 @@
  * - 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;
+import type { EverynotifyConfig, NotificationPayload, TruncationMode } from "./types";
+import type { Logger } from "./logger";
+export declare function truncate(text: string, maxLength: number, from?: TruncationMode): string;
 /**
  * Dispatcher interface returned by createDispatcher
  */
@@ -22,7 +19,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,7 +24,19 @@ var DEFAULT_CONFIG = {
   discord: {
     enabled: false,
     webhookUrl: ""
-  }
+  },
+  log: {
+    enabled: false,
+    level: "warn"
+  },
+  events: {
+    complete: true,
+    subagent_complete: true,
+    error: true,
+    permission: true,
+    question: true
+  },
+  truncateFrom: "end"
 };
 function getConfigPath(scope, directory) {
   if (scope === "global") {
@@ -46,9 +58,18 @@ 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 };
+  }
+  if (source.truncateFrom !== undefined) {
+    result.truncateFrom = source.truncateFrom;
+  }
   return result;
 }
-function loadConfigFile(filePath) {
+function loadConfigFile(filePath, warnings) {
   try {
     if (!fs.existsSync(filePath)) {
       return null;
@@ -58,208 +79,182 @@ function loadConfigFile(filePath) {
     return parsed;
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
-    console.error(`[EveryNotify] Failed to load config from ${filePath}: ${errorMsg}`);
+    warnings.push(`Failed to load config from ${filePath}: ${errorMsg}`);
     return null;
   }
 }
 function loadConfig(directory) {
+  const warnings = [];
   let config = { ...DEFAULT_CONFIG };
   const globalPath = getConfigPath("global", directory);
-  const globalConfig = loadConfigFile(globalPath);
+  const globalConfig = loadConfigFile(globalPath, warnings);
   if (globalConfig) {
     config = deepMerge(config, globalConfig);
   }
   const projectPath = getConfigPath("project", directory);
-  const projectConfig = loadConfigFile(projectPath);
+  const projectConfig = loadConfigFile(projectPath, warnings);
   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");
+    warnings.push("No services configured. Enable services in .everynotify.json");
   }
-  return config;
+  return { config, warnings };
 }
 
 // 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}`);
+  const body = new URLSearchParams({
+    token: config.token,
+    user: config.userKey,
+    message: truncate(payload.message, 1024, config.truncateFrom),
+    title: truncate(payload.title, 250, config.truncateFrom),
+    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();
+    throw new Error(`Pushover API error: ${response.status} ${errorText}`);
   }
 }
 
 // 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);
+function formatMessage(payload, truncateFrom) {
+  const truncatedTitle = truncate(payload.title, 250, truncateFrom);
+  const truncatedMessage = truncate(payload.message, 3840, truncateFrom);
   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}`);
+  const text = formatMessage(payload, config.truncateFrom);
+  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();
+    throw new Error(`Telegram API error: ${response.status} ${errorText}`);
   }
 }
 
 // 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}`);
+  const text = truncate(formatSlackMessage(payload), 40000, config.truncateFrom);
+  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();
+    throw new Error(`Slack API error: ${response.status} ${errorText}`);
   }
 }
 
 // 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}`);
+  const content = truncate(formatDiscordMessage(payload), 2000, config.truncateFrom);
+  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");
+    throw new Error(`Discord rate limited. Retry-After: ${retryAfter}s`);
+  }
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Discord API error: ${response.status} ${errorText}`);
   }
 }
 
 // src/dispatcher.ts
-function createDispatcher(config) {
+function truncate(text, maxLength, from = "end") {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  const indicator = "...";
+  if (maxLength <= indicator.length) {
+    return indicator;
+  }
+  if (from === "start") {
+    return indicator + text.slice(text.length - (maxLength - indicator.length));
+  }
+  return text.slice(0, maxLength - indicator.length) + indicator;
+}
+function createDispatcher(config, logger) {
   const services = [];
+  const globalTruncateFrom = config.truncateFrom ?? "end";
   if (config.pushover.enabled) {
     services.push({
       name: "Pushover",
       send,
-      config: config.pushover
+      config: {
+        ...config.pushover,
+        truncateFrom: config.pushover.truncateFrom ?? globalTruncateFrom
+      }
     });
   }
   if (config.telegram.enabled) {
     services.push({
       name: "Telegram",
       send: send2,
-      config: config.telegram
+      config: {
+        ...config.telegram,
+        truncateFrom: config.telegram.truncateFrom ?? globalTruncateFrom
+      }
     });
   }
   if (config.slack.enabled) {
     services.push({
       name: "Slack",
       send: send3,
-      config: config.slack
+      config: {
+        ...config.slack,
+        truncateFrom: config.slack.truncateFrom ?? globalTruncateFrom
+      }
     });
   }
   if (config.discord.enabled) {
     services.push({
       name: "Discord",
       send: send4,
-      config: config.discord
+      config: {
+        ...config.discord,
+        truncateFrom: config.discord.truncateFrom ?? globalTruncateFrom
+      }
     });
   }
   const lastDispatchTime = new Map;
@@ -285,22 +280,119 @@ function createDispatcher(config) {
     const results = await Promise.allSettled(promises);
     results.forEach((result, index) => {
       if (result.status === "rejected") {
-        console.error(`[EveryNotify] ${services[index].name} failed:`, result.reason);
+        const errorMsg = result.reason instanceof Error ? result.reason.message : String(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, fsDeps) {
+  if (!config.log.enabled) {
+    return { error: () => {}, warn: () => {} };
+  }
+  const _fs = {
+    mkdirSync: fsDeps?.mkdirSync ?? fs2.mkdirSync,
+    appendFileSync: fsDeps?.appendFileSync ?? fs2.appendFileSync,
+    statSync: fsDeps?.statSync ?? fs2.statSync,
+    renameSync: fsDeps?.renameSync ?? fs2.renameSync,
+    readdirSync: fsDeps?.readdirSync ?? fs2.readdirSync,
+    unlinkSync: fsDeps?.unlinkSync ?? fs2.unlinkSync
+  };
+  const logFilePath = getLogFilePath();
+  const logDir = path2.dirname(logFilePath);
+  const level = config.log.level || "warn";
+  let disabled = false;
+  try {
+    _fs.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 rotateIfNeeded() {
+    try {
+      const stat = _fs.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}`;
+        _fs.renameSync(logFilePath, rotatedPath);
+        cleanupRotatedFiles();
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[EveryNotify] Rotation check failed: ${message}`);
+      }
+    }
+  }
+  function cleanupRotatedFiles() {
+    try {
+      const dir = path2.dirname(logFilePath);
+      const baseName = path2.basename(logFilePath);
+      const files = _fs.readdirSync(dir).filter((f) => f.startsWith(`${baseName}.`) && /\d{4}-\d{2}-\d{2}$/.test(f)).sort();
+      while (files.length > 4) {
+        const oldest = files.shift();
+        _fs.unlinkSync(path2.join(dir, oldest));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[EveryNotify] Cleanup failed: ${message}`);
+    }
+  }
+  function writeLog(levelStr, msg) {
+    if (disabled)
+      return;
+    try {
+      rotateIfNeeded();
+      const timestamp = new Date().toISOString();
+      const line = `[${timestamp}] [${levelStr}] [EveryNotify] ${msg}
+`;
+      _fs.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);
+    }
+  };
+}
+
 // src/index.ts
 var EverynotifyPlugin = async (input) => {
   const { client, directory } = input;
-  const config = loadConfig(directory);
-  const { dispatch } = createDispatcher(config);
+  const { config, warnings } = loadConfig(directory);
+  const logger = createLogger(config);
+  for (const warning of warnings) {
+    logger.warn(warning);
+  }
+  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 +412,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 +431,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 +451,60 @@ 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,35 @@
+/**
+ * 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 * as fs from "node:fs";
+import type { EverynotifyConfig } from "./types";
+export interface FsDeps {
+    mkdirSync: typeof fs.mkdirSync;
+    appendFileSync: typeof fs.appendFileSync;
+    statSync: typeof fs.statSync;
+    renameSync: typeof fs.renameSync;
+    readdirSync: typeof fs.readdirSync;
+    unlinkSync: typeof fs.unlinkSync;
+}
+/**
+ * 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
+ * @param fsDeps - Optional fs operations override for testing
+ * @returns Logger instance (no-op if logging disabled)
+ */
+export declare function createLogger(config: EverynotifyConfig, fsDeps?: Partial<FsDeps>): Logger;

package/dist/types.d.ts

@@ -4,6 +4,12 @@
  * All types for notification payloads, service configurations, and dispatch functions.
  * No validation logic here — types only.
  */
+/**
+ * Truncation direction for messages exceeding service limits
+ * - "end": Keep beginning, truncate end (default)
+ * - "start": Keep end, truncate beginning
+ */
+export type TruncationMode = "start" | "end";
 /**
  * Event types that trigger notifications
  */
@@ -32,6 +38,7 @@ export interface PushoverConfig {
     token: string;
     userKey: string;
     priority?: number;
+    truncateFrom?: TruncationMode;
 }
 /**
  * Telegram service configuration
@@ -43,6 +50,7 @@ export interface TelegramConfig {
     enabled: boolean;
     botToken: string;
     chatId: string;
+    truncateFrom?: TruncationMode;
 }
 /**
  * Slack service configuration
@@ -52,6 +60,7 @@ export interface TelegramConfig {
 export interface SlackConfig {
     enabled: boolean;
     webhookUrl: string;
+    truncateFrom?: TruncationMode;
 }
 /**
  * Discord service configuration
@@ -61,6 +70,33 @@ export interface SlackConfig {
 export interface DiscordConfig {
     enabled: boolean;
     webhookUrl: string;
+    truncateFrom?: TruncationMode;
+}
+/**
+ * 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 +106,9 @@ export interface EverynotifyConfig {
     telegram: TelegramConfig;
     slack: SlackConfig;
     discord: DiscordConfig;
+    log: LogConfig;
+    events: EventsConfig;
+    truncateFrom?: TruncationMode;
 }
 /**
  * Function signature for service send functions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sillybit/opencode-plugin-everynotify",
-  "version": "0.1.1",
+  "version": "0.3.4",
   "description": "Multi-service notification plugin for opencode — Pushover, Telegram, Slack, Discord",
   "author": "Sillybit <https://sillybit.io>",
   "repository": {
@@ -25,6 +25,7 @@
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.1.53",
+    "@types/bun": "^1.3.8",
     "@types/node": "^22.0.0",
     "typescript": "^5.9.3"
   },