collabmd 0.1.48 → 0.1.51

package/src/server/application/workspace-reconciliation.js

@@ -16,11 +16,7 @@ import {
 } from '../domain/workspace-state.js';
 
 function createEventId() {
-  if (globalThis.crypto?.randomUUID) {
-    return globalThis.crypto.randomUUID();
-  }
-
-  return `workspace-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
+  return globalThis.crypto.randomUUID();
 }
 
 function countWorkspacePaths(workspaceChange = {}) {
@@ -306,7 +302,7 @@ export class WorkspaceReconciliation {
     });
   }
 
-  async writeEditableContent({ content, origin = 'api', path, requestId = null } = {}) {
+  async writeEditableContent({ content, origin = 'api', path, requestId = null, sourceRef = null } = {}) {
     const result = await this.vaultFileStore.writeEditableVaultContent(path, content);
     if (!result.ok) {
       return result;
@@ -316,6 +312,7 @@ export class WorkspaceReconciliation {
       action: 'write-file',
       origin,
       requestId,
+      sourceRef,
       workspaceChange: createWorkspaceChange({
         changedPaths: [path],
       }),
@@ -344,7 +341,7 @@ export class WorkspaceReconciliation {
     return result;
   }
 
-  async createFile({ content = '', origin = 'api', path, requestId = null } = {}) {
+  async createFile({ content = '', origin = 'api', path, requestId = null, sourceRef = null } = {}) {
     const result = await this.vaultFileStore.createFile(path, content);
     if (!result.ok) {
       return result;
@@ -354,6 +351,7 @@ export class WorkspaceReconciliation {
       action: 'create-file',
       origin,
       requestId,
+      sourceRef,
       workspaceChange: createWorkspaceChange({
         changedPaths: [path],
       }),

package/src/server/config/env.js

@@ -1,4 +1,4 @@
-import { resolve } from 'path';
+import { basename, isAbsolute, relative, resolve } from 'path';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'url';
 
@@ -199,6 +199,94 @@ export function resolveCliVaultDir(positionals = [], env = process.env) {
   return resolve(positionals[0] || env.COLLABMD_VAULT_DIR || '.');
 }
 
+const VAULT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+const VAULT_ID_HINT = 'Use letters, numbers, ".", "_", or "-" starting with a letter or number.';
+
+export function parseVaultList(rawValue) {
+  return normalizeCsvList(rawValue).map((entry) => {
+    const separatorIndex = entry.indexOf('=');
+    const hasName = separatorIndex > 0;
+    const rawDir = (hasName ? entry.slice(separatorIndex + 1) : entry).trim();
+    if (!rawDir) {
+      throw new Error(`Vault entry "${entry}" is missing a directory path.`);
+    }
+    const dir = resolve(rawDir);
+    const id = (hasName ? entry.slice(0, separatorIndex).trim() : basename(dir));
+    if (!VAULT_ID_PATTERN.test(id)) {
+      throw new Error(`Invalid vault id "${id}". ${VAULT_ID_HINT}`);
+    }
+    return { id, dir };
+  });
+}
+
+export function resolveConfiguredVaults(overrides = {}, env = process.env) {
+  if (Array.isArray(overrides.vaults)) {
+    return overrides.vaults.map(({ id, dir, repoUrl }) => {
+      if (!VAULT_ID_PATTERN.test(String(id ?? ''))) {
+        throw new Error(`Invalid vault id "${id}". ${VAULT_ID_HINT}`);
+      }
+      return { id, dir: resolve(dir), repoUrl: normalizeOptionalString(repoUrl) };
+    });
+  }
+  // ponytail: explicit directory (CLI positional) wins over the operator list
+  if (overrides.vaultDir) {
+    const dir = resolve(overrides.vaultDir);
+    return [{ id: basename(dir), dir }];
+  }
+  const rawList = normalizeOptionalString(env.COLLABMD_VAULTS);
+  if (!rawList) {
+    const dir = resolveConfiguredVaultDir(overrides, env);
+    return [{ id: basename(dir), dir }];
+  }
+  const vaults = parseVaultList(rawList);
+  const seenIds = new Set();
+  for (const vault of vaults) {
+    if (seenIds.has(vault.id)) {
+      throw new Error(`Duplicate vault id "${vault.id}" in COLLABMD_VAULTS.`);
+    }
+    seenIds.add(vault.id);
+  }
+  for (let i = 0; i < vaults.length; i += 1) {
+    for (let j = i + 1; j < vaults.length; j += 1) {
+      const between = relative(vaults[i].dir, vaults[j].dir);
+      if (between === '' || (!between.startsWith('..') && !isAbsolute(between))) {
+        throw new Error(`Vaults "${vaults[i].id}" and "${vaults[j].id}" overlap. Vault directories must not nest.`);
+      }
+    }
+  }
+  return vaults;
+}
+
+export function mangleVaultIdForEnv(vaultId) {
+  return String(vaultId ?? '').toUpperCase().replace(/[^A-Z0-9]/g, '_');
+}
+
+// ponytail: explicit repoUrl wins, then COLLABMD_GIT_REPO_URL_<ID>, then the shared URL for the primary
+export function resolveVaultRepoUrls(vaultDefs = [], overrides = {}, env = process.env) {
+  const globalRepoUrl = normalizeOptionalString(overrides.remote?.repoUrl ?? overrides.git?.remote?.repoUrl ?? env.COLLABMD_GIT_REPO_URL);
+  const bySuffix = new Map();
+  for (const def of vaultDefs) {
+    const suffix = mangleVaultIdForEnv(def.id);
+    if (!bySuffix.has(suffix)) {
+      bySuffix.set(suffix, []);
+    }
+    bySuffix.get(suffix).push(def.id);
+  }
+  return vaultDefs.map((def, index) => {
+    if (def.repoUrl) {
+      return def;
+    }
+    const suffix = mangleVaultIdForEnv(def.id);
+    const varName = `COLLABMD_GIT_REPO_URL_${suffix}`;
+    const perVaultUrl = normalizeOptionalString(env[varName]);
+    if (perVaultUrl && bySuffix.get(suffix).length > 1) {
+      throw new Error(`Ambiguous git remote: vaults ${bySuffix.get(suffix).map((id) => `"${id}"`).join(' and ')} share ${varName}.`);
+    }
+    return { ...def, repoUrl: perVaultUrl || (index === 0 ? globalRepoUrl : '') };
+  });
+}
+
 function getDefaultHost(nodeEnv) {
   return nodeEnv === 'production' ? '0.0.0.0' : '127.0.0.1';
 }
@@ -208,7 +296,7 @@ function resolveOptionalPath(filePath) {
   return normalized ? resolve(normalized) : '';
 }
 
-function loadGitConfig(overrides = {}) {
+function loadGitConfig(overrides = {}, { vaultRepoUrls = [] } = {}) {
   const remoteOverrides = overrides.remote ?? {};
   const identityOverrides = overrides.identity ?? {};
   const enabled = overrides.enabled ?? (process.env.COLLABMD_GIT_ENABLED !== 'false');
@@ -240,7 +328,7 @@ function loadGitConfig(overrides = {}) {
     remoteOverrides.sshKnownHostsFile
     ?? process.env.COLLABMD_GIT_SSH_KNOWN_HOSTS_FILE,
   );
-  const remoteEnabled = repoUrl.length > 0;
+  const remoteEnabled = repoUrl.length > 0 || vaultRepoUrls.some((entry) => String(entry ?? '').length > 0);
 
   if (remoteEnabled && !sshPrivateKeyFile && !sshPrivateKeyBase64) {
     throw new Error(
@@ -406,11 +494,57 @@ function loadHostedConfig(overrides = {}, { authStrategy, vaultDir } = {}) {
   };
 }
 
+function loadAgentAccessConfig(overrides = {}, { basePath, oidc, vaultDir } = {}) {
+  const enabled = overrides.enabled ?? parseBooleanFlag(
+    process.env.COLLABMD_AGENT_ACCESS_ENABLED,
+    false,
+  );
+  const publicHostname = oidc?.publicBaseUrl
+    ? new URL(oidc.publicBaseUrl).hostname.toLowerCase()
+    : '';
+  return {
+    allowedHosts: Array.from(new Set([
+      'localhost',
+      '127.0.0.1',
+      '::1',
+      publicHostname,
+      ...normalizeCsvList(
+        overrides.allowedHosts ?? process.env.COLLABMD_AGENT_ALLOWED_HOSTS,
+      ).map((host) => host.toLowerCase()),
+    ].filter(Boolean))),
+    connectionTtlMs: parsePositiveInt(
+      overrides.connectionTtlMs ?? process.env.COLLABMD_AGENT_CONNECTION_TTL_MS,
+      30 * 24 * 60 * 60 * 1000,
+    ),
+    dbPath: resolve(
+      overrides.dbPath
+        ?? process.env.COLLABMD_AGENT_METADATA_DB_PATH
+        ?? resolve(vaultDir, '.collabmd/agent-access.sqlite'),
+    ),
+    requestsPerMinute: parsePositiveInt(
+      overrides.requestsPerMinute ?? process.env.COLLABMD_AGENT_REQUESTS_PER_MINUTE,
+      120,
+    ),
+    enabled,
+    endpoint: `${basePath}/mcp`,
+  };
+}
+
+function resolvePublicDir(nodeEnv) {
+  if (nodeEnv === 'test' && process.env.COLLABMD_E2E_PUBLIC_DIR) {
+    return resolve(process.env.COLLABMD_E2E_PUBLIC_DIR);
+  }
+
+  return resolve(projectRoot, 'dist/client');
+}
+
 export function loadConfig(overrides = {}) {
   const nodeEnv = process.env.NODE_ENV || 'development';
-  const vaultDir = resolveConfiguredVaultDir(overrides);
+  const vaults = resolveVaultRepoUrls(resolveConfiguredVaults(overrides), overrides);
+  // ponytail: vaultDir stays the primary vault; other vaults resolve through the registry
+  const vaultDir = overrides.vaultDir || vaults[0].dir;
   const basePath = normalizeAppBasePath(process.env.BASE_PATH || '');
-  const publicDir = resolve(projectRoot, 'dist/client');
+  const publicDir = resolvePublicDir(nodeEnv);
   const authOverrides = overrides.auth ?? {};
   const authStrategy = normalizeAuthStrategy(
     authOverrides.strategy
@@ -425,8 +559,13 @@ export function loadConfig(overrides = {}) {
   const oidc = authStrategy === AUTH_STRATEGY_OIDC
     ? loadOidcConfig(authOverrides.oidc, { basePath })
     : null;
-  const git = loadGitConfig(overrides.git);
+  const git = loadGitConfig(overrides.git, { vaultRepoUrls: vaults.map((vault) => vault.repoUrl) });
   const hosted = loadHostedConfig(overrides.hosted, { authStrategy, vaultDir });
+  const agentAccess = loadAgentAccessConfig(overrides.agentAccess, {
+    basePath,
+    oidc,
+    vaultDir,
+  });
   const structurizr = loadStructurizrConfig(overrides.structurizr, { vaultDir });
   const build = loadBuildInfo({
     explicitBuildId: process.env.COLLABMD_BUILD_ID,
@@ -435,6 +574,7 @@ export function loadConfig(overrides = {}) {
   });
 
   return {
+    agentAccess,
     auth: {
       generatedPassword: passwordWasGenerated ? password : '',
       oidc,
@@ -481,6 +621,7 @@ export function loadConfig(overrides = {}) {
     plantumlServerUrl: process.env.PLANTUML_SERVER_URL || 'https://www.plantuml.com/plantuml',
     publicDir,
     vaultDir,
+    vaults,
     publicWsBaseUrl: process.env.PUBLIC_WS_BASE_URL || '',
     testWsRoomHydrateDelayMs: parsePositiveInt(process.env.TEST_WS_ROOM_HYDRATE_DELAY_MS, 0),
     wikiLinkAutoCreate: process.env.COLLABMD_WIKI_LINK_AUTO_CREATE !== 'false',

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

@@ -2,32 +2,22 @@ import { createServer } from 'http';
 import { resolve } from 'node:path';
 
 import { loadConfig } from './config/env.js';
+import { AgentConnectionService } from './application/agent-connection-service.js';
+import { AgentContentService } from './application/agent-content-service.js';
 import { createAuthService } from './auth/create-auth-service.js';
 import { logPerfEvent } from './config/perf-logging.js';
-import { BacklinkIndex } from './domain/backlink-index.js';
-import { BaseQueryService } from './domain/bases/base-query-service.js';
-import { CollaborationDocumentStore } from './domain/collaboration/collaboration-document-store.js';
-import { CollaborationRoom } from './domain/collaboration/collaboration-room.js';
 import { renderDocx } 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 { StructurizrWorkspaceService } from './infrastructure/structurizr/structurizr-workspace-service.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 { AgentConnectionStore } from './infrastructure/persistence/agent-connection-store.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 { 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';
+import { createVaultRegistry } from './vault-registry.js';
 
 function getDisplayHost(host) {
   return host === '127.0.0.1' ? 'localhost' : host;
@@ -72,16 +62,20 @@ export function createAppServer(config = loadConfig()) {
         githubAppClient,
       })
     : null;
-  const vaultFileStore = new VaultFileStore({ vaultDir: config.vaultDir });
-  const backlinkIndex = new BacklinkIndex({ vaultFileStore });
-  let fileSystemSyncService = null;
-  let workspaceMutationCoordinator = null;
-  const baseQueryService = new BaseQueryService({
-    maxResultRows: config.maxBaseQueryRows,
-    vaultFileStore,
-    workspaceStateProvider: () => workspaceMutationCoordinator?.workspaceState ?? null,
-    workspaceStateSynchronizer: () => fileSystemSyncService?.flushPendingChanges?.(),
-  });
+  const testControls = {
+    wsRoomHydrateDelayMs: Math.max(0, Number(config.testWsRoomHydrateDelayMs || 0)),
+  };
+  // ponytail: one live context per vault; agent/hosted/structurizr stay on the primary this slice
+  const vaultRegistry = createVaultRegistry({ config, testControls });
+  const primary = vaultRegistry.getPrimaryContext();
+  const vaultFileStore = primary.vaultFileStore;
+  const backlinkIndex = primary.backlinkIndex;
+  const baseQueryService = primary.baseQueryService;
+  const gitService = primary.gitService;
+  const searchService = primary.searchService;
+  const roomRegistry = primary.roomRegistry;
+  const workspaceMutationCoordinator = primary.workspaceMutationCoordinator;
+  const fileSystemSyncService = primary.fileSystemSyncService;
   const plantUmlRenderer = new PlantUmlRenderer({
     serverUrl: config.plantumlServerUrl,
   });
@@ -91,61 +85,23 @@ export function createAppServer(config = loadConfig()) {
     trustedExecutableDsl: config.structurizr?.trustedExecutableDsl,
     vaultDir: config.vaultDir,
   });
-  const gitService = new GitService({
-    commandEnv: config.git?.commandEnv,
-    enabled: config.gitEnabled,
-    vaultDir: config.vaultDir,
-  });
-  const searchService = new RipgrepSearchService({
-    maxBufferBytes: config.searchMaxBufferBytes,
-    maxFileSize: config.searchMaxFileSize,
-    perfLoggingEnabled: config.perfLoggingEnabled,
-    vaultDir: config.vaultDir,
+  const agentConnectionStore = new AgentConnectionStore({
+    dbPath: config.agentAccess.dbPath,
   });
-  const testControls = {
-    wsRoomHydrateDelayMs: Math.max(0, Number(config.testWsRoomHydrateDelayMs || 0)),
-  };
-  const roomRegistry = new RoomRegistry({
-    createRoom: ({ name, onEmpty }) => {
-      const isTransientRoom = name === '__lobby__' || name === WORKSPACE_ROOM_NAME || isDrawioLeaseRoom(name);
-      const room = new CollaborationRoom({
-        documentStore: new CollaborationDocumentStore({
-          backlinkIndex: isTransientRoom ? null : backlinkIndex,
-          name,
-          vaultFileStore: isTransientRoom ? null : vaultFileStore,
-        }),
-        getHydrateDelayMs: () => testControls.wsRoomHydrateDelayMs,
-        idleGraceMs: config.wsRoomIdleGraceMs,
-        maxInitialSyncBytes: config.maxInitialSyncBytes,
-        maxBufferedAmountBytes: config.wsMaxBufferedAmountBytes,
-        name,
-        onEmpty,
-        perfLoggingEnabled: config.perfLoggingEnabled,
-      });
-
-      if (name === WORKSPACE_ROOM_NAME && workspaceMutationCoordinator?.workspaceState) {
-        room.replaceWorkspaceEntries(workspaceMutationCoordinator.workspaceState.entries, {
-          generatedAt: workspaceMutationCoordinator.workspaceState.scannedAt,
-        });
-      }
-
-      return room;
-    },
+  const agentConnectionService = new AgentConnectionService({
+    authStrategy: config.auth.strategy,
+    connectionTtlMs: config.agentAccess.connectionTtlMs,
+    hostedWorkspaceService,
+    store: agentConnectionStore,
   });
-  workspaceMutationCoordinator = new WorkspaceReconciliation({
+  const agentContentService = new AgentContentService({
     backlinkIndex,
     baseQueryService,
+    plantUmlRenderer,
     roomRegistry,
+    searchService,
     vaultFileStore,
-    workspaceStateAdapter: createWorkspaceStateFileSystemAdapter({
-      vaultDir: vaultFileStore.vaultDir,
-    }),
-  });
-  vaultFileStore.setManagedWriteTracker(workspaceMutationCoordinator);
-  fileSystemSyncService = new FileSystemSyncService({
-    mutationCoordinator: workspaceMutationCoordinator,
-    perfLoggingEnabled: config.perfLoggingEnabled,
-    vaultFileStore,
+    workspaceMutationCoordinator,
   });
   const requestHandler = createRequestHandler(
     config,
@@ -164,6 +120,11 @@ export function createAppServer(config = loadConfig()) {
     hostedWorkspaceService,
     githubSetupFlow,
     structurizrWorkspaceService,
+    {
+      connectionService: agentConnectionService,
+      contentService: agentContentService,
+    },
+    vaultRegistry,
   );
   const httpServer = createServer((req, res) => {
     requestHandler(req, res).catch((error) => {
@@ -186,6 +147,7 @@ export function createAppServer(config = loadConfig()) {
     roomRegistry,
     wsBasePath: config.wsBasePath,
     hostedWorkspaceService,
+    vaultRegistry,
   });
 
   let shutdownPromise = null;
@@ -195,74 +157,13 @@ export function createAppServer(config = loadConfig()) {
     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;
-    logPerfEvent(config.perfLoggingEnabled, 'startup', {
-      durationMs: Date.now() - initialWorkspaceScanStartedAt,
-      phase: 'workspace-scan',
-      vaultFileCount,
-    });
-
-    const backlinkBuildStartedAt = Date.now();
-    await backlinkIndex.build({ workspaceState: initialWorkspaceSnapshot });
-    logPerfEvent(config.perfLoggingEnabled, 'startup', {
-      durationMs: Date.now() - backlinkBuildStartedAt,
-      markdownFileCount: initialWorkspaceSnapshot.markdownPaths?.length ?? 0,
-      phase: 'backlink-build',
-    });
-
-    const liveWorkspaceScanStartedAt = Date.now();
-    const liveWorkspaceSnapshot = await vaultFileStore.scanWorkspaceState();
-    const workspaceChangedDuringStartup = !workspaceStateMetadataEqual(initialWorkspaceSnapshot, liveWorkspaceSnapshot);
-    vaultFileCount = liveWorkspaceSnapshot.vaultFileCount ?? vaultFileCount;
-    logPerfEvent(config.perfLoggingEnabled, 'startup', {
-      changedDuringStartup: workspaceChangedDuringStartup,
-      durationMs: Date.now() - liveWorkspaceScanStartedAt,
-      phase: 'workspace-rescan',
-      vaultFileCount,
-    });
-
-    if (workspaceChangedDuringStartup) {
-      const backlinkRebuildStartedAt = Date.now();
-      await backlinkIndex.build({ workspaceState: liveWorkspaceSnapshot });
-      logPerfEvent(config.perfLoggingEnabled, 'startup', {
-        durationMs: Date.now() - backlinkRebuildStartedAt,
-        markdownFileCount: liveWorkspaceSnapshot.markdownPaths?.length ?? 0,
-        phase: 'backlink-rebuild',
-      });
+    if (config.agentAccess.enabled && config.auth.strategy !== 'none') {
+      await agentConnectionService.initialize();
     }
 
-    const workspaceInitStartedAt = Date.now();
-    await workspaceMutationCoordinator.initialize({ snapshot: liveWorkspaceSnapshot });
-    logPerfEvent(config.perfLoggingEnabled, 'startup', {
-      durationMs: Date.now() - workspaceInitStartedAt,
-      phase: 'workspace-init',
-    });
-
-    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',
-      });
-    }
+    const { searchCapability, snapshot: liveWorkspaceSnapshot, vaultFileCount: primaryFileCount } = await vaultRegistry.initializePrimary();
+    config.search = searchCapability;
+    vaultFileCount = primaryFileCount;
 
     return new Promise((resolve, reject) => {
       const listenStartedAt = Date.now();
@@ -300,12 +201,14 @@ export function createAppServer(config = loadConfig()) {
 
     shutdownPromise = (async () => {
       await collaborationGateway.close();
-      await fileSystemSyncService.close();
-      await roomRegistry.reset();
+      await vaultRegistry.closeAll();
       await Promise.all([
         closeHttpServer(httpServer),
         config.git?.cleanup?.(),
         hostedWorkspaceService.close(),
+        config.agentAccess.enabled && config.auth.strategy !== 'none'
+          ? agentConnectionStore.close()
+          : Promise.resolve(),
       ]);
     })().then(() => undefined);
 
@@ -314,6 +217,8 @@ export function createAppServer(config = loadConfig()) {
 
   return {
     close,
+    agentConnectionService,
+    agentContentService,
     collaborationGateway,
     config,
     httpServer,
@@ -331,6 +236,7 @@ export function createAppServer(config = loadConfig()) {
       testControls.wsRoomHydrateDelayMs = Math.max(0, Number(delayMs) || 0);
     },
     vaultFileStore,
+    vaultRegistry,
     get vaultFileCount() { return vaultFileCount; },
   };
 }

package/src/server/domain/bases/base-query-service.js

@@ -87,17 +87,13 @@ function insertSortedBounded(rows, row, {
   }
 }
 
-function escapeRegExp(value = '') {
-  return String(value ?? '').replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
-}
-
 function pruneFilterNodeForProperty(filterNode, propertyId = '') {
   if (!propertyId || !filterNode) {
     return filterNode;
   }
 
   if (typeof filterNode === 'string') {
-    const escapedPropertyId = escapeRegExp(propertyId);
+    const escapedPropertyId = RegExp.escape(String(propertyId));
     const propertyFilterPattern = new RegExp(
       `^!?${escapedPropertyId}(?:\\.(?:contains|startsWith|endsWith|isEmpty)\\(.*\\)|\\s*(?:==|!=|>=|<=|>|<)\\s*.+)$`,
       'u',