hammoc 1.3.0 → 1.5.0

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

@@ -21,11 +21,13 @@ import { notificationService, formatAskQuestionPrompt } from '../services/notifi
 import { preferencesService } from '../services/preferencesService.js';
 import { getOrCreateQueueService, getQueueInstances } from '../controllers/queueController.js';
 import { createLogger } from '../utils/logger.js';
+import { clampEffortForModel, supportsAdaptiveThinking } from '../utils/effortUtils.js';
 import { buildStreamCallbacks } from './streamCallbacks.js';
 import { rateLimitProbeService } from '../services/rateLimitProbeService.js';
 import { ptyService } from '../services/ptyService.js';
 import { projectService } from '../services/projectService.js';
 import { dashboardService } from '../services/dashboardService.js';
+import { fileWatcherService } from '../services/fileWatcherService.js';
 import { summarize } from '../services/summarizeService.js';
 import { parseJSONLFile, transformToHistoryMessages } from '../services/historyParser.js';
 import { buildRawMessageTree, getActiveRawBranch, getDefaultRawBranchSelections, findBranchSelectionsForUuid } from '../utils/messageTree.js';
@@ -93,6 +95,10 @@ const socketToSession = new Map();
 const socketSessionRoom = new Map();
 // Track which project room each socket joined (for leave on session switch)
 const socketProjectRoom = new Map();
+// Story 28.0.5: Track harness rooms each socket has subscribed to, so we can
+// release watcher ref counts on disconnect without leaking chokidar instances.
+// Key: socket.id → Set of "harness:user" | "harness:project:<slug>" room strings.
+const socketHarnessRooms = new Map();
 const chainState = new Map();
 // Per-session drain generation counter for race guard
 const chainDrainGeneration = new Map();
@@ -101,6 +107,30 @@ const chainResumableSessions = new Set();
 let chainItemCounter = 0;
 const CHAIN_MAX_RETRIES = 3;
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+// Debug hook: synthetic failure injection for chain drain (G-02-02 retry test).
+// Only consumed when ENABLE_TEST_ENDPOINTS=true; the POST /api/debug route
+// validates the flag before writing to this map.
+const chainDrainFailureInjection = new Map();
+export function setChainDrainFailureInjection(sessionId, count) {
+    if (count <= 0) {
+        chainDrainFailureInjection.delete(sessionId);
+    }
+    else {
+        chainDrainFailureInjection.set(sessionId, count);
+    }
+}
+function consumeChainDrainFailureInjection(sessionId) {
+    const remaining = chainDrainFailureInjection.get(sessionId) ?? 0;
+    if (remaining <= 0)
+        return false;
+    if (remaining === 1) {
+        chainDrainFailureInjection.delete(sessionId);
+    }
+    else {
+        chainDrainFailureInjection.set(sessionId, remaining - 1);
+    }
+    return true;
+}
 // Story 25.9: Per-socket summarizing state — requestId prevents race between cancel + new request
 const socketSummarizing = new Map();
 /** Generate a unique chain item ID */
@@ -232,6 +262,11 @@ function scheduleChainDrain(sessionId, lang) {
         const abortController = new AbortController();
         let stream;
         try {
+            // Debug: synthetic failure injection for retry tests (G-02-02).
+            // Throws before creating the stream so the retry path is exercised cleanly.
+            if (consumeChainDrainFailureInjection(sessionId)) {
+                throw new Error('Injected chain drain failure (debug)');
+            }
             // Create headless stream inside try — if this throws, sending status is recovered below
             const headless = createHeadlessStream(sessionId, abortController);
             stream = headless.stream;
@@ -701,6 +736,29 @@ export async function initializeWebSocket(httpServer) {
         cors: config.cors,
         maxHttpBufferSize: 100 * 1024 * 1024, // 100MB for base64 image payloads
     });
+    // Mirror project-room membership into fileWatcherService so every code path
+    // that calls socket.join/leave with a `project:<slug>` room transparently
+    // starts or stops the chokidar watcher for that project. socket.io emits
+    // join-room/leave-room exactly once per (socket, room) transition, so the
+    // service's ref count aligns with the number of sockets currently in the room.
+    const projectRoomAdapter = io.of('/').adapter;
+    projectRoomAdapter.on('join-room', (room, _id) => {
+        if (!room.startsWith('project:'))
+            return;
+        const slug = room.slice('project:'.length);
+        projectService
+            .resolveOriginalPath(slug)
+            .then((projectRoot) => fileWatcherService.ensureWatcher(slug, projectRoot))
+            .catch(() => {
+            // Project not found — nothing to watch; silently skip.
+        });
+    });
+    projectRoomAdapter.on('leave-room', (room, _id) => {
+        if (!room.startsWith('project:'))
+            return;
+        const slug = room.slice('project:'.length);
+        fileWatcherService.releaseWatcher(slug);
+    });
     // Session middleware for WebSocket (Story 2.5 - Task 4)
     const sessionMiddleware = await createSessionMiddleware();
     // Parse session from cookie for Socket.io connections
@@ -765,6 +823,28 @@ export async function initializeWebSocket(httpServer) {
                 });
             }
         })();
