collabmd 0.1.27 → 0.1.30

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

@@ -5,10 +5,38 @@ import {
   isPlantUmlFilePath,
 } from '../../../domain/file-kind.js';
 import { createWorkspaceChange } from '../../../domain/workspace-change.js';
+import { basename } from 'node:path';
 import { createRequestError, getRequestErrorStatusCode } from './http-errors.js';
-import { jsonResponse } from './http-response.js';
+import { jsonResponse, sendResponse } from './http-response.js';
 import { parseJsonBody, readBinaryRequestBody } from './request-body.js';
 
+const DOCX_EXPORT_REQUEST_LIMIT_BYTES = 33_554_432;
+const DOCX_MIME_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+
+function encodeContentDispositionFilename(fileName) {
+  return encodeURIComponent(String(fileName ?? ''))
+    .replace(/['()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+
+function createSafeAsciiFilename(fileName) {
+  const fallback = String(fileName ?? '')
+    .replace(/[^\x20-\x7E]+/g, '_')
+    .replace(/["\\]/g, '_')
+    .trim();
+  return fallback || 'document';
+}
+
+function createDocxDownloadHeaders(filePath) {
+  const fileName = basename(String(filePath ?? 'document')).replace(/\.[^.]+$/u, '') || 'document';
+  const exportFileName = `${fileName}.docx`;
+  return {
+    'Cache-Control': 'no-store',
+    'Content-Disposition': `attachment; filename="${createSafeAsciiFilename(exportFileName)}"; filename*=UTF-8''${encodeContentDispositionFilename(exportFileName)}`,
+    'Content-Type': DOCX_MIME_TYPE,
+    'X-Content-Type-Options': 'nosniff',
+  };
+}
+
 function decodeHeaderMetadata(value) {
   const normalized = String(value ?? '').trim();
   if (!normalized) {
@@ -64,10 +92,40 @@ function getDirectoryDeleteStatusCode(message = '') {
 }
 
 export function createVaultApiCommandHandler({
+  docxExporter = null,
   vaultFileStore,
   workspaceMutationCoordinator = null,
 }) {
   return async function handleVaultApiCommand(req, res, requestUrl) {
+    if (requestUrl.pathname === '/api/export/docx' && req.method === 'POST') {
+      try {
+        const body = await parseJsonBody(req, DOCX_EXPORT_REQUEST_LIMIT_BYTES);
+        if (!body?.filePath || typeof body?.html !== 'string') {
+          jsonResponse(req, res, 400, { error: 'Missing filePath or html' });
+          return true;
+        }
+
+        if (!docxExporter?.render) {
+          jsonResponse(req, res, 503, { error: 'DOCX export is unavailable' });
+          return true;
+        }
+
+        const docxBuffer = await docxExporter.render({
+          html: body.html,
+          title: body.title || '',
+        });
+
+        sendResponse(req, res, {
+          body: docxBuffer,
+          headers: createDocxDownloadHeaders(body.filePath),
+          statusCode: 200,
+        });
+      } catch (error) {
+        handleVaultError(req, res, error, '[api] Failed to export DOCX:', 'Failed to export DOCX');
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/file' && req.method === 'PUT') {
       try {
         const body = await parseJsonBody(req);

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

@@ -4,6 +4,7 @@ import { createVaultApiQueryHandler } from './create-vault-api-query-handler.js'
 
 export function createVaultApiHandler({
   backlinkIndex,
+  docxExporter = null,
   plantUmlRenderer = null,
   roomRegistry = null,
   vaultFileStore,
@@ -16,6 +17,7 @@ export function createVaultApiHandler({
   });
   const handleVaultApiCommand = createVaultApiCommandHandler({
     backlinkIndex,
+    docxExporter,
     roomRegistry,
     vaultFileStore,
     workspaceMutationCoordinator,

package/src/server/infrastructure/http/request-body.js

@@ -54,8 +54,8 @@ export async function readBinaryRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_B
   return readRequestBuffer(req, maxBytes);
 }
 
-export async function parseJsonBody(req) {
-  const rawBody = await readRequestBody(req);
+export async function parseJsonBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
+  const rawBody = await readRequestBody(req, maxBytes);
 
   try {
     return JSON.parse(rawBody);

package/src/server/infrastructure/persistence/pull-backup-store.js

@@ -240,7 +240,7 @@ export class PullBackupStore {
   }
 
   async listBackups() {
-    let entries = [];
+    let entries;
     try {
       entries = await readdir(this.getStorageRoot(), { withFileTypes: true });
     } catch (error) {

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -7,6 +7,7 @@ import {
   isMarkdownFilePath,
   isVaultFilePath,
 } from '../../../domain/file-kind.js';
+import { mapWithConcurrency } from '../../shared/async-utils.js';
 import { getVaultContentAdapter } from './vault-content-adapter.js';
 import {
   INVALID_VAULT_FILE_PATH_ERROR,
@@ -36,6 +37,7 @@ const MIME_TYPE_TO_IMAGE_EXTENSION = Object.freeze({
   'image/svg+xml': '.svg',
   'image/webp': '.webp',
 });
+const WORKSPACE_SCAN_CONCURRENCY = 8;
 
 function createTransactionalPath(targetPath, label) {
   return `${targetPath}.collabmd-${label}-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
@@ -74,6 +76,16 @@ function createWorkspaceEntry(relativePath, type) {
   };
 }
 
+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 replacePathPrefix(pathValue, oldPrefix, newPrefix) {
   if (pathValue === oldPrefix) {
     return newPrefix;
@@ -94,6 +106,14 @@ function sortWorkspacePaths(paths = [], direction = 'asc') {
   });
 }
 
+function sortDirectoryEntries(entries = []) {
+  return [...entries].sort((left, right) => {
+    if (left.isDirectory() && !right.isDirectory()) return -1;
+    if (!left.isDirectory() && right.isDirectory()) return 1;
+    return left.name.localeCompare(right.name, undefined, { sensitivity: 'base' });
+  });
+}
+
 async function cleanupPaths(paths = []) {
   await Promise.allSettled(paths.filter(Boolean).map((pathValue) => rm(pathValue, { force: true })));
 }
@@ -398,8 +418,8 @@ export class VaultFileStore {
     const timestamp = createAttachmentTimestamp(now);
     const baseFileName = `${attachmentStem}-${timestamp}`;
     let collisionIndex = 0;
-    let storedPath = '';
-    let absolutePath = '';
+    let storedPath;
+    let absolutePath;
 
     do {
       const suffix = collisionIndex > 0 ? `-${collisionIndex + 1}` : '';
@@ -765,7 +785,8 @@ export class VaultFileStore {
   }
 
   async countVaultFiles() {
-    return this.countFilesInDir(this.vaultDir);
+    const snapshot = await this.scanWorkspaceState();
+    return snapshot.vaultFileCount;
   }
 
   async reconcileSidecars({
@@ -838,6 +859,8 @@ export class VaultFileStore {
   async scanWorkspaceState() {
     const entries = new Map();
     const metadata = new Map();
+    const markdownPaths = [];
+    let vaultFileCount = 0;
 
     const visitDirectory = async (dirPath) => {
       let dirEntries;
@@ -847,64 +870,84 @@ export class VaultFileStore {
         return;
       }
 
-      const sorted = dirEntries.sort((left, right) => {
-        if (left.isDirectory() && !right.isDirectory()) return -1;
-        if (!left.isDirectory() && right.isDirectory()) return 1;
-        return left.name.localeCompare(right.name, undefined, { sensitivity: 'base' });
-      });
+      const sorted = sortDirectoryEntries(dirEntries);
 
-      for (const entry of sorted) {
+      await mapWithConcurrency(sorted, WORKSPACE_SCAN_CONCURRENCY, async (entry) => {
         if (isIgnoredVaultEntry(entry.name)) {
-          continue;
+          return;
         }
 
         const fullPath = join(dirPath, entry.name);
         const relativePath = toVaultRelativePath(this.vaultDir, fullPath).replace(/\\/g, '/');
+        const direntKind = entry.isDirectory()
+          ? 'directory'
+          : (entry.isFile() ? 'file' : null);
 
-        if (entry.isDirectory()) {
+        if (direntKind === 'directory') {
           entries.set(relativePath, createWorkspaceEntry(relativePath, 'directory'));
           try {
             const info = await stat(fullPath);
-            metadata.set(relativePath, {
-              inode: Number(info.ino || 0),
-              mtimeMs: Number(info.mtimeMs || 0),
-              path: relativePath,
-              size: 0,
-              type: 'directory',
-            });
+            metadata.set(relativePath, createWorkspaceMetadata(relativePath, 'directory', info));
           } catch {
             // Ignore transient directories that disappear during scans.
           }
           await visitDirectory(fullPath);
-          continue;
+          return;
         }
 
-        if (!isVaultFilePath(entry.name)) {
-          continue;
+        if (direntKind === 'file') {
+          if (!isVaultFilePath(entry.name)) {
+            return;
+          }
+
+          entries.set(relativePath, createWorkspaceEntry(relativePath, 'file'));
+          vaultFileCount += 1;
+          if (isMarkdownFilePath(relativePath)) {
+            markdownPaths.push(relativePath);
+          }
+          try {
+            const info = await stat(fullPath);
+            metadata.set(relativePath, createWorkspaceMetadata(relativePath, 'file', info));
+          } catch {
+            // Ignore transient files that disappear during scans.
+          }
+          return;
         }
 
-        entries.set(relativePath, createWorkspaceEntry(relativePath, 'file'));
         try {
           const info = await stat(fullPath);
-          metadata.set(relativePath, {
-            inode: Number(info.ino || 0),
-            mtimeMs: Number(info.mtimeMs || 0),
-            path: relativePath,
-            size: Number(info.size || 0),
-            type: 'file',
-          });
+          if (info.isDirectory()) {
+            entries.set(relativePath, createWorkspaceEntry(relativePath, 'directory'));
+            metadata.set(relativePath, createWorkspaceMetadata(relativePath, 'directory', info));
+            await visitDirectory(fullPath);
+            return;
+          }
+
+          if (!info.isFile() || !isVaultFilePath(entry.name)) {
+            return;
+          }
+
+          entries.set(relativePath, createWorkspaceEntry(relativePath, 'file'));
+          metadata.set(relativePath, createWorkspaceMetadata(relativePath, 'file', info));
+          vaultFileCount += 1;
+          if (isMarkdownFilePath(relativePath)) {
+            markdownPaths.push(relativePath);
+          }
         } catch {
-          // Ignore transient files that disappear during scans.
+          // Ignore transient entries that disappear during scans.
         }
-      }
+      });
     };
 
     await visitDirectory(this.vaultDir);
+    markdownPaths.sort((left, right) => left.localeCompare(right, undefined, { sensitivity: 'base' }));
 
     return {
       entries,
       metadata,
+      markdownPaths,
       scannedAt: Date.now(),
+      vaultFileCount,
     };
   }
 }

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

@@ -4,6 +4,7 @@ import { basename, dirname, join } from 'path';
 
 import { createWorkspaceChange } from '../../../domain/workspace-change.js';
 import { getVaultTreeNodeType, isVaultFilePath } from '../../../domain/file-kind.js';
+import { logPerfEvent } from '../../config/perf-logging.js';
 import {
   isIgnoredVaultEntry,
   sanitizeVaultPath,
@@ -194,10 +195,12 @@ export class FileSystemSyncService {
   constructor({
     debounceMs = 180,
     mutationCoordinator,
+    perfLoggingEnabled = false,
     vaultFileStore,
   }) {
     this.debounceMs = debounceMs;
     this.mutationCoordinator = mutationCoordinator;
+    this.perfLoggingEnabled = perfLoggingEnabled;
     this.vaultFileStore = vaultFileStore;
     this.watcher = null;
     this.debounceTimer = null;
@@ -208,8 +211,8 @@ export class FileSystemSyncService {
     this.suspendWatchEventsUntil = 0;
   }
 
-  async start() {
-    this.lastState = this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
+  async start({ snapshot = null } = {}) {
+    this.lastState = snapshot ?? this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
     this.watcher = watch(this.vaultFileStore.vaultDir, { recursive: true }, (eventType, filename) => {
       this.handleWatchEvent(eventType, filename);
     });
@@ -253,7 +256,7 @@ export class FileSystemSyncService {
     this.debounceTimer.unref?.();
   }
 
-  async resetForExternalStateChange() {
+  async resetForExternalStateChange({ snapshot = null } = {}) {
     this.suspendWatchEventsUntil = Math.max(this.suspendWatchEventsUntil, Date.now() + 750);
     clearTimeout(this.debounceTimer);
     this.debounceTimer = null;
@@ -268,7 +271,7 @@ export class FileSystemSyncService {
 
     this.pendingEventTypesByPath.clear();
     this.forceFullScan = false;
-    this.lastState = this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
+    this.lastState = snapshot ?? this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
   }
 
   async readWorkspacePathSnapshot(pathValue) {
@@ -382,15 +385,23 @@ export class FileSystemSyncService {
   }
 
   async buildIncrementalResult() {
-    if (this.forceFullScan || this.pendingEventTypesByPath.size === 0 || !this.lastState) {
-      return null;
+    if (this.forceFullScan) {
+      return { fallbackReason: 'forced-full-scan', incrementalResult: null };
+    }
+
+    if (this.pendingEventTypesByPath.size === 0) {
+      return { fallbackReason: 'no-pending-paths', incrementalResult: null };
+    }
+
+    if (!this.lastState) {
+      return { fallbackReason: 'missing-last-state', incrementalResult: 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;
+      return { fallbackReason: 'too-many-pending-paths', incrementalResult: null };
     }
 
     const nextEntries = new Map(this.lastState.entries);
@@ -411,12 +422,12 @@ export class FileSystemSyncService {
 
       const snapshot = await this.readWorkspacePathSnapshot(pathValue);
       if (!snapshot) {
-        return null;
+        return { fallbackReason: 'snapshot-unavailable', incrementalResult: null };
       }
 
       if (snapshot.entries.size > 0) {
         if (!(await this.ensureAncestorDirectories(nextEntries, nextMetadata, pathValue))) {
-          return null;
+          return { fallbackReason: 'ancestor-missing', incrementalResult: null };
         }
       }
 
@@ -436,8 +447,11 @@ export class FileSystemSyncService {
     const workspaceChange = detectWorkspaceChange(this.lastState, nextState);
 
     return {
-      nextState,
-      workspaceChange,
+      fallbackReason: '',
+      incrementalResult: {
+        nextState,
+        workspaceChange,
+      },
     };
   }
 
@@ -449,7 +463,9 @@ export class FileSystemSyncService {
   }
 
   async flush() {
-    const incrementalResult = await this.buildIncrementalResult();
+    const startedAt = Date.now();
+    const pendingPathCount = this.pendingEventTypesByPath.size;
+    const { fallbackReason, incrementalResult } = await this.buildIncrementalResult();
     this.consumePendingEvents();
 
     const previousWorkspaceState = this.mutationCoordinator.workspaceState;
@@ -463,6 +479,15 @@ export class FileSystemSyncService {
         previousState: previousWorkspaceState,
       });
       this.mutationCoordinator.replaceWorkspaceState(nextState);
+      logPerfEvent(this.perfLoggingEnabled, 'filesystem-sync', {
+        changedPathCount: workspaceChange.changedPaths?.length ?? 0,
+        deletedPathCount: workspaceChange.deletedPaths?.length ?? 0,
+        durationMs: Date.now() - startedAt,
+        fallbackReason,
+        mode: incrementalResult ? 'incremental' : 'full-scan',
+        pendingPathCount,
+        renamedPathCount: workspaceChange.renamedPaths?.length ?? 0,
+      });
       return;
     }
 
@@ -472,6 +497,15 @@ export class FileSystemSyncService {
       nextState,
       workspaceChange: filteredChange,
     });
+    logPerfEvent(this.perfLoggingEnabled, 'filesystem-sync', {
+      changedPathCount: filteredChange.changedPaths?.length ?? 0,
+      deletedPathCount: filteredChange.deletedPaths?.length ?? 0,
+      durationMs: Date.now() - startedAt,
+      fallbackReason,
+      mode: incrementalResult ? 'incremental' : 'full-scan',
+      pendingPathCount,
+      renamedPathCount: filteredChange.renamedPaths?.length ?? 0,
+    });
   }
 
   async close() {

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

@@ -26,6 +26,31 @@ function countWorkspacePaths(workspaceChange = {}) {
   );
 }
 
+function countBacklinkAffectedPaths(workspaceChange = {}) {
+  const affectedPaths = new Set();
+
+  (workspaceChange.changedPaths ?? []).forEach((pathValue) => {
+    if (supportsBacklinksForFilePath(pathValue)) {
+      affectedPaths.add(pathValue);
+    }
+  });
+  (workspaceChange.deletedPaths ?? []).forEach((pathValue) => {
+    if (supportsBacklinksForFilePath(pathValue)) {
+      affectedPaths.add(pathValue);
+    }
+  });
+  (workspaceChange.renamedPaths ?? []).forEach((entry) => {
+    if (supportsBacklinksForFilePath(entry?.oldPath)) {
+      affectedPaths.add(entry.oldPath);
+    }
+    if (supportsBacklinksForFilePath(entry?.newPath)) {
+      affectedPaths.add(entry.newPath);
+    }
+  });
+
+  return affectedPaths.size;
+}
+
 function normalizePaths(paths = []) {
   return Array.from(new Set((paths ?? []).filter(Boolean)));
 }
@@ -386,13 +411,13 @@ export class WorkspaceMutationCoordinator {
     });
   }
 
-  async initialize() {
-    const snapshot = await this.vaultFileStore.scanWorkspaceState();
-    this.replaceWorkspaceState(snapshot);
-    this.getWorkspaceRoom()?.replaceWorkspaceEntries(snapshot.entries, {
-      generatedAt: snapshot.scannedAt,
+  async initialize({ snapshot = null } = {}) {
+    const effectiveSnapshot = snapshot ?? await this.vaultFileStore.scanWorkspaceState();
+    this.replaceWorkspaceState(effectiveSnapshot);
+    this.getWorkspaceRoom()?.replaceWorkspaceEntries(effectiveSnapshot.entries, {
+      generatedAt: effectiveSnapshot.scannedAt,
     });
-    return snapshot;
+    return effectiveSnapshot;
   }
 
   markManagedPaths(paths = [], { durationMs = this.managedWriteWindowMs } = {}) {
@@ -532,7 +557,7 @@ export class WorkspaceMutationCoordinator {
     const previousEntries = this.workspaceState?.entries ?? new Map();
     if (
       forceRebuild
-      || countWorkspacePaths(workspaceChange) > 25
+      || countBacklinkAffectedPaths(workspaceChange) > 25
     ) {
       this.backlinkIndex.scheduleBuild?.();
       return;

package/src/server/shared/async-utils.js

@@ -0,0 +1,25 @@
+export async function mapWithConcurrency(values, concurrency, iteratee) {
+  const items = Array.from(values ?? []);
+  const limit = Math.max(1, Number(concurrency) || 1);
+
+  if (items.length === 0) {
+    return [];
+  }
+
+  const results = new Array(items.length);
+  let nextIndex = 0;
+
+  async function worker() {
+    while (nextIndex < items.length) {
+      const currentIndex = nextIndex;
+      nextIndex += 1;
+      results[currentIndex] = await iteratee(items[currentIndex], currentIndex);
+    }
+  }
+
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => worker()),
+  );
+
+  return results;
+}

package/dist/client/assets/architecture-PBZL5I3N-C1Yv7agI.js

@@ -1 +0,0 @@
-import"./chunk-XZSTWKYB-DZzfqgVn.js";import{n as e}from"./chunk-R5LLSJPH-CZzZlfdI.js";export{e as createArchitectureServices};