@mohak34/opencode-notifier 0.1.22-beta.1 → 0.1.22-beta.3

package/dist/index.js

@@ -4127,12 +4127,26 @@ function runCommand2(config, event, message, sessionTitle, projectName) {
 }
 
 // src/index.ts
-var recentErrors = new Map;
+var IDLE_COMPLETE_DELAY_MS = 350;
+var pendingIdleTimers = new Map;
+var sessionIdleSequence = new Map;
+var sessionErrorSuppressionAt = new Map;
+var sessionLastBusyAt = new Map;
 setInterval(() => {
   const cutoff = Date.now() - 5 * 60 * 1000;
-  for (const [sessionID, timestamp] of recentErrors) {
+  for (const [sessionID] of sessionIdleSequence) {
+    if (!pendingIdleTimers.has(sessionID)) {
+      sessionIdleSequence.delete(sessionID);
+    }
+  }
+  for (const [sessionID, timestamp] of sessionErrorSuppressionAt) {
+    if (timestamp < cutoff) {
+      sessionErrorSuppressionAt.delete(sessionID);
+    }
+  }
+  for (const [sessionID, timestamp] of sessionLastBusyAt) {
     if (timestamp < cutoff) {
-      recentErrors.delete(sessionID);
+      sessionLastBusyAt.delete(sessionID);
     }
   }
 }, 5 * 60 * 1000);
@@ -4173,6 +4187,50 @@ function getSessionIDFromEvent(event) {
   }
   return null;
 }
