termdock 1.4.150 → 1.4.152

package/dist/server/routes/filesystem.js

@@ -4,7 +4,6 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { execFile, spawn } from 'child_process';
-import watcher from '@parcel/watcher';
 import busboy from 'busboy';
 import { pathValidator } from '../utils/pathValidator.js';
 import { isAuthEnabled, isRequestAuthenticated } from '../utils/authProtection.js';
@@ -19,7 +18,8 @@ import { inspectKicadBoardPoint } from '../utils/kicadBoardInspection.js';
 import { appendRipgrepExcludeArgs, createExcludeMatcher, normalizeExcludePatterns } from '../utils/fileSearchOptions.js';
 import { EdaPreviewCache, requestAcceptsEtag } from '../utils/edaPreviewCache.js';
 import { convertHeicPreview, HEIC_PREVIEW_MIME_TYPES, isHeicPreviewPath } from '../utils/heicPreview.js';
-import { getWatchErrorCode, enqueueLatestWatchEvent, inspectLinuxInotifyUsage, isWatchResourceExhaustion, minimizeRecursiveWatchRoots, WATCH_IGNORED_NAMES, WATCH_RESOURCE_BACKOFF_MS, } from '../utils/fileWatchPolicy.js';
+import { getWatchErrorCode, diffWatchSnapshots, enqueueLatestWatchEvent, inspectLinuxInotifyUsage, isWatchResourceExhaustion, normalizeDirectoryWatchRoots, resolveDirectWatchEventPath, WATCH_IGNORED_NAMES, WATCH_RESOURCE_BACKOFF_MS, } from '../utils/fileWatchPolicy.js';
+import { isResponseWritable, writeResponseChunk } from '../utils/httpResponse.js';
 const router = Router();
 const MAX_FILE_SIZE = 1024 * 1024; // 1MB
 const MAX_IMAGE_PREVIEW_SIZE = 20 * 1024 * 1024; // 20MB
@@ -61,13 +61,15 @@ const FS_IO_LOG_NAME = 'fs-io.log';
 const activeDiffSlots = new Map();
 const activeIoSlots = new Map();
 const sharedWatchRegistry = new Map();
-const SHARED_WATCH_EVICT_DELAY_MS = 5_000;
+const SHARED_WATCH_EVICT_DELAY_MS = 60_000;
 const WATCH_STAT_CONCURRENCY = 8;
+const WATCH_POLL_INTERVAL_MS = 4_000;
+const MAX_NATIVE_DIRECTORY_WATCHES = 256;
 let watchAdmissionBlockedUntil = 0;
 function countActiveSharedWatches() {
     let count = 0;
     for (const entry of sharedWatchRegistry.values()) {
-        if (entry.subscription || entry.inFlight)
+        if (entry.nativeWatcher)
             count += 1;
     }
     return count;
@@ -114,76 +116,124 @@ function drainSharedWatchEvents(entry) {
         });
     }
 }
