collabmd 0.1.39 → 0.1.41

package/src/server/create-app-server.js

@@ -9,15 +9,23 @@ import { CollaborationDocumentStore } from './domain/collaboration/collaboration
 import { CollaborationRoom } from './domain/collaboration/collaboration-room.js';
 import { DocxExporter } from './domain/docx-exporter.js';
 import { GitService } from './infrastructure/git/git-service.js';
+import { GitHubAppClient } from './infrastructure/github/github-app-client.js';
+import { GitHubSetupFlow } from './infrastructure/github/github-setup-flow.js';
+import { HostedWorkspaceService } from './domain/hosted-workspace.js';
 import { PlantUmlRenderer } from './infrastructure/plantuml/plantuml-renderer.js';
 import { RoomRegistry } from './domain/collaboration/room-registry.js';
+import { RipgrepSearchService } from './domain/ripgrep-search-service.js';
 import { createRequestHandler } from './infrastructure/http/create-request-handler.js';
+import { HostedMetadataStore } from './infrastructure/persistence/hosted-metadata-store.js';
 import { VaultFileStore } from './infrastructure/persistence/vault-file-store.js';
 import { attachCollaborationGateway } from './infrastructure/websocket/attach-collaboration-gateway.js';
 import { isDrawioLeaseRoom } from '../domain/drawio-room.js';
 import { WORKSPACE_ROOM_NAME } from '../domain/workspace-room.js';
 import { FileSystemSyncService } from './infrastructure/workspace/file-system-sync-service.js';
-import { WorkspaceMutationCoordinator } from './infrastructure/workspace/workspace-mutation-coordinator.js';
+import { WorkspaceReconciliation } from './application/workspace-reconciliation.js';
+import { createWorkspaceStateFileSystemAdapter } from './infrastructure/workspace/workspace-state-file-system-adapter.js';
+import { createSignedCookieManager } from './auth/session-cookie.js';
+import { workspaceStateMetadataEqual } from './domain/workspace-state.js';
 
 function getDisplayHost(host) {
   return host === '127.0.0.1' ? 'localhost' : host;
@@ -40,38 +48,28 @@ function closeHttpServer(httpServer) {
   });
 }
 
-function workspaceStateMetadataEqual(left = null, right = null) {
-  const leftMetadata = left?.metadata;
-  const rightMetadata = right?.metadata;
-  if (!(leftMetadata instanceof Map) || !(rightMetadata instanceof Map)) {
-    return false;
-  }
-
-  if (leftMetadata.size !== rightMetadata.size) {
-    return false;
-  }
-
-  for (const [pathValue, leftEntry] of leftMetadata.entries()) {
-    const rightEntry = rightMetadata.get(pathValue);
-    if (!rightEntry) {
-      return false;
-    }
-
-    if (
-      leftEntry.type !== rightEntry.type
-      || leftEntry.size !== rightEntry.size
-      || leftEntry.inode !== rightEntry.inode
-      || leftEntry.mtimeMs !== rightEntry.mtimeMs
-    ) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
 export function createAppServer(config = loadConfig()) {
   const authService = createAuthService(config);
+  const hostedWorkspaceService = new HostedWorkspaceService({
+    claim: config.hosted?.claim,
+    enabled: config.hosted?.enabled,
+    store: config.hosted?.enabled
+      ? new HostedMetadataStore({ dbPath: config.hosted.metadataDbPath })
+      : null,
+  });
+  const githubAppClient = config.hosted?.enabled
+    ? new GitHubAppClient(config.hosted.githubApp)
+    : null;
+  const githubSetupFlow = config.hosted?.enabled
+    ? new GitHubSetupFlow({
+        cookieManager: createSignedCookieManager({
+          cookieName: config.hosted.githubApp.flowCookieName,
+          cookiePath: config.basePath || '/',
+          secret: config.auth.sessionSecret,
+        }),
+        githubAppClient,
+      })
+    : null;
   const vaultFileStore = new VaultFileStore({ vaultDir: config.vaultDir });
   const backlinkIndex = new BacklinkIndex({ vaultFileStore });
   let fileSystemSyncService = null;
@@ -91,6 +89,10 @@ export function createAppServer(config = loadConfig()) {
     enabled: config.gitEnabled,
     vaultDir: config.vaultDir,
   });
+  const searchService = new RipgrepSearchService({
+    perfLoggingEnabled: config.perfLoggingEnabled,
+    vaultDir: config.vaultDir,
+  });
   const testControls = {
     wsRoomHydrateDelayMs: Math.max(0, Number(config.testWsRoomHydrateDelayMs || 0)),
   };
@@ -121,11 +123,14 @@ export function createAppServer(config = loadConfig()) {
       return room;
     },
   });