+        // Allow clients to re-request terminal access info (e.g., after late listener registration)
+        socket.on('terminal:access:request', () => {
+            try {
+                const lang = socket.data.language || 'en';
+                const t = i18next.getFixedT(lang);
+                const clientIP = extractClientIP(socket);
+                const isLocal = isLocalIP(clientIP);
+                const terminalEnabled = preferencesService.getTerminalEnabled();
+                socket.emit('terminal:access', {
+                    allowed: terminalEnabled && isLocal,
+                    enabled: terminalEnabled,
+                    reason: !terminalEnabled
+                        ? t('ws.error.terminalDisabled')
+                        : !isLocal
+                            ? t('ws.error.terminalAccessDenied')
+                            : undefined,
+                });
+            }
+            catch {
+                socket.emit('terminal:access', { allowed: false, enabled: false });
+            }
+        });
         // Start rate limit polling on first client connection
         if (connectedClients === 1) {
             rateLimitProbeService.startPolling((data) => { io.emit('rateLimit:update', data); }, (data) => { io.emit('apiHealth:update', data); });
@@ -1026,6 +1106,12 @@ export async function initializeWebSocket(httpServer) {
         // Handle session:join event — attach socket to active running stream (broadcast)
         // Also joins a persistent Socket.io room so future streams auto-include this socket.
         socket.on('session:join', (sessionId, projectSlug) => {
+            // Dedup guard: if the same socket re-emits session:join for the same
+            // session it's already in, skip the history / buffer-replay emissions
+            // below. Room and stream.sockets membership are already correct, and
+            // redundant replays on every reconnect (see ea66988 client-side change)
+            // would cost extra bandwidth and trigger unnecessary client re-renders.
+            const alreadyJoinedSame = socketSessionRoom.get(socket.id) === sessionId;
             // Detach this socket from any previously-attached stream to prevent
             // events from the old stream leaking to a different session's listeners
             const prevSessionId = socketToSession.get(socket.id);
@@ -1043,7 +1129,8 @@ export async function initializeWebSocket(httpServer) {
             if (prevRoomSessionId && prevRoomSessionId !== sessionId && prevRoomSessionId !== prevSessionId) {
                 socket.leave(`session:${prevRoomSessionId}`);
             }
-            // Join persistent session room (survives beyond ActiveStream lifecycle)
+            // Join persistent session room (survives beyond ActiveStream lifecycle).
+            // socket.join() is idempotent — safe to call even if already joined.
             socket.join(`session:${sessionId}`);
             // Leave previous project room if switching projects (or if new join has no projectSlug)
             const prevProjectRoom = socketProjectRoom.get(socket.id);
@@ -1091,6 +1178,13 @@ export async function initializeWebSocket(httpServer) {
                 const freshItems = (chainState.get(sessionId) || []).map(toPublicChainItem);
                 socket.emit('chain:update', { sessionId, items: freshItems });
             }
+            // Dedup: a duplicate session:join from the already-present socket for
+            // the same session doesn't need history / buffer-replay — the socket
+            // already has them. Room membership and chain:update above are idempotent
+            // and cheap, so we let those run.
+            if (alreadyJoinedSame) {
+                return;
+            }
             if (!stream || stream.status !== 'running') {
                 // Story 27.1: Deliver buffer messages via stream:history (no HTTP fetch needed).
                 // Wrapped in a helper that re-checks activeStreams because the async
@@ -1382,6 +1476,39 @@ export async function initializeWebSocket(httpServer) {
                 log.error(`Failed to remove persisted failure ${id} for session ${sessionId}:`, err);
             });
         });
+        socket.on('chain:reorder', (data) => {
+            if (!data || typeof data !== 'object')
+                return;
+            const { sessionId, ids } = data;
+            if (!sessionId || typeof sessionId !== 'string' || !UUID_RE.test(sessionId))
+                return;
+            if (!Array.isArray(ids) || ids.length === 0)
+                return;
+            if (!ids.every(id => typeof id === 'string'))
+                return;
+            if (!socket.rooms.has(`session:${sessionId}`))
+                return;
+            const currentItems = chainState.get(sessionId);
+            if (!currentItems)
+                return;
+            // Only reorder pending items — sending/sent items are already processed.
+            const nonPending = currentItems.filter(item => item.status !== 'pending');
+            const pendingById = new Map(currentItems.filter(item => item.status === 'pending').map(item => [item.id, item]));
+            const reordered = [];
+            for (const id of ids) {
+                const item = pendingById.get(id);
+                if (item) {
+                    reordered.push(item);
+                    pendingById.delete(id);
+                }
+            }
+            // Append any pending items not present in ids (safety: preserve unknowns)
+            for (const item of pendingById.values()) {
+                reordered.push(item);
+            }
+            chainState.set(sessionId, [...nonPending, ...reordered]);
+            broadcastChainUpdate(sessionId);
+        });
         socket.on('chain:clear', (data) => {
             if (!data || typeof data !== 'object')
                 return;
@@ -1667,6 +1794,10 @@ export async function initializeWebSocket(httpServer) {
                 socket.emit('snippets:list', { snippets: [] });
             }
         });
+        // Story 29.2: re-emit `snippets:list` after a snippet CRUD so the
+        // originating client's autocomplete surfaces stay in sync without an
+        // explicit refresh round-trip. This is the same channel the existing
+        // listener above answers, so consumers don't need a new event handler.
         // Handle project:join/leave — room for queue event delivery (Story 15.2)
         socket.on('project:join', (projectSlug) => {
             socket.join(`project:${projectSlug}`);
@@ -1679,6 +1810,37 @@ export async function initializeWebSocket(httpServer) {
                 socketProjectRoom.delete(socket.id);
             }
         });
+        // Story 28.0.5: Harness workbench subscription — one room per scope.
+        socket.on('harness:subscribe', async ({ scope, projectSlug }) => {
+            const room = scope === 'user' ? 'harness:user' : `harness:project:${projectSlug ?? ''}`;
+            await socket.join(room);
+            let rooms = socketHarnessRooms.get(socket.id);
+            if (!rooms) {
+                rooms = new Set();
+                socketHarnessRooms.set(socket.id, rooms);
+            }
+            // Idempotent subscribe: increment the watcher ref count only on the
+            // first join so disconnect cleanup matches exactly.
+            if (!rooms.has(room)) {
+                rooms.add(room);
+                try {
+                    await fileWatcherService.ensureHarnessWatcher({ scope, projectSlug });
+                }
+                catch (err) {
+                    log.warn(`harness:subscribe watcher failed for ${room}: ${String(err)}`);
+                }
+            }
+        });
+        socket.on('harness:unsubscribe', async ({ scope, projectSlug }) => {
+            const room = scope === 'user' ? 'harness:user' : `harness:project:${projectSlug ?? ''}`;
+            await socket.leave(room);
+            const rooms = socketHarnessRooms.get(socket.id);
+            if (rooms && rooms.delete(room)) {
+                fileWatcherService.releaseHarnessWatcher({ scope, projectSlug });
+                if (rooms.size === 0)
+                    socketHarnessRooms.delete(socket.id);
+            }
+        });
         // Handle queue events via WebSocket (Story 15.2)
         socket.on('queue:start', async (data) => {
             const { items, sessionId, projectSlug, permissionMode } = data;
@@ -1946,6 +2108,21 @@ export async function initializeWebSocket(httpServer) {
                 }
             }
             socketProjectRoom.delete(socket.id);
+            // Story 28.0.5: Release any harness watcher refs held by this socket so
+            // chokidar instances don't leak when a client drops without unsubscribing.
+            const harnessRooms = socketHarnessRooms.get(socket.id);
+            if (harnessRooms) {
+                for (const room of harnessRooms) {
+                    if (room === 'harness:user') {
+                        fileWatcherService.releaseHarnessWatcher({ scope: 'user' });
+                    }
+                    else if (room.startsWith('harness:project:')) {
+                        const slug = room.slice('harness:project:'.length);
+                        fileWatcherService.releaseHarnessWatcher({ scope: 'project', projectSlug: slug });
+                    }
+                }
+                socketHarnessRooms.delete(socket.id);
+            }
             // Story 25.9: Cleanup summarizing state on disconnect
             const sumState = socketSummarizing.get(socket.id);
             if (sumState?.abortController) {
@@ -1981,6 +2158,31 @@ export function getIO() {
     }
     return io;
 }
+/**
+ * Story 29.2 (AC1.e Phase 1): emit a fresh `snippets:list` payload to the
+ * single socket that triggered a mutation, so the originating client's
+ * SnippetPalette / useSnippets cache picks up the new state without an
+ * explicit refresh round-trip.
+ *
+ * Phase-1 limitation: only the origin socket is notified. Other tabs / browsers
+ * connected to the same project see stale data until their next user action
+ * (panel open, page reload). The Phase-2 `project:${slug}` room fan-out is
+ * deferred until ≥ 3 user reports of multi-tab divergence.
+ *
+ * Failures are swallowed — broadcast is best-effort and must not affect the
+ * REST mutation's success/failure semantics.
+ */
+export async function broadcastSnippetList(workingDirectory, originSocketId) {
+    if (!workingDirectory || !originSocketId || !io)
+        return;
+    try {
+        const snippets = await listSnippets(workingDirectory);
+        io.to(originSocketId).emit('snippets:list', { snippets });
+    }
+    catch (err) {
+        log.warn(`broadcastSnippetList failed for socket ${originSocketId}: ${String(err)}`);
+    }
+}
 /**
  * Get the current number of connected clients
  * @returns Number of connected clients
@@ -2182,10 +2384,17 @@ async function handleChatSend(stream, data, abortController, lang) {
         stream.chatService = chatService;
         // Load preferences early for advanced settings + timeout
         const effectivePrefs = await preferencesService.getEffectivePreferences();
-        // Clamp 'max' effort to 'high' for non-Opus 4.6 models
-        const resolvedEffort = effort ?? effectivePrefs.defaultEffort;
-        const isOpus46 = model && (model === 'claude-opus-4-6' || model === 'opus' || model.includes('opus-4-6'));
-        const effectiveEffort = resolvedEffort === 'max' && !isOpus46 ? 'high' : resolvedEffort;
+        const effectiveEffort = clampEffortForModel(effort ?? effectivePrefs.defaultEffort, model);
+        // Opus 4.7 flipped `thinking.display` default to 'omitted' — ThinkingBlock UI stays blank
+        // unless we explicitly opt in. For adaptive-thinking models, forward an explicit `thinking`
+        // config based on the user's showThinkingBlocks preference (Hammoc default: true).
+        // Legacy models (Sonnet 4.5, Opus 4.5, Haiku, Sonnet 4) keep the `maxThinkingTokens` path
+        // since they don't accept `thinking.type: 'adaptive'`.
+        const adaptiveCapable = supportsAdaptiveThinking(model);
+        const showThinkingBlocks = effectivePrefs.showThinkingBlocks ?? true;
+        const thinkingConfig = adaptiveCapable
+            ? { type: 'adaptive', display: (showThinkingBlocks ? 'summarized' : 'omitted') }
+            : undefined;
         const chatOptions = {
             ...(isResuming ? { resume: sessionId } : { sessionId }),
             abortController,
@@ -2193,7 +2402,11 @@ async function handleChatSend(stream, data, abortController, lang) {
             images,
             // Advanced settings from preferences
             customSystemPrompt: effectivePrefs.customSystemPrompt,
-            maxThinkingTokens: effectivePrefs.maxThinkingTokens,
+            // maxThinkingTokens: legacy path; SDK docs say it takes precedence for backward-compat,
+            // which conflicts with adaptive mode on Opus 4.7 (rejects enabled+budget). Skip on
+            // adaptive-capable models so the explicit `thinking` field governs.
+            ...(!adaptiveCapable && { maxThinkingTokens: effectivePrefs.maxThinkingTokens }),
+            ...(thinkingConfig && { thinking: thinkingConfig }),
             maxTurns: effectivePrefs.maxTurns,
             maxBudgetUsd: effectivePrefs.maxBudgetUsd,
             effort: effectiveEffort,
@@ -2280,9 +2493,9 @@ async function handleChatSend(stream, data, abortController, lang) {
         };
         // Activity-based timeout: resets on every SDK callback event
         // Prevents cancellation while SDK is actively working (e.g., large Write input streaming)
-        // Timeout value from preferences (with env var override), clamped to 30s–30min range
+        // Timeout value from preferences (with env var override), clamped to 5s–30min range
         const rawTimeoutMs = effectivePrefs.chatTimeoutMs ?? config.chat.timeoutMs;
-        const timeoutMs = (rawTimeoutMs >= 30000 && rawTimeoutMs <= 1800000) ? rawTimeoutMs : 300000;
+        const timeoutMs = (rawTimeoutMs >= 5000 && rawTimeoutMs <= 1800000) ? rawTimeoutMs : 300000;
         let lastResetSource = 'initial';
         const resetTimeout = (source) => {
             if (source)