@jingyi0605/codingns 0.4.0 → 0.5.1

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

@@ -39,69 +39,80 @@ 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);
-                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;
+        try {
+            switch (message.type) {
+                case "workbench.subscribe":
+                    void this.sendWorkbenchSnapshotToClient(client, userId, channel, message.knownRevision);
+                    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, message.knownRevisions);
+                    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, message.knownRevisions);
+                    void this.refreshFileTreeSubscriptions(client, true);
+                    return true;
+                case "git.subscribe":
+                    this.ensureGitSubscription(client, message.workspaceId, message.knownRevision);
+                    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, message.knownRevision);
+                    this.scheduleGitRefresh(client, {
+                        force: true
+                    });
+                    return true;
+                case "terminalManager.subscribe":
+                    this.ensureTerminalManagerSubscription(client, message.workspaceId, message.knownRevision);
+                    this.scheduleTerminalManagerRefresh(client);
+                    return true;
+                case "terminalManager.refresh":
+                    this.workspacePanelSnapshotService.invalidateTerminalManager(message.workspaceId.trim());
+                    this.ensureTerminalManagerSubscription(client, message.workspaceId, message.knownRevision);
+                    this.scheduleTerminalManagerRefresh(client, {
+                        force: true
+                    });
+                    return true;
+                case "workspaceManagement.subscribe":
+                    this.clientWorkspaceManagementSubscriptions.set(client, {
+                        workspaceId: message.workspaceId.trim(),
+                        lastPayload: null,
+                        knownRevision: normalizeKnownRevision(message.knownRevision) ?? 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,
+                        knownRevision: normalizeKnownRevision(message.knownRevision) ?? 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) {
@@ -178,11 +189,13 @@ export class WorkbenchWsHub {
         channel.realtimeBroadcastTask = (async () => {
             const startedAtMs = terminalDebugNowMs();
             try {
-                const payload = buildWorkbenchPayload(this.workbenchService.getSnapshot(userId));
+                const snapshot = this.workbenchService.getSnapshot(userId);
+                const payload = buildWorkbenchPayload(snapshot);
                 if (payload === channel.lastWorkbenchPayload) {
                     return;
                 }
                 channel.lastWorkbenchPayload = payload;
+                channel.lastWorkbenchRevision = snapshot.revision;
                 for (const client of channel.clients) {
                     client.send(payload);
                 }
@@ -254,6 +267,7 @@ export class WorkbenchWsHub {
         channel = {
             clients: new Set(),
             lastWorkbenchPayload: null,
+            lastWorkbenchRevision: null,
             workbenchTimer: null,
             workspaceManagementTimer: null,
             realtimeBroadcastTimer: null,
@@ -279,11 +293,12 @@ export class WorkbenchWsHub {
         this.userChannels.set(userId, channel);
         return channel;
     }
-    async sendWorkbenchSnapshotToClient(client, userId, channel) {
+    async sendWorkbenchSnapshotToClient(client, userId, channel, knownRevision) {
         try {
-            const payload = buildWorkbenchPayload(this.workbenchService.getSnapshot(userId));
-            channel.lastWorkbenchPayload = payload;
-            client.send(payload);
+            const snapshot = this.workbenchService.getSnapshot(userId);
+            channel.lastWorkbenchPayload = buildWorkbenchPayload(snapshot);
+            channel.lastWorkbenchRevision = snapshot.revision;
+            client.send(buildWorkbenchPayload(snapshot, knownRevision));
         }
         catch (error) {
             this.reportAsyncError("sendWorkbenchSnapshotToClient", error, { userId });
@@ -306,6 +321,7 @@ export class WorkbenchWsHub {
                     return;
                 }
                 channel.lastWorkbenchPayload = payload;
+                channel.lastWorkbenchRevision = snapshot.revision;
                 for (const client of channel.clients) {
                     client.send(payload);
                 }
@@ -325,30 +341,33 @@ export class WorkbenchWsHub {
         });
         return channel.refreshTask;
     }
-    ensureFileTreeSubscription(client, workspaceId, paths) {
+    ensureFileTreeSubscription(client, workspaceId, paths, knownRevisions) {
         const current = this.clientFileTreeSubscriptions.get(client);
         const normalizedWorkspaceId = workspaceId.trim();
         const normalizedPaths = normalizePanelPaths(paths);
         const nextPaths = normalizedPaths.length > 0 ? normalizedPaths : [""];
+        const nextKnownRevisionByPath = buildKnownRevisionByPathMap(nextPaths, knownRevisions);
         if (current &&
             current.workspaceId === normalizedWorkspaceId &&
             areStringArraysEqual(current.paths, nextPaths)) {
+            current.knownRevisionByPath = nextKnownRevisionByPath;
             return current;
         }
-        if (current) {
-            this.fileWatcher.unsubscribeFileTree(current.workspaceId, current.paths);
-        }
         const next = {
             workspaceId: normalizedWorkspaceId,
             paths: nextPaths,
-            lastPayloadByPath: new Map()
+            lastPayloadByPath: new Map(),
+            knownRevisionByPath: nextKnownRevisionByPath
         };
-        this.clientFileTreeSubscriptions.set(client, next);
         this.fileWatcher.subscribeFileTree(normalizedWorkspaceId, nextPaths);
+        this.clientFileTreeSubscriptions.set(client, next);
+        if (current) {
+            this.fileWatcher.unsubscribeFileTree(current.workspaceId, current.paths);
+        }
         return next;
     }
-    replaceFileTreeSubscription(client, workspaceId, paths) {
-        return this.ensureFileTreeSubscription(client, workspaceId, paths);
+    replaceFileTreeSubscription(client, workspaceId, paths, knownRevisions) {
+        return this.ensureFileTreeSubscription(client, workspaceId, paths, knownRevisions);
     }
     async refreshFileTreeSubscriptions(client, force = false) {
         const subscription = this.clientFileTreeSubscriptions.get(client);
@@ -359,11 +378,12 @@ export class WorkbenchWsHub {
             const uniquePaths = normalizePanelPaths(subscription.paths);
             for (const path of uniquePaths) {
                 const snapshot = await this.workspacePanelSnapshotService.getFileTreeSnapshot(subscription.workspaceId, path, { force });
-                const payload = buildFileTreePayload(snapshot);
+                const payload = buildFileTreePayload(snapshot, subscription.knownRevisionByPath.get(path) ?? null);
                 const lastPayload = subscription.lastPayloadByPath.get(path) ?? null;
                 if (payload === lastPayload) {
                     continue;
                 }
+                subscription.knownRevisionByPath.set(path, snapshot.revision);
                 subscription.lastPayloadByPath.set(path, payload);
                 client.send(payload);
             }
@@ -413,10 +433,11 @@ export class WorkbenchWsHub {
                 if (controller.signal.aborted) {
                     return;
                 }
-                const payload = buildGitPayload(snapshot);
+                const payload = buildGitPayload(snapshot, subscription.knownRevision);
                 if (payload === subscription.lastPayload && !options?.deliverIfUnchanged) {
                     return;
                 }
+                subscription.knownRevision = snapshot.revision;
                 subscription.lastPayload = payload;
                 client.send(payload);
                 logTerminalDebug("workbench.git_refresh.completed", {
@@ -446,22 +467,18 @@ export class WorkbenchWsHub {
         });
         return subscription.refreshTask;
     }
-    ensureGitSubscription(client, workspaceId) {
+    ensureGitSubscription(client, workspaceId, knownRevision) {
         const normalizedWorkspaceId = workspaceId.trim();
         const current = this.clientGitSubscriptions.get(client);
+        const normalizedKnownRevision = normalizeKnownRevision(knownRevision) ?? null;
         if (current && current.workspaceId === normalizedWorkspaceId) {
+            current.knownRevision = normalizedKnownRevision;
             return current;
         }
-        if (current) {
-            current.refreshController?.abort(new Error("git subscription replaced"));
-            if (current.refreshTimer) {
-                clearTimeout(current.refreshTimer);
-            }
-            this.fileWatcher.unsubscribeGit(current.workspaceId);
-        }
         const next = {
             workspaceId: normalizedWorkspaceId,
             lastPayload: null,
+            knownRevision: normalizedKnownRevision,
             lastRequestedAt: 0,
             refreshTask: null,
             refreshController: null,
@@ -469,8 +486,15 @@ export class WorkbenchWsHub {
             queuedRefresh: false,
             queuedForce: false
         };
-        this.clientGitSubscriptions.set(client, next);
         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;
     }
     scheduleGitRefresh(client, options) {
@@ -514,10 +538,12 @@ export class WorkbenchWsHub {
             this.flushQueuedGitRefresh(client);
         }, Math.max(0, delayMs));
     }
-    ensureTerminalManagerSubscription(client, workspaceId) {
+    ensureTerminalManagerSubscription(client, workspaceId, knownRevision) {
         const normalizedWorkspaceId = workspaceId.trim();
         const current = this.clientTerminalManagerSubscriptions.get(client);
+        const normalizedKnownRevision = normalizeKnownRevision(knownRevision) ?? null;
         if (current && current.workspaceId === normalizedWorkspaceId) {
+            current.knownRevision = normalizedKnownRevision;
             return current;
         }
         if (current?.refreshTimer) {
@@ -526,6 +552,7 @@ export class WorkbenchWsHub {
         const next = {
             workspaceId: normalizedWorkspaceId,
             lastPayload: null,
+            knownRevision: normalizedKnownRevision,
             refreshTask: null,
             refreshTimer: null,
             queuedRefresh: false,
@@ -593,11 +620,12 @@ export class WorkbenchWsHub {
                 const startedAtMs = terminalDebugNowMs();
                 const snapshot = await this.workspacePanelSnapshotService.getTerminalManagerSnapshot(subscription.workspaceId, { force });
                 const payloadStartedAtMs = terminalDebugNowMs();
-                const payload = buildTerminalManagerPayload(snapshot);
+                const payload = buildTerminalManagerPayload(snapshot, subscription.knownRevision);
                 const payloadBuildMs = terminalDebugNowMs() - payloadStartedAtMs;
                 if (payload === subscription.lastPayload) {
                     return;
                 }
+                subscription.knownRevision = snapshot.revision;
                 subscription.lastPayload = payload;
                 const sendStartedAtMs = terminalDebugNowMs();
                 client.send(payload);
@@ -632,10 +660,11 @@ export class WorkbenchWsHub {
         }
         try {
             const snapshot = await this.workspacePanelSnapshotService.getWorkspaceManagementSnapshot(subscription.workspaceId, { force });
-            const payload = buildWorkspaceManagementPayload(snapshot);
+            const payload = buildWorkspaceManagementPayload(snapshot, subscription.knownRevision);
             if (payload === subscription.lastPayload) {
                 return;
             }
+            subscription.knownRevision = snapshot.revision;
             subscription.lastPayload = payload;
             client.send(payload);
         }
@@ -691,7 +720,8 @@ function parseWorkbenchMessage(payload) {
         case "workbench.subscribe":
         case "workbench.refresh":
             return {
-                type: candidate.type
+                type: candidate.type,
+                knownRevision: normalizeKnownRevision(candidate.knownRevision)
             };
         case "fileTree.subscribe":
         case "fileTree.refresh":
@@ -701,7 +731,8 @@ function parseWorkbenchMessage(payload) {
                     workspaceId: candidate.workspaceId,
                     paths: Array.isArray(candidate.paths)
                         ? candidate.paths.filter((value) => typeof value === "string")
-                        : undefined
+                        : undefined,
+                    knownRevisions: normalizeKnownRevisionRecord(candidate.knownRevisions)
                 }
                 : null;
         case "git.subscribe":
@@ -709,7 +740,8 @@ function parseWorkbenchMessage(payload) {
             return typeof candidate.workspaceId === "string"
                 ? {
                     type: candidate.type,
-                    workspaceId: candidate.workspaceId
+                    workspaceId: candidate.workspaceId,
+                    knownRevision: normalizeKnownRevision(candidate.knownRevision)
                 }
                 : null;
         case "terminalManager.subscribe":
@@ -719,13 +751,29 @@ function parseWorkbenchMessage(payload) {
             return typeof candidate.workspaceId === "string"
                 ? {
                     type: candidate.type,
-                    workspaceId: candidate.workspaceId
+                    workspaceId: candidate.workspaceId,
+                    knownRevision: normalizeKnownRevision(candidate.knownRevision)
                 }
                 : null;
         default:
             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 ?? [""]) {
@@ -740,34 +788,112 @@ function areStringArraysEqual(left, right) {
     }
     return left.every((value, index) => value === right[index]);
 }
-function buildWorkbenchPayload(snapshot) {
+function buildWorkbenchPayload(snapshot, knownRevision) {
+    if (knownRevision && knownRevision === snapshot.revision) {
+        return JSON.stringify({
+            type: "workbench.snapshot",
+            revision: snapshot.revision,
+            unchanged: true,
+            snapshot: null
+        });
+    }
     return JSON.stringify({
         type: "workbench.snapshot",
+        revision: snapshot.revision,
+        unchanged: false,
         snapshot
     });
 }
-function buildFileTreePayload(snapshot) {
+function buildFileTreePayload(snapshot, knownRevision) {
+    if (knownRevision && knownRevision === snapshot.revision) {
+        return JSON.stringify({
+            type: "fileTree.snapshot",
+            revision: snapshot.revision,
+            unchanged: true,
+            snapshot: null
+        });
+    }
     return JSON.stringify({
         type: "fileTree.snapshot",
+        revision: snapshot.revision,
+        unchanged: false,
         snapshot
     });
 }
-function buildGitPayload(snapshot) {
+function buildGitPayload(snapshot, knownRevision) {
+    if (knownRevision && knownRevision === snapshot.revision) {
+        return JSON.stringify({
+            type: "git.snapshot",
+            revision: snapshot.revision,
+            unchanged: true,
+            snapshot: null
+        });
+    }
     return JSON.stringify({
         type: "git.snapshot",
+        revision: snapshot.revision,
+        unchanged: false,
         snapshot
     });
 }
-function buildTerminalManagerPayload(snapshot) {
+function buildTerminalManagerPayload(snapshot, knownRevision) {
+    if (knownRevision && knownRevision === snapshot.revision) {
+        return JSON.stringify({
+            type: "terminalManager.snapshot",
+            revision: snapshot.revision,
+            unchanged: true,
+            snapshot: null
+        });
+    }
     return JSON.stringify({
         type: "terminalManager.snapshot",
+        revision: snapshot.revision,
+        unchanged: false,
         snapshot
     });
 }
-function buildWorkspaceManagementPayload(snapshot) {
+function buildWorkspaceManagementPayload(snapshot, knownRevision) {
+    if (knownRevision && knownRevision === snapshot.revision) {
+        return JSON.stringify({
+            type: "workspaceManagement.snapshot",
+            revision: snapshot.revision,
+            unchanged: true,
+            snapshot: null
+        });
+    }
     return JSON.stringify({
         type: "workspaceManagement.snapshot",
+        revision: snapshot.revision,
+        unchanged: false,
         snapshot
     });
 }
+function normalizeKnownRevision(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function normalizeKnownRevisionRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const normalizedEntries = Object.entries(value)
+        .map(([key, candidate]) => [key.trim(), normalizeKnownRevision(candidate)])
+        .filter((entry) => Boolean(entry[1]));
+    if (normalizedEntries.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(normalizedEntries);
+}
+function buildKnownRevisionByPathMap(paths, knownRevisions) {
+    const map = new Map();
+    if (!knownRevisions) {
+        return map;
+    }
+    for (const path of paths) {
+        const knownRevision = knownRevisions[path];
+        if (knownRevision) {
+            map.set(path, knownRevision);
+        }
+    }
+    return map;
+}
 //# sourceMappingURL=workbench-ws-hub.js.map