-  workspaceMutationCoordinator = new WorkspaceMutationCoordinator({
+  workspaceMutationCoordinator = new WorkspaceReconciliation({
     backlinkIndex,
     baseQueryService,
     roomRegistry,
     vaultFileStore,
+    workspaceStateAdapter: createWorkspaceStateFileSystemAdapter({
+      vaultDir: vaultFileStore.vaultDir,
+    }),
   });
   vaultFileStore.setManagedWriteTracker(workspaceMutationCoordinator);
   fileSystemSyncService = new FileSystemSyncService({
@@ -143,9 +148,12 @@ export function createAppServer(config = loadConfig()) {
     roomRegistry,
     plantUmlRenderer,
     gitService,
+    searchService,
     testControls,
     workspaceMutationCoordinator,
     fileSystemSyncService,
+    hostedWorkspaceService,
+    githubSetupFlow,
   );
   const httpServer = createServer((req, res) => {
     requestHandler(req, res).catch((error) => {
@@ -167,6 +175,7 @@ export function createAppServer(config = loadConfig()) {
     httpServer,
     roomRegistry,
     wsBasePath: config.wsBasePath,
+    hostedWorkspaceService,
   });
 
   let shutdownPromise = null;
@@ -175,6 +184,16 @@ export function createAppServer(config = loadConfig()) {
   async function listen() {
     const startupStartedAt = Date.now();
 
+    await hostedWorkspaceService.initialize();
+
+    const searchCapabilityStartedAt = Date.now();
+    config.search = await searchService.initialize();
+    logPerfEvent(config.perfLoggingEnabled, 'startup', {
+      available: config.search.available,
+      durationMs: Date.now() - searchCapabilityStartedAt,
+      phase: 'search-capability',
+    });
+
     const initialWorkspaceScanStartedAt = Date.now();
     const initialWorkspaceSnapshot = await vaultFileStore.scanWorkspaceState();
     vaultFileCount = initialWorkspaceSnapshot.vaultFileCount ?? 0;
@@ -220,12 +239,20 @@ export function createAppServer(config = loadConfig()) {
       phase: 'workspace-init',
     });
 
-    const watcherStartStartedAt = Date.now();
-    await fileSystemSyncService.start({ snapshot: liveWorkspaceSnapshot });
-    logPerfEvent(config.perfLoggingEnabled, 'startup', {
-      durationMs: Date.now() - watcherStartStartedAt,
-      phase: 'watcher-start',
-    });
+    if (config.fileWatcherEnabled !== false) {
+      const watcherStartStartedAt = Date.now();
+      await fileSystemSyncService.start({ snapshot: liveWorkspaceSnapshot });
+      logPerfEvent(config.perfLoggingEnabled, 'startup', {
+        durationMs: Date.now() - watcherStartStartedAt,
+        phase: 'watcher-start',
+      });
+    } else {
+      fileSystemSyncService.initializeFromSnapshot({ snapshot: liveWorkspaceSnapshot });
+      logPerfEvent(config.perfLoggingEnabled, 'startup', {
+        durationMs: 0,
+        phase: 'watcher-skipped',
+      });
+    }
 
     return new Promise((resolve, reject) => {
       const listenStartedAt = Date.now();
@@ -268,6 +295,7 @@ export function createAppServer(config = loadConfig()) {
       await Promise.all([
         closeHttpServer(httpServer),
         config.git?.cleanup?.(),
+        hostedWorkspaceService.close(),
       ]);
     })().then(() => undefined);
 
@@ -286,6 +314,8 @@ export function createAppServer(config = loadConfig()) {
     backlinkIndex,
     fileSystemSyncService,
     gitService,
+    hostedWorkspaceService,
+    searchService,
     setTestHydrateDelayMs(delayMs = 0) {
       testControls.wsRoomHydrateDelayMs = Math.max(0, Number(delayMs) || 0);
     },

package/src/server/domain/bases/base-expression-runtime.js

@@ -472,63 +472,65 @@ function invokeGlobalFunction(name, argNodes, scope, evaluate) {
   }
 }
 
-function invokeMethod(target, name, argNodes, scope, evaluate, rootContext) {
-  if (target?.__baseType === 'formula-namespace') {
-    if (argNodes.length > 0) {
-      throw new Error(`Formula namespace property "${name}" is not callable`);
-    }
-    return rootContext.resolveFormulaValue(name, target.row, target.evaluationState);
+const METHOD_NOT_HANDLED = Symbol('base-method-not-handled');
+const NULL_FALSE_METHODS = new Set([
+  'contains',
+  'containsAll',
+  'containsAny',
+  'endsWith',
+  'hasLink',
+  'hasProperty',
+  'hasTag',
+  'inFolder',
+  'linksTo',
+  'startsWith',
+]);
+
+function normalizeLinkComparablePath(value) {
+  if (value?.__baseType === 'file') {
+    return value.path;
   }
+  if (value?.__baseType === 'link') {
+    return value.path;
+  }
+  return String(value ?? '');
+}
 
-  if (target == null) {
-    switch (name) {
-      case 'contains':
-      case 'containsAll':
-      case 'containsAny':
-      case 'endsWith':
-      case 'hasLink':
-      case 'hasProperty':
-      case 'hasTag':
-      case 'inFolder':
-      case 'linksTo':
-      case 'startsWith':
-        return false;
-      case 'isEmpty':
-        return true;
-      default:
-        break;
-    }
+function invokeNullMethod(name) {
+  if (NULL_FALSE_METHODS.has(name)) {
+    return false;
+  }
+  if (name === 'isEmpty') {
+    return true;
   }
+  return METHOD_NOT_HANDLED;
+}
 
-  if (Array.isArray(target)) {
-    if (name === 'contains') {
+function invokeArrayMethod(target, name, argNodes, scope, evaluate) {
+  switch (name) {
+    case 'contains': {
       const needle = evaluate(argNodes[0], scope);
       return target.some((entry) => valuesEqual(entry, needle));
     }
-    if (name === 'containsAll') {
+    case 'containsAll':
       return argNodes.every((node) => target.some((entry) => valuesEqual(entry, evaluate(node, scope))));
-    }
-    if (name === 'containsAny') {
+    case 'containsAny':
       return argNodes.some((node) => target.some((entry) => valuesEqual(entry, evaluate(node, scope))));
-    }
-    if (name === 'filter') {
+    case 'filter': {
       const predicate = argNodes[0];
       return target.filter((value, index) => Boolean(evaluate(predicate, scope.child({ index, value }))));
     }
-    if (name === 'flat') {
+    case 'flat':
       return target.flat();
-    }
-    if (name === 'isEmpty') {
+    case 'isEmpty':
       return target.length === 0;
-    }
-    if (name === 'join') {
+    case 'join':
       return target.map((entry) => toDisplayText(entry)).join(String(evaluate(argNodes[0], scope) ?? ''));
-    }
-    if (name === 'map') {
+    case 'map': {
       const mapper = argNodes[0];
       return target.map((value, index) => evaluate(mapper, scope.child({ index, value })));
     }
-    if (name === 'reduce') {
+    case 'reduce': {
       const reducer = argNodes[0];
       let accumulator = argNodes.length > 1 ? evaluate(argNodes[1], scope) : null;
       target.forEach((value, index) => {
@@ -536,16 +538,13 @@ function invokeMethod(target, name, argNodes, scope, evaluate, rootContext) {
       });
       return accumulator;
     }
-    if (name === 'reverse') {
+    case 'reverse':
       return [...target].reverse();
-    }
-    if (name === 'slice') {
+    case 'slice':
       return target.slice(Number(evaluate(argNodes[0], scope) ?? 0), argNodes[1] ? Number(evaluate(argNodes[1], scope)) : undefined);
-    }
-    if (name === 'sort') {
+    case 'sort':
       return [...target].sort(compareValues);
-    }
-    if (name === 'unique') {
+    case 'unique': {
       const uniqueValues = [];
       target.forEach((value) => {
         if (!uniqueValues.some((entry) => valuesEqual(entry, value))) {
@@ -554,123 +553,160 @@ function invokeMethod(target, name, argNodes, scope, evaluate, rootContext) {
       });
       return uniqueValues;
     }
+    default:
+      return METHOD_NOT_HANDLED;
   }
+}
 
-  if (typeof target === 'string') {
-    switch (name) {
-      case 'contains':
-        return target.toLowerCase().includes(String(evaluate(argNodes[0], scope) ?? '').toLowerCase());
-      case 'endsWith':
-        return target.endsWith(String(evaluate(argNodes[0], scope) ?? ''));
-      case 'isEmpty':
-        return target.length === 0;
-      case 'lower':
-        return target.toLowerCase();
-      case 'replace':
-        return target.replaceAll(String(evaluate(argNodes[0], scope) ?? ''), String(evaluate(argNodes[1], scope) ?? ''));
-      case 'split':
-        return target.split(String(evaluate(argNodes[0], scope) ?? ''));
-      case 'startsWith':
-        return target.startsWith(String(evaluate(argNodes[0], scope) ?? ''));
-      case 'title':
-        return target.replace(/\b\p{L}/gu, (match) => match.toUpperCase());
-      case 'trim':
-        return target.trim();
-      case 'upper':
-        return target.toUpperCase();
-      default:
-        break;
-    }
+function invokeStringMethod(target, name, argNodes, scope, evaluate) {
+  switch (name) {
+    case 'contains':
+      return target.toLowerCase().includes(String(evaluate(argNodes[0], scope) ?? '').toLowerCase());
+    case 'endsWith':
+      return target.endsWith(String(evaluate(argNodes[0], scope) ?? ''));
+    case 'isEmpty':
+      return target.length === 0;
+    case 'lower':
+      return target.toLowerCase();
+    case 'replace':
+      return target.replaceAll(String(evaluate(argNodes[0], scope) ?? ''), String(evaluate(argNodes[1], scope) ?? ''));
+    case 'split':
+      return target.split(String(evaluate(argNodes[0], scope) ?? ''));
+    case 'startsWith':
+      return target.startsWith(String(evaluate(argNodes[0], scope) ?? ''));
+    case 'title':
+      return target.replace(/\b\p{L}/gu, (match) => match.toUpperCase());
+    case 'trim':
+      return target.trim();
+    case 'upper':
+      return target.toUpperCase();
+    default:
+      return METHOD_NOT_HANDLED;
   }
+}
 
-  if (typeof target === 'number') {
-    switch (name) {
-      case 'ceil':
-        return Math.ceil(target);
-      case 'floor':
-        return Math.floor(target);
-      case 'isEmpty':
-        return false;
-      case 'round':
-        return Number.isFinite(evaluate(argNodes[0], scope))
-          ? Number(target.toFixed(Number(evaluate(argNodes[0], scope))))
-          : Math.round(target);
-      case 'toFixed':
-        return target.toFixed(Number(evaluate(argNodes[0], scope) ?? 0));
-      default:
-        break;
+function invokeNumberMethod(target, name, argNodes, scope, evaluate) {
+  switch (name) {
+    case 'ceil':
+      return Math.ceil(target);
+    case 'floor':
+      return Math.floor(target);
+    case 'isEmpty':
+      return false;
+    case 'round': {
+      const precision = evaluate(argNodes[0], scope);
+      return Number.isFinite(precision)
+        ? Number(target.toFixed(Number(precision)))
+        : Math.round(target);
     }
+    case 'toFixed':
+      return target.toFixed(Number(evaluate(argNodes[0], scope) ?? 0));
+    default:
+      return METHOD_NOT_HANDLED;
   }
+}
 
+function invokeDateMethod(target, name, argNodes, scope, evaluate) {
   const asDate = parseDateValue(target);
-  if (asDate) {
-    switch (name) {
-      case 'format':
-        return formatDateValue(asDate, String(evaluate(argNodes[0], scope) ?? 'YYYY-MM-DD'));
-      case 'isEmpty':
-        return false;
-      default:
-        break;
-    }
+  if (!asDate) {
+    return METHOD_NOT_HANDLED;
   }
 
-  if (target?.__baseType === 'file') {
-    switch (name) {
-      case 'asLink':
-        return createLinkValue(target.path, {
-          display: typeof evaluate(argNodes[0], scope) === 'string' ? evaluate(argNodes[0], scope) : '',
-          exists: true,
-        });
-      case 'hasLink': {
-        const needle = evaluate(argNodes[0], scope);
-        const needlePath = needle?.__baseType === 'file'
-          ? needle.path
-          : (needle?.__baseType === 'link' ? needle.path : String(needle ?? ''));
-        return target.links.some((link) => link.path === needlePath || link.rawTarget === needlePath);
-      }
-      case 'hasProperty':
-        return Object.hasOwn(target.properties, String(evaluate(argNodes[0], scope) ?? ''));
-      case 'hasTag':
-        return argNodes.some((node) => {
-          const value = String(evaluate(node, scope) ?? '').replace(/^#/u, '');
-          return target.tags.some((tag) => tag === value || tag.startsWith(`${value}/`));
-        });
-      case 'inFolder': {
-        const folder = String(evaluate(argNodes[0], scope) ?? '').replace(/\/+$/u, '');
-        return !folder || target.folder === folder || target.folder.startsWith(`${folder}/`);
-      }
-      default:
-        break;
-    }
+  switch (name) {
+    case 'format':
+      return formatDateValue(asDate, String(evaluate(argNodes[0], scope) ?? 'YYYY-MM-DD'));
+    case 'isEmpty':
+      return false;
+    default:
+      return METHOD_NOT_HANDLED;
   }
+}
 
-  if (target?.__baseType === 'link') {
-    switch (name) {
-      case 'asFile':
-        return target.path ? rootContext.snapshot.rowsByPath.get(target.path)?.file ?? null : null;
-      case 'linksTo': {
-        const other = evaluate(argNodes[0], scope);
-        const otherPath = other?.__baseType === 'file'
-          ? other.path
-          : (other?.__baseType === 'link' ? other.path : String(other ?? ''));
-        return target.path === otherPath;
-      }
-      default:
-        break;
+function invokeFileMethod(target, name, argNodes, scope, evaluate) {
+  switch (name) {
+    case 'asLink': {
+      const display = evaluate(argNodes[0], scope);
+      return createLinkValue(target.path, {
+        display: typeof display === 'string' ? display : '',
+        exists: true,
+      });
+    }
+    case 'hasLink': {
+      const needlePath = normalizeLinkComparablePath(evaluate(argNodes[0], scope));
+      return target.links.some((link) => link.path === needlePath || link.rawTarget === needlePath);
     }
+    case 'hasProperty':
+      return Object.hasOwn(target.properties, String(evaluate(argNodes[0], scope) ?? ''));
+    case 'hasTag':
+      return argNodes.some((node) => {
+        const value = String(evaluate(node, scope) ?? '').replace(/^#/u, '');
+        return target.tags.some((tag) => tag === value || tag.startsWith(`${value}/`));
+      });
+    case 'inFolder': {
+      const folder = String(evaluate(argNodes[0], scope) ?? '').replace(/\/+$/u, '');
+      return !folder || target.folder === folder || target.folder.startsWith(`${folder}/`);
+    }
+    default:
+      return METHOD_NOT_HANDLED;
+  }
+}
+
+function invokeLinkMethod(target, name, argNodes, scope, evaluate, rootContext) {
+  switch (name) {
+    case 'asFile':
+      return target.path ? rootContext.snapshot.rowsByPath.get(target.path)?.file ?? null : null;
+    case 'linksTo':
+      return target.path === normalizeLinkComparablePath(evaluate(argNodes[0], scope));
+    default:
+      return METHOD_NOT_HANDLED;
   }
+}
 
-  if (isPlainObject(target)) {
-    switch (name) {
-      case 'isEmpty':
-        return Object.keys(target).length === 0;
-      case 'keys':
-        return Object.keys(target);
-      case 'values':
-        return Object.values(target);
-      default:
-        break;
+function invokeObjectMethod(target, name) {
+  switch (name) {
+    case 'isEmpty':
+      return Object.keys(target).length === 0;
+    case 'keys':
+      return Object.keys(target);
+    case 'values':
+      return Object.values(target);
+    default:
+      return METHOD_NOT_HANDLED;
+  }
+}
+
+function invokeMethod(target, name, argNodes, scope, evaluate, rootContext) {
+  if (target?.__baseType === 'formula-namespace') {
+    if (argNodes.length > 0) {
+      throw new Error(`Formula namespace property "${name}" is not callable`);
     }
+    return rootContext.resolveFormulaValue(name, target.row, target.evaluationState);
+  }
+
+  let result = METHOD_NOT_HANDLED;
+  if (target == null) {
+    result = invokeNullMethod(name);
+  } else if (Array.isArray(target)) {
+    result = invokeArrayMethod(target, name, argNodes, scope, evaluate);
+  } else if (typeof target === 'string') {
+    result = invokeStringMethod(target, name, argNodes, scope, evaluate);
+  } else if (typeof target === 'number') {
+    result = invokeNumberMethod(target, name, argNodes, scope, evaluate);
+  } else if (target?.__baseType === 'file') {
+    result = invokeFileMethod(target, name, argNodes, scope, evaluate);
+  } else if (target?.__baseType === 'link') {
+    result = invokeLinkMethod(target, name, argNodes, scope, evaluate, rootContext);
+  } else if (isPlainObject(target)) {
+    result = invokeObjectMethod(target, name);
+  }
+
+  if (result !== METHOD_NOT_HANDLED) {
+    return result;
+  }
+
+  result = invokeDateMethod(target, name, argNodes, scope, evaluate);
+  if (result !== METHOD_NOT_HANDLED) {
+    return result;
   }
 
   throw new Error(`Unsupported method "${name}"`);