+function clearPendingIdleTimer(sessionID) {
+  const timer = pendingIdleTimers.get(sessionID);
+  if (!timer) {
+    return;
+  }
+  clearTimeout(timer);
+  pendingIdleTimers.delete(sessionID);
+}
+function bumpSessionIdleSequence(sessionID) {
+  const nextSequence = (sessionIdleSequence.get(sessionID) ?? 0) + 1;
+  sessionIdleSequence.set(sessionID, nextSequence);
+  return nextSequence;
+}
+function hasCurrentSessionIdleSequence(sessionID, sequence) {
+  return sessionIdleSequence.get(sessionID) === sequence;
+}
+function markSessionError(sessionID) {
+  if (!sessionID) {
+    return;
+  }
+  sessionErrorSuppressionAt.set(sessionID, Date.now());
+  bumpSessionIdleSequence(sessionID);
+  clearPendingIdleTimer(sessionID);
+}
+function markSessionBusy(sessionID) {
+  const now = Date.now();
+  sessionLastBusyAt.set(sessionID, now);
+  sessionErrorSuppressionAt.delete(sessionID);
+  bumpSessionIdleSequence(sessionID);
+  clearPendingIdleTimer(sessionID);
+}
+function shouldSuppressSessionIdle(sessionID) {
+  const errorAt = sessionErrorSuppressionAt.get(sessionID);
+  if (errorAt === undefined) {
+    return false;
+  }
+  const busyAt = sessionLastBusyAt.get(sessionID);
+  if (typeof busyAt === "number" && busyAt > errorAt) {
+    sessionErrorSuppressionAt.delete(sessionID);
+    return false;
+  }
+  sessionErrorSuppressionAt.delete(sessionID);
+  return true;
+}
 async function getElapsedSinceLastPrompt(client, sessionID, nowMs = Date.now()) {
   try {
     const response = await client.session.messages({ path: { id: sessionID } });
@@ -4203,21 +4261,50 @@ async function getSessionInfo(client, sessionID) {
     return { isChild: false, title: null };
   }
 }
-async function handleEventWithElapsedTime(client, config, eventType, projectName, event, preloadedSessionTitle) {
+async function processSessionIdle(client, config, projectName, event, sessionID, sequence, idleReceivedAtMs) {
+  if (!hasCurrentSessionIdleSequence(sessionID, sequence)) {
+    return;
+  }
+  if (shouldSuppressSessionIdle(sessionID)) {
+    return;
+  }
+  const sessionInfo = await getSessionInfo(client, sessionID);
+  if (!hasCurrentSessionIdleSequence(sessionID, sequence)) {
+    return;
+  }
+  if (!sessionInfo.isChild) {
+    await handleEventWithElapsedTime(client, config, "complete", projectName, event, idleReceivedAtMs, sessionInfo.title);
+    return;
+  }
+  await handleEventWithElapsedTime(client, config, "subagent_complete", projectName, event, idleReceivedAtMs, sessionInfo.title);
+}
+function scheduleSessionIdle(client, config, projectName, event, sessionID) {
+  clearPendingIdleTimer(sessionID);
+  const sequence = bumpSessionIdleSequence(sessionID);
+  const idleReceivedAtMs = Date.now();
+  const timer = setTimeout(() => {
+    pendingIdleTimers.delete(sessionID);
+    processSessionIdle(client, config, projectName, event, sessionID, sequence, idleReceivedAtMs).catch(() => {
+      return;
+    });
+  }, IDLE_COMPLETE_DELAY_MS);
+  pendingIdleTimers.set(sessionID, timer);
+}
+async function handleEventWithElapsedTime(client, config, eventType, projectName, event, elapsedReferenceNowMs, preloadedSessionTitle) {
   const sessionID = getSessionIDFromEvent(event);
+  const minDuration = config.command?.minDuration;
+  const shouldLookupElapsed = !!config.command?.enabled && typeof config.command?.path === "string" && config.command.path.length > 0 && typeof minDuration === "number" && Number.isFinite(minDuration) && minDuration > 0;
   let elapsedSeconds = null;
-  let sessionTitle = preloadedSessionTitle ?? null;
-  if (sessionID) {
-    const minDuration = config.command?.minDuration;
-    const shouldLookupElapsed = !!config.command?.enabled && typeof config.command?.path === "string" && config.command.path.length > 0 && typeof minDuration === "number" && Number.isFinite(minDuration) && minDuration > 0;
-    if (shouldLookupElapsed) {
-      elapsedSeconds = await getElapsedSinceLastPrompt(client, sessionID);
-    }
-    if (!sessionTitle && config.showSessionTitle) {
-      const info = await getSessionInfo(client, sessionID);
-      sessionTitle = info.title;
+  if (shouldLookupElapsed) {
+    if (sessionID) {
+      elapsedSeconds = await getElapsedSinceLastPrompt(client, sessionID, elapsedReferenceNowMs);
     }
   }
+  let sessionTitle = preloadedSessionTitle ?? null;
+  if (sessionID && !sessionTitle && config.showSessionTitle) {
+    const info = await getSessionInfo(client, sessionID);
+    sessionTitle = info.title;
+  }
   await handleEvent(config, eventType, projectName, elapsedSeconds, sessionTitle);
 }
 var NotifierPlugin = async ({ client, directory }) => {
@@ -4234,42 +4321,23 @@ var NotifierPlugin = async ({ client, directory }) => {
       if (event.type === "session.idle") {
         const sessionID = getSessionIDFromEvent(event);
         if (sessionID) {
-          await new Promise((resolve) => setTimeout(resolve, 100));
-          const errorTime = recentErrors.get(sessionID);
-          if (errorTime && Date.now() - errorTime < 500) {
-            recentErrors.delete(sessionID);
-            const sessionInfo = await getSessionInfo(client, sessionID);
-            await handleEventWithElapsedTime(client, config, "interrupted", projectName, event, sessionInfo.title);
-          } else {
-            const sessionInfo = await getSessionInfo(client, sessionID);
-            if (!sessionInfo.isChild) {
-              await handleEventWithElapsedTime(client, config, "complete", projectName, event, sessionInfo.title);
-            } else {
-              await handleEventWithElapsedTime(client, config, "subagent_complete", projectName, event, sessionInfo.title);
-            }
-          }
+          scheduleSessionIdle(client, config, projectName, event, sessionID);
         } else {
           await handleEventWithElapsedTime(client, config, "complete", projectName, event);
         }
       }
+      if (event.type === "session.status" && event.properties.status.type === "busy") {
+        markSessionBusy(event.properties.sessionID);
+      }
       if (event.type === "session.error") {
         const sessionID = getSessionIDFromEvent(event);
-        if (sessionID) {
-          recentErrors.set(sessionID, Date.now());
-          let sessionTitle = null;
-          if (config.showSessionTitle) {
-            const info = await getSessionInfo(client, sessionID);
-            sessionTitle = info.title;
-          }
-          setTimeout(() => {
-            if (recentErrors.has(sessionID)) {
-              recentErrors.delete(sessionID);
-              handleEventWithElapsedTime(client, config, "error", projectName, event, sessionTitle);
-            }
-          }, 100);
-        } else {
-          await handleEventWithElapsedTime(client, config, "error", projectName, event);
+        markSessionError(sessionID);
+        let sessionTitle = null;
+        if (sessionID && config.showSessionTitle) {
+          const info = await getSessionInfo(client, sessionID);
+          sessionTitle = info.title;
         }
+        await handleEventWithElapsedTime(client, config, "error", projectName, event, undefined, sessionTitle);
       }
     },
     "permission.ask": async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohak34/opencode-notifier",
-  "version": "0.1.22-beta.1",
+  "version": "0.1.22-beta.3",
   "description": "OpenCode plugin that sends system notifications and plays sounds when permission is needed, generation completes, or errors occur",
   "author": "mohak34",
   "license": "MIT",