opencode-ntfy.sh 0.1.0 → 0.1.7

package/README.md

@@ -7,14 +7,16 @@ or desktop when it needs your attention.
 
 ## Notifications
 
-The plugin sends notifications for two events:
+The plugin sends notifications for three events:
 
 - **Session Idle** -- The AI agent has finished its work and is waiting for
   input. Includes the project name and timestamp.
 - **Session Error** -- The session encountered an error. Includes the project
   name, timestamp, and error message (when available).
+- **Permission Asked** -- The agent needs permission to perform an action.
+  Includes the project name, timestamp, permission type, and patterns.
 
-If `NTFY_TOPIC` is not set, the plugin does nothing.
+If `OPENCODE_NTFY_TOPIC` is not set, the plugin does nothing.
 
 ## Install
 
@@ -35,10 +37,51 @@ Configuration is done through environment variables.
 
 | Variable | Required | Default | Description |
 |---|---|---|---|
-| `NTFY_TOPIC` | Yes | -- | The ntfy.sh topic to publish to. |
-| `NTFY_SERVER` | No | `https://ntfy.sh` | The ntfy server URL. Set this to use a self-hosted instance. |
-| `NTFY_TOKEN` | No | -- | Bearer token for authenticated topics. |
-| `NTFY_PRIORITY` | No | `default` | Notification priority. One of: `min`, `low`, `default`, `high`, `max`. |
+| `OPENCODE_NTFY_TOPIC` | Yes | -- | The ntfy.sh topic to publish to. |
+| `OPENCODE_NTFY_SERVER` | No | `https://ntfy.sh` | The ntfy server URL. Set this to use a self-hosted instance. |
+| `OPENCODE_NTFY_TOKEN` | No | -- | Bearer token for authenticated topics. |
+| `OPENCODE_NTFY_PRIORITY` | No | `default` | Global notification priority. One of: `min`, `low`, `default`, `high`, `max`. |
+
+### Custom Notification Commands
+
+Each notification field (title, message, tags, priority) can be customized
+per event by setting an environment variable containing a shell command. The
+command's stdout (trimmed) is used as the field value. If the command is not
+set or fails, the hardcoded default is used silently.
+
+Before execution, template variables in the command string are substituted
+with their values. Unset variables are substituted with empty strings.
+
+#### Per-Event Environment Variables
+
+| Event | Title | Message | Tags | Priority |
+|---|---|---|---|---|
+| `session.idle` | `OPENCODE_NTFY_SESSION_IDLE_TITLE_CMD` | `OPENCODE_NTFY_SESSION_IDLE_MESSAGE_CMD` | `OPENCODE_NTFY_SESSION_IDLE_TAGS_CMD` | `OPENCODE_NTFY_SESSION_IDLE_PRIORITY_CMD` |
+| `session.error` | `OPENCODE_NTFY_SESSION_ERROR_TITLE_CMD` | `OPENCODE_NTFY_SESSION_ERROR_MESSAGE_CMD` | `OPENCODE_NTFY_SESSION_ERROR_TAGS_CMD` | `OPENCODE_NTFY_SESSION_ERROR_PRIORITY_CMD` |
+| `permission.asked` | `OPENCODE_NTFY_PERMISSION_TITLE_CMD` | `OPENCODE_NTFY_PERMISSION_MESSAGE_CMD` | `OPENCODE_NTFY_PERMISSION_TAGS_CMD` | `OPENCODE_NTFY_PERMISSION_PRIORITY_CMD` |
+
+#### Template Variables
+
+| Variable | Available In | Description |
+|---|---|---|
+| `${event}` | All events | The event type string (e.g., `session.idle`) |
+| `${time}` | All events | ISO 8601 timestamp |
+| `${error}` | `session.error` only | The error message (empty string for other events) |
+| `${permission_type}` | `permission.asked` only | The permission type (empty string for other events) |
+| `${permission_patterns}` | `permission.asked` only | Comma-separated list of patterns (empty string for other events) |
+
+#### Example
+
+```sh
+# Custom title for idle notifications
+export OPENCODE_NTFY_SESSION_IDLE_TITLE_CMD='echo "${event} is done"'
+
+# Custom message with timestamp
+export OPENCODE_NTFY_SESSION_ERROR_MESSAGE_CMD='echo "Error at ${time}: ${error}"'
+
+# Override priority for permission requests
+export OPENCODE_NTFY_PERMISSION_PRIORITY_CMD='echo "high"'
+```
 
 ### Subscribing to notifications
 
@@ -55,17 +98,17 @@ To receive notifications, subscribe to your topic using any
 ### Example
 
 ```sh
-export NTFY_TOPIC="my-opencode-notifications"
+export OPENCODE_NTFY_TOPIC="my-opencode-notifications"
 opencode
 ```
 
 With authentication and a self-hosted server:
 
 ```sh
-export NTFY_TOPIC="my-opencode-notifications"
-export NTFY_SERVER="https://ntfy.example.com"
-export NTFY_TOKEN="tk_mytoken"
-export NTFY_PRIORITY="high"
+export OPENCODE_NTFY_TOPIC="my-opencode-notifications"
+export OPENCODE_NTFY_SERVER="https://ntfy.example.com"
+export OPENCODE_NTFY_TOKEN="tk_mytoken"
+export OPENCODE_NTFY_PRIORITY="high"
 opencode
 ```
 

