bobs-opencode-discord-notifier 0.1.3

package/README.md

@@ -0,0 +1,45 @@
+# opencode-discord-notification
+
+OpenCode plugin that sends Discord notifications on session completion and permission requests.
+
+![Example Notification](screenshots/example.png)
+
+## Features
+
+- ✅ **Completion Notifications:** Get a Discord message when OpenCode finishes a long task.
+- 📊 **Context Stats:** Includes context usage percentage and total tokens.
+- 🤖 **Model Info:** Shows which model was used for the response.
+- ⚠️ **Permission Alerts:** Real-time notifications when OpenCode is blocked waiting for terminal permissions, including the command it's trying to run.
+
+## Installation
+
+Add it to your `opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-discord-notification@0.1.1"]
+}
+```
+
+## Configuration
+
+Create a configuration file at `~/.config/opencode/discord-notification-config.json`:
+
+```json
+{
+  "enabled": true,
+  "webhookUrl": "https://discord.com/api/webhooks/...",
+  "username": "OpenCode Notifier",
+  "avatarUrl": "https://opencode.ai/logo.png"
+}
+```
+
+## Development
+
+1. Clone the repo.
+2. Install dependencies: `bun install`.
+3. Type-check: `bun x tsc`.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "bobs-opencode-discord-notifier",
+  "version": "0.1.3",
+  "description": "OpenCode plugin that sends Discord notifications on session completion and permission requests.",
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "type": "module",
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "opencode",
+    "plugin",
+    "discord",
+    "notification",
+    "ai"
+  ],
+  "author": "BobBurton9000",
+  "license": "MIT",
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "latest",
+    "@types/node": "latest",
+    "typescript": "latest"
+  }
+}

package/src/index.ts

@@ -0,0 +1,141 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { Plugin } from "@opencode-ai/plugin";
+
+interface DiscordWebhookConfig {
+  webhookUrl?: string;
+  enabled?: boolean;
+  username?: string;
+  avatarUrl?: string;
+}
+
+export const DiscordNotificationPlugin: Plugin = async ({ client, project }) => {
+  return {
+    event: async ({ event }) => {
+      // 1. Handle Session Completed (Green)
+      if (event.type === "session.idle") {
+        await handleNotification(client, project, event, "idle");
+      }
+      // 2. Handle Permission Request (Orange)
+      else if ((event.type as string) === "permission.asked") {
+        await handleNotification(client, project, event, "permission");
+      }
+    },
+  };
+};
+
+async function handleNotification(client: any, project: any, event: any, type: "idle" | "permission") {
+  try {
+    // 1. GET CONFIGURATION
+    // Priority 1: project.config (opencode.json)
+    // Priority 2: Local file (for development or if schema is strict)
+    let config: DiscordWebhookConfig = project.config?.discordNotifications || {};
+
+    if (!config.webhookUrl) {
+      try {
+        const configPath = join(homedir(), ".config", "opencode", "discord-notification-config.json");
+        if (existsSync(configPath)) {
+          config = JSON.parse(readFileSync(configPath, "utf-8"));
+        }
+      } catch (e) {}
+    }
+
+    if (!config.enabled || !config.webhookUrl) return;
+
+    const sessionId = event.properties?.sessionID || event.properties?.id || event.properties?.sessionId;
+    if (!sessionId) return;
+
+    // Only wait on idle to give tokens time to settle
+    if (type === "idle") {
+      await new Promise(resolve => setTimeout(resolve, 1500));
+    }
+
+    const [sRes, mRes] = await Promise.all([
+      client.session.get({ path: { id: sessionId } }),
+      client.session.messages({ path: { id: sessionId } })
+    ]);
+    
+    const session = (sRes as any).data || sRes;
+    const messages = (mRes as any).data || mRes || [];
+
+    let lastText = "Response completed.";
+    let contextUsage = "N/A";
+    let modelName = session?.model?.name || "Unknown";
+    let totalTokensAccumulated = 0;
+    let pendingCommand = "";
+
+    // Analyze messages
+    messages.forEach((m: any) => {
+      const isAssistant = (m.info?.role || m.role) === "assistant";
+      if (isAssistant) {
+        const t = m.info?.tokens || m.tokens;
+        if (t) {
+          const turnTotal = (t.input || 0) + (t.output || 0) + (t.cache?.read || 0);
+          totalTokensAccumulated = Math.max(totalTokensAccumulated, turnTotal);
+        }
+        if (type === "permission" && m.parts) {
+          const toolPart = m.parts.find((p: any) => p.type === "tool" && (p.state?.status === "pending" || p.state?.status === "running"));
+          if (toolPart) {
+            const input = toolPart.state?.input || {};
+            pendingCommand = input.command || input.filePath || JSON.stringify(input);
+          }
+        }
+      }
+    });
+
+    if (totalTokensAccumulated > 0 && session?.model?.limit?.context) {
+      const percentage = ((totalTokensAccumulated / session.model.limit.context) * 100).toFixed(2);
+      contextUsage = `${percentage}%`;
+    }
+
+    const assistantMessages = messages.filter((m: any) => (m.info?.role || m.role) === "assistant");
+    const lastAssistant = assistantMessages[assistantMessages.length - 1];
+    if (lastAssistant) {
+      const text = lastAssistant.parts?.filter((p: any) => p.type === "text").map((p: any) => p.text).join("\n");
+      if (text) lastText = text;
+      modelName = (lastAssistant.info?.modelID || lastAssistant.modelID) || modelName;
+    }
+
+    const isPermission = type === "permission";
+    const title = isPermission ? "⚠️ Permission Required" : "✅ Response Completed";
+    const color = isPermission ? 0xffa500 : 0x00ff00;
+    
+    let description = lastText;
+    const fields = [
+      { name: "📊 Context Usage", value: contextUsage, inline: true },
+      { name: "🔢 Total Tokens", value: `${totalTokensAccumulated.toLocaleString()} tokens`, inline: true },
+      { name: "🤖 Model", value: modelName, inline: true }
+    ];
+
+    if (isPermission) {
+      fields.unshift({ 
+        name: "🔒 Blocked Command / Action", 
+        value: `\`\`\`bash\n${pendingCommand || "Check terminal for details"}\n\`\`\``, 
+        inline: false 
+      });
+      description = "OpenCode has paused execution and is waiting for you to authorize the operation shown above.";
+    }
+
+    await fetch(config.webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        username: config.username || "OpenCode Notifier",
+        avatar_url: config.avatarUrl,
+        embeds: [{
+          title,
+          description: description.length > 1500 ? description.substring(0, 1497) + "..." : description,
+          color,
+          fields,
+          footer: { text: `Session ID: ${sessionId}` },
+          timestamp: new Date().toISOString()
+        }]
+      }),
+    });
+  } catch (e) {
+    console.error("Discord Plugin Error:", e);
+  }
+}
+
+export default DiscordNotificationPlugin;