@thelastwinner/opencode-notifier 0.1.30

package/dist/notify.d.ts

@@ -0,0 +1 @@
+export declare function sendNotification(title: string, message: string, timeout: number, iconPath?: string, notificationSystem?: "osascript" | "node-notifier", linuxGrouping?: boolean): Promise<void>;

package/dist/notify.js

@@ -0,0 +1,124 @@
+// src/notify.ts
+import os from "os";
+import { exec, execFile } from "child_process";
+import notifier from "node-notifier";
+var DEBOUNCE_MS = 1e3;
+var platform = os.type();
+var platformNotifier;
+if (platform === "Linux" || platform.match(/BSD$/)) {
+  const { NotifySend } = notifier;
+  platformNotifier = new NotifySend({ withFallback: false });
+} else if (platform === "Windows_NT") {
+  const { WindowsToaster } = notifier;
+  platformNotifier = new WindowsToaster({ withFallback: false });
+} else if (platform !== "Darwin") {
+  platformNotifier = notifier;
+}
+var lastNotificationTime = {};
+var lastLinuxNotificationId = null;
+var linuxNotifySendSupportsReplace = null;
+function detectNotifySendCapabilities() {
+  return new Promise((resolve) => {
+    execFile("notify-send", ["--version"], (error, stdout) => {
+      if (error) {
+        resolve(false);
+        return;
+      }
+      const match = stdout.match(/(\d+)\.(\d+)/);
+      if (match) {
+        const major = parseInt(match[1], 10);
+        const minor = parseInt(match[2], 10);
+        resolve(major > 0 || major === 0 && minor >= 8);
+        return;
+      }
+      resolve(false);
+    });
+  });
+}
+function sendLinuxNotificationDirect(title, message, timeout, iconPath, grouping = true) {
+  return new Promise((resolve) => {
+    const args = [];
+    if (iconPath) {
+      args.push("--icon", iconPath);
+    }
+    args.push("--expire-time", String(timeout * 1e3));
+    if (grouping && lastLinuxNotificationId !== null) {
+      args.push("--replace-id", String(lastLinuxNotificationId));
+    }
+    if (grouping) {
+      args.push("--print-id");
+    }
+    args.push("--", title, message);
+    execFile("notify-send", args, (error, stdout) => {
+      if (!error && grouping && stdout) {
+        const id = parseInt(stdout.trim(), 10);
+        if (!isNaN(id)) {
+          lastLinuxNotificationId = id;
+        }
+      }
+      resolve();
+    });
+  });
+}
+async function sendNotification(title, message, timeout, iconPath, notificationSystem = "osascript", linuxGrouping = true) {
+  const now = Date.now();
+  if (lastNotificationTime[message] && now - lastNotificationTime[message] < DEBOUNCE_MS) {
+    return;
+  }
+  lastNotificationTime[message] = now;
+  if (platform === "Darwin") {
+    if (notificationSystem === "node-notifier") {
+      return new Promise((resolve) => {
+        const notificationOptions = {
+          title,
+          message,
+          timeout,
+          icon: iconPath
+        };
+        notifier.notify(
+          notificationOptions,
+          () => {
+            resolve();
+          }
+        );
+      });
+    }
+    return new Promise((resolve) => {
+      const escapedMessage = message.replace(/"/g, '\\"');
+      const escapedTitle = title.replace(/"/g, '\\"');
+      exec(
+        `osascript -e 'display notification "${escapedMessage}" with title "${escapedTitle}"'`,
+        () => {
+          resolve();
+        }
+      );
+    });
+  }
+  if (platform === "Linux" || platform.match(/BSD$/)) {
+    if (linuxGrouping) {
+      if (linuxNotifySendSupportsReplace === null) {
+        linuxNotifySendSupportsReplace = await detectNotifySendCapabilities();
+      }
+      if (linuxNotifySendSupportsReplace) {
+        return sendLinuxNotificationDirect(title, message, timeout, iconPath, true);
+      }
+    }
+  }
+  return new Promise((resolve) => {
+    const notificationOptions = {
+      title,
+      message,
+      timeout,
+      icon: iconPath
+    };
+    platformNotifier.notify(
+      notificationOptions,
+      () => {
+        resolve();
+      }
+    );
+  });
+}
+export {
+  sendNotification
+};

package/dist/sound.d.ts

@@ -0,0 +1,2 @@
+import type { EventType } from "./config";
+export declare function playSound(event: EventType, customPath: string | null, volume: number): Promise<void>;

package/dist/sound.js

@@ -0,0 +1,127 @@
+// src/sound.ts
+import { platform } from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+import { spawn } from "child_process";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var DEBOUNCE_MS = 1e3;
+var FULL_VOLUME_PERCENT = 100;
+var FULL_VOLUME_PULSE = 65536;
+var lastSoundTime = {};
+function getBundledSoundPath(event) {
+  const soundFilename = `${event}.wav`;
+  const possiblePaths = [
+    join(__dirname, "..", "sounds", soundFilename),
+    join(__dirname, "sounds", soundFilename)
+  ];
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return join(__dirname, "..", "sounds", soundFilename);
+}
+function getSoundFilePath(event, customPath) {
+  if (customPath && existsSync(customPath)) {
+    return customPath;
+  }
+  const bundledPath = getBundledSoundPath(event);
+  if (existsSync(bundledPath)) {
+    return bundledPath;
+  }
+  return null;
+}
+async function runCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      stdio: "ignore",
+      detached: false
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command exited with code ${code}`));
+      }
+    });
+  });
+}
+function normalizeVolume(volume) {
+  if (!Number.isFinite(volume)) {
+    return 1;
+  }
+  if (volume < 0) {
+    return 0;
+  }
+  if (volume > 1) {
+    return 1;
+  }
+  return volume;
+}
+function toPercentVolume(volume) {
+  return Math.round(volume * FULL_VOLUME_PERCENT);
+}
+function toPulseVolume(volume) {
+  return Math.round(volume * FULL_VOLUME_PULSE);
+}
+async function playOnLinux(soundPath, volume) {
+  const percentVolume = toPercentVolume(volume);
+  const pulseVolume = toPulseVolume(volume);
+  const players = [
+    { command: "paplay", args: [`--volume=${pulseVolume}`, soundPath] },
+    { command: "aplay", args: [soundPath] },
+    { command: "mpv", args: ["--no-video", "--no-terminal", `--volume=${percentVolume}`, soundPath] },
+    { command: "ffplay", args: ["-nodisp", "-autoexit", "-loglevel", "quiet", "-volume", `${percentVolume}`, soundPath] }
+  ];
+  for (const player of players) {
+    try {
+      await runCommand(player.command, player.args);
+      return;
+    } catch {
+      continue;
+    }
+  }
+}
+async function playOnMac(soundPath, volume) {
+  await runCommand("afplay", ["-v", `${volume}`, soundPath]);
+}
+async function playOnWindows(soundPath) {
+  const script = `& { (New-Object Media.SoundPlayer $args[0]).PlaySync() }`;
+  await runCommand("powershell", ["-c", script, soundPath]);
+}
+async function playSound(event, customPath, volume) {
+  const now = Date.now();
+  if (lastSoundTime[event] && now - lastSoundTime[event] < DEBOUNCE_MS) {
+    return;
+  }
+  lastSoundTime[event] = now;
+  const soundPath = getSoundFilePath(event, customPath);
+  const normalizedVolume = normalizeVolume(volume);
+  if (!soundPath) {
+    return;
+  }
+  const os = platform();
+  try {
+    switch (os) {
+      case "darwin":
+        await playOnMac(soundPath, normalizedVolume);
+        break;
+      case "linux":
+        await playOnLinux(soundPath, normalizedVolume);
+        break;
+      case "win32":
+        await playOnWindows(soundPath);
+        break;
+      default:
+        break;
+    }
+  } catch {
+  }
+}
+export {
+  playSound
+};

package/dist/wechat-webhook.d.ts

@@ -0,0 +1,8 @@
+interface WechatWebhookConfig {
+    enabled: boolean;
+    webhookUrl: string;
+    mentionedList?: string[];
+    mentionedMobileList?: string[];
+}
+export declare function sendWechatWebhook(config: WechatWebhookConfig, title: string, message: string): Promise<void>;
+export {};

package/dist/wechat-webhook.js

@@ -0,0 +1,43 @@
+// src/wechat-webhook.ts
+async function sendWebhookRequest(url, message) {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json; charset=utf-8"
+      },
+      body: JSON.stringify(message)
+    });
+    if (!response.ok) {
+      return false;
+    }
+    const data = await response.json();
+    return data.errcode === 0;
+  } catch {
+    return false;
+  }
+}
+async function sendWechatWebhook(config, title, message) {
+  if (!config.enabled || !config.webhookUrl) {
+    return;
+  }
+  const fullMessage = `${title}
+
+${message}`;
+  const webhookMessage = {
+    msgtype: "text",
+    text: {
+      content: fullMessage
+    }
+  };
+  if (config.mentionedList && config.mentionedList.length > 0) {
+    webhookMessage.text.mentioned_list = config.mentionedList;
+  }
+  if (config.mentionedMobileList && config.mentionedMobileList.length > 0) {
+    webhookMessage.text.mentioned_mobile_list = config.mentionedMobileList;
+  }
+  await sendWebhookRequest(config.webhookUrl, webhookMessage);
+}
+export {
+  sendWechatWebhook
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@thelastwinner/opencode-notifier",
+  "version": "0.1.30",
+  "description": "OpenCode plugin that sends system notifications and plays sounds when permission is needed, generation completes, or errors occur",
+  "author": "mohak34",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mohak34/opencode-notifier.git"
+  },
+  "homepage": "https://github.com/mohak34/opencode-notifier#readme",
+  "bugs": {
+    "url": "https://github.com/mohak34/opencode-notifier/issues"
+  },
+  "files": [
+    "dist",
+    "sounds",
+    "logos"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node",
+    "prepublishOnly": "bun run build",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "notifications",
+    "sound",
+    "alerts"
+  ],
+  "dependencies": {
+    "node-notifier": "^10.0.1"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.0.224",
+    "@types/node": "^22.0.0",
+    "@types/node-notifier": "^8.0.5",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  }
+}