@pranjalmandavkar/opencode-notifier 1.0.0

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@pranjalmandavkar/opencode-notifier",
+  "version": "1.0.0",
+  "description": "Opencode Plugin that sends system notification when permission is needed, generation is complete or error occurs in session",
+  "author": "MandavkarPranjal",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mandavkarpranjal/opencode-notifier.git"
+  },
+  "homepage": "https://github.com/mandavkarpranjal/opencode-notifier#readme",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "notification",
+    "alerts"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node",
+    "typecheck": "tsc --noEmit",
+    "release:patch": "bun run build && npm version patch && npm publish --access public",
+    "release:minor": "bun run build && npm version minor && npm publish --access public",
+    "release:major": "bun run build && npm version major && npm publish --access public"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.1.25",
+    "@types/bun": "latest",
+    "@types/node": "^25.0.9",
+    "@types/node-notifier": "^8.0.5"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "^1.1.25"
+  },
+  "dependencies": {
+    "node-notifier": "^10.0.1"
+  }
+}

package/src/config.ts

@@ -0,0 +1,157 @@
+import { readFileSync, existsSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+
+export type EventType = "permission" | "complete" | "error" | "question"
+
+export interface EventConfig {
+    sound: boolean
+    notification: boolean
+}
+
+export interface NotifierConfig {
+    sound: boolean
+    notification: boolean
+    timeout: number
+    showProjectName: boolean
+    events: {
+        permission: EventConfig
+        complete: EventConfig
+        error: EventConfig
+        question: EventConfig
+    }
+    messages: {
+        permission: string
+        complete: string
+        error: string
+        question: string
+    }
+    sounds: {
+        permission: string | null
+        complete: string | null
+        error: string | null
+        question: string | null
+    }
+}
+
+const DEFAULT_EVENT_CONFIG: EventConfig = {
+    sound: true,
+    notification: true,
+}
+
+const DEFAULT_CONFIG: NotifierConfig = {
+    sound: true,
+    notification: true,
+    timeout: 5,
+    showProjectName: true,
+    events: {
+        permission: { ...DEFAULT_EVENT_CONFIG },
+        complete: { ...DEFAULT_EVENT_CONFIG },
+        error: { ...DEFAULT_EVENT_CONFIG },
+        question: { ...DEFAULT_EVENT_CONFIG },
+    },
+    messages: {
+        permission: "Session needs permission",
+        complete: "Session has finished",
+        error: "Session encountered an error",
+        question: "Session has a question",
+    },
+    sounds: {
+        permission: null,
+        complete: null,
+        error: null,
+        question: null
+    },
+}
+
+function getConfigPath(): string {
+    return join(homedir(), ".config", "opencode", "opencode-notifier.json")
+}
+
+function parseEventConfig(
+    userEvent: boolean | { sound?: boolean; notification?: boolean } | undefined,
+    defaultConfig: EventConfig
+): EventConfig {
+    if (userEvent === undefined) {
+        return defaultConfig
+    }
+
+    if (typeof userEvent === "boolean") {
+        return {
+            sound: userEvent,
+            notification: userEvent,
+        }
+    }
+
+    return {
+        sound: userEvent.sound ?? defaultConfig.sound,
+        notification: userEvent.notification ?? defaultConfig.notification,
+    }
+}
+
+export function loadConfig(): NotifierConfig {
+    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: EventConfig = {
+            sound: globalSound,
+            notification: globalNotification,
+        }
+
+        return {
+            sound: globalSound,
+            notification: globalNotification,
+            timeout:
+                typeof userConfig.timeout === "number" && userConfig.timeout > 0
+                    ? userConfig.timeout
+                    : DEFAULT_CONFIG.timeout,
+            showProjectName: userConfig.showProjectName ?? DEFAULT_CONFIG.showProjectName,
+            events: {
+                permission: parseEventConfig(userConfig.events?.permission ?? userConfig.permission, defaultWithGlobal),
+                complete: parseEventConfig(userConfig.events?.complete ?? userConfig.complete, defaultWithGlobal),
+                error: parseEventConfig(userConfig.events?.error ?? userConfig.error, defaultWithGlobal),
+                question: parseEventConfig(userConfig.events?.question ?? userConfig.question, defaultWithGlobal),
+            },
+            messages: {
+                permission: userConfig.messages?.permission ?? DEFAULT_CONFIG.messages.permission,
+                complete: userConfig.messages?.complete ?? DEFAULT_CONFIG.messages.complete,
+                error: userConfig.messages?.error ?? DEFAULT_CONFIG.messages.error,
+                question: userConfig.messages?.question ?? DEFAULT_CONFIG.messages.question,
+            },
+            sounds: {
+                permission: userConfig.sounds?.permission ?? DEFAULT_CONFIG.sounds.permission,
+                complete: userConfig.sounds?.complete ?? DEFAULT_CONFIG.sounds.complete,
+                error: userConfig.sounds?.error ?? DEFAULT_CONFIG.sounds.error,
+                question: userConfig.sounds?.question ?? DEFAULT_CONFIG.sounds.question,
+            },
+        }
+    } catch {
+        return DEFAULT_CONFIG
+    }
+}
+
+export function isEventNotificationEnabled(config: NotifierConfig, event: EventType): boolean {
+    return config.events[event].notification
+}
+
+export function getMessage(config: NotifierConfig, event: EventType): string {
+    return config.messages[event]
+}
+
+export function isEventSoundEnabled(config: NotifierConfig, event: EventType): boolean {
+    return config.events[event].sound
+}
+
+export function getSound(config: NotifierConfig, event: EventType): string | null {
+    return config.sounds[event]
+}

