opencode-plugin-apprise 1.0.0 → 1.1.0

package/dist/hooks/permission.d.ts

@@ -4,7 +4,7 @@ import type { PluginConfig } from "../types.js";
 export interface PermissionHooks {
     /** Primary: permission.ask hook */
     permissionAsk: NonNullable<Hooks["permission.ask"]>;
-    /** Fallback: event hook watching permission.updated */
+    /** Fallback: event hook watching permission.asked */
     eventFallback: NonNullable<Hooks["event"]>;
 }
 export declare function createPermissionHooks(config: PluginConfig, dedup: DedupChecker): PermissionHooks;

package/dist/hooks/question.d.ts

@@ -1,8 +1,4 @@
 import type { Hooks } from "@opencode-ai/plugin";
 import type { DedupChecker } from "../dedup.js";
 import type { PluginConfig } from "../types.js";
-export interface QuestionHooks {
-    before: NonNullable<Hooks["tool.execute.before"]>;
-    after: NonNullable<Hooks["tool.execute.after"]>;
-}
-export declare function createQuestionHooks(config: PluginConfig, dedup: DedupChecker, delayMs?: number): QuestionHooks;
+export declare function createQuestionHook(config: PluginConfig, dedup: DedupChecker, delayMs?: number): NonNullable<Hooks["event"]>;

package/dist/opencode-plugin-apprise.js

@@ -242,21 +242,6 @@ async function sendHookNotification(hookName, config, dedup, payload) {
   }
 }
 
-// src/hooks/background.ts
-function createBackgroundHook(config, dedup) {
-  return async ({ event }) => {
-    if (event.type !== "session.status")
-      return;
-    const props = event.properties;
-    if (props.status.type !== "idle")
-      return;
-    const payload = createPayload("background", "✅ Background Task Complete", {
-      taskName: `Session ${props.sessionID}`
-    });
-    await sendHookNotification("background", config, dedup, payload);
-  };
-}
-
 // src/hooks/idle.ts
 function extractText(message) {
   if (!message || typeof message !== "object") {
@@ -268,9 +253,11 @@ function extractText(message) {
 }
 function createIdleHook(ctx, config, dedup) {
   return async ({ event }) => {
-    if (event.type !== "session.idle")
+    if (event.type !== "session.status")
       return;
     const props = event.properties;
+    if (props.status.type !== "idle")
+      return;
     if (!props.sessionID)
       return;
     let userRequest = undefined;
@@ -320,65 +307,71 @@ function createIdleHook(ctx, config, dedup) {
 // src/hooks/permission.ts
 function createPermissionHooks(config, dedup) {
   const notifiedPermissions = new Set;
-  async function notifyPermission(permission) {
-    const permId = permission.id ?? "unknown";
+  const permissionAsk = async (input, _output) => {
+    const permId = input.id ?? "unknown";
     if (notifiedPermissions.has(permId))
       return;
     notifiedPermissions.add(permId);
-    const toolName = permission.toolName ?? "Unknown Tool";
-    const action = permission.action ?? "Unknown Action";
+    const title = input.title ?? "Unknown";
+    const pattern = input.pattern;
+    const action = Array.isArray(pattern) ? pattern.join(", ") : pattern ?? "Unknown";
     const payload = createPayload("permission", "\uD83D\uDD10 OpenCode Permission Required", {
-      toolName,
+      toolName: title,
       action
     });
     await sendHookNotification("permission", config, dedup, payload);
-  }
-  const permissionAsk = async (input, _output) => {
-    await notifyPermission(input);
   };
   const eventFallback = async ({ event }) => {
-    if (event.type !== "permission.updated")
+    const eventType = event.type;
+    if (eventType !== "permission.asked")
+      return;
+    const props = event.properties;
+    const permId = props.id ?? "unknown";
+    if (notifiedPermissions.has(permId))
       return;
-    const permission = event.properties;
-    await notifyPermission(permission);
+    notifiedPermissions.add(permId);
+    const payload = createPayload("permission", "\uD83D\uDD10 OpenCode Permission Required", {
+      toolName: props.permission ?? "Unknown",
+      action: props.patterns?.join(", ") ?? "Unknown"
+    });
+    await sendHookNotification("permission", config, dedup, payload);
   };
   return { permissionAsk, eventFallback };
 }
 
 // src/hooks/question.ts
-function createQuestionHooks(config, dedup, delayMs = 30000) {
+function createQuestionHook(config, dedup, delayMs = 30000) {
   const timers = new Map;
-  const before = async ({ tool, callID }, input) => {
-    if (tool.toLowerCase() !== "question")
+  return async ({ event }) => {
+    const eventType = event.type;
+    if (eventType === "question.replied" || eventType === "question.rejected") {
+      const props2 = event.properties;
+      const timer2 = timers.get(props2.requestID);
+      if (timer2) {
+        clearTimeout(timer2);
+        timers.delete(props2.requestID);
+      }
       return;
-    const args = input?.args;
-    const question = typeof args?.question === "string" ? args.question : undefined;
-    const options = Array.isArray(args?.options) ? args.options.filter((option) => typeof option === "string") : undefined;
+    }
+    if (eventType !== "question.asked")
+      return;
+    const props = event.properties;
+    const firstQuestion = props.questions[0];
+    if (!firstQuestion)
+      return;
+    const question = firstQuestion.question;
+    const options = firstQuestion.options.map((opt) => opt.label);
+    const requestId = props.id;
     const timer = setTimeout(async () => {
-      if (!question)
-        return;
+      timers.delete(requestId);
       const payload = createPayload("question", "❓ OpenCode Question", {
         question,
-        options,
-        toolName: "Question"
+        options: options.length > 0 ? options : undefined
       });
       await sendHookNotification("question", config, dedup, payload);
     }, delayMs);
-    timers.set(callID, timer);
-  };
-  const after = async ({
-    tool,
-    callID
-  }) => {
-    if (tool.toLowerCase() !== "question")
-      return;
-    const timer = timers.get(callID);
-    if (timer) {
-      clearTimeout(timer);
-      timers.delete(callID);
-    }
+    timers.set(requestId, timer);
   };
-  return { before, after };
 }
 
 // src/index.ts
@@ -400,18 +393,15 @@ var plugin = async (input) => {
   }
   const dedup = createDedupChecker();
   const idleHook = createIdleHook(input, config, dedup);
-  const questionHooks = createQuestionHooks(config, dedup);
-  const backgroundHook = createBackgroundHook(config, dedup);
+  const questionHook = createQuestionHook(config, dedup);
   const permissionHooks = createPermissionHooks(config, dedup);
   const combinedEventHook = async ({ event }) => {
-    await idleHook({ event });
-    await backgroundHook({ event });
+    await questionHook({ event });
     await permissionHooks.eventFallback({ event });
+    await idleHook({ event });
   };
   return {
     event: combinedEventHook,
-    "tool.execute.before": questionHooks.before,
-    "tool.execute.after": questionHooks.after,
     "permission.ask": permissionHooks.permissionAsk
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-plugin-apprise",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "OpenCode plugin that sends rich notifications via Apprise CLI when the agent needs your attention",
   "type": "module",
   "main": "dist/opencode-plugin-apprise.js",