package/dist/config.d.ts

@@ -3,5 +3,6 @@ export interface NtfyConfig {
     server: string;
     token?: string;
     priority: string;
+    iconUrl: string;
 }
 export declare function loadConfig(env: Record<string, string | undefined>): NtfyConfig;

package/dist/config.js

@@ -1,17 +1,35 @@
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 const VALID_PRIORITIES = ["min", "low", "default", "high", "max"];
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+const PACKAGE_VERSION = pkg.version;
+const BASE_ICON_URL = `https://raw.githubusercontent.com/lannuttia/opencode-ntfy.sh/v${PACKAGE_VERSION}/assets`;
+function resolveIconUrl(env) {
+    const mode = env.OPENCODE_NTFY_ICON_MODE === "light" ? "light" : "dark";
+    if (mode === "light" && env.OPENCODE_NTFY_ICON_LIGHT) {
+        return env.OPENCODE_NTFY_ICON_LIGHT;
+    }
+    if (mode === "dark" && env.OPENCODE_NTFY_ICON_DARK) {
+        return env.OPENCODE_NTFY_ICON_DARK;
+    }
+    return `${BASE_ICON_URL}/opencode-icon-${mode}.png`;
+}
 export function loadConfig(env) {
-    const topic = env.NTFY_TOPIC;
+    const topic = env.OPENCODE_NTFY_TOPIC;
     if (!topic) {
-        throw new Error("NTFY_TOPIC environment variable is required");
+        throw new Error("OPENCODE_NTFY_TOPIC environment variable is required");
     }
-    const priority = env.NTFY_PRIORITY || "default";
+    const priority = env.OPENCODE_NTFY_PRIORITY || "default";
     if (!VALID_PRIORITIES.includes(priority)) {
-        throw new Error(`NTFY_PRIORITY must be one of: ${VALID_PRIORITIES.join(", ")}`);
+        throw new Error(`OPENCODE_NTFY_PRIORITY must be one of: ${VALID_PRIORITIES.join(", ")}`);
     }
     return {
         topic,
-        server: env.NTFY_SERVER || "https://ntfy.sh",
-        token: env.NTFY_TOKEN,
+        server: env.OPENCODE_NTFY_SERVER || "https://ntfy.sh",
+        token: env.OPENCODE_NTFY_TOKEN,
         priority,
+        iconUrl: resolveIconUrl(env),
     };
 }

package/dist/exec.d.ts

@@ -0,0 +1,4 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type BunShell = PluginInput["$"];
+export declare function resolveField($: BunShell, commandTemplate: string | undefined, variables: Record<string, string>, fallback: string): Promise<string>;
+export {};

package/dist/exec.js

