opencode-plugin-apprise 1.0.0 → 1.2.0

package/dist/hooks/idle.d.ts

@@ -1,4 +1,4 @@
 import type { Hooks, PluginInput } from "@opencode-ai/plugin";
 import type { DedupChecker } from "../dedup.js";
 import type { PluginConfig } from "../types.js";
-export declare function createIdleHook(ctx: PluginInput, config: PluginConfig, dedup: DedupChecker): NonNullable<Hooks["event"]>;
+export declare function createIdleHook(ctx: PluginInput, config: PluginConfig, dedup: DedupChecker, interactiveSessions: Set<string>): NonNullable<Hooks["event"]>;

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

@@ -54,7 +54,6 @@ function createDedupChecker() {
 var TYPE_MAP = {
   idle: "info",
   question: "warning",
-  background: "success",
   permission: "warning"
 };
 var DEFAULT_TRUNCATE_LENGTH = 1500;
@@ -127,17 +126,6 @@ ${context.options.map((option, index) => `  ${index + 1}. ${option}`).join(`
       }
       body = parts.join(`
 
-`);
-      break;
-    }
-    case "background": {
-      const parts = [];
-      if (context.taskName)
-        parts.push(`Task: ${context.taskName}`);
-      if (context.agentResponse)
-        parts.push(`Result: ${context.agentResponse}`);
-      body = parts.join(`
-
 `);
       break;
     }
@@ -220,7 +208,6 @@ var EMPTY_CONTEXT = {
   question: undefined,
   options: undefined,
   todoStatus: undefined,
-  taskName: undefined,
   toolName: undefined,
   action: undefined
 };
@@ -242,21 +229,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") {
@@ -266,13 +238,17 @@ function extractText(message) {
   return parts.join(`
 `).trim() || undefined;
 }
-function createIdleHook(ctx, config, dedup) {
+function createIdleHook(ctx, config, dedup, interactiveSessions) {
   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;
+    if (!interactiveSessions.has(props.sessionID))
+      return;
     let userRequest = undefined;
     let agentResponse = undefined;
     let todoStatus = undefined;
@@ -320,65 +296,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
@@ -399,20 +381,22 @@ var plugin = async (input) => {
     return {};
   }
   const dedup = createDedupChecker();
-  const idleHook = createIdleHook(input, config, dedup);
-  const questionHooks = createQuestionHooks(config, dedup);
-  const backgroundHook = createBackgroundHook(config, dedup);
+  const interactiveSessions = new Set;
+  const idleHook = createIdleHook(input, config, dedup, interactiveSessions);
+  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 });
+  };
+  const chatMessageHook = async (input2) => {
+    interactiveSessions.add(input2.sessionID);
   };
   return {
     event: combinedEventHook,
-    "tool.execute.before": questionHooks.before,
-    "tool.execute.after": questionHooks.after,
-    "permission.ask": permissionHooks.permissionAsk
+    "permission.ask": permissionHooks.permissionAsk,
+    "chat.message": chatMessageHook
   };
 };
 var src_default = plugin;

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 export interface PluginConfig {
     tag?: string;
 }
-export type HookEventType = "idle" | "question" | "background" | "permission";
+export type HookEventType = "idle" | "question" | "permission";
 export type AppriseNotificationType = "info" | "warning" | "success" | "failure";
 export interface NotificationContext {
     userRequest: string | undefined;
@@ -9,7 +9,6 @@ export interface NotificationContext {
     question: string | undefined;
     options: string[] | undefined;
     todoStatus: string | undefined;
-    taskName: string | undefined;
     toolName: string | undefined;
     action: string | undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-plugin-apprise",
-  "version": "1.0.0",
+  "version": "1.2.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",

package/dist/hooks/background.d.ts

@@ -1,4 +0,0 @@
-import type { Hooks } from "@opencode-ai/plugin";
-import type { DedupChecker } from "../dedup.js";
-import type { PluginConfig } from "../types.js";
-export declare function createBackgroundHook(config: PluginConfig, dedup: DedupChecker): NonNullable<Hooks["event"]>;