kimaki 0.4.78 → 0.4.80

package/dist/opencode-interrupt-plugin.js

@@ -2,6 +2,12 @@
 // step boundary, with a hard timeout as fallback.
 // Tracks only whether each user message has started processing by
 // correlating assistant message parentID events.
+//
+// State design: all mutable state (pending messages, recovery locks, event
+// waiters, latest assistant IDs) is encapsulated in a closure-based factory
+// (createInterruptState). The plugin hooks only interact with the returned
+// API — they cannot directly touch Maps/Sets or break invariants like
+// forgetting to clear a timer.
 const DEFAULT_INTERRUPT_STEP_TIMEOUT_MS = 3_000;
 function getInterruptStepTimeoutMsFromEnv() {
     const raw = process.env['KIMAKI_INTERRUPT_STEP_TIMEOUT_MS'];
@@ -14,16 +20,17 @@ function getInterruptStepTimeoutMsFromEnv() {
     }
     return parsed;
 }
-// Interrupt a session when a queued user message has not started yet.
-// "Started" is detected when an assistant message.updated has parentID equal to
-// the queued user message ID.
-const interruptOpencodeSessionOnUserMessage = async (ctx) => {
-    const interruptStepTimeoutMs = getInterruptStepTimeoutMsFromEnv();
+// ── Encapsulated interrupt state ─────────────────────────────────
+// All 4 mutable variables (pendingByMessageId, latestAssistantMessageID,
+// recoveringSessions, waiters) are trapped inside this closure. The plugin
+// hooks only see the returned API methods — they cannot break invariants
+// like forgetting to clear a timer or leaving a stale recovery lock.
+function createInterruptState() {
     const pendingByMessageId = new Map();
     const latestAssistantMessageIDBySession = new Map();
     const recoveringSessions = new Set();
     const waiters = new Set();
-    function clearPendingByMessageId({ messageID }) {
+    function clearPending(messageID) {
         const pending = pendingByMessageId.get(messageID);
         if (!pending) {
             return;
@@ -31,6 +38,14 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
         clearTimeout(pending.timer);
         pendingByMessageId.delete(messageID);
     }
+    function dispatchEvent(event) {
+        Array.from(waiters).forEach((waiter) => {
+            if (!waiter.match(event)) {
+                return;
+            }
+            waiter.finish();
+        });
+    }
     function waitForEvent(input) {
         return new Promise((resolve) => {
             const finish = (matched) => {
@@ -50,32 +65,7 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
             waiters.add(waiter);
         });
     }
-    function scheduleTimeout({ messageID, sessionID, delayMs, }) {
-        const existing = pendingByMessageId.get(messageID);
-        if (existing) {
-            clearTimeout(existing.timer);
-        }
-        const timer = setTimeout(() => {
-            void interruptPendingMessage({ messageID });
-        }, delayMs);
-        pendingByMessageId.set(messageID, {
-            sessionID,
-            started: false,
-            timer,
-            abortAfterStepMessageID: latestAssistantMessageIDBySession.get(sessionID),
-            agent: undefined,
-            model: undefined,
-        });
-    }
-    function markStarted({ messageID }) {
-        const pending = pendingByMessageId.get(messageID);
-        if (!pending) {
-            return;
-        }
-        pending.started = true;
-        clearPendingByMessageId({ messageID });
-    }
-    function getNextPendingMessage({ sessionID }) {
+    function getNextPendingForSession(sessionID) {
         for (const [messageID, pending] of pendingByMessageId.entries()) {
             if (pending.sessionID !== sessionID) {
                 continue;
@@ -87,24 +77,98 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
         }
         return undefined;
     }
-    async function interruptPendingMessage({ messageID }) {
-        const pending = pendingByMessageId.get(messageID);
+    return {
+        dispatchEvent,
+        waitForEvent,
+        getNextPendingForSession,
+        hasPending(messageID) {
+            return pendingByMessageId.has(messageID);
+        },
+        getPending(messageID) {
+            return pendingByMessageId.get(messageID);
+        },
+        // Schedule a timeout to interrupt a pending message. Cleans up any
+        // existing timer for the same messageID before setting a new one.
+        schedulePending({ messageID, sessionID, delayMs, onTimeout, }) {
+            const existing = pendingByMessageId.get(messageID);
+            if (existing) {
+                clearTimeout(existing.timer);
+            }
+            const timer = setTimeout(onTimeout, delayMs);
+            pendingByMessageId.set(messageID, {
+                sessionID,
+                started: false,
+                timer,
+                abortAfterStepMessageID: latestAssistantMessageIDBySession.get(sessionID),
+                agent: undefined,
+                model: undefined,
+            });
+        },
+        markStarted(messageID) {
+            const pending = pendingByMessageId.get(messageID);
+            if (!pending) {
+                return;
+            }
+            pending.started = true;
+            clearPending(messageID);
+        },
+        clearPending,
+        isRecovering(sessionID) {
+            return recoveringSessions.has(sessionID);
+        },
+        setRecovering(sessionID) {
+            recoveringSessions.add(sessionID);
+        },
+        clearRecovering(sessionID) {
+            recoveringSessions.delete(sessionID);
+        },
+        setLatestAssistantMessage(sessionID, messageID) {
+            latestAssistantMessageIDBySession.set(sessionID, messageID);
+        },
+        clearLatestAssistantMessage(sessionID) {
+            latestAssistantMessageIDBySession.delete(sessionID);
+        },
+        // Clean up all state for a deleted session — timers, recovery locks, etc.
+        cleanupSession(sessionID) {
+            latestAssistantMessageIDBySession.delete(sessionID);
+            Array.from(pendingByMessageId.entries()).forEach(([messageID, pending]) => {
+                if (pending.sessionID !== sessionID) {
+                    return;
+                }
+                clearPending(messageID);
+            });
+        },
+    };
+}
+// ── Plugin ───────────────────────────────────────────────────────
+const interruptOpencodeSessionOnUserMessage = async (ctx) => {
+    const interruptStepTimeoutMs = getInterruptStepTimeoutMsFromEnv();
+    const state = createInterruptState();
+    async function interruptPendingMessage(messageID) {
+        const pending = state.getPending(messageID);
         if (!pending) {
-            clearPendingByMessageId({ messageID });
+            state.clearPending(messageID);
             return;
         }
         if (pending.started) {
-            clearPendingByMessageId({ messageID });
+            state.clearPending(messageID);
             return;
         }
         const sessionID = pending.sessionID;
-        if (recoveringSessions.has(sessionID)) {
-            scheduleTimeout({ messageID, sessionID, delayMs: 200 });
+        if (state.isRecovering(sessionID)) {
+            state.schedulePending({
+                messageID,
+                sessionID,
+                delayMs: 200,
+                onTimeout: () => {
+                    void interruptPendingMessage(messageID);
+                },
+            });
             return;
         }
-        recoveringSessions.add(sessionID);
+        state.setRecovering(sessionID);
         try {
-            const abortedAssistantWait = waitForEvent({
+            const abortedAssistantWait = state.waitForEvent({
                 match: (event) => {
                     return (event.type === 'message.updated'
                         && event.properties.info.role === 'assistant'
@@ -113,7 +177,7 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
                 },
                 timeoutMs: 5_000,
             });
-            const idleWait = waitForEvent({
+            const idleWait = state.waitForEvent({
                 match: (event) => {
                     return event.type === 'session.idle' && event.properties.sessionID === sessionID;
                 },
@@ -124,9 +188,9 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
             });
             await abortedAssistantWait;
             await idleWait;
-            const currentPending = pendingByMessageId.get(messageID);
+            const currentPending = state.getPending(messageID);
             if (!currentPending || currentPending.started) {
-                clearPendingByMessageId({ messageID });
+                state.clearPending(messageID);
                 return;
             }
             // Keep the queued user message execution context across abort+resume.
@@ -143,33 +207,33 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
                 path: { id: sessionID },
                 body: resumeBody,
             });
-            clearPendingByMessageId({ messageID });
-            const nextPending = getNextPendingMessage({ sessionID });
+            state.clearPending(messageID);
+            const nextPending = state.getNextPendingForSession(sessionID);
             if (!nextPending) {
                 return;
             }
-            scheduleTimeout({ messageID: nextPending.messageID, sessionID, delayMs: 50 });
+            state.schedulePending({
+                messageID: nextPending.messageID,
+                sessionID,
+                delayMs: 50,
+                onTimeout: () => {
+                    void interruptPendingMessage(nextPending.messageID);
+                },
+            });
         }
         finally {
-            recoveringSessions.delete(sessionID);
+            state.clearRecovering(sessionID);
         }
     }
     return {
         async event({ event }) {
-            Array.from(waiters).forEach((waiter) => {
-                if (!waiter.match(event)) {
-                    return;
-                }
-                waiter.finish();
-            });
+            state.dispatchEvent(event);
             if (event.type === 'message.part.updated' && event.properties.part.type === 'step-finish') {
-                const nextPending = getNextPendingMessage({
-                    sessionID: event.properties.part.sessionID,
-                });
+                const nextPending = state.getNextPendingForSession(event.properties.part.sessionID);
                 if (!nextPending) {
                     return;
                 }
-                if (recoveringSessions.has(nextPending.pending.sessionID)) {
+                if (state.isRecovering(nextPending.pending.sessionID)) {
                     return;
                 }
                 if (!nextPending.pending.abortAfterStepMessageID) {
@@ -178,16 +242,14 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
                 if (event.properties.part.messageID !== nextPending.pending.abortAfterStepMessageID) {
                     return;
                 }
-                void interruptPendingMessage({ messageID: nextPending.messageID });
+                void interruptPendingMessage(nextPending.messageID);
                 return;
             }
             if (event.type === 'message.updated' && event.properties.info.role === 'assistant') {
                 if (!event.properties.info.error) {
-                    latestAssistantMessageIDBySession.set(event.properties.info.sessionID, event.properties.info.id);
+                    state.setLatestAssistantMessage(event.properties.info.sessionID, event.properties.info.id);
                 }
-                const nextPending = getNextPendingMessage({
-                    sessionID: event.properties.info.sessionID,
-                });
+                const nextPending = state.getNextPendingForSession(event.properties.info.sessionID);
                 if (nextPending
                     && !nextPending.pending.started
                     && !event.properties.info.error
@@ -195,22 +257,15 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
                     nextPending.pending.abortAfterStepMessageID = event.properties.info.id;
                 }
                 const parentID = event.properties.info.parentID;
-                markStarted({ messageID: parentID });
+                state.markStarted(parentID);
                 return;
             }
             if (event.type === 'session.idle') {
-                latestAssistantMessageIDBySession.delete(event.properties.sessionID);
+                state.clearLatestAssistantMessage(event.properties.sessionID);
                 return;
             }
             if (event.type === 'session.deleted') {
-                const sessionID = event.properties.info.id;
-                latestAssistantMessageIDBySession.delete(sessionID);
-                Array.from(pendingByMessageId.entries()).forEach(([messageID, pending]) => {
-                    if (pending.sessionID !== sessionID) {
-                        return;
-                    }
-                    clearPendingByMessageId({ messageID });
-                });
+                state.cleanupSession(event.properties.info.id);
             }
         },
         async 'chat.message'(input, output) {
@@ -227,15 +282,18 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
             if (!messageID) {
                 return;
             }
-            if (pendingByMessageId.has(messageID)) {
+            if (state.hasPending(messageID)) {
                 return;
             }
-            scheduleTimeout({
+            state.schedulePending({
                 messageID,
                 sessionID,
                 delayMs: interruptStepTimeoutMs,
+                onTimeout: () => {
+                    void interruptPendingMessage(messageID);
+                },
             });
-            const pending = pendingByMessageId.get(messageID);
+            const pending = state.getPending(messageID);
             if (!pending) {
                 return;
             }