package/src/index.ts

@@ -0,0 +1,69 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import { basename } from "path"
+import { loadConfig, isEventNotificationEnabled, getMessage, isEventSoundEnabled, getSound } from "./config"
+import type { EventType, NotifierConfig } from "./config"
+import { sendNotification } from "./notify"
+import { playSound } from "./sound"
+
+function getNotificationTitle(config: NotifierConfig, projectName: string | null): string {
+    if (config.showProjectName && projectName) {
+        return `OpenCode (${projectName})`
+    }
+    return "OpenCode"
+}
+
+async function handleEvent(
+    config: NotifierConfig,
+    eventType: EventType,
+    projectName: string | null
+): Promise<void> {
+    const promises: Promise<void>[] = []
+
+    if (isEventNotificationEnabled(config, eventType)) {
+        const title = getNotificationTitle(config, projectName)
+        const message = getMessage(config, eventType)
+        promises.push(sendNotification(title, message, config.timeout))
+    }
+
+    if (isEventSoundEnabled(config, eventType)) {
+        const customSound = getSound(config, eventType)
+        promises.push(playSound(eventType, customSound))
+    }
+
+    await Promise.allSettled(promises)
+}
+
+export const NotifierPlugin: Plugin = async ({ project, client, $, directory, worktree }) => {
+    const config = loadConfig()
+    const projectName = directory ? basename(directory) : null
+
+    return {
+        event: async ({ event }) => {
+            if (event.type === "permission.updated") {
+                await handleEvent(config, "permission", projectName)
+            }
+
+            if ((event as any).type === "permission.asked") {
+                await handleEvent(config, "permission", projectName)
+            }
+
+            if (event.type === "session.idle") {
+                await handleEvent(config, "complete", projectName)
+            }
+
+            if (event.type === "session.error") {
+                await handleEvent(config, "error", projectName)
+            }
+        },
+        "permission.ask": async () => {
+            await handleEvent(config, "permission", projectName)
+        },
+        "tool.execute.before": async (input, output) => {
+            if (input.tool === "question") {
+                await handleEvent(config, "question", projectName)
+            }
+        },
+    }
+}
+
+export default NotifierPlugin

