hammoc 1.2.3 → 1.3.0

package/packages/server/dist/handlers/websocket.js

@@ -416,9 +416,17 @@ export function getJoinedSessionIdsByProject(projectSlug) {
 async function completeBufferAndBroadcast(sessionId, projectSlug, stream) {
     const aborted = stream?.abortController.signal.aborted ?? false;
     const usage = stream?.deferredUsage;
+    // Guard: if a new stream has taken over during async polling, skip emit
+    // to prevent overwriting the newer stream's client state with stale data.
+    const isStreamReplaced = () => stream && activeStreams.has(sessionId) && activeStreams.get(sessionId) !== stream;
     if (projectSlug) {
         try {
             const messages = await pollFileStabilityThenReload(sessionId, projectSlug);
+            if (isStreamReplaced()) {
+                log.info(`completeBufferAndBroadcast: stream replaced during JSONL polling, skipping emit for ${sessionId}`);
+                sessionBufferManager.setStreaming(sessionId, false);
+                return;
+            }
             sessionBufferManager.setStreaming(sessionId, false);
             io.to(`session:${sessionId}`).emit('stream:complete-messages', {
                 sessionId, messages, usage, ...(aborted && { aborted: true }),
@@ -426,6 +434,11 @@ async function completeBufferAndBroadcast(sessionId, projectSlug, stream) {
         }
         catch (err) {
             log.error(`completeBufferAndBroadcast: failed for ${sessionId}:`, err);
+            if (isStreamReplaced()) {
+                log.info(`completeBufferAndBroadcast: stream replaced (error path), skipping emit for ${sessionId}`);
+                sessionBufferManager.setStreaming(sessionId, false);
+                return;
+            }
             sessionBufferManager.setStreaming(sessionId, false);
             const fallback = sessionBufferManager.get(sessionId)?.messages ?? [];
             io.to(`session:${sessionId}`).emit('stream:complete-messages', {
@@ -501,7 +514,7 @@ function cleanupStream(streamKey, expectedStream) {
 }
 /** Normalize legacy 'never' sync policy to 'streaming' */
 function normalizeSyncPolicy(policy) {
-    return policy === 'always' ? 'always' : 'streaming';
+    return policy === 'streaming' ? 'streaming' : 'always';
 }
 /**
  * Persist the stream's final permission mode to .hammoc/session-permissions.json.
@@ -859,33 +872,41 @@ export async function initializeWebSocket(httpServer) {
                     // from disk and broadcast confirmed messages to all session viewers.
                     const sendEndSlug = sessionProjectMap.get(endedSessionId) ?? null;
                     await completeBufferAndBroadcast(endedSessionId, sendEndSlug, stream);
-                    cleanupStream(endedSessionId);
-                    emitStreamChange(endedSessionId, false, sendEndSlug);
-                    // Persist per-session permission mode before cleanup
-                    const sendFinalMode = stream.chatService?.getPermissionMode();
-                    if (sendFinalMode)
-                        await persistSessionPermissionMode(endedSessionId, sendFinalMode);
-                    // Story 20.1: Trigger dashboard status change on stream end
-                    const endProjectSlug = sessionProjectMap.get(endedSessionId);
-                    if (endProjectSlug) {
-                        // Update sessions-index.json so future list queries hit cache
-                        new SessionService().updateSessionIndex(endProjectSlug, endedSessionId).catch((err) => {
-                            log.warn(`Failed to update session index: project=${endProjectSlug} session=${endedSessionId}`, err);
-                        });
-                        triggerDashboardStatusChange(endProjectSlug);
-                        sessionProjectMap.delete(endedSessionId);
-                    }
-                    // Story 24.1: Schedule chain drain if pending items exist (browser-independent)
-                    const pendingChain = chainState.get(endedSessionId);
-                    const pendingCount = pendingChain?.filter(item => item.status === 'pending').length ?? 0;
-                    log.info(`[CHAIN-DRAIN] chat:send finally: chainItems=${pendingChain?.length ?? 0}, pendingCount=${pendingCount}, statuses=${JSON.stringify(pendingChain?.map(i => ({ id: i.id.slice(0, 8), status: i.status })) ?? [])}`);
-                    if (pendingChain && pendingChain.some(item => item.status === 'pending')) {
-                        scheduleChainDrain(endedSessionId, lang);
+                    // Re-check after async operation — a new chat:send may have replaced
+                    // this stream during JSONL polling, taking over activeStreams/socketToSession.
+                    // Cleaning up or emitting inactive would corrupt the replacement stream.
+                    if (activeStreams.get(endedSessionId) !== stream && activeStreams.has(endedSessionId)) {
+                        log.info(`chat:send finally: stream replaced after completeBufferAndBroadcast for ${endedSessionId}, skipping cleanup`);
                     }
                     else {
-                        log.info(`[CHAIN-DRAIN] chat:send finally: no pending chain items, calling cleanupChainIfIdle for ${endedSessionId}`);
-                        cleanupChainIfIdle(endedSessionId);
-                    }
+                        cleanupStream(endedSessionId, stream);
+                        emitStreamChange(endedSessionId, false, sendEndSlug);
+                        // Persist per-session permission mode before cleanup
+                        const sendFinalMode = stream.chatService?.getPermissionMode();
+                        if (sendFinalMode)
+                            await persistSessionPermissionMode(endedSessionId, sendFinalMode);
+                        // Story 20.1: Trigger dashboard status change on stream end
+                        const endProjectSlug = sessionProjectMap.get(endedSessionId);
+                        if (endProjectSlug) {
+                            // Update sessions-index.json so future list queries hit cache
+                            new SessionService().updateSessionIndex(endProjectSlug, endedSessionId).catch((err) => {
+                                log.warn(`Failed to update session index: project=${endProjectSlug} session=${endedSessionId}`, err);
+                            });
+                            triggerDashboardStatusChange(endProjectSlug);
+                            sessionProjectMap.delete(endedSessionId);
+                        }
+                        // Story 24.1: Schedule chain drain if pending items exist (browser-independent)
+                        const pendingChain = chainState.get(endedSessionId);
+                        const pendingCount = pendingChain?.filter(item => item.status === 'pending').length ?? 0;
+                        log.info(`[CHAIN-DRAIN] chat:send finally: chainItems=${pendingChain?.length ?? 0}, pendingCount=${pendingCount}, statuses=${JSON.stringify(pendingChain?.map(i => ({ id: i.id.slice(0, 8), status: i.status })) ?? [])}`);
+                        if (pendingChain && pendingChain.some(item => item.status === 'pending')) {
+                            scheduleChainDrain(endedSessionId, lang);
+                        }
+                        else {
+                            log.info(`[CHAIN-DRAIN] chat:send finally: no pending chain items, calling cleanupChainIfIdle for ${endedSessionId}`);
+                            cleanupChainIfIdle(endedSessionId);
+                        }
+                    } // end re-check else (stream not replaced after await)
                 }
                 else {
                     log.warn(`[CHAIN-DRAIN] chat:send finally: stream is NOT current active stream (replaced?): endedSessionId=${endedSessionId}`);
@@ -989,7 +1010,7 @@ export async function initializeWebSocket(httpServer) {
             // Use projectSlug from client as fallback when sessionProjectMap entry is gone (stream ended)
             await persistSessionPermissionMode(sessionId, mode, projectSlug);
             // 3) Broadcast to other viewers based on sync policy
-            let syncPolicy = 'streaming';
+            let syncPolicy = 'always';
             try {
                 const prefs = await preferencesService.readPreferences();
                 syncPolicy = normalizeSyncPolicy(prefs.permissionSyncPolicy);
@@ -1159,7 +1180,7 @@ export async function initializeWebSocket(httpServer) {
             const permissionMode = stream.chatService?.getPermissionMode();
             // Story 27.1: Deliver buffer messages (history + streaming data accumulated so far)
             // so a new browser joining mid-stream sees the full context immediately.
-            let buf = sessionBufferManager.get(sessionId);
+            const buf = sessionBufferManager.get(sessionId);
             // Buffer may have been destroyed if all sockets left briefly — recover from JSONL
             if (!buf) {
                 const slug = sessionProjectMap.get(sessionId);
@@ -1415,7 +1436,7 @@ export async function initializeWebSocket(httpServer) {
             log.info(`session:rewind-files sessionId=${sessionId}, messageUuid=${messageUuid}, dryRun=${!!dryRun}`);
             try {
                 const sessionService = new SessionService();
-                const projectSlug = sessionService.encodeProjectPath(workingDirectory);
+                const _projectSlug = sessionService.encodeProjectPath(workingDirectory);
                 const rewindQuery = sdkQuery({
                     prompt: '',
                     options: {
@@ -1448,8 +1469,16 @@ export async function initializeWebSocket(httpServer) {
                     }
                 }
                 finally {
+                    // Mark session as dirty BEFORE close — SDK query({ prompt: '' })
+                    // writes an empty user message to the JSONL which causes
+                    // cache_control 400 errors. chatService will clean the JSONL
+                    // before the next resume.
+                    sessionService.markRewindDirty(workingDirectory, sessionId);
                     // Clean up the query object
-                    rewindQuery.close();
+                    try {
+                        rewindQuery.close();
+                    }
+                    catch { /* best-effort */ }
                 }
             }
             catch (err) {
@@ -1697,7 +1726,13 @@ export async function initializeWebSocket(httpServer) {
             const qs = getOrCreateQueueService(data.projectSlug);
             const result = parseQueueScript(data.rawLine);
             if (result.items.length > 0) {
-                qs.addItem(result.items[0]);
+                const added = qs.addItem(result.items[0]);
+                if (!added && result.items[0].loop) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    socket.emit('queue:addItemRejected', {
+                        reason: 'Block directives (@loop/@end) cannot be added via addItem',
+                    });
+                }
             }
         });
         socket.on('queue:reorderItems', (data) => {
@@ -2082,7 +2117,7 @@ async function handleChatSend(stream, data, abortController, lang) {
     // Root-level edit branching is not supported — the SDK's --resume-session-at
     // only accepts assistant message UUIDs, and there is no assistant before the
     // first user message. The client should not send ROOT_BRANCH_KEY; reject if received.
-    let resumeSessionAt = rawResumeSessionAt;
+    const resumeSessionAt = rawResumeSessionAt;
     if (resumeSessionAt === ROOT_BRANCH_KEY) {
         emit('error', {
             code: ERROR_CODES.VALIDATION_ERROR,
@@ -2287,7 +2322,7 @@ async function handleChatSend(stream, data, abortController, lang) {
         };
         // Defer completion until JSONL is flushed — keeps client in streaming state.
         // Usage data is stored and included in stream:complete-messages.
-        const baseOnComplete = callbacks.onComplete;
+        const _baseOnComplete = callbacks.onComplete;
         callbacks.onComplete = (response) => {
             if (response.usage) {
                 stream.deferredUsage = response.usage;
@@ -2385,18 +2420,41 @@ async function handleChatSend(stream, data, abortController, lang) {
                 origOnComplete?.(gatedComplete);
         }
         catch (sendError) {
-            // Resume failed — retry once without resume so SDK creates a fresh session.
-            // Guards:
-            //  1. Only when resuming (not a fresh session send)
-            //  2. Skip if intentionally aborted (user-abort / another-client / timeout)
-            //  3. Skip if SDK already emitted output (onSessionInit fired) — retrying would duplicate side-effects
-            //  4. Skip for non-session errors (rate-limit / auth / network / service-unavailable)
             const parsedError = parseSDKError(sendError, lang);
-            const isNonSessionError = !!parsedError.code && parsedError.code !== SDKErrorCode.UNKNOWN;
+            // Context overflow during resume — auto-compact then retry the original message.
+            // /compact is a CLI-level command processed before context evaluation,
+            // so it works even when context is overflowing.
             if (isResumeAttempt
+                && parsedError.code === SDKErrorCode.CONTEXT_OVERFLOW
+                && !abortController.signal.aborted
+                && !hasEmittedOutput) {
+                log.info(`[AUTO-COMPACT] context overflow on resume, running /compact: sessionId=${sessionId}`);
+                emit('system:info', { message: 'Context limit reached — auto-compacting…' });
+                gatedResultError = null;
+                gatedComplete = null;
+                ungateCallbacks();
+                resetTimeout('auto-compact');
+                // Run /compact to shrink context (preserves session file)
+                await chatService.sendMessageWithCallbacks('/compact', callbacks, chatOptions, canUseTool, (messageType) => {
+                    resetTimeout(`compact:${messageType}`);
+                });
+                // Retry the original message after compaction
+                log.info(`[AUTO-COMPACT] compaction done, retrying original message: sessionId=${sessionId}`);
+                resetTimeout('auto-compact-retry');
+                await chatService.sendMessageWithCallbacks(content, callbacks, chatOptions, canUseTool, (messageType) => {
+                    resetTimeout(`retry:${messageType}`);
+                });
+                // Resume failed for other unknown reasons — retry without resume (fresh session).
+                // Guards:
+                //  1. Only when resuming (not a fresh session send)
+                //  2. Skip if intentionally aborted (user-abort / another-client / timeout)
+                //  3. Skip if SDK already emitted output (onSessionInit fired) — retrying would duplicate side-effects
+                //  4. Skip for non-session errors (rate-limit / auth / network / service-unavailable)
+            }
+            else if (isResumeAttempt
                 && !abortController.signal.aborted
                 && !hasEmittedOutput
-                && !isNonSessionError
+                && parsedError.code === SDKErrorCode.UNKNOWN
                 && !chatOptions.resumeSessionAt) {
                 log.info(`[RESUME-RETRY] resume failed, retrying without resume: sessionId=${sessionId}, error=${parsedError.message.slice(0, 120)}`);
                 // Discard gated events and restore original callbacks for the retry