collabmd 0.1.20 → 0.1.23

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,9 +88,45 @@ 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,
+    getHydrateDelayMs = null,
     name,
     idleGraceMs = 0,
     maxBufferedAmountBytes,
@@ -104,6 +142,7 @@ export class CollaborationRoom {
       name,
       vaultFileStore,
     });
+    this.getHydrateDelayMs = getHydrateDelayMs;
     this.onEmpty = onEmpty;
     this.doc = new Y.Doc({ gc: true });
     this.awareness = new awarenessProtocol.Awareness(this.doc);
@@ -115,6 +154,12 @@ export class CollaborationRoom {
     this.destroyed = false;
     this.cachedInitialSyncMessage = null;
     this.activePersistPromise = null;
+    this.debugMetrics = {
+      hydrateCount: 0,
+      initialSyncCount: 0,
+      lastHydrate: null,
+      lastInitialSyncAt: 0,
+    };
     this.persistence = new RoomPersistenceController({
       idleGraceMs: this.idleGraceMs,
       onDestroy: () => {
@@ -136,64 +181,96 @@ export class CollaborationRoom {
 
     if (!this.hydratePromise) {
       this.hydratePromise = (async () => {
-        if (this.documentStore?.hasPersistence()) {
-          const snapshot = await this.documentStore.readSnapshot();
-          if (snapshot) {
-            try {
-              if (isExcalidrawRoom(this.name)) {
-                const validationDoc = new Y.Doc({ gc: true });
-                try {
-                  Y.applyUpdate(validationDoc, snapshot, 'hydrate');
-                  if (!this.ensureStructuredExcalidrawState(validationDoc)) {
-                    throw new Error('snapshot did not contain a valid structured Excalidraw scene');
-                  }
+        const startedAt = Date.now();
+        let hydrateSource = 'empty';
+        let snapshotExists = false;
+        let snapshotValid = false;
+        let commentThreadCount = 0;
+        const hydrateDelayMs = Math.max(0, Number(this.getHydrateDelayMs?.() || 0));
+
+        try {
+          if (hydrateDelayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, hydrateDelayMs));
+          }
 
-                  Y.applyUpdate(this.doc, Y.encodeStateAsUpdate(validationDoc), 'hydrate');
-                } finally {
-                  validationDoc.destroy();
+          if (this.documentStore?.hasPersistence()) {
+            const snapshot = await this.documentStore.readSnapshot();
+            if (snapshot) {
+              snapshotExists = true;
+              try {
+                if (isExcalidrawRoom(this.name)) {
+                  const validationDoc = new Y.Doc({ gc: true });
+                  try {
+                    Y.applyUpdate(validationDoc, snapshot, 'hydrate');
+                    if (!this.ensureStructuredExcalidrawState(validationDoc)) {
+                      throw new Error('snapshot did not contain a valid structured Excalidraw scene');
+                    }
+
+                    Y.applyUpdate(this.doc, Y.encodeStateAsUpdate(validationDoc), 'hydrate');
+                  } finally {
+                    validationDoc.destroy();
+                  }
+                } else {
+                  Y.applyUpdate(this.doc, snapshot, 'hydrate');
                 }
-              } else {
-                Y.applyUpdate(this.doc, snapshot, 'hydrate');
-              }
 
-              this.hydrated = true;
-              return;
-            } catch (error) {
-              console.warn(
-                `[room:${this.name}] Discarding invalid collaboration snapshot: ${error.message}`,
-              );
-              await this.documentStore.deleteSnapshot?.();
+                snapshotValid = true;
+                hydrateSource = 'snapshot';
+                this.hydrated = true;
+                return;
+              } catch (error) {
+                console.warn(
+                  `[room:${this.name}] Discarding invalid collaboration snapshot: ${error.message}`,
+                );
+                await this.documentStore.deleteSnapshot?.();
+              }
             }
-          }
 
-          const [content, commentThreads] = await Promise.all([
-            this.documentStore.readContent(),
-            this.documentStore.readCommentThreads(),
-          ]);
-          if (content !== null || commentThreads.length > 0) {
-            const ytext = this.doc.getText('codemirror');
-            const comments = this.doc.getArray('comments');
-            this.doc.transact(() => {
-              if (isExcalidrawRoom(this.name)) {
-                const parsedScene = tryParseExcalidrawSceneJson(content);
-                if (parsedScene) {
-                  migrateLegacyExcalidrawRoomData(this.doc, parsedScene);
+            const [content, commentThreads] = await Promise.all([
+              this.documentStore.readContent(),
+              this.documentStore.readCommentThreads(),
+            ]);
+            commentThreadCount = commentThreads.length;
+            if (content !== null || commentThreads.length > 0) {
+              hydrateSource = 'content';
+              const ytext = this.doc.getText('codemirror');
+              const comments = this.doc.getArray('comments');
+              this.doc.transact(() => {
+                if (isExcalidrawRoom(this.name)) {
+                  const parsedScene = tryParseExcalidrawSceneJson(content);
+                  if (parsedScene) {
+                    migrateLegacyExcalidrawRoomData(this.doc, parsedScene);
+                  } else if (content !== null) {
+                    ytext.insert(0, content);
+                  }
                 } else if (content !== null) {
                   ytext.insert(0, content);
                 }
-              } else if (content !== null) {
-                ytext.insert(0, content);
-              }
-              populateCommentThreads(comments, commentThreads);
-            }, 'hydrate');
+                populateCommentThreads(comments, commentThreads);
+              }, 'hydrate');
+
+              void this.documentStore.writeSnapshot(Y.encodeStateAsUpdate(this.doc)).catch((error) => {
+                console.error(`[room:${this.name}] Failed to prime collaboration snapshot: ${error.message}`);
+              });
+            }
+          }
 
-            void this.documentStore.writeSnapshot(Y.encodeStateAsUpdate(this.doc)).catch((error) => {
-              console.error(`[room:${this.name}] Failed to prime collaboration snapshot: ${error.message}`);
-            });
+          this.hydrated = true;
+        } finally {
+          if (this.hydrated) {
+            this.debugMetrics.hydrateCount += 1;
+            this.debugMetrics.lastHydrate = {
+              commentThreadCount,
+              durationMs: Date.now() - startedAt,
+              snapshotExists,
+              snapshotValid,
+              source: hydrateSource,
+            };
+            console.info(
+              `[perf][room:${this.name}] hydrate durationMs=${this.debugMetrics.lastHydrate.durationMs} source=${this.debugMetrics.lastHydrate.source} snapshotExists=${this.debugMetrics.lastHydrate.snapshotExists} snapshotValid=${this.debugMetrics.lastHydrate.snapshotValid} commentThreads=${this.debugMetrics.lastHydrate.commentThreadCount}`,
+            );
           }
         }
-
-        this.hydrated = true;
       })().catch((error) => {
         this.hydratePromise = null;
         console.error(`[room:${this.name}] Failed to hydrate from disk: ${error.message}`);
@@ -332,36 +409,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) {
@@ -403,6 +519,9 @@ export class CollaborationRoom {
   }
 
   sendInitialSync(ws) {
+    this.debugMetrics.initialSyncCount += 1;
+    this.debugMetrics.lastInitialSyncAt = Date.now();
+    console.info(`[perf][room:${this.name}] send-initial-sync count=${this.debugMetrics.initialSyncCount}`);
     return sendMessage.call(this, ws, this.getInitialSyncMessage(), this);
   }
 
@@ -537,6 +656,10 @@ export class CollaborationRoom {
   }
 
   getPersistedContent() {
+    if (isWorkspaceRoom(this.name)) {
+      return null;
+    }
+
     if (!isExcalidrawRoom(this.name)) {
       return this.doc.getText('codemirror').toString();
     }
@@ -600,4 +723,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/index.js

@@ -60,7 +60,9 @@ server.listen().then(({ host, port, wsPath }) => {
   if (server.config.auth.strategy === 'password') {
     console.log(`  auth: password (${server.config.auth.password})`);
   } else if (server.config.auth.strategy === 'oidc') {
-    console.log('  auth: oidc (not implemented yet)');
+    console.log(`  auth: oidc (${server.config.auth.oidc.provider})`);
+    console.log(`  public: ${server.config.auth.oidc.publicBaseUrl}`);
+    console.log(`  callback: ${server.config.auth.oidc.callbackUrl}`);
   } else {
     console.log('  auth: none');
   }

package/src/server/infrastructure/git/command-runner.js

@@ -31,13 +31,14 @@ export class GitCommandRunner {
     }
   }
 
-  async execGit(args) {
+  async execGit(args, { env = null } = {}) {
     const result = await this.execFileImpl('git', ['-c', 'core.quotepath=false', ...args], {
       cwd: this.vaultDir,
       encoding: 'utf8',
       env: {
         ...process.env,
         ...(this.commandEnv ?? {}),
+        ...(env ?? {}),
       },
       maxBuffer: 5 * 1024 * 1024,
       timeout: 10_000,

package/src/server/infrastructure/git/git-service.js

@@ -2,12 +2,29 @@ import { createGitRequestError } from './errors.js';
 import { normalizeRelativeGitPath } from './path-utils.js';
 import { GitCommandRunner } from './command-runner.js';
 import { GitDiffService } from './diff-service.js';
+import { GitHistoryService } from './history-service.js';
 import { parseNameStatusOutput } from './parsers.js';
 import { createEmptyWorkspaceChange, createWorkspaceChange } from './responses.js';
 import { GitStatusService } from './status-service.js';
 import { GitUntrackedFileService } from './untracked-files.js';
 import { PullBackupStore } from '../persistence/pull-backup-store.js';
 
+function buildAuthorEnv(author = null) {
+  const name = String(author?.name ?? '').trim();
+  const email = String(author?.email ?? '').trim();
+
+  if (!name || !email) {
+    return null;
+  }
+
+  return {
+    GIT_AUTHOR_EMAIL: email,
+    GIT_AUTHOR_NAME: name,
+    GIT_COMMITTER_EMAIL: email,
+    GIT_COMMITTER_NAME: name,
+  };
+}
+
 export class GitService {
   constructor({
     commandEnv = null,
@@ -37,6 +54,11 @@ export class GitService {
       statusService: this.statusService,
       untrackedFileService: this.untrackedFileService,
     });
+    this.historyService = new GitHistoryService({
+      commandRunner: this.commandRunner,
+      maxInitialPatchBytes,
+      maxInitialPatchLines,
+    });
     this.pullBackupStore = new PullBackupStore({ vaultDir });
   }
 
@@ -51,6 +73,7 @@ export class GitService {
   invalidateStatusCache() {
     this.statusService.invalidate();
     this.diffService.invalidate();
+    this.historyService.invalidate();
   }
 
   async getStatus(options = {}) {
@@ -87,7 +110,7 @@ export class GitService {
     };
   }
 
-  async commitStaged({ message } = {}) {
+  async commitStaged({ author = null, message } = {}) {
     const normalizedMessage = String(message ?? '').trim();
     if (!normalizedMessage) {
       throw createGitRequestError(400, 'Missing commit message');
@@ -98,7 +121,9 @@ export class GitService {
       throw createGitRequestError(409, 'No staged changes to commit');
     }
 
-    await this.commandRunner.execGit(['commit', '-m', normalizedMessage]);
+    await this.commandRunner.execGit(['commit', '-m', normalizedMessage], {
+      env: buildAuthorEnv(author),
+    });
     const hash = (await this.commandRunner.execGit(['rev-parse', 'HEAD'])).trim();
     const shortHash = (await this.commandRunner.execGit(['rev-parse', '--short', 'HEAD'])).trim();
     this.invalidateStatusCache();
@@ -233,6 +258,27 @@ export class GitService {
     });
   }
 
+  async getHistory({ limit = 30, offset = 0 } = {}) {
+    return this.historyService.listHistory({ limit, offset });
+  }
+
+  async getFileHistory({ limit = 30, offset = 0, path } = {}) {
+    return this.historyService.listFileHistory({ limit, offset, path });
+  }
+
+  async getCommit({ allowLargePatch = false, hash, metaOnly = false, path = null } = {}) {
+    return this.historyService.getCommit({
+      allowLargePatch,
+      hash,
+      metaOnly,
+      path,
+    });
+  }
+
+  async getFileSnapshot({ hash, path } = {}) {
+    return this.historyService.getFileSnapshot({ hash, path });
+  }
+
   async getHeadRef() {
     try {
       const output = await this.commandRunner.execGit(['rev-parse', 'HEAD']);