@@ -0,0 +1,20 @@
+function substituteVariables(template, variables) {
+    return template.replace(/\$\{(\w+)\}/g, (_, name) => variables[name] ?? "");
+}
+export async function resolveField($, commandTemplate, variables, fallback) {
+    if (!commandTemplate) {
+        return fallback;
+    }
+    try {
+        const command = substituteVariables(commandTemplate, variables);
+        const result = await $ `${{ raw: command }}`.nothrow().quiet();
+        if (result.exitCode !== 0) {
+            return fallback;
+        }
+        const text = result.text().trim();
+        return text || fallback;
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/index.js

@@ -1,52 +1,97 @@
 import { loadConfig } from "./config.js";
 import { sendNotification } from "./notify.js";
+import { resolveField } from "./exec.js";
 function getProjectName(directory) {
     return directory.split("/").pop() || directory;
 }
+async function resolveAndSend($, config, envPrefix, vars, defaults) {
+    const titleCmd = process.env[`OPENCODE_NTFY_${envPrefix}_TITLE_CMD`];
+    const messageCmd = process.env[`OPENCODE_NTFY_${envPrefix}_MESSAGE_CMD`];
+    const tagsCmd = process.env[`OPENCODE_NTFY_${envPrefix}_TAGS_CMD`];
+    const priorityCmd = process.env[`OPENCODE_NTFY_${envPrefix}_PRIORITY_CMD`];
+    const title = await resolveField($, titleCmd, vars, defaults.title);
+    const message = await resolveField($, messageCmd, vars, defaults.message);
+    const tags = await resolveField($, tagsCmd, vars, defaults.tags);
+    const priority = await resolveField($, priorityCmd, vars, config.priority);
+    await sendNotification(config, {
+        title,
+        message,
+        tags,
+        priority: priorityCmd ? priority : undefined,
+    });
+}
+function buildVars(event, time, extra = {}) {
+    return {
+        event,
+        time,
+        error: extra.error ?? "",
+        permission_type: extra.permission_type ?? "",
+        permission_patterns: extra.permission_patterns ?? "",
+    };
+}
 export const plugin = async (input) => {
-    if (!process.env.NTFY_TOPIC) {
+    if (!process.env.OPENCODE_NTFY_TOPIC) {
         return {};
     }
     const config = loadConfig(process.env);
     const project = getProjectName(input.directory);
+    const $ = input.$;
     return {
         event: async ({ event }) => {
             if (event.type === "session.idle") {
-                await sendNotification(config, {
+                const time = new Date().toISOString();
+                const vars = buildVars("session.idle", time);
+                await resolveAndSend($, config, "SESSION_IDLE", vars, {
                     title: `${project} - Session Idle`,
-                    message: `Event: session.idle\nProject: ${project}\nTime: ${new Date().toISOString()}`,
+                    message: `Event: session.idle\nProject: ${project}\nTime: ${time}`,
                     tags: "hourglass_done",
                 });
             }
             else if (event.type === "session.error") {
                 const error = event.properties.error;
                 const errorMsg = error && "data" in error && "message" in error.data
-                    ? `\nError: ${error.data.message}`
+                    ? String(error.data.message)
                     : "";
-                await sendNotification(config, {
+                const time = new Date().toISOString();
+                const vars = buildVars("session.error", time, { error: errorMsg });
+                await resolveAndSend($, config, "SESSION_ERROR", vars, {
                     title: `${project} - Session Error`,
-                    message: `Event: session.error\nProject: ${project}\nTime: ${new Date().toISOString()}${errorMsg}`,
+                    message: `Event: session.error\nProject: ${project}\nTime: ${time}${errorMsg ? `\nError: ${errorMsg}` : ""}`,
                     tags: "warning",
                 });
             }
             else if (event.type === "permission.asked") {
                 const props = event.properties;
-                const permission = props.permission || "";
+                const permissionType = props.permission || "";
                 const patterns = props.patterns?.join(", ") || "";
-                const detail = permission
-                    ? `\nPermission: ${permission}${patterns ? ` (${patterns})` : ""}`
+                const time = new Date().toISOString();
+                const vars = buildVars("permission.asked", time, {
+                    permission_type: permissionType,
+                    permission_patterns: patterns,
+                });
+                const detail = permissionType
+                    ? `\nPermission: ${permissionType}${patterns ? ` (${patterns})` : ""}`
                     : "";
-                await sendNotification(config, {
+                await resolveAndSend($, config, "PERMISSION", vars, {
                     title: `${project} - Permission Requested`,
-                    message: `Event: permission.asked\nProject: ${project}\nTime: ${new Date().toISOString()}${detail}`,
+                    message: `Event: permission.asked\nProject: ${project}\nTime: ${time}${detail}`,
                     tags: "lock",
                 });
             }
         },
         "permission.ask": async (permission) => {
-            await sendNotification(config, {
+            const time = new Date().toISOString();
+            const permissionType = permission.type || "";
+            const patterns = Array.isArray(permission.pattern)
+                ? permission.pattern.join(", ")
+                : permission.pattern || "";
+            const vars = buildVars("permission.asked", time, {
+                permission_type: permissionType,
+                permission_patterns: patterns,
+            });
+            await resolveAndSend($, config, "PERMISSION", vars, {
                 title: `${project} - Permission Requested`,
-                message: `Event: permission.asked\nProject: ${project}\nTime: ${new Date().toISOString()}\nPermission: ${permission.title}`,
+                message: `Event: permission.asked\nProject: ${project}\nTime: ${time}\nPermission: ${permission.title}`,
                 tags: "lock",
             });
         },

package/dist/notify.d.ts

@@ -3,5 +3,6 @@ export interface NotificationPayload {
     title: string;
     message: string;
     tags: string;
+    priority?: string;
 }
 export declare function sendNotification(config: NtfyConfig, payload: NotificationPayload): Promise<void>;

package/dist/notify.js

@@ -2,8 +2,9 @@ export async function sendNotification(config, payload) {
     const url = `${config.server}/${config.topic}`;
     const headers = {
         Title: payload.title,
-        Priority: config.priority,
+        Priority: payload.priority ?? config.priority,
         Tags: payload.tags,
+        "X-Icon": config.iconUrl,
     };
     if (config.token) {
         headers.Authorization = `Bearer ${config.token}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ntfy.sh",
-  "version": "0.1.0",
+  "version": "0.1.7",
   "description": "OpenCode plugin that sends push notifications via ntfy.sh",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,6 +13,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "prepublishOnly": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest"
   },
@@ -21,11 +22,25 @@
     "@types/node": "^25.2.3",
     "msw": "^2.12.10",
     "typescript": "^5.7.0",
-    "vitest": "^3.0.0",
-    "yaml": "^2.8.2"
+    "vitest": "^3.0.0"
   },
   "files": [
     "dist"
   ],
-  "license": "MIT"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lannuttia/opencode-ntfy.sh.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "ntfy",
+    "ntfy.sh",
+    "notifications",
+    "push-notifications",
+    "ai",
+    "coding-assistant",
+    "plugin"
+  ]
 }