collabmd 0.1.19 → 0.1.21

package/src/server/infrastructure/workspace/file-system-sync-service.js

@@ -0,0 +1,488 @@
+import { watch } from 'fs';
+import { readdir, stat } from 'fs/promises';
+import { basename, dirname, join } from 'path';
+
+import { createWorkspaceChange } from '../../../domain/workspace-change.js';
+import { getVaultTreeNodeType, isVaultFilePath } from '../../../domain/file-kind.js';
+import {
+  isIgnoredVaultEntry,
+  sanitizeVaultPath,
+} from '../persistence/path-utils.js';
+
+const MAX_INCREMENTAL_PENDING_PATHS = 16;
+
+function entrySignature(entry = {}) {
+  return `${entry.type}:${entry.inode}:${entry.size}:${entry.mtimeMs}`;
+}
+
+function sortByPath(values = []) {
+  return [...values].sort((left, right) => left.localeCompare(right, undefined, { sensitivity: 'base' }));
+}
+
+function normalizeWatchedPath(filename) {
+  if (typeof filename !== 'string' && !Buffer.isBuffer(filename)) {
+    return '';
+  }
+
+  const normalized = String(filename).trim().replace(/\\/g, '/').replace(/^\.\/+/, '');
+  if (!normalized || normalized === '.') {
+    return '';
+  }
+
+  return normalized
+    .split('/')
+    .filter(Boolean)
+    .join('/');
+}
+
+function isIgnoredWatchedPath(pathValue) {
+  if (!pathValue) {
+    return true;
+  }
+
+  const segments = String(pathValue).split('/').filter(Boolean);
+  if (segments.length === 0) {
+    return true;
+  }
+
+  if (segments.some((segment) => isIgnoredVaultEntry(segment))) {
+    return true;
+  }
+
+  return basename(pathValue).includes('.collabmd-');
+}
+
+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 isPathWithinPrefix(pathValue, prefix) {
+  return pathValue === prefix || pathValue.startsWith(`${prefix}/`);
+}
+
+function buildPrefixRenameEntries(previousState, nextState, oldPrefix, newPrefix) {
+  const renames = [];
+  previousState.metadata.forEach((entry, pathValue) => {
+    if (entry.type !== 'file' || !pathValue.startsWith(`${oldPrefix}/`)) {
+      return;
+    }
+
+    const suffix = pathValue.slice(oldPrefix.length + 1);
+    const nextPath = `${newPrefix}/${suffix}`;
+    if (nextState.metadata.get(nextPath)?.type === 'file') {
+      renames.push({ oldPath: pathValue, newPath: nextPath });
+    }
+  });
+  return renames;
+}
+
+function detectWorkspaceChange(previousState, nextState) {
+  const previousMetadata = previousState?.metadata ?? new Map();
+  const nextMetadata = nextState?.metadata ?? new Map();
+  const changedPaths = new Set();
+  const deletedPaths = new Set();
+  const addedPaths = new Set();
+  const renamedPaths = [];
+
+  previousMetadata.forEach((previousEntry, pathValue) => {
+    const nextEntry = nextMetadata.get(pathValue);
+    if (!nextEntry) {
+      if (previousEntry.type === 'file') {
+        deletedPaths.add(pathValue);
+      }
+      return;
+    }
+
+    if (entrySignature(previousEntry) !== entrySignature(nextEntry) && nextEntry.type === 'file') {
+      changedPaths.add(pathValue);
+    }
+  });
+
+  nextMetadata.forEach((nextEntry, pathValue) => {
+    if (!previousMetadata.has(pathValue) && nextEntry.type === 'file') {
+      addedPaths.add(pathValue);
+    }
+  });
+
+  const deletedBySignature = new Map();
+  deletedPaths.forEach((pathValue) => {
+    const metadata = previousMetadata.get(pathValue);
+    const signature = entrySignature(metadata);
+    const bucket = deletedBySignature.get(signature) ?? [];
+    bucket.push(pathValue);
+    deletedBySignature.set(signature, bucket);
+  });
+
+  const addedBySignature = new Map();
+  addedPaths.forEach((pathValue) => {
+    const metadata = nextMetadata.get(pathValue);
+    const signature = entrySignature(metadata);
+    const bucket = addedBySignature.get(signature) ?? [];
+    bucket.push(pathValue);
+    addedBySignature.set(signature, bucket);
+  });
+
+  Array.from(deletedBySignature.keys()).forEach((signature) => {
+    const removed = deletedBySignature.get(signature) ?? [];
+    const added = addedBySignature.get(signature) ?? [];
+    if (removed.length === 1 && added.length === 1) {
+      renamedPaths.push({ oldPath: removed[0], newPath: added[0] });
+      deletedPaths.delete(removed[0]);
+      addedPaths.delete(added[0]);
+    }
+  });
+
+  const previousDirectories = Array.from(previousMetadata.entries())
+    .filter(([, entry]) => entry.type === 'directory' && !nextMetadata.has(entry.path));
+  const nextDirectories = Array.from(nextMetadata.entries())
+    .filter(([, entry]) => entry.type === 'directory' && !previousMetadata.has(entry.path));
+
+  previousDirectories.forEach(([oldPath, oldEntry]) => {
+    const match = nextDirectories.find(([, nextEntry]) => entrySignature(oldEntry) === entrySignature(nextEntry));
+    if (!match) {
+      return;
+    }
+
+    const [newPath] = match;
+    buildPrefixRenameEntries(previousState, nextState, oldPath, newPath).forEach((entry) => {
+      renamedPaths.push(entry);
+      deletedPaths.delete(entry.oldPath);
+      addedPaths.delete(entry.newPath);
+    });
+  });
+
+  addedPaths.forEach((pathValue) => {
+    changedPaths.add(pathValue);
+  });
+
+  return createWorkspaceChange({
+    changedPaths: sortByPath(Array.from(changedPaths)),
+    deletedPaths: sortByPath(Array.from(deletedPaths)),
+    renamedPaths,
+    refreshExplorer: true,
+  });
+}
+
+export class FileSystemSyncService {
+  constructor({
+    debounceMs = 180,
+    mutationCoordinator,
+    vaultFileStore,
+  }) {
+    this.debounceMs = debounceMs;
+    this.mutationCoordinator = mutationCoordinator;
+    this.vaultFileStore = vaultFileStore;
+    this.watcher = null;
+    this.debounceTimer = null;
+    this.runningFlush = null;
+    this.lastState = null;
+    this.pendingEventTypesByPath = new Map();
+    this.forceFullScan = false;
+    this.suspendWatchEventsUntil = 0;
+  }
+
+  async start() {
+    this.lastState = this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
+    this.watcher = watch(this.vaultFileStore.vaultDir, { recursive: true }, (eventType, filename) => {
+      this.handleWatchEvent(eventType, filename);
+    });
+  }
+
+  handleWatchEvent(eventType, filename) {
+    if (Date.now() <= this.suspendWatchEventsUntil) {
+      return;
+    }
+
+    const normalizedPath = normalizeWatchedPath(filename);
+    if (!normalizedPath) {
+      this.forceFullScan = true;
+      this.scheduleFlush();
+      return;
+    }
+
+    if (isIgnoredWatchedPath(normalizedPath)) {
+      return;
+    }
+
+    const bucket = this.pendingEventTypesByPath.get(normalizedPath) ?? new Set();
+    bucket.add(String(eventType || 'change'));
+    this.pendingEventTypesByPath.set(normalizedPath, bucket);
+
+    if (this.pendingEventTypesByPath.size > MAX_INCREMENTAL_PENDING_PATHS) {
+      this.forceFullScan = true;
+    }
+
+    this.scheduleFlush();
+  }
+
+  scheduleFlush() {
+    clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null;
+      this.runningFlush = this.flush().finally(() => {
+        this.runningFlush = null;
+      });
+    }, this.debounceMs);
+    this.debounceTimer.unref?.();
+  }
+
+  async resetForExternalStateChange() {
+    this.suspendWatchEventsUntil = Math.max(this.suspendWatchEventsUntil, Date.now() + 750);
+    clearTimeout(this.debounceTimer);
+    this.debounceTimer = null;
+    this.pendingEventTypesByPath.clear();
+    this.forceFullScan = false;
+
+    try {
+      await this.runningFlush;
+    } catch {
+      // Ignore stale flush failures while rebaselining around an external reset.
+    }
+
+    this.pendingEventTypesByPath.clear();
+    this.forceFullScan = false;
+    this.lastState = this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
+  }
+
+  async readWorkspacePathSnapshot(pathValue) {
+    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);
+      const entries = new Map();
+      const metadata = new Map();
+
+      if (info.isDirectory()) {
+        const visitDirectory = async (directoryPath, relativePath) => {
+          entries.set(relativePath, createWorkspaceEntry(relativePath, 'directory'));
+          metadata.set(relativePath, createWorkspaceMetadata(relativePath, 'directory', await stat(directoryPath)));
+
+          let dirEntries;
+          try {
+            dirEntries = await readdir(directoryPath, { withFileTypes: true });
+          } catch {
+            return;
+          }
+
+          for (const entry of dirEntries) {
+            if (isIgnoredVaultEntry(entry.name)) {
+              continue;
+            }
+
+            const childAbsolutePath = join(directoryPath, entry.name);
+            const childRelativePath = `${relativePath}/${entry.name}`.replace(/\\/g, '/');
+
+            if (entry.isDirectory()) {
+              await visitDirectory(childAbsolutePath, childRelativePath);
+              continue;
+            }
+
+            if (!isVaultFilePath(childRelativePath)) {
+              continue;
+            }
+
+            try {
+              const childInfo = await stat(childAbsolutePath);
+              if (!childInfo.isFile()) {
+                continue;
+              }
+
+              entries.set(childRelativePath, createWorkspaceEntry(childRelativePath, 'file'));
+              metadata.set(childRelativePath, createWorkspaceMetadata(childRelativePath, 'file', childInfo));
+            } catch (error) {
+              if (error?.code !== 'ENOENT' && error?.code !== 'ENOTDIR') {
+                throw error;
+              }
+            }
+          }
+        };
+
+        await visitDirectory(absolutePath, normalizedPath);
+        return { entries, metadata };
+      }
+
+      if (!info.isFile() || !isVaultFilePath(normalizedPath)) {
+        return { entries, metadata };
+      }
+
+      entries.set(normalizedPath, createWorkspaceEntry(normalizedPath, 'file'));
+      metadata.set(normalizedPath, createWorkspaceMetadata(normalizedPath, 'file', info));
+      return { entries, metadata };
+    } catch (error) {
+      if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') {
+        return {
+          entries: new Map(),
+          metadata: new Map(),
+        };
+      }
+
+      throw error;
+    }
+  }
+
+  async ensureAncestorDirectories(nextEntries, nextMetadata, pathValue) {
+    const parentPath = getParentDirectoryPath(pathValue);
+    if (!parentPath) {
+      return true;
+    }
+
+    const segments = parentPath.split('/').filter(Boolean);
+    let currentPath = '';
+    for (const segment of segments) {
+      currentPath = currentPath ? `${currentPath}/${segment}` : segment;
+      if (nextEntries.has(currentPath) && nextMetadata.has(currentPath)) {
+        continue;
+      }
+
+      const directorySnapshot = await this.readWorkspacePathSnapshot(currentPath);
+      if (!directorySnapshot?.entries?.has(currentPath) || !directorySnapshot.metadata?.has(currentPath)) {
+        return false;
+      }
+
+      nextEntries.set(currentPath, directorySnapshot.entries.get(currentPath));
+      nextMetadata.set(currentPath, directorySnapshot.metadata.get(currentPath));
+    }
+
+    return true;
+  }
+
+  async buildIncrementalResult() {
+    if (this.forceFullScan || this.pendingEventTypesByPath.size === 0 || !this.lastState) {
+      return null;
+    }
+
+    const pendingPaths = Array.from(this.pendingEventTypesByPath.keys())
+      .filter(Boolean)
+      .sort((left, right) => left.localeCompare(right, undefined, { sensitivity: 'base' }));
+    if (pendingPaths.length === 0 || pendingPaths.length > MAX_INCREMENTAL_PENDING_PATHS) {
+      return null;
+    }
+
+    const nextEntries = new Map(this.lastState.entries);
+    const nextMetadata = new Map(this.lastState.metadata);
+    const previousState = this.lastState;
+
+    for (const pathValue of pendingPaths) {
+      Array.from(previousState.entries.keys())
+        .filter((candidatePath) => isPathWithinPrefix(candidatePath, pathValue))
+        .forEach((candidatePath) => {
+          nextEntries.delete(candidatePath);
+        });
+      Array.from(previousState.metadata.keys())
+        .filter((candidatePath) => isPathWithinPrefix(candidatePath, pathValue))
+        .forEach((candidatePath) => {
+          nextMetadata.delete(candidatePath);
+        });
+
+      const snapshot = await this.readWorkspacePathSnapshot(pathValue);
+      if (!snapshot) {
+        return null;
+      }
+
+      if (snapshot.entries.size > 0) {
+        if (!(await this.ensureAncestorDirectories(nextEntries, nextMetadata, pathValue))) {
+          return null;
+        }
+      }
+
+      snapshot.entries.forEach((entry, entryPath) => {
+        nextEntries.set(entryPath, entry);
+      });
+      snapshot.metadata.forEach((metadata, metadataPath) => {
+        nextMetadata.set(metadataPath, metadata);
+      });
+    }
+
+    const nextState = {
+      entries: nextEntries,
+      metadata: nextMetadata,
+      scannedAt: Date.now(),
+    };
+    const workspaceChange = detectWorkspaceChange(this.lastState, nextState);
+
+    return {
+      nextState,
+      workspaceChange,
+    };
+  }
+
+  consumePendingEvents() {
+    const hadPendingEvents = this.pendingEventTypesByPath.size > 0 || this.forceFullScan;
+    this.pendingEventTypesByPath.clear();
+    this.forceFullScan = false;
+    return hadPendingEvents;
+  }
+
+  async flush() {
+    const incrementalResult = await this.buildIncrementalResult();
+    this.consumePendingEvents();
+
+    const previousWorkspaceState = this.mutationCoordinator.workspaceState;
+    const nextState = incrementalResult?.nextState ?? await this.vaultFileStore.scanWorkspaceState();
+    const workspaceChange = incrementalResult?.workspaceChange ?? detectWorkspaceChange(this.lastState, nextState);
+    this.lastState = nextState;
+
+    const filteredChange = this.mutationCoordinator.filterManagedWorkspaceChange(workspaceChange);
+    if (!filteredChange) {
+      this.mutationCoordinator.syncWorkspaceEntries(nextState, {
+        previousState: previousWorkspaceState,
+      });
+      this.mutationCoordinator.replaceWorkspaceState(nextState);
+      return;
+    }
+
+    await this.mutationCoordinator.apply({
+      action: 'filesystem-sync',
+      origin: 'filesystem',
+      nextState,
+      workspaceChange: filteredChange,
+    });
+  }
+
+  async close() {
+    clearTimeout(this.debounceTimer);
+    this.debounceTimer = null;
+    this.pendingEventTypesByPath.clear();
+    this.forceFullScan = false;
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    await this.runningFlush;
+  }
+}