@thelastwinner/opencode-notifier 0.1.30

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mohak S
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+
+[English](./README_EN.md) | **简体中文**
+
+OpenCode 插件，在需要权限、生成完成、发生错误或调用 question 工具时播放提示音并发送系统通知。支持 macOS、Linux 和 Windows。
+
+## 快速开始
+
+在你的 \`opencode.json\` 中添加：
+
+\`\`\`json
+{
+  "plugin": ["@theLastWinner/opencode-notifier@latest"]
+}
+\`\`\`
+
+重启 OpenCode。完成。

package/dist/command.d.ts

@@ -0,0 +1,2 @@
+import type { EventType, NotifierConfig } from "./config";
+export declare function runCommand(config: NotifierConfig, event: EventType, message: string, sessionTitle?: string | null, projectName?: string | null): void;

package/dist/command.js

@@ -0,0 +1,25 @@
+// src/command.ts
+import { spawn } from "child_process";
+function substituteTokens(value, event, message, sessionTitle, projectName) {
+  let result = value.replaceAll("{event}", event).replaceAll("{message}", message);
+  result = result.replaceAll("{sessionTitle}", sessionTitle || "");
+  result = result.replaceAll("{projectName}", projectName || "");
+  return result;
+}
+function runCommand(config, event, message, sessionTitle, projectName) {
+  if (!config.command.enabled || !config.command.path) {
+    return;
+  }
+  const args = (config.command.args ?? []).map((arg) => substituteTokens(arg, event, message, sessionTitle, projectName));
+  const command = substituteTokens(config.command.path, event, message, sessionTitle, projectName);
+  const proc = spawn(command, args, {
+    stdio: "ignore",
+    detached: true
+  });
+  proc.on("error", () => {
+  });
+  proc.unref();
+}
+export {
+  runCommand
+};

package/dist/config.d.ts

@@ -0,0 +1,81 @@
+export type EventType = "permission" | "complete" | "subagent_complete" | "error" | "question" | "interrupted" | "user_cancelled";
+export interface EventConfig {
+    sound: boolean;
+    notification: boolean;
+}
+export interface CommandConfig {
+    enabled: boolean;
+    path: string;
+    args?: string[];
+    minDuration?: number;
+}
+export interface WechatWebhookConfig {
+    enabled: boolean;
+    webhookUrl: string;
+    mentionedList?: string[];
+    mentionedMobileList?: string[];
+}
+export interface LinuxConfig {
+    grouping: boolean;
+}
+export interface MessageContext {
+    sessionTitle?: string | null;
+    projectName?: string | null;
+}
+export interface NotifierConfig {
+    sound: boolean;
+    notification: boolean;
+    timeout: number;
+    showProjectName: boolean;
+    showSessionTitle: boolean;
+    showIcon: boolean;
+    notificationSystem: "osascript" | "node-notifier";
+    linux: LinuxConfig;
+    command: CommandConfig;
+    wechatWebhook: WechatWebhookConfig;
+    events: {
+        permission: EventConfig;
+        complete: EventConfig;
+        subagent_complete: EventConfig;
+        error: EventConfig;
+        question: EventConfig;
+        interrupted: EventConfig;
+        user_cancelled: EventConfig;
+    };
+    messages: {
+        permission: string;
+        complete: string;
+        subagent_complete: string;
+        error: string;
+        question: string;
+        interrupted: string;
+        user_cancelled: string;
+    };
+    sounds: {
+        permission: string | null;
+        complete: string | null;
+        subagent_complete: string | null;
+        error: string | null;
+        question: string | null;
+        interrupted: string | null;
+        user_cancelled: string | null;
+    };
+    volumes: {
+        permission: number;
+        complete: number;
+        subagent_complete: number;
+        error: number;
+        question: number;
+        interrupted: number;
+        user_cancelled: number;
+    };
+}
+export declare function getConfigPath(): string;
+export declare function loadConfig(): NotifierConfig;
+export declare function isEventSoundEnabled(config: NotifierConfig, event: EventType): boolean;
+export declare function isEventNotificationEnabled(config: NotifierConfig, event: EventType): boolean;
+export declare function getMessage(config: NotifierConfig, event: EventType): string;
+export declare function getSoundPath(config: NotifierConfig, event: EventType): string | null;
+export declare function getSoundVolume(config: NotifierConfig, event: EventType): number;
+export declare function getIconPath(config: NotifierConfig): string | undefined;
+export declare function interpolateMessage(message: string, context: MessageContext): string;

package/dist/config.js

@@ -0,0 +1,245 @@
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+var DEFAULT_EVENT_CONFIG = {
+  sound: true,
+  notification: true
+};
+var DEFAULT_CONFIG = {
+  sound: true,
+  notification: true,
+  timeout: 5,
+  showProjectName: true,
+  showSessionTitle: false,
+  showIcon: true,
+  notificationSystem: "osascript",
+  linux: {
+    grouping: false
+  },
+  command: {
+    enabled: false,
+    path: "",
+    minDuration: 0
+  },
+  wechatWebhook: {
+    enabled: false,
+    webhookUrl: ""
+  },
+  events: {
+    permission: { ...DEFAULT_EVENT_CONFIG },
+    complete: { ...DEFAULT_EVENT_CONFIG },
+    subagent_complete: { sound: false, notification: false },
+    error: { ...DEFAULT_EVENT_CONFIG },
+    question: { ...DEFAULT_EVENT_CONFIG },
+    interrupted: { ...DEFAULT_EVENT_CONFIG },
+    user_cancelled: { sound: false, notification: false }
+  },
+  messages: {
+    permission: "Session needs permission: {sessionTitle}",
+    complete: "Session has finished: {sessionTitle}",
+    subagent_complete: "Subagent task completed: {sessionTitle}",
+    error: "Session encountered an error: {sessionTitle}",
+    question: "Session has a question: {sessionTitle}",
+    interrupted: "Session was interrupted: {sessionTitle}",
+    user_cancelled: "Session was cancelled by user: {sessionTitle}"
+  },
+  sounds: {
+    permission: null,
+    complete: null,
+    subagent_complete: null,
+    error: null,
+    question: null,
+    interrupted: null,
+    user_cancelled: null
+  },
+  volumes: {
+    permission: 1,
+    complete: 1,
+    subagent_complete: 1,
+    error: 1,
+    question: 1,
+    interrupted: 1,
+    user_cancelled: 1
+  }
+};
+function getConfigPath() {
+  if (process.env.OPENCODE_NOTIFIER_CONFIG_PATH) {
+    return process.env.OPENCODE_NOTIFIER_CONFIG_PATH;
+  }
+  return join(homedir(), ".config", "opencode", "opencode-notifier.json");
+}
+function parseEventConfig(userEvent, defaultConfig) {
+  if (userEvent === void 0) {
+    return defaultConfig;
+  }
+  if (typeof userEvent === "boolean") {
+    return {
+      sound: userEvent,
+      notification: userEvent
+    };
+  }
+  return {
+    sound: userEvent.sound ?? defaultConfig.sound,
+    notification: userEvent.notification ?? defaultConfig.notification
+  };
+}
+function parseVolume(value, defaultVolume) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return defaultVolume;
+  }
+  if (value < 0) {
+    return 0;
+  }
+  if (value > 1) {
+    return 1;
+  }
+  return value;
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const fileContent = readFileSync(configPath, "utf-8");
+    const userConfig = JSON.parse(fileContent);
+    const globalSound = userConfig.sound ?? DEFAULT_CONFIG.sound;
+    const globalNotification = userConfig.notification ?? DEFAULT_CONFIG.notification;
+    const defaultWithGlobal = {
+      sound: globalSound,
+      notification: globalNotification
+    };
+    const userCommand = userConfig.command ?? {};
+    const commandArgs = Array.isArray(userCommand.args) ? userCommand.args.filter((arg) => typeof arg === "string") : void 0;
+    const commandMinDuration = typeof userCommand.minDuration === "number" && Number.isFinite(userCommand.minDuration) && userCommand.minDuration > 0 ? userCommand.minDuration : 0;
+    const userWechatWebhook = userConfig.wechatWebhook ?? {};
+    const wechatWebhookEnabled = typeof userWechatWebhook.enabled === "boolean" ? userWechatWebhook.enabled : false;
+    const wechatWebhookUrl = typeof userWechatWebhook.webhookUrl === "string" ? userWechatWebhook.webhookUrl : "";
+    let wechatMentionedList = void 0;
+    if (Array.isArray(userWechatWebhook.mentionedList)) {
+      wechatMentionedList = userWechatWebhook.mentionedList.filter((item) => typeof item === "string");
+    }
+    let wechatMentionedMobileList = void 0;
+    if (Array.isArray(userWechatWebhook.mentionedMobileList)) {
+      wechatMentionedMobileList = userWechatWebhook.mentionedMobileList.filter((item) => typeof item === "string");
+    }
+    return {
+      sound: globalSound,
+      notification: globalNotification,
+      timeout: typeof userConfig.timeout === "number" && userConfig.timeout > 0 ? userConfig.timeout : DEFAULT_CONFIG.timeout,
+      showProjectName: userConfig.showProjectName ?? DEFAULT_CONFIG.showProjectName,
+      showSessionTitle: userConfig.showSessionTitle ?? DEFAULT_CONFIG.showSessionTitle,
+      showIcon: userConfig.showIcon ?? DEFAULT_CONFIG.showIcon,
+      notificationSystem: userConfig.notificationSystem === "node-notifier" ? "node-notifier" : "osascript",
+      linux: {
+        grouping: typeof userConfig.linux?.grouping === "boolean" ? userConfig.linux.grouping : DEFAULT_CONFIG.linux.grouping
+      },
+      command: {
+        enabled: typeof userCommand.enabled === "boolean" ? userCommand.enabled : DEFAULT_CONFIG.command.enabled,
+        path: typeof userCommand.path === "string" ? userCommand.path : DEFAULT_CONFIG.command.path,
+        args: commandArgs,
+        minDuration: commandMinDuration
+      },
+      wechatWebhook: {
+        enabled: wechatWebhookEnabled,
+        webhookUrl: wechatWebhookUrl,
+        mentionedList: wechatMentionedList,
+        mentionedMobileList: wechatMentionedMobileList
+      },
+      events: {
+        permission: parseEventConfig(userConfig.events?.permission ?? userConfig.permission, defaultWithGlobal),
+        complete: parseEventConfig(userConfig.events?.complete ?? userConfig.complete, defaultWithGlobal),
+        subagent_complete: parseEventConfig(userConfig.events?.subagent_complete ?? userConfig.subagent_complete, { sound: false, notification: false }),
+        error: parseEventConfig(userConfig.events?.error ?? userConfig.error, defaultWithGlobal),
+        question: parseEventConfig(userConfig.events?.question ?? userConfig.question, defaultWithGlobal),
+        interrupted: parseEventConfig(userConfig.events?.interrupted ?? userConfig.interrupted, defaultWithGlobal),
+        user_cancelled: parseEventConfig(userConfig.events?.user_cancelled ?? userConfig.user_cancelled, { sound: false, notification: false })
+      },
+      messages: {
+        permission: userConfig.messages?.permission ?? DEFAULT_CONFIG.messages.permission,
+        complete: userConfig.messages?.complete ?? DEFAULT_CONFIG.messages.complete,
+        subagent_complete: userConfig.messages?.subagent_complete ?? DEFAULT_CONFIG.messages.subagent_complete,
+        error: userConfig.messages?.error ?? DEFAULT_CONFIG.messages.error,
+        question: userConfig.messages?.question ?? DEFAULT_CONFIG.messages.question,
+        interrupted: userConfig.messages?.interrupted ?? DEFAULT_CONFIG.messages.interrupted,
+        user_cancelled: userConfig.messages?.user_cancelled ?? DEFAULT_CONFIG.messages.user_cancelled
+      },
+      sounds: {
+        permission: userConfig.sounds?.permission ?? DEFAULT_CONFIG.sounds.permission,
+        complete: userConfig.sounds?.complete ?? DEFAULT_CONFIG.sounds.complete,
+        subagent_complete: userConfig.sounds?.subagent_complete ?? DEFAULT_CONFIG.sounds.subagent_complete,
+        error: userConfig.sounds?.error ?? DEFAULT_CONFIG.sounds.error,
+        question: userConfig.sounds?.question ?? DEFAULT_CONFIG.sounds.question,
+        interrupted: userConfig.sounds?.interrupted ?? DEFAULT_CONFIG.sounds.interrupted,
+        user_cancelled: userConfig.sounds?.user_cancelled ?? DEFAULT_CONFIG.sounds.user_cancelled
+      },
+      volumes: {
+        permission: parseVolume(userConfig.volumes?.permission, DEFAULT_CONFIG.volumes.permission),
+        complete: parseVolume(userConfig.volumes?.complete, DEFAULT_CONFIG.volumes.complete),
+        subagent_complete: parseVolume(
+          userConfig.volumes?.subagent_complete,
+          DEFAULT_CONFIG.volumes.subagent_complete
+        ),
+        error: parseVolume(userConfig.volumes?.error, DEFAULT_CONFIG.volumes.error),
+        question: parseVolume(userConfig.volumes?.question, DEFAULT_CONFIG.volumes.question),
+        interrupted: parseVolume(userConfig.volumes?.interrupted, DEFAULT_CONFIG.volumes.interrupted),
+        user_cancelled: parseVolume(userConfig.volumes?.user_cancelled, DEFAULT_CONFIG.volumes.user_cancelled)
+      }
+    };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+function isEventSoundEnabled(config, event) {
+  return config.events[event].sound;
+}
+function isEventNotificationEnabled(config, event) {
+  return config.events[event].notification;
+}
+function getMessage(config, event) {
+  return config.messages[event];
+}
+function getSoundPath(config, event) {
+  return config.sounds[event];
+}
+function getSoundVolume(config, event) {
+  return config.volumes[event];
+}
+function getIconPath(config) {
+  if (!config.showIcon) {
+    return void 0;
+  }
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const iconPath = join(__dirname, "..", "logos", "opencode-logo-dark.png");
+    if (existsSync(iconPath)) {
+      return iconPath;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function interpolateMessage(message, context) {
+  let result = message;
+  const sessionTitle = context.sessionTitle || "";
+  result = result.replaceAll("{sessionTitle}", sessionTitle);
+  const projectName = context.projectName || "";
+  result = result.replaceAll("{projectName}", projectName);
+  result = result.replace(/\s*[:\-|]\s*$/, "").trim();
+  result = result.replace(/\s{2,}/g, " ");
+  return result;
+}
+export {
+  getConfigPath,
+  getIconPath,
+  getMessage,
+  getSoundPath,
+  getSoundVolume,
+  interpolateMessage,
+  isEventNotificationEnabled,
+  isEventSoundEnabled,
+  loadConfig
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const NotifierPlugin: Plugin;
+export default NotifierPlugin;