opencode-auto-resume 1.1.5 → 1.1.6

package/README.md

@@ -265,11 +265,7 @@ Periodic: cleanup idle sessions older than 10min or >50 entries
 
 ## Installation
 
-### Via npm (recommended)
-
-```bash
-npm install opencode-auto-resume
-```
+### Opencode
 
 Add to your `opencode.jsonc`:
 
@@ -294,17 +290,6 @@ With options:
 }
 ```
 
-### Via GitHub (manual clone)
-
-OpenCode may clone the repository to `~/.config/opencode/plugins/opencode-auto-resume/` automatically.
-
-**To update** the plugin:
-```bash
-cd ~/.config/opencode/plugins/opencode-auto-resume
-git pull
-bun run build
-```
-
 ## Configuration
 
 ```json

package/dist/index.js

@@ -12593,7 +12593,21 @@ var AutoResumePlugin = async (ctx, options) => {
   async function log(level, msg) {
     try {
       await ctx.client.app.log({ body: { service: "auto-resume", level, message: msg } });
-    } catch {}
+    } catch (e) {
+      console.error("[auto-resume] log() failed:", e instanceof Error ? e.message : String(e));
+    }
+  }
+  async function safe(fn, ctxLabel) {
+    try {
+      return await fn();
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.error(`[auto-resume] ${ctxLabel}: ${msg}`);
+      try {
+        await log("error", `${ctxLabel}: ${msg}`);
+      } catch {}
+      return;
+    }
   }
   function ensureWatch(sid) {
     let w = sessions.get(sid);
@@ -13497,186 +13511,188 @@ var AutoResumePlugin = async (ctx, options) => {
     if (timer)
       return;
     timer = setInterval(async () => {
-      const now = Date.now();
-      const numBusy = busyCount();
-      const statusMap = await getSessionStatusMap();
-      for (const [sid, w] of sessions) {
-        const realStatus = statusMap[sid];
-        if (realStatus && realStatus !== w.status) {
-          w.status = realStatus;
-          if (realStatus === "busy")
-            w.idleSince = null;
-        }
-        if (w.status !== "busy")
-          continue;
-        if (w.userCancelled)
-          continue;
-        if (w.aborting)
-          continue;
-        if (w.orphanWatchStartAt !== null) {
-          const orphanIdle = now - w.orphanWatchStartAt;
-          if (orphanIdle >= subagentWaitMs + gracePeriodMs) {
-            if (w.resumeAttempts < maxRetries) {
-              if (hasInflightTools(w)) {
-                await log("debug", `Parent ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping orphan-watch abort`);
-                w.orphanWatchStartAt = now;
-                continue;
-              }
-              const hasActiveTool = await checkSessionHasActiveTool(sid);
-              if (hasActiveTool) {
-                await log("debug", `Parent ${short(sid)} has active tool call, skipping orphan-watch abort`);
-                w.orphanWatchStartAt = now;
-                continue;
-              }
-              const subStatus = await checkSubagentStatus(sid);
-              if (subStatus.status === "crashed" && subStatus.stuckSid) {
-                const recovered = await recoverSubagent(subStatus.stuckSid);
-                if (recovered) {
-                  await log("info", `Sent recovery prompt to stuck subagent ${short(subStatus.stuckSid)}, waiting...`);
-                } else {
-                  await log("info", `Subagent crashed, triggering abort+resume on ${short(sid)}`);
-                  tryAbortAndResume(sid, w);
+      await safe(async () => {
+        const now = Date.now();
+        const numBusy = busyCount();
+        const statusMap = await getSessionStatusMap();
+        for (const [sid, w] of sessions) {
+          const realStatus = statusMap[sid];
+          if (realStatus && realStatus !== w.status) {
+            w.status = realStatus;
+            if (realStatus === "busy")
+              w.idleSince = null;
+          }
+          if (w.status !== "busy")
+            continue;
+          if (w.userCancelled)
+            continue;
+          if (w.aborting)
+            continue;
+          if (w.orphanWatchStartAt !== null) {
+            const orphanIdle = now - w.orphanWatchStartAt;
+            if (orphanIdle >= subagentWaitMs + gracePeriodMs) {
+              if (w.resumeAttempts < maxRetries) {
+                if (hasInflightTools(w)) {
+                  await log("debug", `Parent ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping orphan-watch abort`);
+                  w.orphanWatchStartAt = now;
+                  continue;
                 }
-              } else if (subStatus.status === "idle") {
-                const hasBusySub = await hasBusySubagents(sid);
-                if (hasBusySub) {
-                  await log("debug", `Subagents exist but not busy yet, waiting for startup...`);
+                const hasActiveTool = await checkSessionHasActiveTool(sid);
+                if (hasActiveTool) {
+                  await log("debug", `Parent ${short(sid)} has active tool call, skipping orphan-watch abort`);
+                  w.orphanWatchStartAt = now;
+                  continue;
+                }
+                const subStatus = await checkSubagentStatus(sid);
+                if (subStatus.status === "crashed" && subStatus.stuckSid) {
+                  const recovered = await recoverSubagent(subStatus.stuckSid);
+                  if (recovered) {
+                    await log("info", `Sent recovery prompt to stuck subagent ${short(subStatus.stuckSid)}, waiting...`);
+                  } else {
+                    await log("info", `Subagent crashed, triggering abort+resume on ${short(sid)}`);
+                    tryAbortAndResume(sid, w);
+                  }
+                } else if (subStatus.status === "idle") {
+                  const hasBusySub = await hasBusySubagents(sid);
+                  if (hasBusySub) {
+                    await log("debug", `Subagents exist but not busy yet, waiting for startup...`);
+                  } else {
+                    await log("info", `Parent ${short(sid)} stuck with no active subagents. Triggering abort+resume.`);
+                    tryAbortAndResume(sid, w);
+                  }
                 } else {
-                  await log("info", `Parent ${short(sid)} stuck with no active subagents. Triggering abort+resume.`);
-                  tryAbortAndResume(sid, w);
+                  await log("debug", `Subagent still running, waiting...`);
                 }
-              } else {
-                await log("debug", `Subagent still running, waiting...`);
+              } else if (!w.gaveUp) {
+                w.gaveUp = true;
+                dbg(`State transition on ${short(sid)}: gaveUp=false -> true`);
+                w.orphanWatchStartAt = null;
+                w.aborting = false;
+                log("warn", `${short(sid)} - orphan retries exhausted.`);
               }
-            } else if (!w.gaveUp) {
-              w.gaveUp = true;
-              dbg(`State transition on ${short(sid)}: gaveUp=false -> true`);
-              w.orphanWatchStartAt = null;
-              w.aborting = false;
-              log("warn", `${short(sid)} - orphan retries exhausted.`);
             }
-          }
-          continue;
-        }
-        if (numBusy > 1)
-          continue;
-        if (now - w.lastSubagentCheckAt < checkIntervalMs * 2)
-          continue;
-        w.lastSubagentCheckAt = now;
-        if (w.lastActivityAt > 0 && now - w.lastActivityAt > subagentWaitMs) {
-          if (realStatus === "busy") {
-            await log("debug", `Session ${short(sid)} is still busy (real status), skipping abort`);
-            w.lastSubagentCheckAt = now;
-            continue;
-          }
-          if (hasInflightTools(w)) {
-            await log("debug", `Session ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping abort check`);
-            w.lastSubagentCheckAt = now;
             continue;
           }
-          const hasActiveTool = await checkSessionHasActiveTool(sid);
-          if (hasActiveTool) {
-            await log("debug", `Session ${short(sid)} has active tool call, skipping abort check`);
-            w.lastSubagentCheckAt = now;
+          if (numBusy > 1)
             continue;
-          }
-          const subStatus = await checkSubagentStatus(sid);
-          if (subStatus.status === "idle" || subStatus.status === "unknown") {
-            await log("info", `Parent ${short(sid)} stuck with no active subagents. Triggering abort+resume.`);
-            tryAbortAndResume(sid, w);
+          if (now - w.lastSubagentCheckAt < checkIntervalMs * 2)
             continue;
-          } else if (subStatus.status === "crashed" && subStatus.stuckSid) {
-            const recovered = await recoverSubagent(subStatus.stuckSid);
-            if (recovered) {
-              await log("info", `Sent recovery prompt to stuck subagent ${short(subStatus.stuckSid)}, waiting...`);
-            } else {
-              await log("info", `Parent ${short(sid)} subagent recovery failed. Triggering abort+resume.`);
-              tryAbortAndResume(sid, w);
+          w.lastSubagentCheckAt = now;
+          if (w.lastActivityAt > 0 && now - w.lastActivityAt > subagentWaitMs) {
+            if (realStatus === "busy") {
+              await log("debug", `Session ${short(sid)} is still busy (real status), skipping abort`);
+              w.lastSubagentCheckAt = now;
+              continue;
+            }
+            if (hasInflightTools(w)) {
+              await log("debug", `Session ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping abort check`);
+              w.lastSubagentCheckAt = now;
+              continue;
             }
-            continue;
-          }
-        }
-        const idle = now - w.lastActivityAt;
-        if (idle >= chunkTimeoutMs + gracePeriodMs) {
-          if (hasInflightTools(w)) {
-            await log("debug", `Session ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping stall recovery`);
-            w.lastSubagentCheckAt = now;
-          } else {
             const hasActiveTool = await checkSessionHasActiveTool(sid);
             if (hasActiveTool) {
-              await log("debug", `Session ${short(sid)} has active tool call, skipping stall recovery`);
+              await log("debug", `Session ${short(sid)} has active tool call, skipping abort check`);
               w.lastSubagentCheckAt = now;
-            } else if (w.resumeAttempts < maxRetries) {
-              tryResume(sid, w, "Stream stall");
-            } else if (!w.gaveUp) {
-              w.gaveUp = true;
-              dbg(`State transition on ${short(sid)}: gaveUp=false -> true`);
-              log("warn", `${short(sid)} - all ${maxRetries} retries exhausted.`);
+              continue;
+            }
+            const subStatus = await checkSubagentStatus(sid);
+            if (subStatus.status === "idle" || subStatus.status === "unknown") {
+              await log("info", `Parent ${short(sid)} stuck with no active subagents. Triggering abort+resume.`);
+              tryAbortAndResume(sid, w);
+              continue;
+            } else if (subStatus.status === "crashed" && subStatus.stuckSid) {
+              const recovered = await recoverSubagent(subStatus.stuckSid);
+              if (recovered) {
+                await log("info", `Sent recovery prompt to stuck subagent ${short(subStatus.stuckSid)}, waiting...`);
+              } else {
+                await log("info", `Parent ${short(sid)} subagent recovery failed. Triggering abort+resume.`);
+                tryAbortAndResume(sid, w);
+              }
+              continue;
+            }
+          }
+          const idle = now - w.lastActivityAt;
+          if (idle >= chunkTimeoutMs + gracePeriodMs) {
+            if (hasInflightTools(w)) {
+              await log("debug", `Session ${short(sid)} has ${w.pendingTools} tool(s) in-flight, skipping stall recovery`);
+              w.lastSubagentCheckAt = now;
+            } else {
+              const hasActiveTool = await checkSessionHasActiveTool(sid);
+              if (hasActiveTool) {
+                await log("debug", `Session ${short(sid)} has active tool call, skipping stall recovery`);
+                w.lastSubagentCheckAt = now;
+              } else if (w.resumeAttempts < maxRetries) {
+                tryResume(sid, w, "Stream stall");
+              } else if (!w.gaveUp) {
+                w.gaveUp = true;
+                dbg(`State transition on ${short(sid)}: gaveUp=false -> true`);
+                log("warn", `${short(sid)} - all ${maxRetries} retries exhausted.`);
+              }
             }
           }
         }
-      }
-      for (const [sid, w] of sessions) {
-        if (w.pendingRecovery && w.status === "idle" && !w.userCancelled && !w.aborting && !w.continuing && !w.gaveUp && w.recoveryAttempts === 0) {
-          dbg(`Pending recovery check on ${short(sid)}: pendingRecovery=${w.pendingRecovery}, status=${w.status}, userCancelled=${w.userCancelled}, aborting=${w.aborting}, continuing=${w.continuing}, gaveUp=${w.gaveUp}, recoveryAttempts=${w.recoveryAttempts}, pendingRecoveryAt=${w.pendingRecoveryAt}`);
-          const elapsed = Date.now() - w.pendingRecoveryAt;
-          const requiredBackoff2 = backoffMs(w.recoveryAttempts, baseBackoffMs, maxBackoffMs);
-          if (elapsed < requiredBackoff2) {
-            dbg(`Backoff check on ${short(sid)}: elapsed=${elapsed}ms, required=${requiredBackoff2}ms, attempt=${w.recoveryAttempts}, pass=false`);
-            dbg(`Pending recovery on ${short(sid)} waiting for backoff: ${requiredBackoff2 - elapsed}ms remaining`);
+        for (const [sid, w] of sessions) {
+          if (w.pendingRecovery && w.status === "idle" && !w.userCancelled && !w.aborting && !w.continuing && !w.gaveUp && w.recoveryAttempts === 0) {
+            dbg(`Pending recovery check on ${short(sid)}: pendingRecovery=${w.pendingRecovery}, status=${w.status}, userCancelled=${w.userCancelled}, aborting=${w.aborting}, continuing=${w.continuing}, gaveUp=${w.gaveUp}, recoveryAttempts=${w.recoveryAttempts}, pendingRecoveryAt=${w.pendingRecoveryAt}`);
+            const elapsed = Date.now() - w.pendingRecoveryAt;
+            const requiredBackoff2 = backoffMs(w.recoveryAttempts, baseBackoffMs, maxBackoffMs);
+            if (elapsed < requiredBackoff2) {
+              dbg(`Backoff check on ${short(sid)}: elapsed=${elapsed}ms, required=${requiredBackoff2}ms, attempt=${w.recoveryAttempts}, pass=false`);
+              dbg(`Pending recovery on ${short(sid)} waiting for backoff: ${requiredBackoff2 - elapsed}ms remaining`);
+              continue;
+            }
+            dbg(`Backoff check on ${short(sid)}: elapsed=${elapsed}ms, required=${requiredBackoff2}ms, attempt=${w.recoveryAttempts}, pass=true`);
+            await log("info", `Pending recovery triggered on ${short(sid)}: reason=${w.pendingRecoveryReason}, attempt=${w.recoveryAttempts + 1}, maxRetries=${maxRecoveryRetries}`);
+            dbg(`Recovery timing on ${short(sid)}: detectionToAttemptMs=${Date.now() - w.pendingRecoveryAt}`);
+            w.recoveryAttempts++;
+            dbg(`State transition on ${short(sid)}: recoveryAttempts=${w.recoveryAttempts - 1} -> ${w.recoveryAttempts}`);
+            try {
+              await sendContinuePrompt(sid, continuePrompt, w);
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              await log("warn", `${short(sid)} - pending recovery failed: ${errMsg}`);
+              w.recoveryAttempts = 0;
+            }
+          }
+          if (w.status !== "idle")
+            continue;
+          if (w.isSubagent)
+            continue;
+          if (w.userCancelled || w.completionSignaled)
+            continue;
+          if (w.continuing)
+            continue;
+          if (busyCount() !== 0)
+            continue;
+          const open = getOpenTodos(w.todos || []);
+          if (open.length === 0)
+            continue;
+          if (w.todoNudgeAttempts >= maxRetries)
+            continue;
+          const elapsedSinceLastNudge = Date.now() - w.lastRetryAt;
+          const requiredBackoff = backoffMs(w.todoNudgeAttempts, baseBackoffMs, maxBackoffMs);
+          if (w.lastRetryAt > 0 && elapsedSinceLastNudge < requiredBackoff)
+            continue;
+          const isCelebration = await lastAssistantEndsWithCelebration(sid);
+          if (isCelebration) {
+            w.toolTextRecovered = true;
+            w.completionSignaled = true;
             continue;
           }
-          dbg(`Backoff check on ${short(sid)}: elapsed=${elapsed}ms, required=${requiredBackoff2}ms, attempt=${w.recoveryAttempts}, pass=true`);
-          await log("info", `Pending recovery triggered on ${short(sid)}: reason=${w.pendingRecoveryReason}, attempt=${w.recoveryAttempts + 1}, maxRetries=${maxRecoveryRetries}`);
-          dbg(`Recovery timing on ${short(sid)}: detectionToAttemptMs=${Date.now() - w.pendingRecoveryAt}`);
-          w.recoveryAttempts++;
-          dbg(`State transition on ${short(sid)}: recoveryAttempts=${w.recoveryAttempts - 1} -> ${w.recoveryAttempts}`);
-          try {
-            await sendContinuePrompt(sid, continuePrompt, w);
-          } catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            await log("warn", `${short(sid)} - pending recovery failed: ${errMsg}`);
-            w.recoveryAttempts = 0;
+          const reminder = buildOpenTodosReminder(w.todos || []);
+          const sent = await tryResume(sid, w, "Idle with open todos (periodic)", reminder);
+          if (sent) {
+            w.todoNudgeAttempts++;
+            await log("info", `${short(sid)} - idle periodic recheck: nudge ${w.todoNudgeAttempts}/${maxRetries}`);
           }
         }
-        if (w.status !== "idle")
-          continue;
-        if (w.isSubagent)
-          continue;
-        if (w.userCancelled || w.completionSignaled)
-          continue;
-        if (w.continuing)
-          continue;
-        if (busyCount() !== 0)
-          continue;
-        const open = getOpenTodos(w.todos || []);
-        if (open.length === 0)
-          continue;
-        if (w.todoNudgeAttempts >= maxRetries)
-          continue;
-        const elapsedSinceLastNudge = Date.now() - w.lastRetryAt;
-        const requiredBackoff = backoffMs(w.todoNudgeAttempts, baseBackoffMs, maxBackoffMs);
-        if (w.lastRetryAt > 0 && elapsedSinceLastNudge < requiredBackoff)
-          continue;
-        const isCelebration = await lastAssistantEndsWithCelebration(sid);
-        if (isCelebration) {
-          w.toolTextRecovered = true;
-          w.completionSignaled = true;
-          continue;
-        }
-        const reminder = buildOpenTodosReminder(w.todos || []);
-        const sent = await tryResume(sid, w, "Idle with open todos (periodic)", reminder);
-        if (sent) {
-          w.todoNudgeAttempts++;
-          await log("info", `${short(sid)} - idle periodic recheck: nudge ${w.todoNudgeAttempts}/${maxRetries}`);
-        }
-      }
-      cleanupIdleSessions();
+        cleanupIdleSessions();
+      }, "periodic timer");
     }, checkIntervalMs);
     if (timer.unref)
       timer.unref();
     discoveryTimer = setInterval(() => {
-      discoverSessions();
+      safe(discoverSessions, "discoveryTimer").catch(() => {});
     }, SESSION_DISCOVERY_INTERVAL_MS);
     if (discoveryTimer.unref)
       discoveryTimer.unref();
@@ -13997,7 +14013,11 @@ var AutoResumePlugin = async (ctx, options) => {
         initialised = true;
         log("info", `opencode-auto-resume ready. timeout=${chunkTimeoutMs}ms, orphan=${subagentWaitMs}ms, loop=${loopMaxContinues}x/${loopWindowMs / 1000}s`);
       }
-      handleEvent(event);
+      handleEvent(event).catch((e) => {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`[auto-resume] handleEvent error: ${msg}`);
+        log("error", `handleEvent error: ${msg}`).catch(() => {});
+      });
     },
     config: async () => {
       log("info", `opencode-auto-resume config OK`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-auto-resume",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "OpenCode plugin that automatically resumes stalled LLM sessions when thinking/streaming freezes mid-generation.",
   "keywords": [
     "opencode",