package/src/notify.ts

@@ -0,0 +1,62 @@
+import os from "os"
+import { exec } from "child_process"
+import notifier from "node-notifier"
+
+const DEBOUNCE_MS = 1000
+
+const platform = os.type()
+
+let platformNotifier: any
+
+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
+}
+
+const lastNotificationTime: Record<string, number> = {}
+
+export async function sendNotification(
+    title: string,
+    message: string,
+    timeout: number
+): Promise<void> {
+    const now = Date.now()
+    if (lastNotificationTime[message] && now - lastNotificationTime[message] < DEBOUNCE_MS) {
+        return
+    }
+    lastNotificationTime[message] = now
+
+    if (platform === "Darwin") {
+        return new Promise((resolve) => {
+            const escapedMessage = message.replace(/"/g, '\\"')
+            const escapedTitle = title.replace(/"/g, '\\"')
+            exec(
+                `osascript -e 'display notification "${escapedMessage}" with title "${escapedTitle}"'`,
+                () => {
+                    resolve()
+                }
+            )
+        })
+    }
+
+    return new Promise((resolve) => {
+        const notificationOptions: any = {
+            title: title,
+            message: message,
+            timeout: timeout,
+            icon: undefined,
+        }
+
+        platformNotifier.notify(
+            notificationOptions,
+            () => {
+                resolve()
+            }
+        )
+    })
+}

package/src/sound.ts

@@ -0,0 +1,126 @@
+import { platform } from "os"
+import { join, dirname } from "path"
+import { fileURLToPath } from "url"
+import { existsSync } from "fs"
+import { spawn } from "child_process"
+import type { EventType } from "./config"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const DEBOUNCE_MS = 1000
+
+const lastSoundTime: Record<string, number> = {}
+
+function getBundledSoundPath(event: EventType): string {
+    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: EventType, customPath: string | null): string | null {
+    if (customPath && existsSync(customPath)) {
+        return customPath
+    }
+
+    const bundledPath = getBundledSoundPath(event)
+    if (existsSync(bundledPath)) {
+        return bundledPath
+    }
+
+    return null
+}
+
+async function runCommand(command: string, args: string[]): Promise<void> {
+    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}`))
+            }
+        })
+    })
+}
+
+async function playOnLinux(soundPath: string): Promise<void> {
+    const players = [
+        { command: "paplay", args: [soundPath] },
+        { command: "aplay", args: [soundPath] },
+        { command: "mpv", args: ["--no-video", "--no-terminal", soundPath] },
+        { command: "ffplay", args: ["-nodisp", "-autoexit", "-loglevel", "quiet", soundPath] },
+    ]
+
+    for (const player of players) {
+        try {
+            await runCommand(player.command, player.args)
+            return
+        } catch {
+            continue
+        }
+    }
+}
+
+async function playOnMac(soundPath: string): Promise<void> {
+    await runCommand("afplay", [soundPath])
+}
+
+async function playOnWindows(soundPath: string): Promise<void> {
+    const script = `& { (New-Object Media.SoundPlayer $args[0]).PlaySync() }`
+    await runCommand("powershell", ["-c", script, soundPath])
+}
+
+export async function playSound(
+    event: EventType,
+    customPath: string | null
+): Promise<void> {
+    const now = Date.now()
+    if (lastSoundTime[event] && now - lastSoundTime[event] < DEBOUNCE_MS) {
+        return
+    }
+    lastSoundTime[event] = now
+
+    const soundPath = getSoundFilePath(event, customPath)
+
+    if (!soundPath) {
+        return
+    }
+
+    const os = platform()
+
+    try {
+        switch (os) {
+            case "darwin":
+                await playOnMac(soundPath)
+                break
+            case "linux":
+                await playOnLinux(soundPath)
+                break
+            case "win32":
+                await playOnWindows(soundPath)
+                break
+            default:
+                break
+        }
+    } catch {
+        // Silent fail - notification will still work
+    }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}