-function enqueueSharedNativeEvents(rootPath, entry, events) {
-    for (const event of events) {
-        const changedPath = path.resolve(event.path);
-        if (!isPathInside(rootPath, changedPath) || isIgnoredWatchPath(rootPath, changedPath))
-            continue;
-        if (entry.clients.size === 0) {
-            // The native subscription is kept briefly for cheap stream hand-off.
-            // Only request a rescan when something actually changed in that gap.
-            entry.needsRescanOnAttach = true;
-            return;
-        }
-        if (enqueueLatestWatchEvent(entry.pendingEvents, changedPath, event.type, WATCH_EVENT_STORM_LIMIT) === 'overflow') {
-            entry.pendingEvents.clear();
-            entry.eventGeneration += 1;
-            broadcastSharedWatchEvent(entry, { type: 'rescan-required', path: rootPath, reason: 'event-storm' });
-            return;
-        }
-        // The latest event for one path wins. This turns save bursts and atomic
-        // editor renames into one stat operation instead of one operation/event.
+function enqueueSharedNativeEvent(rootPath, entry, filename) {
+    if (!filename) {
+        entry.pendingEvents.clear();
+        entry.eventGeneration += 1;
+        broadcastSharedWatchEvent(entry, { type: 'rescan-required', path: rootPath, reason: 'directory-rescan' });
+        return;
+    }
+    const changedPath = resolveDirectWatchEventPath(rootPath, filename);
+    if (!changedPath || isIgnoredWatchPath(rootPath, changedPath))
+        return;
+    if (entry.clients.size === 0) {
+        entry.needsRescanOnAttach = true;
+        return;
+    }
+    if (enqueueLatestWatchEvent(entry.pendingEvents, changedPath, 'update', WATCH_EVENT_STORM_LIMIT) === 'overflow') {
+        entry.pendingEvents.clear();
+        entry.eventGeneration += 1;
+        broadcastSharedWatchEvent(entry, { type: 'rescan-required', path: rootPath, reason: 'event-storm' });
+        return;
     }
     drainSharedWatchEvents(entry);
 }
-function sharedWatchCallback(rootPath, entry) {
-    return (error, events) => {
-        if (entry.failure)
-            return;
-        if (error) {
-            entry.failure = error.message || 'watch-error';
-            const reason = entry.failure;
-            entry.pendingEvents.clear();
-            entry.eventGeneration += 1;
-            const resourceExhausted = isWatchResourceExhaustion(error);
-            if (resourceExhausted)
-                watchAdmissionBlockedUntil = Date.now() + WATCH_RESOURCE_BACKOFF_MS;
-            console.warn('[file-watch] Native subscription callback failed; degrading to manual refresh', {
-                rootPath,
-                code: getWatchErrorCode(error),
-                activeSubscriptions: countActiveSharedWatches(),
-                registrySize: sharedWatchRegistry.size,
-                resourceBackoffMs: resourceExhausted ? WATCH_RESOURCE_BACKOFF_MS : 0,
-                error: reason,
-            });
-            const failedSubscription = entry.subscription;
-            entry.subscription = null;
-            void failedSubscription?.unsubscribe().catch(() => undefined);
-            if (resourceExhausted) {
-                void inspectLinuxInotifyUsage().then((diagnostics) => {
-                    if (diagnostics)
-                        console.warn('[file-watch] Linux inotify usage after callback failure', diagnostics);
-                }).catch(() => undefined);
+async function readDirectorySnapshot(rootPath) {
+    const dirents = await fs.promises.readdir(rootPath, { withFileTypes: true });
+    const visible = dirents.filter((dirent) => !WATCH_IGNORED_NAMES.has(dirent.name));
+    const snapshot = new Map();
+    let cursor = 0;
+    const workers = Array.from({ length: Math.min(WATCH_STAT_CONCURRENCY, visible.length) }, async () => {
+        while (cursor < visible.length) {
+            const dirent = visible[cursor++];
+            const entryPath = path.join(rootPath, dirent.name);
+            try {
+                const stat = await fs.promises.lstat(entryPath);
+                snapshot.set(entryPath, {
+                    signature: `${stat.mode}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`,
+                    entry: toFileEntry(entryPath, stat, dirent.isSymbolicLink()),
+                });
             }
-            for (const client of [...entry.clients]) {
-                if (!client.closed)
-                    client.degrade(reason);
+            catch (error) {
+                if (getWatchErrorCode(error) !== 'ENOENT')
+                    throw error;
             }
+        }
+    });
+    await Promise.all(workers);
+    return snapshot;
+}
+function scheduleSharedWatchPoll(rootPath, entry, delay = WATCH_POLL_INTERVAL_MS) {
+    if (entry.pollTimer || entry.mode !== 'polling' || entry.refs === 0)
+        return;
+    entry.pollTimer = setTimeout(() => {
+        entry.pollTimer = null;
+        void pollSharedWatch(rootPath, entry);
+    }, delay);
+    entry.pollTimer.unref?.();
+}
+async function pollSharedWatch(rootPath, entry) {
+    if (entry.mode !== 'polling' || entry.refs === 0)
+        return;
+    try {
+        const next = await readDirectorySnapshot(rootPath);
+        const previous = entry.pollSnapshot;
+        entry.pollSnapshot = next;
+        entry.failure = null;
+        if (previous) {
+            for (const change of diffWatchSnapshots(previous, next)) {
+                broadcastSharedWatchEvent(entry, {
+                    type: change.type === 'delete' ? 'deleted' : change.type === 'create' ? 'created' : 'updated',
+                    path: change.path,
+                    entry: change.value?.entry,
+                });
+            }
+        }
+    }
+    catch (error) {
+        entry.failure = error instanceof Error ? error.message : String(error);
+        if (getWatchErrorCode(error) === 'ENOENT') {
+            for (const client of [...entry.clients])
+                if (!client.closed)
+                    client.degrade(entry.failure);
             return;
         }
-        enqueueSharedNativeEvents(rootPath, entry, events);
-    };
+        console.warn('[file-watch] Polling refresh failed; will retry', { rootPath, error: entry.failure });
+    }
+    scheduleSharedWatchPoll(rootPath, entry);
+}
+async function startPollingWatch(rootPath, entry, reason) {
+    entry.nativeWatcher?.close();
+    entry.nativeWatcher = null;
+    entry.mode = 'polling';
+    entry.pendingEvents.clear();
+    entry.eventGeneration += 1;
+    try {
+        entry.pollSnapshot = await readDirectorySnapshot(rootPath);
+        entry.failure = null;
+    }
+    catch (error) {
+        entry.failure = error instanceof Error ? error.message : String(error);
+        return false;
+    }
+    broadcastSharedWatchEvent(entry, { type: 'rescan-required', path: rootPath, reason: 'polling-fallback' });
+    scheduleSharedWatchPoll(rootPath, entry);
+    console.warn('[file-watch] Using polling fallback', { rootPath, intervalMs: WATCH_POLL_INTERVAL_MS, reason });
+    return true;
 }
 async function acquireSharedWatch(rootPath, client) {
     let entry = sharedWatchRegistry.get(rootPath);
     if (!entry) {
         entry = {
             refs: 0,
-            subscription: null,
+            nativeWatcher: null,
+            mode: 'starting',
             failure: null,
             clients: new Set(),
             inFlight: null,
             evictTimer: null,
+            pollTimer: null,
+            pollSnapshot: null,
             pendingEvents: new Map(),
             statWorkers: 0,
             eventGeneration: 0,
@@ -201,72 +251,66 @@ async function acquireSharedWatch(rootPath, client) {
         entry.needsRescanOnAttach = false;
         client.enqueue({ type: 'rescan-required', path: rootPath, reason: 'reconnected' });
     }
-    if (entry.failure)
-        return null;
-    if (entry.subscription)
+    if (entry.mode === 'polling' && entry.pollSnapshot) {
+        scheduleSharedWatchPoll(rootPath, entry, 0);
+        return rootPath;
+    }
+    if (entry.nativeWatcher)
         return rootPath;
     if (!entry.inFlight) {
         const now = Date.now();
         const activeSubscriptions = countActiveSharedWatches();
-        if (now < watchAdmissionBlockedUntil) {
-            entry.failure = `native watcher admission paused for ${Math.ceil((watchAdmissionBlockedUntil - now) / 1000)}s after resource exhaustion`;
-            console.warn('[file-watch] Subscription skipped while resource backoff is active', {
-                rootPath,
-                activeSubscriptions,
-                registrySize: sharedWatchRegistry.size,
-            });
-            return null;
-        }
-        const startedAt = Date.now();
-        console.info('[file-watch] Starting native subscription', {
-            rootPath,
-            activeSubscriptions: activeSubscriptions + 1,
-            registrySize: sharedWatchRegistry.size,
-        });
-        entry.inFlight = watcher.subscribe(rootPath, sharedWatchCallback(rootPath, entry), {
-            ignore: Array.from(WATCH_IGNORED_NAMES).map((name) => `**/${name}/**`),
-        })
-            .then((subscription) => {
-            const current = sharedWatchRegistry.get(rootPath);
-            if (!current || current.refs === 0) {
-                // Nobody is watching anymore (client disconnected mid-scan): free
-                // the freshly built subscription instead of leaking its DirTree.
-                void subscription.unsubscribe().catch(() => undefined);
-                return null;
+        entry.inFlight = (async () => {
+            if (now < watchAdmissionBlockedUntil || activeSubscriptions >= MAX_NATIVE_DIRECTORY_WATCHES) {
+                const reason = now < watchAdmissionBlockedUntil ? 'native watcher resource backoff' : 'native watcher process budget reached';
+                return startPollingWatch(rootPath, entry, reason);
             }
-            current.subscription = subscription;
-            console.info('[file-watch] Native subscription ready', {
-                rootPath,
-                scanDurationMs: Date.now() - startedAt,
-                activeSubscriptions: countActiveSharedWatches(),
-                registrySize: sharedWatchRegistry.size,
-            });
-            return subscription;
-        })
-            .catch((error) => {
-            const current = sharedWatchRegistry.get(rootPath);
-            if (current)
-                current.failure = error instanceof Error ? error.message : String(error);
-            const resourceExhausted = isWatchResourceExhaustion(error);
-            if (resourceExhausted)
-                watchAdmissionBlockedUntil = Date.now() + WATCH_RESOURCE_BACKOFF_MS;
-            console.warn('[file-watch] Native subscription failed; degrading to manual refresh', {
-                rootPath,
-                code: getWatchErrorCode(error),
-                scanDurationMs: Date.now() - startedAt,
-                activeSubscriptions: countActiveSharedWatches(),
-                registrySize: sharedWatchRegistry.size,
-                resourceBackoffMs: resourceExhausted ? WATCH_RESOURCE_BACKOFF_MS : 0,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            if (resourceExhausted) {
-                void inspectLinuxInotifyUsage().then((diagnostics) => {
-                    if (diagnostics)
-                        console.warn('[file-watch] Linux inotify usage after resource exhaustion', diagnostics);
-                }).catch(() => undefined);
+            try {
+                const nativeWatcher = fs.watch(rootPath, { persistent: false }, (_eventType, filename) => {
+                    enqueueSharedNativeEvent(rootPath, entry, filename);
+                });
+                entry.nativeWatcher = nativeWatcher;
+                entry.mode = 'native';
+                entry.failure = null;
+                nativeWatcher.on('error', (error) => {
+                    if (entry.mode !== 'native')
+                        return;
+                    const resourceExhausted = isWatchResourceExhaustion(error);
+                    if (resourceExhausted)
+                        watchAdmissionBlockedUntil = Date.now() + WATCH_RESOURCE_BACKOFF_MS;
+                    if (resourceExhausted)
+                        void inspectLinuxInotifyUsage().then((diagnostics) => {
+                            if (diagnostics)
+                                console.warn('[file-watch] Linux inotify usage after watcher failure', diagnostics);
+                        }).catch(() => undefined);
+                    void startPollingWatch(rootPath, entry, error.message || 'native watcher error').then((started) => {
+                        if (!started) {
+                            const reason = entry.failure ?? 'watch-unavailable';
+                            for (const client of [...entry.clients])
+                                if (!client.closed)
+                                    client.degrade(reason);
+                        }
+                    });
+                });
+                console.info('[file-watch] Native directory watch ready', {
+                    rootPath,
+                    activeSubscriptions: activeSubscriptions + 1,
+                    registrySize: sharedWatchRegistry.size,
+                });
+                return true;
             }
-            return null;
-        })
+            catch (error) {
+                const resourceExhausted = isWatchResourceExhaustion(error);
+                if (resourceExhausted)
+                    watchAdmissionBlockedUntil = Date.now() + WATCH_RESOURCE_BACKOFF_MS;
+                if (resourceExhausted)
+                    void inspectLinuxInotifyUsage().then((diagnostics) => {
+                        if (diagnostics)
+                            console.warn('[file-watch] Linux inotify usage after watcher admission failure', diagnostics);
+                    }).catch(() => undefined);
+                return startPollingWatch(rootPath, entry, error instanceof Error ? error.message : String(error));
+            }
+        })()
             .finally(() => {
             const current = sharedWatchRegistry.get(rootPath);
             if (current)
@@ -291,7 +335,11 @@ function releaseSharedWatch(rootPath, client) {
         || entry.statWorkers > 0;
     entry.pendingEvents.clear();
     entry.eventGeneration += 1;
-    if (!entry.subscription && !entry.inFlight) {
+    if (entry.pollTimer) {
+        clearTimeout(entry.pollTimer);
+        entry.pollTimer = null;
+    }
+    if (!entry.nativeWatcher && !entry.inFlight) {
         sharedWatchRegistry.delete(rootPath);
         return;
     }
@@ -302,8 +350,10 @@ function releaseSharedWatch(rootPath, client) {
         if (!current || current.refs > 0)
             return;
         sharedWatchRegistry.delete(rootPath);
-        void current.subscription?.unsubscribe().catch(() => undefined);
-        current.subscription = null;
+        if (current.pollTimer)
+            clearTimeout(current.pollTimer);
+        current.nativeWatcher?.close();
+        current.nativeWatcher = null;
     }, SHARED_WATCH_EVICT_DELAY_MS);
     entry.evictTimer.unref?.();
 }
@@ -1663,13 +1713,17 @@ async function searchWithFallback(rootPath, queryLower, showHidden, excludePatte
     };
 }
 function writeSearchEvent(res, type, payload) {
-    res.write(`${JSON.stringify({ type, ...payload })}\n`);
+    writeResponseChunk(res, `${JSON.stringify({ type, ...payload })}\n`);
 }
 function createSearchBatchEmitter(res) {
     let batch = [];
     const flush = () => {
-        if (batch.length === 0 || res.destroyed)
+        if (batch.length === 0)
             return;
+        if (!isResponseWritable(res)) {
+            batch = [];
+            return;
+        }
         writeSearchEvent(res, 'batch', { entries: batch });
         batch = [];
     };
@@ -1807,8 +1861,12 @@ async function streamSearchWithFallback(rootPath, queryLower, showHidden, exclud
 function createContentBatchEmitter(res) {
     let batch = [];
     const flush = () => {
-        if (batch.length === 0 || res.destroyed)
+        if (batch.length === 0)
             return;
+        if (!isResponseWritable(res)) {
+            batch = [];
+            return;
+        }
         writeSearchEvent(res, 'content-batch', { contentEntries: batch });
         batch = [];
     };
@@ -2569,8 +2627,17 @@ router.get('/list', async (req, res) => {
 // deep directory listing; it uses the OS watcher and sends small batched events
 // so the client can patch only directories it has already loaded.
 router.get('/watch', async (req, res) => {
+    const repeatedRootsParam = req.query.root;
     const rootsParam = req.query.roots;
-    const rawRoots = (Array.isArray(rootsParam) ? rootsParam : typeof rootsParam === 'string' ? rootsParam.split('|') : [])
+    const rawRoots = (Array.isArray(repeatedRootsParam)
+        ? repeatedRootsParam
+        : typeof repeatedRootsParam === 'string'
+            ? [repeatedRootsParam]
+            : Array.isArray(rootsParam)
+                ? rootsParam
+                : typeof rootsParam === 'string'
+                    ? rootsParam.split('|')
+                    : [])
         .filter((root) => typeof root === 'string');
     const validatedRoots = [];
     for (const rawRoot of rawRoots) {
@@ -2586,7 +2653,7 @@ router.get('/watch', async (req, res) => {
             // Ignore invalid watch roots; the visible tree will still work via manual list requests.
         }
     }
-    const roots = minimizeRecursiveWatchRoots(validatedRoots);
+    const roots = normalizeDirectoryWatchRoots(validatedRoots);
     if (roots.length === 0) {
         res.status(400).json({ error: 'No valid roots to watch' });
         return;
@@ -2598,10 +2665,8 @@ router.get('/watch', async (req, res) => {
     let pending = [];
     let flushTimer = null;
     const attachedRoots = new Map();
-    // Register cleanup before the first native subscription starts. A recursive
-    // initial scan can take seconds on a large repository; the browser may abort
-    // during that await when the user switches files or roots. Registering this
-    // only after attachRoot() leaked the pending subscription and its reference.
+    // Register cleanup before the first native watch or fallback snapshot starts;
+    // the browser may abort while roots are being validated or attached.
     const closeWatchStream = () => {
         if (closed)
             return;
@@ -2614,9 +2679,9 @@ router.get('/watch', async (req, res) => {
     };
     res.once('close', closeWatchStream);
     const writeEvent = (type, payload) => {
-        if (closed || res.destroyed)
-            return;
-        res.write(`${JSON.stringify({ type, ...payload })}\n`);
+        if (closed)
+            return false;
+        return writeResponseChunk(res, `${JSON.stringify({ type, ...payload })}\n`);
     };
     const flush = () => {
         flushTimer = null;
@@ -2645,7 +2710,7 @@ router.get('/watch', async (req, res) => {
         requestedRoots: rawRoots.length,
         validatedRoots: validatedRoots.length,
         subscribedRoots: roots.length,
-        collapsedOverlappingRoots: validatedRoots.length - roots.length,
+        deduplicatedRoots: validatedRoots.length - roots.length,
         activeSubscriptions: countActiveSharedWatches(),
         registrySize: sharedWatchRegistry.size,
     });
@@ -2656,11 +2721,14 @@ router.get('/watch', async (req, res) => {
             closed: false,
             enqueue,
             degrade: (reason) => {
-                if (closed)
+                if (closed || !isResponseWritable(res)) {
+                    closeWatchStream();
                     return;
+                }
                 enqueue({ type: 'rescan-required', path: rootPath, reason });
                 flush();
-                if (!res.writableEnded)
+                closeWatchStream();
+                if (isResponseWritable(res))
                     res.end();
             },
         };
@@ -2776,14 +2844,15 @@ router.get('/search', async (req, res) => {
             writeSearchEvent(res, 'meta', { path: resolvedPath, query, engine: 'rg', mode: 'content', limited: false });
             try {
                 const result = await streamContentSearchWithRipgrep(resolvedPath, query, showHidden, excludePatterns, contentOptions, controller.signal, res);
-                if (!controller.signal.aborted && !res.destroyed) {
+                if (!controller.signal.aborted && isResponseWritable(res)) {
                     writeSearchEvent(res, 'done', { total: result.total, truncated: result.limited, limited: result.limited, engine: 'rg', mode: 'content' });
                     logSearch('ok', { count: result.total, truncated: result.limited, extra: { mode: 'content', engine: 'rg' } });
-                    res.end();
+                    if (isResponseWritable(res))
+                        res.end();
                 }
             }
             catch (error) {
-                if (controller.signal.aborted || res.destroyed) {
+                if (controller.signal.aborted || !isResponseWritable(res)) {
                     const payload = getErrorPayload(controller.signal.reason ?? error);
                     logSearch('error', { code: payload.code, error: payload.error, extra: { mode: 'content', engine: 'rg' } });
                     return;
@@ -2791,7 +2860,8 @@ router.get('/search', async (req, res) => {
                 const message = error instanceof Error ? error.message : 'Content search failed';
                 logSearch('error', { code: 'CONTENT_SEARCH_UNAVAILABLE', error: message, extra: { mode: 'content', engine: 'rg' } });
                 writeSearchEvent(res, 'error', { message, code: 'CONTENT_SEARCH_UNAVAILABLE' });
-                res.end();
+                if (isResponseWritable(res))
+                    res.end();
             }
             return;
         }
@@ -2802,24 +2872,26 @@ router.get('/search', async (req, res) => {
             writeSearchEvent(res, 'meta', { path: resolvedPath, query, engine: 'rg', limited: false });
             try {
                 const total = await streamSearchWithRipgrep(resolvedPath, queryLower, showHidden, excludePatterns, controller.signal, res);
-                if (!controller.signal.aborted && !res.destroyed) {
+                if (!controller.signal.aborted && isResponseWritable(res)) {
                     writeSearchEvent(res, 'done', { total, truncated: false, limited: false, engine: 'rg' });
                     logSearch('ok', { count: total, truncated: false, extra: { mode: 'name', engine: 'rg' } });
-                    res.end();
+                    if (isResponseWritable(res))
+                        res.end();
                 }
             }
             catch (error) {
-                if (controller.signal.aborted || res.destroyed) {
+                if (controller.signal.aborted || !isResponseWritable(res)) {
                     const payload = getErrorPayload(controller.signal.reason ?? error);
                     logSearch('error', { code: payload.code, error: payload.error, extra: { mode: 'name', engine: 'rg' } });
                     return;
                 }
                 writeSearchEvent(res, 'meta', { path: resolvedPath, query, engine: 'fallback', limited: false });
                 const result = await streamSearchWithFallback(resolvedPath, queryLower, showHidden, excludePatterns, controller.signal, res);
-                if (!controller.signal.aborted && !res.destroyed) {
+                if (!controller.signal.aborted && isResponseWritable(res)) {
                     writeSearchEvent(res, 'done', { total: result.total, truncated: result.limited, limited: result.limited, engine: 'fallback' });
                     logSearch('ok', { count: result.total, truncated: result.limited, extra: { mode: 'name', engine: 'fallback' } });
-                    res.end();
+                    if (isResponseWritable(res))
+                        res.end();
                 }
             }
             return;

package/dist/server/routes/terminal.js

@@ -19,6 +19,7 @@ import { normalizeLocalAccessName, getLocaleSetting, setLocaleSetting, getContex
 import { loadContextDraft, saveContextDraft } from '../utils/contextDraft.js';
 import { getOnboardingServerUrl } from '../onboardingServer.js';
 import { inspectLinuxInotifyUsage, isWatchResourceExhaustion } from '../utils/fileWatchPolicy.js';
+import { writeResponseChunk } from '../utils/httpResponse.js';
 import { getFocusSequence, removeClientFocusState, scanFocusTrackingMode, setClientFocusState, } from '../utils/tmuxFocus.js';
 import { extractProgramLabelFromArgs, normalizeProgramName, normalizeTmuxMetadataProgram, selectTmuxForegroundProgram, tmuxMetadataChanged, } from '../utils/tmuxProgramDetection.js';
 import { agentBySlug, buildResumeCommand, detectAgentFromCommand, inferResumeSessionId, listAgents, } from '../agent/registry.js';
@@ -3965,7 +3966,7 @@ function shouldRetryShellSpawn(error) {
     return /posix_spawnp failed|ENOENT|EACCES/i.test(errorMessage);
 }
 function writeSse(res, payload) {
-    res.write(`data: ${JSON.stringify(payload)}\n\n`);
+    return writeResponseChunk(res, `data: ${JSON.stringify(payload)}\n\n`);
 }
 function getTotalClients(sessionId) {
     let count = 0;
@@ -4006,7 +4007,8 @@ function broadcastEvent(sessionId, payload) {
     if (session) {
         for (const [clientId, client] of session.clients.entries()) {
             try {
-                writeSse(client, payload);
+                if (!writeSse(client, payload))
+                    closeClient(session, sessionId, clientId);
             }
             catch {
                 closeClient(session, sessionId, clientId);
@@ -6514,11 +6516,7 @@ router.get('/:sessionId/stream', async (req, res) => {
         }, ACTIVE_PROGRAM_POLL_INTERVAL);
     }
     const heartbeatInterval = setInterval(() => {
-        try {
-            res.write(': heartbeat\n\n');
-        }
-        catch (error) {
-            console.error(`Heartbeat failed for client ${clientId}:`, error);
+        if (!writeResponseChunk(res, ': heartbeat\n\n')) {
             clearInterval(heartbeatInterval);
         }
     }, 15000);

package/dist/server/utils/fileWatchPolicy.js

@@ -10,24 +10,31 @@ export function enqueueLatestWatchEvent(pending, eventPath, eventType, maxPendin
     pending.set(eventPath, eventType);
     return 'queued';
 }
-function isSameOrDescendant(parentPath, candidatePath) {
-    const relative = path.relative(parentPath, candidatePath);
-    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+export function resolveDirectWatchEventPath(rootPath, filename) {
+    const resolvedRoot = path.resolve(rootPath);
+    const candidate = path.resolve(resolvedRoot, filename.toString());
+    return path.dirname(candidate) === resolvedRoot ? candidate : null;
+}
+export function diffWatchSnapshots(previous, next) {
+    const changes = [];
+    for (const entryPath of previous.keys()) {
+        if (!next.has(entryPath))
+            changes.push({ type: 'delete', path: entryPath });
+    }
+    for (const [entryPath, value] of next) {
+        const old = previous.get(entryPath);
+        if (!old || old.signature !== value.signature) {
+            changes.push({ type: old ? 'update' : 'create', path: entryPath, value });
+        }
+    }
+    return changes;
 }
 /**
- * Recursive watchers already cover every descendant. Keep only the shallowest
- * roots so expanding a folder inside an already watched folder cannot allocate
- * another overlapping native watcher.
+ * Non-recursive directory watchers need every visible directory, including
+ * nested ones. Normalize and deduplicate without collapsing descendants.
  */
-export function minimizeRecursiveWatchRoots(roots) {
-    const uniqueRoots = [...new Set(roots.map((root) => path.resolve(root)))];
-    uniqueRoots.sort((a, b) => a.split(path.sep).length - b.split(path.sep).length || a.localeCompare(b));
-    const minimal = [];
-    for (const root of uniqueRoots) {
-        if (!minimal.some((parent) => isSameOrDescendant(parent, root)))
-            minimal.push(root);
-    }
-    return minimal;
+export function normalizeDirectoryWatchRoots(roots) {
+    return [...new Set(roots.map((root) => path.resolve(root)))].sort((a, b) => a.localeCompare(b));
 }
 export function getWatchErrorCode(error) {
     if (!error || typeof error !== 'object')

package/dist/server/utils/httpResponse.js

@@ -0,0 +1,14 @@
+export function isResponseWritable(response) {
+    return !response.destroyed && !response.writableEnded && !response.writableFinished;
+}
+export function writeResponseChunk(response, chunk) {
+    if (!isResponseWritable(response))
+        return false;
+    try {
+        response.write(chunk);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}