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

package/dist/index.js

@@ -3894,9 +3894,6 @@ function getMessage(config, event) {
 function getSoundPath(config, event) {
   return config.sounds[event];
 }
-function getSoundVolume(config, event) {
-  return config.volumes[event];
-}
 function getIconPath(config) {
   if (!config.showIcon) {
     return;
@@ -3911,16 +3908,6 @@ function getIconPath(config) {
   } catch {}
   return;
 }
-function interpolateMessage(message, context) {
-  let result = message;
-  const sessionTitle = context.sessionTitle || "";
-  result = result.replaceAll("{sessionTitle}", sessionTitle);
-  const projectName = context.projectName || "";
-  result = result.replaceAll("{projectName}", projectName);
-  result = result.replace(/\s*[:\-|]\s*$/, "").trim();
-  result = result.replace(/\s{2,}/g, " ");
-  return result;
-}
 
 // src/notify.ts
 var import_node_notifier = __toESM(require_node_notifier(), 1);
@@ -4127,12 +4114,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) {
-      recentErrors.delete(sessionID);
+      sessionErrorSuppressionAt.delete(sessionID);
+    }
+  }
+  for (const [sessionID, timestamp] of sessionLastBusyAt) {
+    if (timestamp < cutoff) {
+      sessionLastBusyAt.delete(sessionID);
     }
   }
 }, 5 * 60 * 1000);
@@ -4142,13 +4143,9 @@ function getNotificationTitle(config, projectName) {
   }
   return "OpenCode";
 }
-async function handleEvent(config, eventType, projectName, elapsedSeconds, sessionTitle) {
+async function handleEvent(config, eventType, projectName, elapsedSeconds) {
   const promises = [];
-  const rawMessage = getMessage(config, eventType);
-  const message = interpolateMessage(rawMessage, {
-    sessionTitle: config.showSessionTitle ? sessionTitle : null,
-    projectName
-  });
+  const message = getMessage(config, eventType);
   if (isEventNotificationEnabled(config, eventType)) {
     const title = getNotificationTitle(config, projectName);
     const iconPath = getIconPath(config);
@@ -4156,13 +4153,12 @@ async function handleEvent(config, eventType, projectName, elapsedSeconds, sessi
   }
   if (isEventSoundEnabled(config, eventType)) {
     const customSoundPath = getSoundPath(config, eventType);
-    const soundVolume = getSoundVolume(config, eventType);
-    promises.push(playSound(eventType, customSoundPath, soundVolume));
+    promises.push(playSound(eventType, customSoundPath, 1));
   }
   const minDuration = config.command?.minDuration;
   const shouldSkipCommand = typeof minDuration === "number" && Number.isFinite(minDuration) && minDuration > 0 && typeof elapsedSeconds === "number" && Number.isFinite(elapsedSeconds) && elapsedSeconds < minDuration;
   if (!shouldSkipCommand) {
-    runCommand2(config, eventType, message, sessionTitle, projectName);
+    runCommand2(config, eventType, message);
   }
   await Promise.allSettled(promises);
 }
@@ -4173,6 +4169,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 } });
@@ -4192,33 +4232,55 @@ async function getElapsedSinceLastPrompt(client, sessionID, nowMs = Date.now())
   } catch {}
   return null;
 }
-async function getSessionInfo(client, sessionID) {
+async function isChildSession(client, sessionID) {
   try {
     const response = await client.session.get({ path: { id: sessionID } });
-    return {
-      isChild: !!response.data?.parentID,
-      title: response.data?.title ?? null
-    };
+    const parentID = response.data?.parentID;
+    return !!parentID;
   } catch {
-    return { isChild: false, title: null };
+    return false;
+  }
+}
+async function processSessionIdle(client, config, projectName, event, sessionID, sequence, idleReceivedAtMs) {
+  if (!hasCurrentSessionIdleSequence(sessionID, sequence)) {
+    return;
   }
+  if (shouldSuppressSessionIdle(sessionID)) {
+    return;
+  }
+  const isChild = await isChildSession(client, sessionID);
+  if (!hasCurrentSessionIdleSequence(sessionID, sequence)) {
+    return;
+  }
+  if (!isChild) {
+    await handleEventWithElapsedTime(client, config, "complete", projectName, event, idleReceivedAtMs);
+    return;
+  }
+  await handleEventWithElapsedTime(client, config, "subagent_complete", projectName, event, idleReceivedAtMs);
+}
+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, preloadedSessionTitle) {
-  const sessionID = getSessionIDFromEvent(event);
+async function handleEventWithElapsedTime(client, config, eventType, projectName, event, elapsedReferenceNowMs) {
+  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) {
+    const sessionID = getSessionIDFromEvent(event);
+    if (sessionID) {
+      elapsedSeconds = await getElapsedSinceLastPrompt(client, sessionID, elapsedReferenceNowMs);
     }
   }
-  await handleEvent(config, eventType, projectName, elapsedSeconds, sessionTitle);
+  await handleEvent(config, eventType, projectName, elapsedSeconds);
 }
 var NotifierPlugin = async ({ client, directory }) => {
   const config = loadConfig();
@@ -4234,42 +4296,17 @@ 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(getSessionIDFromEvent(event));
+        await handleEventWithElapsedTime(client, config, "error", projectName, event);
       }
     },
     "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.2",
   "description": "OpenCode plugin that sends system notifications and plays sounds when permission is needed, generation completes, or errors occur",
   "author": "mohak34",
   "license": "MIT",