collabmd 0.1.20 → 0.1.21

package/src/server/domain/collaboration/collaboration-room.js

@@ -17,6 +17,8 @@ import {
   serializeExcalidrawRoomScene,
   tryParseExcalidrawSceneJson,
 } from '../../../domain/excalidraw-room-codec.js';
+import { normalizeWorkspaceEvent } from '../../../domain/workspace-change.js';
+import { WORKSPACE_EVENT_MAX_MESSAGES, WORKSPACE_ROOM_NAME } from '../../../domain/workspace-room.js';
 
 function closeSlowClient(ws, clientState, { maxBufferedAmountBytes, name }) {
   if (!clientState || clientState.backpressureCloseIssued) {
@@ -86,6 +88,41 @@ function isExcalidrawRoom(name) {
   return typeof name === 'string' && name.endsWith('.excalidraw');
 }
 
+function isWorkspaceRoom(name) {
+  return name === WORKSPACE_ROOM_NAME;
+}
+
+function computeTextReplacement(currentContent, nextContent) {
+  const currentText = String(currentContent ?? '');
+  const nextText = String(nextContent ?? '');
+  if (currentText === nextText) {
+    return null;
+  }
+
+  let prefixLength = 0;
+  const maxPrefix = Math.min(currentText.length, nextText.length);
+  while (prefixLength < maxPrefix && currentText[prefixLength] === nextText[prefixLength]) {
+    prefixLength += 1;
+  }
+
+  let currentSuffixLength = currentText.length;
+  let nextSuffixLength = nextText.length;
+  while (
+    currentSuffixLength > prefixLength
+    && nextSuffixLength > prefixLength
+    && currentText[currentSuffixLength - 1] === nextText[nextSuffixLength - 1]
+  ) {
+    currentSuffixLength -= 1;
+    nextSuffixLength -= 1;
+  }
+
+  return {
+    deleteCount: currentSuffixLength - prefixLength,
+    insertText: nextText.slice(prefixLength, nextSuffixLength),
+    start: prefixLength,
+  };
+}
+
 export class CollaborationRoom {
   constructor({
     documentStore = null,
@@ -332,36 +369,75 @@ export class CollaborationRoom {
       return false;
     }
 
-    const ytext = this.doc.getText('codemirror');
-    const comments = this.doc.getArray('comments');
-    const parsedExcalidrawScene = isExcalidrawRoom(this.name)
-      ? tryParseExcalidrawSceneJson(content)
-      : null;
-    if (isExcalidrawRoom(this.name) && !parsedExcalidrawScene) {
-      return false;
+    return this.applyExternalContent(content, {
+      commentThreads,
+      replaceCommentThreads: true,
+    });
+  }
+
+  async applyExternalContent(content, {
+    commentThreads = [],
+    replaceCommentThreads = false,
+  } = {}) {
+    if (this.deleted || this.destroyed) {
+      return { ok: false, reason: 'room-unavailable' };
     }
 
-    this.doc.transact(() => {
-      if (isExcalidrawRoom(this.name)) {
-        if (ytext.length > 0) {
-          ytext.delete(0, ytext.length);
-        }
+    const comments = this.doc.getArray('comments');
+    if (isExcalidrawRoom(this.name)) {
+      const parsedExcalidrawScene = tryParseExcalidrawSceneJson(content);
+      if (!parsedExcalidrawScene) {
+        return { ok: false, reason: 'invalid-excalidraw' };
+      }
+
+      this.doc.transact(() => {
         replaceExcalidrawRoomScene(this.doc, parsedExcalidrawScene);
-      } else {
-        if (ytext.length > 0) {
-          ytext.delete(0, ytext.length);
-        }
-        if (content) {
-          ytext.insert(0, content);
+        if (replaceCommentThreads) {
+          if (comments.length > 0) {
+            comments.delete(0, comments.length);
+          }
+          populateCommentThreads(comments, commentThreads);
         }
+      }, 'workspace-reconcile');
+
+      return { ok: true, highlightRange: null };
+    }
+
+    const ytext = this.doc.getText('codemirror');
+    const replacement = computeTextReplacement(ytext.toString(), content);
+    if (!replacement && !replaceCommentThreads) {
+      return { highlightRange: null, ok: true, skipped: true };
+    }
+
+    this.doc.transact(() => {
+      if (replacement?.deleteCount) {
+        ytext.delete(replacement.start, replacement.deleteCount);
       }
-      if (comments.length > 0) {
-        comments.delete(0, comments.length);
+      if (replacement?.insertText) {
+        ytext.insert(replacement.start, replacement.insertText);
+      }
+      if (replaceCommentThreads) {
+        if (comments.length > 0) {
+          comments.delete(0, comments.length);
+        }
+        populateCommentThreads(comments, commentThreads);
       }
-      populateCommentThreads(comments, commentThreads);
     }, 'workspace-reconcile');
 
-    return true;
+    return {
+      highlightRange: replacement
+        ? {
+          from: replacement.start,
+          to: replacement.start + replacement.insertText.length,
+        }
+        : null,
+      ok: true,
+    };
+  }
+
+  applyExternalDeletion() {
+    this.markDeleted();
+    return this.destroy();
   }
 
   rename(nextName) {
@@ -537,6 +613,10 @@ export class CollaborationRoom {
   }
 
   getPersistedContent() {
+    if (isWorkspaceRoom(this.name)) {
+      return null;
+    }
+
     if (!isExcalidrawRoom(this.name)) {
       return this.doc.getText('codemirror').toString();
     }
@@ -600,4 +680,93 @@ export class CollaborationRoom {
       console.error(`[room:${this.name}] Failed to handle message:`, error.message);
     }
   }
+
+  replaceWorkspaceEntries(entries = new Map(), {
+    generatedAt = Date.now(),
+  } = {}) {
+    if (!isWorkspaceRoom(this.name)) {
+      return false;
+    }
+
+    const normalizedEntries = entries instanceof Map ? entries : new Map(entries);
+    const entriesMap = this.doc.getMap('entries');
+    const metaMap = this.doc.getMap('meta');
+
+    this.doc.transact(() => {
+      Array.from(entriesMap.keys()).forEach((key) => {
+        if (!normalizedEntries.has(key)) {
+          entriesMap.delete(key);
+        }
+      });
+
+      normalizedEntries.forEach((entry, pathValue) => {
+        entriesMap.set(pathValue, entry);
+      });
+
+      metaMap.set('lastSnapshotAt', generatedAt);
+      metaMap.set('revision', Number(metaMap.get('revision') || 0) + 1);
+    }, 'workspace-room-entries');
+
+    return true;
+  }
+
+  applyWorkspaceEntryPatch({
+    deletes = [],
+    upserts = new Map(),
+  } = {}, {
+    generatedAt = Date.now(),
+  } = {}) {
+    if (!isWorkspaceRoom(this.name)) {
+      return false;
+    }
+
+    const normalizedUpserts = upserts instanceof Map ? upserts : new Map(upserts);
+    const normalizedDeletes = Array.from(new Set((deletes ?? []).filter(Boolean)));
+    if (normalizedUpserts.size === 0 && normalizedDeletes.length === 0) {
+      return false;
+    }
+
+    const entriesMap = this.doc.getMap('entries');
+    const metaMap = this.doc.getMap('meta');
+
+    this.doc.transact(() => {
+      normalizedDeletes.forEach((pathValue) => {
+        entriesMap.delete(pathValue);
+      });
+
+      normalizedUpserts.forEach((entry, pathValue) => {
+        entriesMap.set(pathValue, entry);
+      });
+
+      metaMap.set('lastSnapshotAt', generatedAt);
+      metaMap.set('revision', Number(metaMap.get('revision') || 0) + 1);
+    }, 'workspace-room-entry-patch');
+
+    return true;
+  }
+
+  publishWorkspaceEvent(event) {
+    if (!isWorkspaceRoom(this.name)) {
+      return null;
+    }
+
+    const normalizedEvent = normalizeWorkspaceEvent(event);
+    if (!normalizedEvent) {
+      return null;
+    }
+
+    const events = this.doc.getArray('events');
+    const metaMap = this.doc.getMap('meta');
+    this.doc.transact(() => {
+      events.push([normalizedEvent]);
+      const overflow = events.length - WORKSPACE_EVENT_MAX_MESSAGES;
+      if (overflow > 0) {
+        events.delete(0, overflow);
+      }
+      metaMap.set('lastEventAt', normalizedEvent.createdAt);
+      metaMap.set('revision', Number(metaMap.get('revision') || 0) + 1);
+    }, 'workspace-room-event');
+
+    return normalizedEvent;
+  }
 }

package/src/server/domain/collaboration/room-registry.js

@@ -57,27 +57,67 @@ export class RoomRegistry {
     this.rooms.clear();
   }
 
+  getRooms() {
+    return Array.from(this.rooms.entries());
+  }
+
+  async reloadAllFromDisk() {
+    await Promise.allSettled(
+      Array.from(this.rooms.values(), (room) => room.reloadFromDisk?.()),
+    );
+  }
+
   async reconcileWorkspaceChange(workspaceChange = {}) {
     const deletedPaths = new Set(workspaceChange.deletedPaths ?? []);
     const renamedPaths = Array.isArray(workspaceChange.renamedPaths) ? workspaceChange.renamedPaths : [];
-    const renamedOldPaths = new Set(renamedPaths.map((entry) => entry?.oldPath).filter(Boolean));
+    const pendingDeletes = [];
+    const highlightRanges = [];
+    const reloadRequiredPaths = [];
 
-    await Promise.allSettled(
-      [...deletedPaths, ...renamedOldPaths].map(async (pathValue) => {
-        const room = this.rooms.get(pathValue);
-        if (!room) {
-          return;
-        }
+    renamedPaths.forEach((entry) => {
+      if (!entry?.oldPath || !entry?.newPath) {
+        return;
+      }
 
+      if (this.rename(entry.oldPath, entry.newPath)) {
+        return;
+      }
+
+      const room = this.rooms.get(entry.oldPath);
+      if (room) {
+        pendingDeletes.push([entry.oldPath, room]);
+      }
+    });
+
+    deletedPaths.forEach((pathValue) => {
+      if (!pathValue) {
+        return;
+      }
+
+      const room = this.rooms.get(pathValue);
+      if (room) {
+        pendingDeletes.push([pathValue, room]);
+      }
+    });
+
+    await Promise.allSettled(
+      pendingDeletes.map(async ([pathValue, room]) => {
         room.markDeleted?.();
-        await room.destroy?.();
+        if (typeof room.applyExternalDeletion === 'function') {
+          await room.applyExternalDeletion();
+        } else {
+          await room.destroy?.();
+        }
         if (this.rooms.get(pathValue) === room) {
           this.rooms.delete(pathValue);
         }
       }),
     );
 
-    const blockedPaths = new Set([...deletedPaths, ...renamedOldPaths]);
+    const blockedPaths = new Set([
+      ...deletedPaths,
+      ...renamedPaths.flatMap((entry) => [entry?.oldPath, entry?.newPath]),
+    ]);
     await Promise.allSettled(
       Array.from(new Set(workspaceChange.changedPaths ?? []))
         .filter((pathValue) => pathValue && !blockedPaths.has(pathValue))
@@ -87,8 +127,22 @@ export class RoomRegistry {
             return;
           }
 
-          await room.reloadFromDisk?.();
+          const result = await room.reloadFromDisk?.();
+          if (result && result.ok === false && result.reason === 'invalid-excalidraw') {
+            reloadRequiredPaths.push(pathValue);
+          } else if (result?.highlightRange) {
+            highlightRanges.push({
+              from: result.highlightRange.from,
+              path: pathValue,
+              to: result.highlightRange.to,
+            });
+          }
         }),
     );
+
+    return {
+      highlightRanges,
+      reloadRequiredPaths,
+    };
   }
 }

package/src/server/infrastructure/git/responses.js

@@ -1,3 +1,8 @@
+import {
+  createEmptyWorkspaceChange as createSharedEmptyWorkspaceChange,
+  createWorkspaceChange as createSharedWorkspaceChange,
+} from '../../../domain/workspace-change.js';
+
 const STATUS_MAP = {
   A: { code: 'A', label: 'added', status: 'added' },
   C: { code: 'C', label: 'copied', status: 'copied' },
@@ -43,12 +48,7 @@ export function createEmptyBranchStatus() {
 }
 
 export function createEmptyWorkspaceChange() {
-  return {
-    changedPaths: [],
-    deletedPaths: [],
-    refreshExplorer: true,
-    renamedPaths: [],
-  };
+  return createSharedEmptyWorkspaceChange();
 }
 
 export function createEmptyStatusResponse() {
@@ -92,17 +92,10 @@ export function createWorkspaceChange({
   refreshExplorer = true,
   renamedPaths = [],
 } = {}) {
-  return {
-    changedPaths: Array.from(new Set((changedPaths ?? []).filter(Boolean))),
-    deletedPaths: Array.from(new Set((deletedPaths ?? []).filter(Boolean))),
-    refreshExplorer: Boolean(refreshExplorer),
-    renamedPaths: Array.from(new Map(
-      (renamedPaths ?? [])
-        .filter((entry) => entry?.oldPath && entry?.newPath && entry.oldPath !== entry.newPath)
-        .map((entry) => [`${entry.oldPath}:${entry.newPath}`, {
-          newPath: entry.newPath,
-          oldPath: entry.oldPath,
-        }]),
-    ).values()),
-  };
+  return createSharedWorkspaceChange({
+    changedPaths,
+    deletedPaths,
+    refreshExplorer,
+    renamedPaths,
+  });
 }

package/src/server/infrastructure/http/create-git-api-command-handler.js

@@ -1,7 +1,7 @@
 import { getRequestErrorStatusCode } from './http-errors.js';
 import { jsonResponse } from './http-response.js';
 import { parseJsonBody } from './request-body.js';
-import { createEmptyWorkspaceChange } from '../git/responses.js';
+import { createEmptyWorkspaceChange, hasWorkspaceMutation } from '../../../domain/workspace-change.js';
 
 async function parseRequiredBody(req, res, fieldName) {
   const body = await parseJsonBody(req);
@@ -29,19 +29,16 @@ function handleGitError(req, res, error, logMessage, fallbackMessage) {
   return true;
 }
 
-function hasWorkspaceMutation(workspaceChange = {}) {
-  return Boolean(
-    (workspaceChange.changedPaths?.length ?? 0) > 0
-    || (workspaceChange.deletedPaths?.length ?? 0) > 0
-    || (workspaceChange.renamedPaths?.length ?? 0) > 0,
-  );
+function readRequestId(req) {
+  const value = String(req.headers['x-collabmd-request-id'] || '').trim();
+  return value ? value.slice(0, 120) : null;
 }
 
 async function applyWorkspaceMutationEffects({
-  backlinkIndex,
+  action,
+  req,
   responsePayload,
-  roomRegistry,
-  vaultFileStore,
+  workspaceMutationCoordinator,
 }) {
   const workspaceChange = responsePayload?.workspaceChange ?? createEmptyWorkspaceChange();
   responsePayload.workspaceChange = workspaceChange;
@@ -50,18 +47,19 @@ async function applyWorkspaceMutationEffects({
     return responsePayload;
   }
 
-  await vaultFileStore?.reconcileSidecars?.(workspaceChange);
-  await vaultFileStore?.reconcileCollaborationSnapshots?.(workspaceChange);
-  await backlinkIndex?.build?.();
-  await roomRegistry?.reconcileWorkspaceChange?.(workspaceChange);
+  await workspaceMutationCoordinator?.apply?.({
+    action,
+    origin: 'git',
+    requestId: readRequestId(req),
+    sourceRef: responsePayload?.sourceRef ?? null,
+    workspaceChange,
+  });
   return responsePayload;
 }
 
 export function createGitApiCommandHandler({
-  backlinkIndex = null,
   gitService,
-  roomRegistry = null,
-  vaultFileStore = null,
+  workspaceMutationCoordinator = null,
 }) {
   return async function handleGitApiCommand(req, res, requestUrl) {
     if (requestUrl.pathname === '/api/git/stage' && req.method === 'POST') {
@@ -72,10 +70,12 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.stageFile(body.path),
-          roomRegistry,
-          vaultFileStore,
+          action: 'stage',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.stageFile(body.path),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to stage git file:', 'Failed to stage git file');
@@ -91,10 +91,12 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.unstageFile(body.path),
-          roomRegistry,
-          vaultFileStore,
+          action: 'unstage',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.unstageFile(body.path),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to unstage git file:', 'Failed to unstage git file');
@@ -110,12 +112,14 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.commitStaged({
-            message: body.message,
-          }),
-          roomRegistry,
-          vaultFileStore,
+          action: 'commit',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.commitStaged({
+              message: body.message,
+            }),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to commit staged changes:', 'Failed to commit staged changes');
@@ -126,10 +130,12 @@ export function createGitApiCommandHandler({
     if (requestUrl.pathname === '/api/git/push' && req.method === 'POST') {
       try {
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.pushBranch(),
-          roomRegistry,
-          vaultFileStore,
+          action: 'push',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.pushBranch(),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to push git branch:', 'Failed to push git branch');
@@ -140,10 +146,12 @@ export function createGitApiCommandHandler({
     if (requestUrl.pathname === '/api/git/pull' && req.method === 'POST') {
       try {
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.pullBranch(),
-          roomRegistry,
-          vaultFileStore,
+          action: 'pull',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.pullBranch(),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to pull git branch:', 'Failed to pull git branch');
@@ -159,10 +167,12 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.resetFileToHead(body.path),
-          roomRegistry,
-          vaultFileStore,
+          action: 'reset-file',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.resetFileToHead(body.path),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to reset git file:', 'Failed to reset git file');

package/src/server/infrastructure/http/create-git-api-handler.js

@@ -7,6 +7,7 @@ export function createGitApiHandler({
   gitService = null,
   roomRegistry = null,
   vaultFileStore = null,
+  workspaceMutationCoordinator = null,
 }) {
   const handleGitApiQuery = createGitApiQueryHandler({ gitService });
   const handleGitApiCommand = createGitApiCommandHandler({
@@ -14,6 +15,7 @@ export function createGitApiHandler({
     gitService,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
 
   return async function handleGitApi(req, res, requestUrl) {

package/src/server/infrastructure/http/create-request-handler.js

@@ -42,6 +42,8 @@ export function createRequestHandler(
   roomRegistry = null,
   plantUmlRenderer = null,
   gitService = null,
+  workspaceMutationCoordinator = null,
+  fileSystemSyncService = null,
 ) {
   const handleEsmProxy = createEsmProxyHandler();
   const handleStaticRequest = createStaticHandler(config, authService);
@@ -51,12 +53,14 @@ export function createRequestHandler(
     gitService,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
   const handleVaultApi = createVaultApiHandler({
     backlinkIndex,
     plantUmlRenderer,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
 
   return async function handleRequest(req, res) {
@@ -103,8 +107,11 @@ export function createRequestHandler(
     }
 
     if (config.nodeEnv === 'test' && requestUrl.pathname === '/api/test/reset-state' && req.method === 'POST') {
+      await fileSystemSyncService?.resetForExternalStateChange?.();
       await roomRegistry?.reset?.();
       await backlinkIndex?.build?.();
+      await workspaceMutationCoordinator?.initialize?.();
+      await fileSystemSyncService?.resetForExternalStateChange?.();
       jsonResponse(req, res, 200, { ok: true });
       return;
     }