collabmd 0.1.19 → 0.1.21

package/src/server/domain/backlink-index.js

@@ -14,9 +14,27 @@ import { createWikiTargetIndex, resolveWikiTargetWithIndex } from '../../domain/
 
 const WIKI_LINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
 
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((nextResolve, nextReject) => {
+    resolve = nextResolve;
+    reject = nextReject;
+  });
+  return { promise, reject, resolve };
+}
+
 export class BacklinkIndex {
-  constructor({ vaultFileStore }) {
+  constructor({
+    rebuildDelayMs = 150,
+    setTimeoutFn = setTimeout,
+    clearTimeoutFn = clearTimeout,
+    vaultFileStore,
+  }) {
     this.vaultFileStore = vaultFileStore;
+    this.rebuildDelayMs = rebuildDelayMs;
+    this.setTimeoutFn = setTimeoutFn;
+    this.clearTimeoutFn = clearTimeoutFn;
     /** @type {Map<string, Set<string>>} sourcePath → set of resolved target paths */
     this.forward = new Map();
     /** @type {Map<string, Set<string>>} targetPath → set of source paths */
@@ -29,6 +47,11 @@ export class BacklinkIndex {
     this._fileSet = new Set();
     this._wikiTargetIndex = createWikiTargetIndex(this._fileList);
     this._built = false;
+    this._requestedBuildVersion = 0;
+    this._completedBuildVersion = 0;
+    this._buildPromise = null;
+    this._scheduledBuildTimer = null;
+    this._scheduledBuildDeferred = null;
   }
 
   /**
@@ -36,6 +59,74 @@ export class BacklinkIndex {
    * Called once at server startup.
    */
   async build() {
+    this._requestedBuildVersion += 1;
+    return this.flushScheduledBuild();
+  }
+
+  scheduleBuild({ delayMs = this.rebuildDelayMs } = {}) {
+    this._requestedBuildVersion += 1;
+    if (!this._scheduledBuildDeferred) {
+      this._scheduledBuildDeferred = createDeferred();
+    }
+
+    if (this._scheduledBuildTimer) {
+      this.clearTimeoutFn(this._scheduledBuildTimer);
+    }
+
+    this._scheduledBuildTimer = this.setTimeoutFn(() => {
+      this._scheduledBuildTimer = null;
+      const deferred = this._scheduledBuildDeferred;
+      this._scheduledBuildDeferred = null;
+      this._ensureBuiltToRequestedVersion()
+        .then(() => deferred?.resolve())
+        .catch((error) => deferred?.reject(error));
+    }, delayMs);
+    this._scheduledBuildTimer.unref?.();
+
+    return this._scheduledBuildDeferred.promise;
+  }
+
+  async flushScheduledBuild() {
+    if (this._scheduledBuildTimer) {
+      this.clearTimeoutFn(this._scheduledBuildTimer);
+      this._scheduledBuildTimer = null;
+    }
+
+    const deferred = this._scheduledBuildDeferred;
+    this._scheduledBuildDeferred = null;
+
+    try {
+      await this._ensureBuiltToRequestedVersion();
+      deferred?.resolve();
+    } catch (error) {
+      deferred?.reject(error);
+      throw error;
+    }
+  }
+
+  async _ensureBuiltToRequestedVersion() {
+    while (this._completedBuildVersion < this._requestedBuildVersion) {
+      await this._runSingleBuild();
+    }
+  }
+
+  async _runSingleBuild() {
+    if (this._buildPromise) {
+      return this._buildPromise;
+    }
+
+    const targetVersion = this._requestedBuildVersion;
+    this._buildPromise = (async () => {
+      await this._performBuild();
+      this._completedBuildVersion = Math.max(this._completedBuildVersion, targetVersion);
+    })().finally(() => {
+      this._buildPromise = null;
+    });
+
+    return this._buildPromise;
+  }
+
+  async _performBuild() {
     this.forward.clear();
     this.reverse.clear();
     this.contextsBySource.clear();
@@ -169,6 +260,8 @@ export class BacklinkIndex {
    * Returns: [{ file: string, contexts: string[] }]
    */
   async getBacklinks(filePath) {
+    await this.flushScheduledBuild();
+
     const sources = this.reverse.get(filePath);
     if (!sources || sources.size === 0) {
       return [];

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/errors.js

@@ -1,5 +1,8 @@
-export function createGitRequestError(statusCode, message) {
+export function createGitRequestError(statusCode, message, requestCode = null) {
   const error = new Error(message);
   error.statusCode = statusCode;
+  if (requestCode) {
+    error.requestCode = requestCode;
+  }
   return error;
 }