@sillybit/opencode-plugin-everynotify 0.2.0 → 0.3.4

package/README.md

@@ -27,6 +27,7 @@ In long-running development tasks or deep research sessions, it's common to swit
 - ✅ **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
 
@@ -117,7 +118,8 @@ Create your `.everynotify.json` with the tokens for the services you want to use
     "error": true,
     "permission": false,
     "question": true
-  }
+  },
+  "truncateFrom": "end"
 }
 ```
 
@@ -135,6 +137,41 @@ You can control which events trigger notifications by adding an `events` block t
 | `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.
@@ -227,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,13 +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";
+import type { EverynotifyConfig, NotificationPayload, TruncationMode } from "./types";
 import type { Logger } from "./logger";
-/**
- * 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;
+export declare function truncate(text: string, maxLength: number, from?: TruncationMode): string;
 /**
  * Dispatcher interface returned by createDispatcher
  */

package/dist/index.js

@@ -35,7 +35,8 @@ var DEFAULT_CONFIG = {
     error: true,
     permission: true,
     question: true
-  }
+  },
+  truncateFrom: "end"
 };
 function getConfigPath(scope, directory) {
   if (scope === "global") {
@@ -63,9 +64,12 @@ function deepMerge(target, source) {
   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;
@@ -75,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 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;
@@ -303,7 +281,6 @@ function createDispatcher(config, logger) {
     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}`);
       }
     });
@@ -318,30 +295,70 @@ import * as os2 from "node:os";
 function getLogFilePath() {
   return path2.join(os2.homedir(), ".config", "opencode", ".everynotify.log");
 }
-function createLogger(config) {
+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 {
-    fs2.mkdirSync(logDir, { recursive: true });
+    _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(logFilePath);
+      rotateIfNeeded();
       const timestamp = new Date().toISOString();
       const line = `[${timestamp}] [${levelStr}] [EveryNotify] ${msg}
 `;
-      fs2.appendFileSync(logFilePath, line, "utf-8");
+      _fs.appendFileSync(logFilePath, line, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.error(`[EveryNotify] Log write failed: ${message}`);
@@ -358,44 +375,15 @@ function createLogger(config) {
     }
   };
 }
-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 { 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;
@@ -488,7 +476,6 @@ var EverynotifyPlugin = async (input) => {
       }
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      console.error(`[EveryNotify] Event hook error: ${errorMsg}`);
       logger.error(`Event hook error: ${errorMsg}`);
     }
   }
@@ -502,7 +489,6 @@ var EverynotifyPlugin = async (input) => {
       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}`);
     }
   }
@@ -518,7 +504,6 @@ var EverynotifyPlugin = async (input) => {
       }
     } 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}`);
     }
   }

package/dist/logger.d.ts

@@ -4,7 +4,16 @@
  * 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
  */
@@ -20,6 +29,7 @@ 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): Logger;
+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,7 @@ export interface SlackConfig {
 export interface DiscordConfig {
     enabled: boolean;
     webhookUrl: string;
+    truncateFrom?: TruncationMode;
 }
 /**
  * Logging configuration
@@ -98,6 +108,7 @@ export interface EverynotifyConfig {
     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.2.0",
+  "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"
   },