fix(opencode-plugin): recover stale commit state (#1187)

Author: 13ernkastel

examples/opencode-memory-plugin/openviking-memory.ts

@@ -611,6 +611,31 @@ function upsertBufferedMessage(
   sessionMessageBuffer.set(sessionId, freshBuffer)
 }
 
+function cleanupOrphanedMessageBuffers(now: number): void {
+  for (const [sessionId, buffer] of sessionMessageBuffer.entries()) {
+    if (sessionMap.has(sessionId)) {
+      continue
+    }
+
+    const oldestMessage = buffer[0]
+    if (!oldestMessage) {
+      sessionMessageBuffer.delete(sessionId)
+      continue
+    }
+
+    if (now - oldestMessage.timestamp <= BUFFERED_MESSAGE_TTL_MS * 2) {
+      continue
+    }
+
+    log("INFO", "buffer", "Cleaning up orphaned message buffer", {
+      session_id: sessionId,
+      buffer_age_ms: now - oldestMessage.timestamp,
+      message_count: buffer.length,
+    })
+    sessionMessageBuffer.delete(sessionId)
+  }
+}
+
 function getAutoCommitIntervalMinutes(config: OpenVikingConfig): number {
   const configured = Number(config.autoCommit?.intervalMinutes ?? DEFAULT_CONFIG.autoCommit?.intervalMinutes ?? 10)
   if (!Number.isFinite(configured)) {
@@ -730,6 +755,15 @@ function clearCommitState(mapping: SessionMapping): void {
   mapping.commitStartedAt = undefined
 }
 
+function isMissingCommitTaskError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false
+  }
+
+  const message = error.message.toLowerCase()
+  return message.includes("resource not found") || message.includes("not found")
+}
+
 let backgroundCommitSupported: boolean | null = null
 const COMMIT_TIMEOUT_MS = 180000
 
@@ -988,7 +1022,19 @@ async function pollCommitTaskOnce(
   }
 
   if (!mapping.commitTaskId) {
-    return "running"
+    const recoveredTaskId = await findRunningCommitTaskId(mapping.ovSessionId, config)
+    if (!recoveredTaskId) {
+      log("INFO", "session", "Clearing stale in-flight commit without task id", {
+        openviking_session: mapping.ovSessionId,
+        opencode_session: opencodeSessionId,
+      })
+      clearCommitState(mapping)
+      debouncedSaveSessionMap()
+      return "unknown"
+    }
+
+    mapping.commitTaskId = recoveredTaskId
+    debouncedSaveSessionMap()
   }
 
   try {
@@ -1041,12 +1087,23 @@ async function pollCommitTaskOnce(
     }
 
     return task.status
-  } catch (error: any) {
+  } catch (error: unknown) {
+    if (isMissingCommitTaskError(error)) {
+      log("INFO", "session", "Commit task disappeared; clearing stale state", {
+        openviking_session: mapping.ovSessionId,
+        opencode_session: opencodeSessionId,
+        task_id: mapping.commitTaskId,
+      })
+      clearCommitState(mapping)
+      debouncedSaveSessionMap()
+      return "unknown"
+    }
+
     log("ERROR", "session", "Failed to poll OpenViking background commit", {
       openviking_session: mapping.ovSessionId,
       opencode_session: opencodeSessionId,
       task_id: mapping.commitTaskId,
-      error: error.message,
+      error: error instanceof Error ? error.message : String(error),
     })
     return "unknown"
   }
@@ -1070,41 +1127,63 @@ async function waitForCommitCompletion(
       return null
     }
     if (!mapping.commitTaskId) {
-      await sleep(500, abortSignal)
-      continue
+      const recoveredTaskId = await findRunningCommitTaskId(mapping.ovSessionId, config)
+      if (!recoveredTaskId) {
+        clearCommitState(mapping)
+        debouncedSaveSessionMap()
+        return null
+      }
+
+      mapping.commitTaskId = recoveredTaskId
+      debouncedSaveSessionMap()
     }
 
-    const response = await makeRequest<OpenVikingResponse<TaskResult>>(config, {
-      method: "GET",
-      endpoint: `/api/v1/tasks/${mapping.commitTaskId}`,
-      timeoutMs: 5000,
-      abortSignal,
-    })
-    const task = unwrapResponse(response)
+    try {
+      const response = await makeRequest<OpenVikingResponse<TaskResult>>(config, {
+        method: "GET",
+        endpoint: `/api/v1/tasks/${mapping.commitTaskId}`,
+        timeoutMs: 5000,
+        abortSignal,
+      })
+      const task = unwrapResponse(response)
 
-    if (task.status === "completed") {
-      const memoriesExtracted = totalMemoriesFromResult(task.result)
-      const archived = task.result?.archived ?? false
+      if (task.status === "completed") {
+        const memoriesExtracted = totalMemoriesFromResult(task.result)
+        const archived = task.result?.archived ?? false
 
-      await finalizeCommitSuccess(mapping, opencodeSessionId, config)
+        await finalizeCommitSuccess(mapping, opencodeSessionId, config)
 
-      log("INFO", "memcommit", "Background commit completed while waiting", {
-        openviking_session: mapping.ovSessionId,
-        opencode_session: opencodeSessionId,
-        task_id: task.task_id,
-        memories_extracted: memoriesExtracted,
-        archived,
-      })
-      return task
-    }
+        log("INFO", "memcommit", "Background commit completed while waiting", {
+          openviking_session: mapping.ovSessionId,
+          opencode_session: opencodeSessionId,
+          task_id: task.task_id,
+          memories_extracted: memoriesExtracted,
+          archived,
+        })
+        return task
+      }
 
-    if (task.status === "failed") {
-      clearCommitState(mapping)
-      debouncedSaveSessionMap()
-      throw new Error(task.error || "Background commit failed")
-    }
+      if (task.status === "failed") {
+        clearCommitState(mapping)
+        debouncedSaveSessionMap()
+        throw new Error(task.error || "Background commit failed")
+      }
+
+      await sleep(2000, abortSignal)
+    } catch (error: unknown) {
+      if (isMissingCommitTaskError(error)) {
+        log("INFO", "session", "Commit task disappeared while waiting; clearing stale state", {
+          openviking_session: mapping.ovSessionId,
+          opencode_session: opencodeSessionId,
+          task_id: mapping.commitTaskId,
+        })
+        clearCommitState(mapping)
+        debouncedSaveSessionMap()
+        return null
+      }
 
-    await sleep(2000, abortSignal)
+      throw error
+    }
   }
 
   return null
@@ -1117,6 +1196,11 @@ async function waitForCommitCompletion(
 let autoCommitTimer: NodeJS.Timeout | null = null
 
 function startAutoCommit(config: OpenVikingConfig) {
+  if (autoCommitTimer) {
+    log("INFO", "auto-commit", "Auto-commit scheduler already running")
+    return
+  }
+
   if (!config.autoCommit?.enabled) {
     log("INFO", "auto-commit", "Auto-commit disabled in config")
     return
@@ -1146,6 +1230,8 @@ async function checkAndCommitSessions(config: OpenVikingConfig): Promise<void> {
   const intervalMs = getAutoCommitIntervalMinutes(config) * 60 * 1000
   const now = Date.now()
 
+  cleanupOrphanedMessageBuffers(now)
+
   for (const [opencodeSessionId, mapping] of sessionMap.entries()) {
     if (mapping.commitInFlight) {
       await pollCommitTaskOnce(mapping, opencodeSessionId, config)