@jingyi0605/codingns 0.3.6 → 0.5.0

package/dist/server/ws/workbench-ws-hub.js

@@ -1,8 +1,10 @@
 import { AppError } from "../shared/errors/app-error.js";
 import { logTerminalDebug, terminalDebugNowMs } from "../shared/utils/terminal-debug-log.js";
 const WORKBENCH_REFRESH_INTERVAL_MS = 60_000;
-const SIDEBAR_REFRESH_INTERVAL_MS = 5_000;
 const GIT_SUBSCRIPTION_MIN_REFRESH_INTERVAL_MS = 15_000;
+const GIT_REFRESH_QUIET_WINDOW_MS = 800;
+const TERMINAL_MANAGER_REFRESH_QUIET_WINDOW_MS = 300;
+const WORKSPACE_MANAGEMENT_REFRESH_INTERVAL_MS = 5_000;
 const WORKBENCH_REALTIME_BROADCAST_DEBOUNCE_MS = 120;
 const WORKSPACE_MANAGEMENT_TIMER_REFRESH_ENABLED = readBooleanEnv(process.env.CODINGNS_WORKSPACE_MANAGEMENT_AUTO_REFRESH, false);
 export class WorkbenchWsHub {
@@ -15,12 +17,18 @@ export class WorkbenchWsHub {
     clientGitSubscriptions = new WeakMap();
     clientTerminalManagerSubscriptions = new WeakMap();
     clientWorkspaceManagementSubscriptions = new WeakMap();
-    constructor(workbenchService, workspacePanelSnapshotService, fileWatcher) {
+    constructor(workbenchService, workspacePanelSnapshotService, fileWatcher, terminalService) {
         this.workbenchService = workbenchService;
         this.workspacePanelSnapshotService = workspacePanelSnapshotService;
         this.fileWatcher = fileWatcher;
-        this.fileWatcher.setOnChange((workspaceId) => {
-            this.handleWorkspaceFileChange(workspaceId);
+        this.fileWatcher.setOnChange((event) => {
+            this.handleWorkspaceWatcherChange(event);
+        });
+        terminalService?.on("status", (terminal) => {
+            this.handleTerminalManagerChange(terminal.workspaceId);
+        });
+        terminalService?.on("exit", ({ terminal }) => {
+            this.handleTerminalManagerChange(terminal.workspaceId);
         });
     }
     handleMessage(client, payload, authContext) {
@@ -31,85 +39,78 @@ export class WorkbenchWsHub {
         const userId = authContext.user.userId;
         const channel = this.getOrCreateChannel(userId);
         this.attachClient(client, userId, channel);
-        switch (message.type) {
-            case "workbench.subscribe":
-                void this.sendWorkbenchSnapshotToClient(client, userId, channel);
-                return true;
-            case "workbench.refresh":
-                void this.syncTitlesAndBroadcast(userId);
-                void this.refreshAndBroadcast(userId, true);
-                return true;
-            case "fileTree.subscribe":
-                this.clientFileTreeSubscriptions.set(client, {
-                    workspaceId: message.workspaceId.trim(),
-                    paths: normalizePanelPaths(message.paths),
-                    lastPayloadByPath: new Map()
-                });
-                this.fileWatcher.subscribe(message.workspaceId.trim());
-                void this.refreshFileTreeSubscriptions(client);
-                return true;
-            case "fileTree.refresh":
-                for (const path of normalizePanelPaths(message.paths)) {
-                    this.workspacePanelSnapshotService.invalidateFileTree(message.workspaceId.trim(), path);
-                }
-                this.ensureFileTreeSubscription(client, message.workspaceId, message.paths);
-                void this.refreshFileTreeSubscriptions(client, true);
-                return true;
-            case "git.subscribe":
-                this.clientGitSubscriptions.set(client, {
-                    workspaceId: message.workspaceId.trim(),
-                    lastPayload: null,
-                    lastRequestedAt: 0,
-                    refreshTask: null,
-                    refreshController: null
-                });
-                this.fileWatcher.subscribe(message.workspaceId.trim());
-                void this.refreshGitSubscription(client);
-                return true;
-            case "git.refresh":
-                this.workspacePanelSnapshotService.invalidateGit(message.workspaceId.trim());
-                this.abortGitRefresh(client, "git subscription replaced");
-                this.clientGitSubscriptions.set(client, {
-                    workspaceId: message.workspaceId.trim(),
-                    lastPayload: null,
-                    lastRequestedAt: 0,
-                    refreshTask: null,
-                    refreshController: null
-                });
-                void this.refreshGitSubscription(client, true);
-                return true;
-            case "terminalManager.subscribe":
-                this.clientTerminalManagerSubscriptions.set(client, {
-                    workspaceId: message.workspaceId.trim(),
-                    lastPayload: null
-                });
-                void this.refreshTerminalManagerSubscription(client);
-                return true;
-            case "terminalManager.refresh":
-                this.workspacePanelSnapshotService.invalidateTerminalManager(message.workspaceId.trim());
-                this.clientTerminalManagerSubscriptions.set(client, {
-                    workspaceId: message.workspaceId.trim(),
-                    lastPayload: null
-                });
-                void this.refreshTerminalManagerSubscription(client, true);
-                return true;
-            case "workspaceManagement.subscribe":
-                this.clientWorkspaceManagementSubscriptions.set(client, {
-                    workspaceId: message.workspaceId.trim(),
-                    lastPayload: null
-                });
-                void this.refreshWorkspaceManagementSubscription(client);
-                return true;
-            case "workspaceManagement.refresh":
-                this.workspacePanelSnapshotService.invalidateWorkspaceManagement(message.workspaceId.trim());
-                this.clientWorkspaceManagementSubscriptions.set(client, {
-                    workspaceId: message.workspaceId.trim(),
-                    lastPayload: null
-                });
-                void this.refreshWorkspaceManagementSubscription(client, true);
-                return true;
-            default:
-                return false;
+        try {
+            switch (message.type) {
+                case "workbench.subscribe":
+                    void this.sendWorkbenchSnapshotToClient(client, userId, channel);
+                    if (this.workbenchService.shouldRefreshSnapshot()) {
+                        this.workbenchService.scheduleSnapshotRefresh(userId);
+                    }
+                    return true;
+                case "workbench.refresh":
+                    void this.refreshAndBroadcast(userId, true);
+                    return true;
+                case "fileTree.subscribe":
+                    this.replaceFileTreeSubscription(client, message.workspaceId, message.paths);
+                    void this.refreshFileTreeSubscriptions(client);
+                    return true;
+                case "fileTree.refresh":
+                    for (const path of normalizePanelPaths(message.paths)) {
+                        this.workspacePanelSnapshotService.invalidateFileTree(message.workspaceId.trim(), path);
+                    }
+                    this.ensureFileTreeSubscription(client, message.workspaceId, message.paths);
+                    void this.refreshFileTreeSubscriptions(client, true);
+                    return true;
+                case "git.subscribe":
+                    this.ensureGitSubscription(client, message.workspaceId);
+                    void this.refreshGitSubscription(client, false, {
+                        deliverIfUnchanged: true,
+                        ignoreMinInterval: true
+                    });
+                    return true;
+                case "git.refresh":
+                    this.workspacePanelSnapshotService.invalidateGit(message.workspaceId.trim());
+                    this.ensureGitSubscription(client, message.workspaceId);
+                    this.scheduleGitRefresh(client, {
+                        force: true
+                    });
+                    return true;
+                case "terminalManager.subscribe":
+                    this.ensureTerminalManagerSubscription(client, message.workspaceId);
+                    this.scheduleTerminalManagerRefresh(client);
+                    return true;
+                case "terminalManager.refresh":
+                    this.workspacePanelSnapshotService.invalidateTerminalManager(message.workspaceId.trim());
+                    this.ensureTerminalManagerSubscription(client, message.workspaceId);
+                    this.scheduleTerminalManagerRefresh(client, {
+                        force: true
+                    });
+                    return true;
+                case "workspaceManagement.subscribe":
+                    this.clientWorkspaceManagementSubscriptions.set(client, {
+                        workspaceId: message.workspaceId.trim(),
+                        lastPayload: null
+                    });
+                    void this.refreshWorkspaceManagementSubscription(client);
+                    return true;
+                case "workspaceManagement.refresh":
+                    this.workspacePanelSnapshotService.invalidateWorkspaceManagement(message.workspaceId.trim());
+                    this.clientWorkspaceManagementSubscriptions.set(client, {
+                        workspaceId: message.workspaceId.trim(),
+                        lastPayload: null
+                    });
+                    void this.refreshWorkspaceManagementSubscription(client, true);
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        catch (error) {
+            this.reportAsyncError("handleMessage", error, {
+                userId,
+                workspaceId: extractWorkspaceIdFromWorkbenchMessage(message)
+            });
+            return true;
         }
     }
     cleanupClient(client) {
@@ -127,12 +128,19 @@ export class WorkbenchWsHub {
         // 文件监听器引用计数递减
         const fileTreeSub = this.clientFileTreeSubscriptions.get(client);
         if (fileTreeSub) {
-            this.fileWatcher.unsubscribe(fileTreeSub.workspaceId);
+            this.fileWatcher.unsubscribeFileTree(fileTreeSub.workspaceId, fileTreeSub.paths);
         }
         const gitSub = this.clientGitSubscriptions.get(client);
         if (gitSub) {
             gitSub.refreshController?.abort(new Error("git subscription closed"));
-            this.fileWatcher.unsubscribe(gitSub.workspaceId);
+            if (gitSub.refreshTimer) {
+                clearTimeout(gitSub.refreshTimer);
+            }
+            this.fileWatcher.unsubscribeGit(gitSub.workspaceId);
+        }
+        const terminalManagerSub = this.clientTerminalManagerSubscriptions.get(client);
+        if (terminalManagerSub?.refreshTimer) {
+            clearTimeout(terminalManagerSub.refreshTimer);
         }
         this.clientFileTreeSubscriptions.delete(client);
         this.clientGitSubscriptions.delete(client);
@@ -144,8 +152,8 @@ export class WorkbenchWsHub {
         if (channel.workbenchTimer) {
             clearInterval(channel.workbenchTimer);
         }
-        if (channel.sidebarTimer) {
-            clearInterval(channel.sidebarTimer);
+        if (channel.workspaceManagementTimer) {
+            clearInterval(channel.workspaceManagementTimer);
         }
         if (channel.realtimeBroadcastTimer) {
             clearTimeout(channel.realtimeBroadcastTimer);
@@ -208,22 +216,42 @@ export class WorkbenchWsHub {
         channel.clients.add(client);
         this.clientUsers.set(client, userId);
     }
-    /**
-     * 文件变化回调：chokidar 检测到工作区文件变化后，失效缓存并推送更新给订阅了该工作区的客户端。
-     */
-    handleWorkspaceFileChange(workspaceId) {
-        this.workspacePanelSnapshotService.invalidateFileTree(workspaceId);
-        this.workspacePanelSnapshotService.invalidateGit(workspaceId);
+    handleWorkspaceWatcherChange(event) {
+        if (event.scope === "fileTree") {
+            this.workspacePanelSnapshotService.invalidateFileTree(event.workspaceId);
+            this.workspacePanelSnapshotService.invalidateGit(event.workspaceId);
+        }
+        else {
+            this.workspacePanelSnapshotService.invalidateGit(event.workspaceId);
+        }
         for (const [, channel] of this.userChannels) {
             for (const client of channel.clients) {
                 const fileTreeSub = this.clientFileTreeSubscriptions.get(client);
-                if (fileTreeSub && fileTreeSub.workspaceId === workspaceId) {
+                if (event.scope === "fileTree" &&
+                    fileTreeSub &&
+                    fileTreeSub.workspaceId === event.workspaceId) {
                     void this.refreshFileTreeSubscriptions(client, true);
                 }
                 const gitSub = this.clientGitSubscriptions.get(client);
-                if (gitSub && gitSub.workspaceId === workspaceId) {
-                    void this.refreshGitSubscription(client, true);
+                if (gitSub && gitSub.workspaceId === event.workspaceId) {
+                    this.scheduleGitRefresh(client, {
+                        quietWindowMs: GIT_REFRESH_QUIET_WINDOW_MS
+                    });
+                }
+            }
+        }
+    }
+    handleTerminalManagerChange(workspaceId) {
+        this.workspacePanelSnapshotService.invalidateTerminalManager(workspaceId);
+        for (const [, channel] of this.userChannels) {
+            for (const client of channel.clients) {
+                const subscription = this.clientTerminalManagerSubscriptions.get(client);
+                if (!subscription || subscription.workspaceId !== workspaceId) {
+                    continue;
                 }
+                this.scheduleTerminalManagerRefresh(client, {
+                    quietWindowMs: TERMINAL_MANAGER_REFRESH_QUIET_WINDOW_MS
+                });
             }
         }
     }
@@ -236,12 +264,11 @@ export class WorkbenchWsHub {
             clients: new Set(),
             lastWorkbenchPayload: null,
             workbenchTimer: null,
-            sidebarTimer: null,
+            workspaceManagementTimer: null,
             realtimeBroadcastTimer: null,
             realtimeBroadcastQueued: false,
             realtimeBroadcastTask: null,
-            refreshTask: null,
-            titleSyncTask: null
+            refreshTask: null
         };
         channel.workbenchTimer = setInterval(() => {
             if (!this.workbenchService.shouldRefreshSnapshot()) {
@@ -251,47 +278,16 @@ export class WorkbenchWsHub {
                 this.reportAsyncError("workbenchTimer", error, { userId });
             });
         }, WORKBENCH_REFRESH_INTERVAL_MS);
-        channel.sidebarTimer = setInterval(() => {
-            void this.refreshSidebarSubscriptions(userId).catch((error) => {
-                this.reportAsyncError("sidebarTimer", error, { userId });
-            });
-        }, SIDEBAR_REFRESH_INTERVAL_MS);
+        if (WORKSPACE_MANAGEMENT_TIMER_REFRESH_ENABLED) {
+            channel.workspaceManagementTimer = setInterval(() => {
+                void this.refreshWorkspaceManagementSubscriptions(userId).catch((error) => {
+                    this.reportAsyncError("workspaceManagementTimer", error, { userId });
+                });
+            }, WORKSPACE_MANAGEMENT_REFRESH_INTERVAL_MS);
+        }
         this.userChannels.set(userId, channel);
         return channel;
     }
-    async syncTitlesAndBroadcast(userId) {
-        const channel = this.getOrCreateChannel(userId);
-        if (channel.titleSyncTask) {
-            return channel.titleSyncTask;
-        }
-        channel.titleSyncTask = (async () => {
-            const startedAtMs = terminalDebugNowMs();
-            try {
-                const snapshot = await this.workbenchService
-                    .scheduleSessionTitleSync(userId, "workbench_ws.sync_titles")
-                    .promise;
-                const payload = buildWorkbenchPayload(snapshot);
-                if (payload === channel.lastWorkbenchPayload) {
-                    return;
-                }
-                channel.lastWorkbenchPayload = payload;
-                for (const client of channel.clients) {
-                    client.send(payload);
-                }
-                logTerminalDebug("workbench.sync_titles.completed", {
-                    userId,
-                    clientCount: channel.clients.size,
-                    durationMs: terminalDebugNowMs() - startedAtMs
-                });
-            }
-            catch (error) {
-                this.reportAsyncError("syncTitlesAndBroadcast", error, { userId });
-            }
-        })().finally(() => {
-            channel.titleSyncTask = null;
-        });
-        return channel.titleSyncTask;
-    }
     async sendWorkbenchSnapshotToClient(client, userId, channel) {
         try {
             const payload = buildWorkbenchPayload(this.workbenchService.getSnapshot(userId));
@@ -338,48 +334,30 @@ export class WorkbenchWsHub {
         });
         return channel.refreshTask;
     }
-    async refreshSidebarSubscriptions(userId) {
-        const channel = this.userChannels.get(userId);
-        if (!channel) {
-            return;
-        }
-        const startedAtMs = terminalDebugNowMs();
-        await Promise.all([...channel.clients].map(async (client) => {
-            const refreshTasks = [
-                this.refreshGitSubscription(client),
-                this.refreshTerminalManagerSubscription(client)
-            ];
-            if (WORKSPACE_MANAGEMENT_TIMER_REFRESH_ENABLED) {
-                refreshTasks.push(this.refreshWorkspaceManagementSubscription(client));
-            }
-            await Promise.allSettled(refreshTasks);
-        }));
-        logTerminalDebug("workbench.sidebar_refresh.completed", {
-            userId,
-            clientCount: channel.clients.size,
-            durationMs: terminalDebugNowMs() - startedAtMs
-        });
-    }
     ensureFileTreeSubscription(client, workspaceId, paths) {
         const current = this.clientFileTreeSubscriptions.get(client);
         const normalizedWorkspaceId = workspaceId.trim();
         const normalizedPaths = normalizePanelPaths(paths);
-        if (!current || current.workspaceId !== normalizedWorkspaceId) {
-            const next = {
-                workspaceId: normalizedWorkspaceId,
-                paths: normalizedPaths,
-                lastPayloadByPath: new Map()
-            };
-            this.clientFileTreeSubscriptions.set(client, next);
-            return next;
-        }
-        if (normalizedPaths.length > 0) {
-            current.paths = normalizedPaths;
-        }
-        if (current.paths.length === 0) {
-            current.paths = [""];
+        const nextPaths = normalizedPaths.length > 0 ? normalizedPaths : [""];
+        if (current &&
+            current.workspaceId === normalizedWorkspaceId &&
+            areStringArraysEqual(current.paths, nextPaths)) {
+            return current;
+        }
+        const next = {
+            workspaceId: normalizedWorkspaceId,
+            paths: nextPaths,
+            lastPayloadByPath: new Map()
+        };
+        this.fileWatcher.subscribeFileTree(normalizedWorkspaceId, nextPaths);
+        this.clientFileTreeSubscriptions.set(client, next);
+        if (current) {
+            this.fileWatcher.unsubscribeFileTree(current.workspaceId, current.paths);
         }
-        return current;
+        return next;
+    }
+    replaceFileTreeSubscription(client, workspaceId, paths) {
+        return this.ensureFileTreeSubscription(client, workspaceId, paths);
     }
     async refreshFileTreeSubscriptions(client, force = false) {
         const subscription = this.clientFileTreeSubscriptions.get(client);
@@ -405,21 +383,30 @@ export class WorkbenchWsHub {
             });
         }
     }
-    async refreshGitSubscription(client, force = false) {
+    async refreshGitSubscription(client, force = false, options) {
         const subscription = this.clientGitSubscriptions.get(client);
         if (!subscription) {
             return;
         }
         if (subscription.refreshTask) {
-            if (!force) {
+            subscription.queuedRefresh = true;
+            subscription.queuedForce = subscription.queuedForce || force;
+            if (!options?.deliverIfUnchanged) {
                 return subscription.refreshTask;
             }
-            subscription.refreshController?.abort(new Error("git subscription superseded"));
-            await subscription.refreshTask;
+            return await subscription.refreshTask.finally(() => {
+                if (subscription.lastPayload) {
+                    client.send(subscription.lastPayload);
+                }
+            });
         }
         const now = Date.now();
-        if (!force
+        if (!options?.ignoreMinInterval &&
+            !force
             && now - subscription.lastRequestedAt < GIT_SUBSCRIPTION_MIN_REFRESH_INTERVAL_MS) {
+            subscription.queuedRefresh = true;
+            subscription.queuedForce = subscription.queuedForce || force;
+            this.deferQueuedGitRefresh(client, GIT_SUBSCRIPTION_MIN_REFRESH_INTERVAL_MS - (now - subscription.lastRequestedAt));
             return;
         }
         subscription.lastRequestedAt = now;
@@ -436,7 +423,7 @@ export class WorkbenchWsHub {
                     return;
                 }
                 const payload = buildGitPayload(snapshot);
-                if (payload === subscription.lastPayload) {
+                if (payload === subscription.lastPayload && !options?.deliverIfUnchanged) {
                     return;
                 }
                 subscription.lastPayload = payload;
@@ -462,45 +449,190 @@ export class WorkbenchWsHub {
             if (subscription.refreshController === controller) {
                 subscription.refreshController = null;
             }
+            if (subscription.queuedRefresh && !subscription.refreshTimer) {
+                this.flushQueuedGitRefresh(client);
+            }
         });
         return subscription.refreshTask;
     }
-    abortGitRefresh(client, reason) {
-        this.clientGitSubscriptions.get(client)?.refreshController?.abort(new Error(reason));
+    ensureGitSubscription(client, workspaceId) {
+        const normalizedWorkspaceId = workspaceId.trim();
+        const current = this.clientGitSubscriptions.get(client);
+        if (current && current.workspaceId === normalizedWorkspaceId) {
+            return current;
+        }
+        const next = {
+            workspaceId: normalizedWorkspaceId,
+            lastPayload: null,
+            lastRequestedAt: 0,
+            refreshTask: null,
+            refreshController: null,
+            refreshTimer: null,
+            queuedRefresh: false,
+            queuedForce: false
+        };
+        this.fileWatcher.subscribeGit(normalizedWorkspaceId);
+        this.clientGitSubscriptions.set(client, next);
+        if (current) {
+            current.refreshController?.abort(new Error("git subscription replaced"));
+            if (current.refreshTimer) {
+                clearTimeout(current.refreshTimer);
+            }
+            this.fileWatcher.unsubscribeGit(current.workspaceId);
+        }
+        return next;
     }
-    async refreshTerminalManagerSubscription(client, force = false) {
+    scheduleGitRefresh(client, options) {
+        const subscription = this.clientGitSubscriptions.get(client);
+        if (!subscription) {
+            return;
+        }
+        subscription.queuedRefresh = true;
+        subscription.queuedForce = subscription.queuedForce || (options?.force ?? false);
+        if (subscription.refreshTimer) {
+            clearTimeout(subscription.refreshTimer);
+            subscription.refreshTimer = null;
+        }
+        const quietWindowMs = options?.quietWindowMs ?? 0;
+        if (quietWindowMs > 0) {
+            this.deferQueuedGitRefresh(client, quietWindowMs);
+            return;
+        }
+        this.flushQueuedGitRefresh(client);
+    }
+    flushQueuedGitRefresh(client) {
+        const subscription = this.clientGitSubscriptions.get(client);
+        if (!subscription || subscription.refreshTimer || subscription.refreshTask || !subscription.queuedRefresh) {
+            return;
+        }
+        const force = subscription.queuedForce;
+        subscription.queuedRefresh = false;
+        subscription.queuedForce = false;
+        void this.refreshGitSubscription(client, force);
+    }
+    deferQueuedGitRefresh(client, delayMs) {
+        const subscription = this.clientGitSubscriptions.get(client);
+        if (!subscription) {
+            return;
+        }
+        if (subscription.refreshTimer) {
+            clearTimeout(subscription.refreshTimer);
+        }
+        subscription.refreshTimer = setTimeout(() => {
+            subscription.refreshTimer = null;
+            this.flushQueuedGitRefresh(client);
+        }, Math.max(0, delayMs));
+    }
+    ensureTerminalManagerSubscription(client, workspaceId) {
+        const normalizedWorkspaceId = workspaceId.trim();
+        const current = this.clientTerminalManagerSubscriptions.get(client);
+        if (current && current.workspaceId === normalizedWorkspaceId) {
+            return current;
+        }
+        if (current?.refreshTimer) {
+            clearTimeout(current.refreshTimer);
+        }
+        const next = {
+            workspaceId: normalizedWorkspaceId,
+            lastPayload: null,
+            refreshTask: null,
+            refreshTimer: null,
+            queuedRefresh: false,
+            queuedForce: false
+        };
+        this.clientTerminalManagerSubscriptions.set(client, next);
+        return next;
+    }
+    scheduleTerminalManagerRefresh(client, options) {
         const subscription = this.clientTerminalManagerSubscriptions.get(client);
         if (!subscription) {
             return;
         }
-        try {
-            const startedAtMs = terminalDebugNowMs();
-            const snapshot = await this.workspacePanelSnapshotService.getTerminalManagerSnapshot(subscription.workspaceId, { force });
-            const payloadStartedAtMs = terminalDebugNowMs();
-            const payload = buildTerminalManagerPayload(snapshot);
-            const payloadBuildMs = terminalDebugNowMs() - payloadStartedAtMs;
-            if (payload === subscription.lastPayload) {
-                return;
-            }
-            subscription.lastPayload = payload;
-            const sendStartedAtMs = terminalDebugNowMs();
-            client.send(payload);
-            logTerminalDebug("workbench.terminal_manager_refresh.completed", {
-                workspaceId: subscription.workspaceId,
-                force,
-                terminalCount: snapshot.terminals.length,
-                templateCount: snapshot.templates.length,
-                templateStatusCount: snapshot.templateStatuses.length,
-                payloadBuildMs,
-                sendMs: terminalDebugNowMs() - sendStartedAtMs,
-                durationMs: terminalDebugNowMs() - startedAtMs
-            });
+        subscription.queuedRefresh = true;
+        subscription.queuedForce = subscription.queuedForce || (options?.force ?? false);
+        if (subscription.refreshTimer) {
+            clearTimeout(subscription.refreshTimer);
+            subscription.refreshTimer = null;
         }
-        catch (error) {
-            this.reportAsyncError("refreshTerminalManagerSubscription", error, {
-                workspaceId: subscription.workspaceId
-            });
+        const quietWindowMs = options?.quietWindowMs ?? 0;
+        if (quietWindowMs > 0) {
+            this.deferQueuedTerminalManagerRefresh(client, quietWindowMs);
+            return;
+        }
+        this.flushQueuedTerminalManagerRefresh(client);
+    }
+    flushQueuedTerminalManagerRefresh(client) {
+        const subscription = this.clientTerminalManagerSubscriptions.get(client);
+        if (!subscription || subscription.refreshTimer || !subscription.queuedRefresh) {
+            return;
+        }
+        if (subscription.refreshTask) {
+            return;
         }
+        const force = subscription.queuedForce;
+        subscription.queuedRefresh = false;
+        subscription.queuedForce = false;
+        void this.refreshTerminalManagerSubscription(client, force);
+    }
+    deferQueuedTerminalManagerRefresh(client, delayMs) {
+        const subscription = this.clientTerminalManagerSubscriptions.get(client);
+        if (!subscription) {
+            return;
+        }
+        if (subscription.refreshTimer) {
+            clearTimeout(subscription.refreshTimer);
+        }
+        subscription.refreshTimer = setTimeout(() => {
+            subscription.refreshTimer = null;
+            this.flushQueuedTerminalManagerRefresh(client);
+        }, Math.max(0, delayMs));
+    }
+    async refreshTerminalManagerSubscription(client, force = false) {
+        const subscription = this.clientTerminalManagerSubscriptions.get(client);
+        if (!subscription) {
+            return;
+        }
+        if (subscription.refreshTask) {
+            subscription.queuedRefresh = true;
+            subscription.queuedForce = subscription.queuedForce || force;
+            return subscription.refreshTask;
+        }
+        subscription.refreshTask = (async () => {
+            try {
+                const startedAtMs = terminalDebugNowMs();
+                const snapshot = await this.workspacePanelSnapshotService.getTerminalManagerSnapshot(subscription.workspaceId, { force });
+                const payloadStartedAtMs = terminalDebugNowMs();
+                const payload = buildTerminalManagerPayload(snapshot);
+                const payloadBuildMs = terminalDebugNowMs() - payloadStartedAtMs;
+                if (payload === subscription.lastPayload) {
+                    return;
+                }
+                subscription.lastPayload = payload;
+                const sendStartedAtMs = terminalDebugNowMs();
+                client.send(payload);
+                logTerminalDebug("workbench.terminal_manager_refresh.completed", {
+                    workspaceId: subscription.workspaceId,
+                    force,
+                    terminalCount: snapshot.terminals.length,
+                    templateCount: snapshot.templates.length,
+                    templateStatusCount: snapshot.templateStatuses.length,
+                    payloadBuildMs,
+                    sendMs: terminalDebugNowMs() - sendStartedAtMs,
+                    durationMs: terminalDebugNowMs() - startedAtMs
+                });
+            }
+            catch (error) {
+                this.reportAsyncError("refreshTerminalManagerSubscription", error, {
+                    workspaceId: subscription.workspaceId
+                });
+            }
+        })().finally(() => {
+            subscription.refreshTask = null;
+            if (subscription.queuedRefresh && !subscription.refreshTimer) {
+                this.flushQueuedTerminalManagerRefresh(client);
+            }
+        });
+        return subscription.refreshTask;
     }
     async refreshWorkspaceManagementSubscription(client, force = false) {
         const subscription = this.clientWorkspaceManagementSubscriptions.get(client);
@@ -522,6 +654,13 @@ export class WorkbenchWsHub {
             });
         }
     }
+    async refreshWorkspaceManagementSubscriptions(userId) {
+        const channel = this.userChannels.get(userId);
+        if (!channel) {
+            return;
+        }
+        await Promise.allSettled([...channel.clients].map((client) => this.refreshWorkspaceManagementSubscription(client)));
+    }
     reportAsyncError(scope, error, context = {}) {
         const appError = error instanceof AppError
             ? error
@@ -596,6 +735,21 @@ function parseWorkbenchMessage(payload) {
             return null;
     }
 }
+function extractWorkspaceIdFromWorkbenchMessage(message) {
+    switch (message.type) {
+        case "fileTree.subscribe":
+        case "fileTree.refresh":
+        case "git.subscribe":
+        case "git.refresh":
+        case "terminalManager.subscribe":
+        case "terminalManager.refresh":
+        case "workspaceManagement.subscribe":
+        case "workspaceManagement.refresh":
+            return message.workspaceId.trim();
+        default:
+            return undefined;
+    }
+}
 function normalizePanelPaths(paths) {
     const uniquePaths = new Set();
     for (const value of paths ?? [""]) {
@@ -604,6 +758,12 @@ function normalizePanelPaths(paths) {
     }
     return [...uniquePaths];
 }
+function areStringArraysEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
 function buildWorkbenchPayload(snapshot) {
     return JSON.stringify({
         type: "workbench.snapshot",