collabmd 0.1.20 → 0.1.23

package/src/server/infrastructure/workspace/workspace-mutation-coordinator.js

@@ -0,0 +1,551 @@
+import { stat } from 'node:fs/promises';
+import { basename, dirname } from 'node:path';
+
+import { getVaultTreeNodeType, isVaultFilePath, supportsBacklinksForFilePath } from '../../../domain/file-kind.js';
+import {
+  createEmptyWorkspaceChange,
+  createWorkspaceChange,
+  normalizeWorkspaceEvent,
+} from '../../../domain/workspace-change.js';
+import { WORKSPACE_ROOM_NAME } from '../../../domain/workspace-room.js';
+import { sanitizeVaultPath } from '../persistence/path-utils.js';
+
+function createEventId() {
+  if (globalThis.crypto?.randomUUID) {
+    return globalThis.crypto.randomUUID();
+  }
+
+  return `workspace-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
+}
+
+function countWorkspacePaths(workspaceChange = {}) {
+  return (
+    (workspaceChange.changedPaths?.length ?? 0)
+    + (workspaceChange.deletedPaths?.length ?? 0)
+    + (workspaceChange.renamedPaths?.length ?? 0)
+  );
+}
+
+function normalizePaths(paths = []) {
+  return Array.from(new Set((paths ?? []).filter(Boolean)));
+}
+
+function normalizeWorkspacePath(pathValue = '') {
+  return String(pathValue ?? '').replace(/\\/g, '/').trim();
+}
+
+function getParentDirectoryPath(pathValue = '') {
+  const parentPath = dirname(normalizeWorkspacePath(pathValue)).replace(/\\/g, '/');
+  return parentPath === '.' ? '' : parentPath;
+}
+
+function createWorkspaceEntry(pathValue, nodeType) {
+  const normalizedPath = normalizeWorkspacePath(pathValue);
+  return {
+    fileKind: nodeType === 'directory' ? null : getVaultTreeNodeType(normalizedPath),
+    name: basename(normalizedPath),
+    nodeType,
+    parentPath: getParentDirectoryPath(normalizedPath),
+    path: normalizedPath,
+    type: nodeType === 'directory' ? 'directory' : getVaultTreeNodeType(normalizedPath),
+  };
+}
+
+function createWorkspaceMetadata(pathValue, type, info) {
+  return {
+    inode: Number(info.ino || 0),
+    mtimeMs: Number(info.mtimeMs || 0),
+    path: pathValue,
+    size: type === 'directory' ? 0 : Number(info.size || 0),
+    type,
+  };
+}
+
+function compareWorkspaceTreeNodes(left = {}, right = {}) {
+  const leftIsDirectory = left.type === 'directory';
+  const rightIsDirectory = right.type === 'directory';
+  if (leftIsDirectory && !rightIsDirectory) {
+    return -1;
+  }
+  if (!leftIsDirectory && rightIsDirectory) {
+    return 1;
+  }
+
+  return String(left.name ?? '').localeCompare(String(right.name ?? ''), undefined, { sensitivity: 'base' });
+}
+
+function sortWorkspaceTree(nodes = []) {
+  nodes.sort(compareWorkspaceTreeNodes);
+  nodes.forEach((node) => {
+    if (node.type === 'directory') {
+      sortWorkspaceTree(node.children);
+    }
+  });
+  return nodes;
+}
+
+function createWorkspaceTree(entries = new Map()) {
+  const nodesByPath = new Map();
+  const rootNodes = [];
+
+  entries.forEach((entry, pathValue) => {
+    const normalizedPath = normalizeWorkspacePath(pathValue);
+    if (!normalizedPath) {
+      return;
+    }
+
+    if (entry?.type === 'directory' || entry?.nodeType === 'directory') {
+      nodesByPath.set(normalizedPath, {
+        children: [],
+        name: entry?.name ?? basename(normalizedPath),
+        path: normalizedPath,
+        type: 'directory',
+      });
+      return;
+    }
+
+    nodesByPath.set(normalizedPath, {
+      name: entry?.name ?? basename(normalizedPath),
+      path: normalizedPath,
+      type: entry?.type ?? getVaultTreeNodeType(normalizedPath),
+    });
+  });
+
+  nodesByPath.forEach((node, pathValue) => {
+    const parentPath = getParentDirectoryPath(pathValue);
+    const parentNode = parentPath ? nodesByPath.get(parentPath) : null;
+    if (parentNode?.type === 'directory') {
+      parentNode.children.push(node);
+      return;
+    }
+
+    rootNodes.push(node);
+  });
+
+  return sortWorkspaceTree(rootNodes);
+}
+
+function workspaceEntriesEqual(left = {}, right = {}) {
+  return (
+    left.fileKind === right.fileKind
+    && left.name === right.name
+    && left.nodeType === right.nodeType
+    && left.parentPath === right.parentPath
+    && left.path === right.path
+    && left.type === right.type
+  );
+}
+
+function diffWorkspaceEntries(previousEntries = new Map(), nextEntries = new Map()) {
+  const upserts = new Map();
+  const deletes = [];
+
+  previousEntries.forEach((previousEntry, pathValue) => {
+    const nextEntry = nextEntries.get(pathValue);
+    if (!nextEntry) {
+      deletes.push(pathValue);
+      return;
+    }
+
+    if (!workspaceEntriesEqual(previousEntry, nextEntry)) {
+      upserts.set(pathValue, nextEntry);
+    }
+  });
+
+  nextEntries.forEach((nextEntry, pathValue) => {
+    if (!previousEntries.has(pathValue)) {
+      upserts.set(pathValue, nextEntry);
+    }
+  });
+
+  return { deletes, upserts };
+}
+
+export class WorkspaceMutationCoordinator {
+  constructor({
+    backlinkIndex,
+    roomRegistry,
+    vaultFileStore,
+    managedWriteWindowMs = 1200,
+  }) {
+    this.backlinkIndex = backlinkIndex ?? null;
+    this.roomRegistry = roomRegistry;
+    this.vaultFileStore = vaultFileStore;
+    this.managedWriteWindowMs = managedWriteWindowMs;
+    this.managedPathExpiry = new Map();
+    this.globalSuppressionUntil = 0;
+    this.workspaceState = null;
+    this.workspaceTree = [];
+  }
+
+  replaceWorkspaceState(nextState) {
+    this.workspaceState = nextState ?? null;
+    this.workspaceTree = createWorkspaceTree(nextState?.entries ?? new Map());
+    return this.workspaceState;
+  }
+
+  getWorkspaceTree() {
+    return this.workspaceTree;
+  }
+
+  isIncrementalApiAction(action) {
+    return action === 'create-directory'
+      || action === 'create-file'
+      || action === 'delete-file'
+      || action === 'rename-file'
+      || action === 'upload-attachment'
+      || action === 'write-file';
+  }
+
+  async readWorkspacePathState(pathValue, {
+    expectDirectory = false,
+  } = {}) {
+    const normalizedPath = normalizeWorkspacePath(pathValue);
+    if (!normalizedPath) {
+      return null;
+    }
+
+    const absolutePath = sanitizeVaultPath(this.vaultFileStore?.vaultDir, normalizedPath);
+    if (!absolutePath) {
+      return null;
+    }
+
+    try {
+      const info = await stat(absolutePath);
+      if (expectDirectory) {
+        if (!info.isDirectory()) {
+          return null;
+        }
+
+        return {
+          entry: createWorkspaceEntry(normalizedPath, 'directory'),
+          metadata: createWorkspaceMetadata(normalizedPath, 'directory', info),
+        };
+      }
+
+      if (!info.isFile() || !isVaultFilePath(normalizedPath)) {
+        return null;
+      }
+
+      return {
+        entry: createWorkspaceEntry(normalizedPath, 'file'),
+        metadata: createWorkspaceMetadata(normalizedPath, 'file', info),
+      };
+    } catch (error) {
+      if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') {
+        return null;
+      }
+
+      throw error;
+    }
+  }
+
+  async ensureDirectoryEntries(nextEntries, nextMetadata, pathValue, {
+    includeSelf = false,
+  } = {}) {
+    const rootPath = includeSelf ? normalizeWorkspacePath(pathValue) : getParentDirectoryPath(pathValue);
+    if (!rootPath) {
+      return true;
+    }
+
+    const segments = rootPath.split('/').filter(Boolean);
+    let currentPath = '';
+    for (const segment of segments) {
+      currentPath = currentPath ? `${currentPath}/${segment}` : segment;
+      if (nextEntries.has(currentPath) && nextMetadata.has(currentPath)) {
+        continue;
+      }
+
+      const directoryState = await this.readWorkspacePathState(currentPath, {
+        expectDirectory: true,
+      });
+      if (!directoryState) {
+        return false;
+      }
+
+      nextEntries.set(currentPath, directoryState.entry);
+      nextMetadata.set(currentPath, directoryState.metadata);
+    }
+
+    return true;
+  }
+
+  async deriveNextWorkspaceStateForApiMutation(action, workspaceChange = {}) {
+    if (!this.isIncrementalApiAction(action)) {
+      return null;
+    }
+
+    const previousState = this.workspaceState;
+    if (!previousState?.entries || !previousState?.metadata) {
+      return null;
+    }
+
+    const nextEntries = new Map(previousState.entries);
+    const nextMetadata = new Map(previousState.metadata);
+
+    for (const pathValue of workspaceChange.deletedPaths ?? []) {
+      nextEntries.delete(pathValue);
+      nextMetadata.delete(pathValue);
+    }
+
+    for (const entry of workspaceChange.renamedPaths ?? []) {
+      nextEntries.delete(entry.oldPath);
+      nextMetadata.delete(entry.oldPath);
+
+      if (!(await this.ensureDirectoryEntries(nextEntries, nextMetadata, entry.newPath))) {
+        return null;
+      }
+
+      const nextPathState = await this.readWorkspacePathState(entry.newPath);
+      if (!nextPathState) {
+        return null;
+      }
+
+      nextEntries.set(entry.newPath, nextPathState.entry);
+      nextMetadata.set(entry.newPath, nextPathState.metadata);
+    }
+
+    const changedPaths = normalizePaths(workspaceChange.changedPaths ?? []);
+    for (const pathValue of changedPaths) {
+      const expectsDirectory = action === 'create-directory';
+      if (expectsDirectory) {
+        if (!(await this.ensureDirectoryEntries(nextEntries, nextMetadata, pathValue, { includeSelf: true }))) {
+          return null;
+        }
+
+        const directoryState = await this.readWorkspacePathState(pathValue, {
+          expectDirectory: true,
+        });
+        if (!directoryState) {
+          return null;
+        }
+
+        nextEntries.set(pathValue, directoryState.entry);
+        nextMetadata.set(pathValue, directoryState.metadata);
+        continue;
+      }
+
+      if (!(await this.ensureDirectoryEntries(nextEntries, nextMetadata, pathValue))) {
+        return null;
+      }
+
+      const nextPathState = await this.readWorkspacePathState(pathValue);
+      if (!nextPathState) {
+        return null;
+      }
+
+      nextEntries.set(pathValue, nextPathState.entry);
+      nextMetadata.set(pathValue, nextPathState.metadata);
+    }
+
+    return {
+      entries: nextEntries,
+      metadata: nextMetadata,
+      scannedAt: Date.now(),
+    };
+  }
+
+  getWorkspaceRoom() {
+    return this.roomRegistry?.getOrCreate?.(WORKSPACE_ROOM_NAME) ?? null;
+  }
+
+  syncWorkspaceEntries(nextState, {
+    previousState = this.workspaceState,
+  } = {}) {
+    const room = this.getWorkspaceRoom();
+    if (!room || !nextState) {
+      return false;
+    }
+
+    const patch = diffWorkspaceEntries(
+      previousState?.entries ?? new Map(),
+      nextState.entries ?? new Map(),
+    );
+    return room.applyWorkspaceEntryPatch(patch, {
+      generatedAt: nextState.scannedAt,
+    });
+  }
+
+  async initialize() {
+    const snapshot = await this.vaultFileStore.scanWorkspaceState();
+    this.replaceWorkspaceState(snapshot);
+    this.getWorkspaceRoom()?.replaceWorkspaceEntries(snapshot.entries, {
+      generatedAt: snapshot.scannedAt,
+    });
+    return snapshot;
+  }
+
+  markManagedPaths(paths = [], { durationMs = this.managedWriteWindowMs } = {}) {
+    const expiresAt = Date.now() + durationMs;
+    normalizePaths(paths).forEach((pathValue) => {
+      this.managedPathExpiry.set(pathValue, expiresAt);
+    });
+  }
+
+  runManagedWrite(paths = [], operation) {
+    this.markManagedPaths(paths);
+    return Promise.resolve(operation()).finally(() => {
+      this.markManagedPaths(paths);
+    });
+  }
+
+  async runManagedWorkspaceMutation(operation) {
+    this.globalSuppressionUntil = Math.max(this.globalSuppressionUntil, Date.now() + this.managedWriteWindowMs);
+    try {
+      return await operation();
+    } finally {
+      this.globalSuppressionUntil = Math.max(this.globalSuppressionUntil, Date.now() + this.managedWriteWindowMs);
+    }
+  }
+
+  isGloballySuppressed() {
+    return Date.now() <= this.globalSuppressionUntil;
+  }
+
+  cleanupExpiredManagedPaths() {
+    const now = Date.now();
+    Array.from(this.managedPathExpiry.entries()).forEach(([pathValue, expiresAt]) => {
+      if (expiresAt <= now) {
+        this.managedPathExpiry.delete(pathValue);
+      }
+    });
+  }
+
+  isManagedPath(pathValue) {
+    this.cleanupExpiredManagedPaths();
+    const expiresAt = this.managedPathExpiry.get(pathValue);
+    return Number.isFinite(expiresAt) && expiresAt > Date.now();
+  }
+
+  filterManagedWorkspaceChange(workspaceChange = {}) {
+    if (this.isGloballySuppressed()) {
+      return null;
+    }
+
+    const filtered = createWorkspaceChange({
+      changedPaths: (workspaceChange.changedPaths ?? []).filter((pathValue) => !this.isManagedPath(pathValue)),
+      deletedPaths: (workspaceChange.deletedPaths ?? []).filter((pathValue) => !this.isManagedPath(pathValue)),
+      renamedPaths: (workspaceChange.renamedPaths ?? []).filter((entry) => (
+        entry?.oldPath
+        && entry?.newPath
+        && !this.isManagedPath(entry.oldPath)
+        && !this.isManagedPath(entry.newPath)
+      )),
+      refreshExplorer: workspaceChange.refreshExplorer !== false,
+    });
+
+    if (countWorkspacePaths(filtered) === 0) {
+      return null;
+    }
+
+    return filtered;
+  }
+
+  async reconcileBacklinks(workspaceChange, nextState, {
+    forceRebuild = false,
+  } = {}) {
+    if (!this.backlinkIndex) {
+      return;
+    }
+
+    const previousEntries = this.workspaceState?.entries ?? new Map();
+    if (
+      forceRebuild
+      || countWorkspacePaths(workspaceChange) > 25
+    ) {
+      this.backlinkIndex.scheduleBuild?.();
+      return;
+    }
+
+    for (const pathValue of workspaceChange.deletedPaths ?? []) {
+      if (supportsBacklinksForFilePath(pathValue)) {
+        this.backlinkIndex.onFileDeleted(pathValue);
+      }
+    }
+
+    for (const entry of workspaceChange.renamedPaths ?? []) {
+      if (supportsBacklinksForFilePath(entry.oldPath) || supportsBacklinksForFilePath(entry.newPath)) {
+        this.backlinkIndex.onFileRenamed(entry.oldPath, entry.newPath);
+      }
+    }
+
+    for (const pathValue of workspaceChange.changedPaths ?? []) {
+      if (!supportsBacklinksForFilePath(pathValue)) {
+        continue;
+      }
+
+      const existsNow = nextState.entries.has(pathValue);
+      const existedBefore = previousEntries.has(pathValue);
+      if (!existsNow) {
+        if (existedBefore) {
+          this.backlinkIndex.onFileDeleted(pathValue);
+        }
+        continue;
+      }
+
+      const content = await this.vaultFileStore.readMarkdownFile(pathValue);
+      if (content === null) {
+        continue;
+      }
+
+      if (existedBefore) {
+        this.backlinkIndex.updateFile(pathValue, content);
+      } else {
+        this.backlinkIndex.onFileCreated(pathValue, content);
+      }
+    }
+  }
+
+  async apply({
+    action = 'workspace',
+    origin = 'api',
+    publishEvent = true,
+    requestId = null,
+    sourceRef = null,
+    workspaceChange = createEmptyWorkspaceChange(),
+    nextState = null,
+    forceBacklinkRebuild = false,
+  } = {}) {
+    const normalizedChange = createWorkspaceChange(workspaceChange);
+    const previousState = this.workspaceState;
+    const derivedState = nextState
+      ? null
+      : await this.deriveNextWorkspaceStateForApiMutation(action, normalizedChange);
+    const resolvedState = nextState ?? derivedState ?? await this.vaultFileStore.scanWorkspaceState();
+
+    await this.vaultFileStore.reconcileSidecars?.(normalizedChange);
+    await this.vaultFileStore.reconcileCollaborationSnapshots?.(normalizedChange);
+    await this.reconcileBacklinks(normalizedChange, resolvedState, {
+      forceRebuild: forceBacklinkRebuild,
+    });
+
+    const roomEffects = await this.roomRegistry?.reconcileWorkspaceChange?.(normalizedChange) ?? {};
+    const highlightRanges = normalizePaths(
+      (roomEffects.highlightRanges ?? []).map((entry) => entry?.path),
+    ).map((pathValue) => roomEffects.highlightRanges.find((entry) => entry.path === pathValue));
+    const reloadRequiredPaths = normalizePaths(roomEffects.reloadRequiredPaths ?? []);
+
+    this.syncWorkspaceEntries(resolvedState, {
+      previousState,
+    });
+    this.replaceWorkspaceState(resolvedState);
+
+    if (!publishEvent) {
+      return null;
+    }
+
+    const event = normalizeWorkspaceEvent({
+      action,
+      createdAt: Date.now(),
+      highlightRanges,
+      id: createEventId(),
+      origin,
+      reloadRequiredPaths,
+      requestId,
+      sourceRef,
+      workspaceChange: normalizedChange,
+    });
+    this.getWorkspaceRoom()?.publishWorkspaceEvent(event);
+    return event;
+  }
+}

package/public/assets/js/chunks/chunk-R3DDMJHH.js

@@ -1 +0,0 @@
-function x(t){let e=String(t??"").trim();return e?e.endsWith(".md")?e:`${e}.md`:null}function l(t,e){let n=x(t);if(!n||!Array.isArray(e)||e.length===0)return null;let o=String(t??"").trim();return e.find(r=>r===n||r.endsWith(`/${n}`)||r.replace(/\.md$/i,"")===o)??null}function N(t){return String(t).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#39;")}function k(t,e){return l(t,e)??void 0}function M(t,e,n){return Math.min(Math.max(t,e),n)}function h(t){return String(t??"").replace(/\\/g,"/").split("/").filter(Boolean)}function _(t,e){let n=h(t),o=String(e??"").split("/").map(u=>{try{return decodeURIComponent(u)}catch{return u}});if(o.length===0)return"";n.pop();let r=[...n];for(let u of o){let c=String(u??"").trim();if(!(!c||c===".")){if(c===".."){if(r.length===0)return"";r.pop();continue}r.push(c)}}return r.join("/")}var s=Object.freeze([".md",".markdown",".mdx"]),m=".excalidraw",p=Object.freeze([".mmd",".mermaid"]),f=Object.freeze([".puml",".plantuml"]),g=Object.freeze([".png",".jpg",".jpeg",".webp",".gif",".svg"]),E=Object.freeze([m,...p,...f]),S=Object.freeze([...s,...E,...g]),T=/\.(?:md|markdown|mdx|excalidraw|mmd|mermaid|puml|plantuml|png|jpe?g|webp|gif|svg)$/i;function d(t){return String(t??"").trim().toLowerCase()}function a(t,e){let n=d(t);return e.some(o=>n.endsWith(o))}function i(t){return a(t,s)?"markdown":a(t,[m])?"excalidraw":a(t,p)?"mermaid":a(t,f)?"plantuml":a(t,g)?"image":null}function P(t){let e=i(t);return e?e==="image"?"image":e==="markdown"?"file":e:null}function O(t){let e=d(t);return S.find(n=>e.endsWith(n))??""}function w(t){return i(t)==="markdown"}function W(t){return i(t)==="excalidraw"}function z(t){return i(t)==="mermaid"}function L(t){return i(t)==="plantuml"}function j(t){return i(t)==="image"}function v(t){let e=i(t);return e==="excalidraw"||e==="mermaid"||e==="plantuml"}function X(t){let e=i(t);return e==="markdown"||e==="mermaid"||e==="plantuml"}function b(t){return w(t)}function R(t){return String(t??"").replace(T,"")}export{N as a,k as b,M as c,_ as d,i as e,P as f,O as g,w as h,W as i,z as j,L as k,j as l,v as m,X as n,b as o,R as p};