@getpaseo/server 0.1.26 → 0.1.27

package/dist/server/server/session.js

@@ -699,6 +699,100 @@ export class Session {
             paseoHome: this.paseoHome,
         });
     }
+    buildPersistedProjectRecord(input) {
+        return createPersistedProjectRecord({
+            projectId: input.placement.projectKey,
+            rootPath: deriveProjectRootPath({
+                cwd: input.workspaceId,
+                checkout: input.placement.checkout,
+            }),
+            kind: deriveProjectKind(input.placement.checkout),
+            displayName: input.placement.projectName,
+            createdAt: input.createdAt,
+            updatedAt: input.updatedAt,
+            archivedAt: null,
+        });
+    }
+    buildPersistedWorkspaceRecord(input) {
+        return createPersistedWorkspaceRecord({
+            workspaceId: input.workspaceId,
+            projectId: input.placement.projectKey,
+            cwd: input.workspaceId,
+            kind: deriveWorkspaceKind(input.placement.checkout),
+            displayName: deriveWorkspaceDisplayName({
+                cwd: input.workspaceId,
+                checkout: input.placement.checkout,
+            }),
+            createdAt: input.createdAt,
+            updatedAt: input.updatedAt,
+            archivedAt: null,
+        });
+    }
+    async archiveProjectRecordIfEmpty(projectId, archivedAt) {
+        const siblingWorkspaces = (await this.workspaceRegistry.list()).filter((workspace) => workspace.projectId === projectId && !workspace.archivedAt);
+        if (siblingWorkspaces.length === 0) {
+            await this.projectRegistry.archive(projectId, archivedAt);
+        }
+    }
+    async reconcileWorkspaceRecord(workspaceId) {
+        const normalizedWorkspaceId = normalizePersistedWorkspaceId(workspaceId);
+        const existing = await this.workspaceRegistry.get(normalizedWorkspaceId);
+        const placement = await this.buildProjectPlacement(normalizedWorkspaceId);
+        const now = new Date().toISOString();
+        const nextProjectCreatedAt = existing?.createdAt ?? now;
+        const nextWorkspaceCreatedAt = existing?.createdAt ?? now;
+        const currentProjectRecord = await this.projectRegistry.get(placement.projectKey);
+        const nextProjectRecord = this.buildPersistedProjectRecord({
+            workspaceId: normalizedWorkspaceId,
+            placement,
+            createdAt: currentProjectRecord?.createdAt ?? nextProjectCreatedAt,
+            updatedAt: now,
+        });
+        const nextWorkspaceRecord = this.buildPersistedWorkspaceRecord({
+            workspaceId: normalizedWorkspaceId,
+            placement,
+            createdAt: nextWorkspaceCreatedAt,
+            updatedAt: now,
+        });
+        const needsWorkspaceUpdate = !existing ||
+            existing.archivedAt ||
+            existing.projectId !== nextWorkspaceRecord.projectId ||
+            existing.kind !== nextWorkspaceRecord.kind ||
+            existing.displayName !== nextWorkspaceRecord.displayName;
+        const needsProjectUpdate = !currentProjectRecord ||
+            currentProjectRecord.archivedAt ||
+            currentProjectRecord.rootPath !== nextProjectRecord.rootPath ||
+            currentProjectRecord.kind !== nextProjectRecord.kind ||
+            currentProjectRecord.displayName !== nextProjectRecord.displayName;
+        if (!needsWorkspaceUpdate && !needsProjectUpdate) {
+            return {
+                workspace: existing,
+                changed: false,
+            };
+        }
+        await this.projectRegistry.upsert(nextProjectRecord);
+        await this.workspaceRegistry.upsert(nextWorkspaceRecord);
+        if (existing &&
+            !existing.archivedAt &&
+            existing.projectId !== nextWorkspaceRecord.projectId) {
+            await this.archiveProjectRecordIfEmpty(existing.projectId, now);
+        }
+        return {
+            workspace: nextWorkspaceRecord,
+            changed: true,
+        };
+    }
+    async reconcileActiveWorkspaceRecords() {
+        const changedWorkspaceIds = new Set();
+        const activeWorkspaces = (await this.workspaceRegistry.list()).filter((workspace) => !workspace.archivedAt);
+        for (const workspace of activeWorkspaces) {
+            const result = await this.reconcileWorkspaceRecord(workspace.workspaceId);
+            if (result.changed) {
+                changedWorkspaceIds.add(result.workspace.workspaceId);
+            }
+        }
+        return changedWorkspaceIds;
+    }
     async forwardAgentUpdate(agent) {
         try {
             await this.ensureWorkspaceRegistered(agent.cwd);
@@ -4027,7 +4121,7 @@ export class Session {
             diffStat,
         };
     }
-    async listWorkspaceDescriptors() {
+    async listWorkspaceDescriptorsSnapshot() {
         const [agents, persistedWorkspaces, persistedProjects] = await Promise.all([
             this.listAgentPayloads(),
             this.workspaceRegistry.list(),
@@ -4058,6 +4152,10 @@ export class Session {
         }
         return Array.from(descriptorsByWorkspaceId.values());
     }
+    async listWorkspaceDescriptors() {
+        await this.reconcileActiveWorkspaceRecords();
+        return this.listWorkspaceDescriptorsSnapshot();
+    }
     normalizeFetchWorkspacesSort(sort) {
         const fallback = [{ key: 'activity_at', direction: 'desc' }];
         if (!sort || sort.length === 0) {
@@ -4257,41 +4355,7 @@ export class Session {
     }
     async ensureWorkspaceRegistered(cwd) {
         const workspaceId = normalizePersistedWorkspaceId(cwd);
-        const existing = await this.workspaceRegistry.get(workspaceId);
-        if (existing && !existing.archivedAt) {
-            return existing;
-        }
-        const placement = await this.buildProjectPlacement(workspaceId);
-        const now = new Date().toISOString();
-        const projectExisting = await this.projectRegistry.get(placement.projectKey);
-        const projectRecord = createPersistedProjectRecord({
-            projectId: placement.projectKey,
-            rootPath: deriveProjectRootPath({
-                cwd: workspaceId,
-                checkout: placement.checkout,
-            }),
-            kind: deriveProjectKind(placement.checkout),
-            displayName: placement.projectName,
-            createdAt: projectExisting?.createdAt ?? now,
-            updatedAt: now,
-            archivedAt: null,
-        });
-        await this.projectRegistry.upsert(projectRecord);
-        const workspaceRecord = createPersistedWorkspaceRecord({
-            workspaceId,
-            projectId: placement.projectKey,
-            cwd: workspaceId,
-            kind: deriveWorkspaceKind(placement.checkout),
-            displayName: deriveWorkspaceDisplayName({
-                cwd: workspaceId,
-                checkout: placement.checkout,
-            }),
-            createdAt: existing?.createdAt ?? now,
-            updatedAt: now,
-            archivedAt: null,
-        });
-        await this.workspaceRegistry.upsert(workspaceRecord);
-        return workspaceRecord;
+        return (await this.reconcileWorkspaceRecord(workspaceId)).workspace;
     }
     async archiveWorkspaceRecord(workspaceId, archivedAt) {
         const existing = await this.workspaceRegistry.get(workspaceId);
@@ -4311,32 +4375,31 @@ export class Session {
             return;
         }
         const workspaceId = normalizePersistedWorkspaceId(cwd);
-        const all = await this.listWorkspaceDescriptors();
-        const workspace = all.find((entry) => entry.id === workspaceId);
-        if (!workspace) {
-            this.bufferOrEmitWorkspaceUpdate(subscription, {
-                kind: 'remove',
-                id: workspaceId,
-            });
-            return;
-        }
-        if (!this.matchesWorkspaceFilter({ workspace, filter: subscription.filter })) {
+        const changedWorkspaceIds = await this.reconcileActiveWorkspaceRecords();
+        const all = await this.listWorkspaceDescriptorsSnapshot();
+        const descriptorsByWorkspaceId = new Map(all.map((entry) => [entry.id, entry]));
+        const workspaceIdsToEmit = new Set([workspaceId, ...changedWorkspaceIds]);
+        for (const nextWorkspaceId of workspaceIdsToEmit) {
+            const workspace = descriptorsByWorkspaceId.get(nextWorkspaceId);
+            if (!workspace || !this.matchesWorkspaceFilter({ workspace, filter: subscription.filter })) {
+                this.bufferOrEmitWorkspaceUpdate(subscription, {
+                    kind: 'remove',
+                    id: nextWorkspaceId,
+                });
+                continue;
+            }
             this.bufferOrEmitWorkspaceUpdate(subscription, {
-                kind: 'remove',
-                id: workspaceId,
+                kind: 'upsert',
+                workspace,
             });
-            return;
         }
-        this.bufferOrEmitWorkspaceUpdate(subscription, {
-            kind: 'upsert',
-            workspace,
-        });
     }
     async emitWorkspaceUpdatesForCwds(cwds) {
         if (!this.workspaceUpdatesSubscription) {
             return;
         }
-        const uniqueWorkspaceCwds = new Set();
+        const changedWorkspaceIds = await this.reconcileActiveWorkspaceRecords();
+        const uniqueWorkspaceCwds = new Set(changedWorkspaceIds);
         for (const cwd of cwds) {
             const normalized = normalizePersistedWorkspaceId(cwd);
             if (!normalized) {
@@ -4344,8 +4407,22 @@ export class Session {
             }
             uniqueWorkspaceCwds.add(normalized);
         }
-        for (const workspaceCwd of uniqueWorkspaceCwds) {
-            await this.emitWorkspaceUpdateForCwd(workspaceCwd);
+        const subscription = this.workspaceUpdatesSubscription;
+        const all = await this.listWorkspaceDescriptorsSnapshot();
+        const descriptorsByWorkspaceId = new Map(all.map((entry) => [entry.id, entry]));
+        for (const workspaceId of uniqueWorkspaceCwds) {
+            const workspace = descriptorsByWorkspaceId.get(workspaceId);
+            if (!workspace || !this.matchesWorkspaceFilter({ workspace, filter: subscription.filter })) {
+                this.bufferOrEmitWorkspaceUpdate(subscription, {
+                    kind: 'remove',
+                    id: workspaceId,
+                });
+                continue;
+            }
+            this.bufferOrEmitWorkspaceUpdate(subscription, {
+                kind: 'upsert',
+                workspace,
+            });
         }
     }
     async handleFetchAgents(request) {
@@ -5749,7 +5826,7 @@ export class Session {
         const streamId = this.allocateTerminalStreamId();
         const requestedResumeOffset = typeof msg.resumeOffset === 'number'
             ? msg.resumeOffset
-            : session.getOutputOffset();
+            : 0;
         const initialOffset = Math.max(0, Math.floor(requestedResumeOffset));
         const binding = {
             terminalId: msg.terminalId,