collabmd 0.1.48 → 0.1.51

package/src/server/infrastructure/git/parsers.js

@@ -1,4 +1,4 @@
-import { decodeQuotedPath, parseRenamePath, stripDiffPrefix } from './path-utils.js';
+import { decodeQuotedPath, stripDiffPrefix } from './path-utils.js';
 import { createEmptyBranchStatus, createStatusInfo } from './responses.js';
 
 function parseBranchLine(line) {
@@ -91,11 +91,8 @@ export function splitContentLines(content) {
 }
 
 export function parseStatusOutput(output) {
-  const lines = String(output ?? '')
-    .split(/\r?\n/u)
-    .filter(Boolean);
-  const [branchLine = '', ...statusLines] = lines;
-  const branch = parseBranchLine(branchLine);
+  const records = String(output ?? '').split('\0');
+  const branch = parseBranchLine(records.shift() || '');
   const sections = {
     staged: [],
     'working-tree': [],
@@ -103,14 +100,15 @@ export function parseStatusOutput(output) {
   };
   const uniquePaths = new Set();
 
-  for (const line of statusLines) {
-    if (line.length < 3) {
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (record.length < 3) {
       continue;
     }
 
-    const indexStatus = line[0];
-    const workTreeStatus = line[1];
-    const rawPath = line.slice(3);
+    const indexStatus = record[0];
+    const workTreeStatus = record[1];
+    const path = record.slice(3);
 
     if (indexStatus === '!' && workTreeStatus === '!') {
       continue;
@@ -120,7 +118,7 @@ export function parseStatusOutput(output) {
       const file = {
         ...createStatusInfo('?'),
         oldPath: null,
-        path: decodeQuotedPath(rawPath),
+        path,
         scope: 'untracked',
       };
       sections.untracked.push(file);
@@ -128,13 +126,17 @@ export function parseStatusOutput(output) {
       continue;
     }
 
-    const parsedPath = parseRenamePath(rawPath);
+    const hasSourcePath = ['R', 'C'].includes(indexStatus) || ['R', 'C'].includes(workTreeStatus);
+    const oldPath = hasSourcePath ? records[index + 1] || null : null;
+    if (hasSourcePath) {
+      index += 1;
+    }
 
     if (indexStatus !== ' ') {
       const file = {
         ...createStatusInfo(indexStatus),
-        oldPath: parsedPath.oldPath,
-        path: parsedPath.path,
+        oldPath,
+        path,
         scope: 'staged',
       };
       sections.staged.push(file);
@@ -144,8 +146,8 @@ export function parseStatusOutput(output) {
     if (workTreeStatus !== ' ') {
       const file = {
         ...createStatusInfo(workTreeStatus),
-        oldPath: parsedPath.oldPath,
-        path: parsedPath.path,
+        oldPath,
+        path,
         scope: 'working-tree',
       };
       sections['working-tree'].push(file);

package/src/server/infrastructure/git/path-utils.js

@@ -34,22 +34,6 @@ export function normalizeRelativeGitPath(pathValue) {
   return normalized.join('/');
 }
 
-export function parseRenamePath(rawPath) {
-  const decodedPath = decodeQuotedPath(rawPath);
-  const separator = ' -> ';
-  const separatorIndex = decodedPath.indexOf(separator);
-  if (separatorIndex === -1) {
-    return {
-      oldPath: null,
-      path: decodedPath,
-    };
-  }
-
-  return {
-    oldPath: decodedPath.slice(0, separatorIndex),
-    path: decodedPath.slice(separatorIndex + separator.length),
-  };
-}
 
 export function stripDiffPrefix(pathValue) {
   const normalizedPath = String(pathValue ?? '').replace(/\s+$/u, '');

package/src/server/infrastructure/git/status-service.js

@@ -42,7 +42,7 @@ export class GitStatusService {
 
     const statusPromise = (async () => {
       const parsed = parseStatusOutput(
-        await this.commandRunner.execGit(['status', '--porcelain=v1', '--branch', '--untracked-files=all']),
+        await this.commandRunner.execGit(['status', '--porcelain=v1', '-z', '--branch', '--untracked-files=all']),
       );
       const sections = [
         { files: parsed.sections.staged, key: 'staged', label: 'Staged Changes' },

package/src/server/infrastructure/git/untracked-files.js

@@ -1,6 +1,7 @@
 import { createReadStream } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { createInterface } from 'node:readline';
 
 import { getVaultFileKind, isImageAttachmentFilePath } from '../../../domain/file-kind.js';
 import { mapWithConcurrency } from '../../shared/async-utils.js';
@@ -13,29 +14,19 @@ async function countFileLines(filePath) {
     return 0;
   }
 
-  return new Promise((resolve, reject) => {
-    const stream = createReadStream(filePath, { encoding: 'utf8' });
-    let lineCount = 0;
-    let sawData = false;
-    let lastCharacter = '\n';
+  const lines = createInterface({
+    crlfDelay: Infinity,
+    input: createReadStream(filePath, { encoding: 'utf8' }),
+  });
+  let lineCount = 0;
 
-    stream.on('data', (chunk) => {
-      if (!chunk) {
-        return;
-      }
+  for await (const line of lines) {
+    if (typeof line === 'string') {
+      lineCount += 1;
+    }
+  }
 
-      sawData = true;
-      lastCharacter = chunk[chunk.length - 1];
-      lineCount += chunk.match(/\n/gu)?.length ?? 0;
-    });
-    stream.on('error', reject);
-    stream.on('end', () => {
-      if (sawData && lastCharacter !== '\n') {
-        lineCount += 1;
-      }
-      resolve(lineCount);
-    });
-  });
+  return lineCount;
 }
 
 function buildSyntheticAddedFileDiff(pathValue, content) {

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

@@ -0,0 +1,171 @@
+import { fromJsonSchema } from '@modelcontextprotocol/server';
+
+import { getAgentToolDefinition } from '../../../domain/agent-tool-definitions.js';
+import { encodeAgentToolImage } from '../../shared/agent-tool-image.js';
+import { readRequestId } from './http-request-helpers.js';
+import { jsonResponse } from './http-response.js';
+import { parseJsonBody } from './request-body.js';
+
+const WEBMCP_TOOL_PATH = '/api/agent/tools/';
+const WEBMCP_INPUT_SCHEMAS = new Map();
+
+function createAgentError(code, message, statusCode) {
+  const error = new Error(message);
+  error.code = code;
+  error.statusCode = statusCode;
+  return error;
+}
+
+function sendAgentError(req, res, error) {
+  const statusCode = Number(error?.statusCode) || 500;
+  if (statusCode >= 500) console.error('[agent] Request failed:', error.message);
+  jsonResponse(req, res, statusCode, {
+    code: error?.code || 'AGENT_REQUEST_FAILED',
+    error: statusCode >= 500 ? 'Agent request failed' : error.message,
+    ...(Number.isFinite(error?.retryAfterMs) ? { retryAfterMs: error.retryAfterMs } : {}),
+  });
+}
+
+async function validateWebMcpInput(definition, input) {
+  let schema = WEBMCP_INPUT_SCHEMAS.get(definition.name);
+  if (!schema) {
+    schema = fromJsonSchema(definition.inputSchema);
+    WEBMCP_INPUT_SCHEMAS.set(definition.name, schema);
+  }
+  const validation = await schema['~standard'].validate(input);
+  if (validation.issues?.length) {
+    throw createAgentError('AGENT_INPUT_INVALID', 'WebMCP tool input does not match its schema', 400);
+  }
+}
+
+async function createWebMcpActor({ agentConnectionService, authService, config, req }) {
+  let subject;
+  if (config.auth.strategy === 'none') {
+    subject = {
+      collaborator: null,
+      subjectId: req.socket?.remoteAddress || 'unknown',
+      subjectType: 'anonymous',
+    };
+  } else {
+    const user = authService.getAuthenticatedUser?.(req) ?? null;
+    subject = await agentConnectionService.resolveManagementSubject(user);
+  }
+  const actorId = `webmcp:${subject.subjectType}:${subject.subjectId}`;
+  return {
+    collaborator: subject.collaborator,
+    connectionId: actorId,
+    origin: 'webmcp',
+    rateLimitKey: actorId,
+    requestId: readRequestId(req),
+    scopes: ['vault:edit', 'vault:read'],
+    sourceRef: 'webmcp',
+  };
+}
+
+async function mapWebMcpResult(definition, value) {
+  if (value.svg && ['image', 'optional-image'].includes(definition.resultKind)) {
+    const { data, mimeType, structuredContent } = await encodeAgentToolImage(value);
+    return {
+      ...structuredContent,
+      image: { data, encoding: 'base64', mimeType },
+      scene: value.scene,
+    };
+  }
+  if (definition.resultKind === 'optional-image' && value.verification?.svg) {
+    const { verification, ...result } = value;
+    const { data, mimeType, structuredContent } = await encodeAgentToolImage(verification);
+    return {
+      ...result,
+      image: { data, encoding: 'base64', mimeType },
+      verification: {
+        ...structuredContent,
+        scene: verification.scene,
+      },
+    };
+  }
+  return value;
+}
+
+export function createAgentApiHandler({
+  agentConnectionService,
+  agentContentService,
+  authService,
+  config,
+  rateLimiter,
+}) {
+  return async function handleAgentApi(req, res, requestUrl) {
+    if (!requestUrl.pathname.startsWith('/api/agent')) return false;
+
+    try {
+      if (requestUrl.pathname.startsWith(WEBMCP_TOOL_PATH)) {
+        if (req.method !== 'POST') {
+          throw createAgentError('AGENT_METHOD_NOT_ALLOWED', 'WebMCP tools require POST', 405);
+        }
+        const name = decodeURIComponent(requestUrl.pathname.slice(WEBMCP_TOOL_PATH.length));
+        const definition = getAgentToolDefinition(name);
+        if (!definition?.webMcp) {
+          throw createAgentError('AGENT_TOOL_NOT_FOUND', 'WebMCP tool not found', 404);
+        }
+        const input = await parseJsonBody(req);
+        await validateWebMcpInput(definition, input);
+        const actor = await createWebMcpActor({
+          agentConnectionService,
+          authService,
+          config,
+          req,
+        });
+        rateLimiter(actor.rateLimitKey);
+        const cancellation = new AbortController();
+        const abort = () => cancellation.abort();
+        req.once('aborted', abort);
+        try {
+          const value = await agentContentService[definition.method](actor, {
+            ...input,
+            signal: cancellation.signal,
+          });
+          jsonResponse(req, res, 200, await mapWebMcpResult(definition, value));
+        } finally {
+          req.off('aborted', abort);
+        }
+        return true;
+      }
+
+      if (!config.agentAccess?.enabled) {
+        jsonResponse(req, res, 404, { error: 'Agent Access is not enabled' });
+        return true;
+      }
+      const user = authService.getAuthenticatedUser?.(req) ?? null;
+      if (requestUrl.pathname === '/api/agent/connections' && req.method === 'GET') {
+        jsonResponse(req, res, 200, {
+          connections: await agentConnectionService.listConnections(user),
+        });
+        return true;
+      }
+      if (requestUrl.pathname === '/api/agent/connections' && req.method === 'POST') {
+        const body = await parseJsonBody(req);
+        jsonResponse(req, res, 201, await agentConnectionService.createConnection({
+          clientKind: body?.clientKind,
+          label: body?.label,
+          scopes: body?.scopes,
+          user,
+        }));
+        return true;
+      }
+      if (requestUrl.pathname.startsWith('/api/agent/connections/') && req.method === 'DELETE') {
+        const connectionId = decodeURIComponent(
+          requestUrl.pathname.slice('/api/agent/connections/'.length).split('/')[0] || '',
+        );
+        jsonResponse(req, res, 200, await agentConnectionService.revokeConnection({
+          connectionId,
+          user,
+        }));
+        return true;
+      }
+      jsonResponse(req, res, 404, { error: 'Agent endpoint not found' });
+      return true;
+    } catch (error) {
+      sendAgentError(req, res, error);
+      return true;
+    }
+  };
+}

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

@@ -84,6 +84,38 @@ export function createGitApiCommandHandler({
       return true;
     }
 
+    if (requestUrl.pathname === '/api/git/stage-all' && req.method === 'POST') {
+      try {
+        jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
+          action: 'stage-all',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.stageAll(),
+          ),
+          workspaceMutationCoordinator,
+        }));
+      } catch (error) {
+        handleApiError(req, res, error, '[api] Failed to stage all git changes:', 'Failed to stage all git changes');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/unstage-all' && req.method === 'POST') {
+      try {
+        jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
+          action: 'unstage-all',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.unstageAll(),
+          ),
+          workspaceMutationCoordinator,
+        }));
+      } catch (error) {
+        handleApiError(req, res, error, '[api] Failed to unstage all git changes:', 'Failed to unstage all git changes');
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/git/commit' && req.method === 'POST') {
       try {
         const body = await parseRequiredBody(req, res, 'message');

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

@@ -43,6 +43,11 @@ export function createHostedApiHandler({
         user,
       }));
     }],
+    ['POST /api/hosted/setup/complete', async ({ req, res, user }) => {
+      const admin = await hostedWorkspaceService.requireAdmin(user);
+      const team = await hostedWorkspaceService.completeWorkspaceSetup({ user: admin });
+      jsonResponse(req, res, 200, { ok: true, setupComplete: true, team });
+    }],
     ['GET /api/hosted/vault-source', async ({ req, res, user }) => {
       jsonResponse(req, res, 200, { vaultSource: await hostedWorkspaceService.getVaultSource(user) });
     }],

package/src/server/infrastructure/http/create-request-handler.js

@@ -1,3 +1,6 @@
+import { createAgentApiHandler } from './create-agent-api-handler.js';
+import { createAgentMcpHandler } from '../mcp/create-agent-mcp-handler.js';
+import { createAgentToolRateLimiter } from '../../shared/agent-tool-rate-limiter.js';
 import { createAuthApiHandler } from './create-auth-api-handler.js';
 import { createGitApiCommandHandler } from './create-git-api-command-handler.js';
 import { createGitApiQueryHandler } from './create-git-api-query-handler.js';
@@ -38,6 +41,8 @@ export function createRequestHandler(
   hostedWorkspaceService = null,
   githubSetupFlow = null,
   structurizrWorkspaceService = null,
+  agentIntegration = null,
+  vaultRegistry = null,
 ) {
   const handleStaticRequest = createStaticHandler(config, authService, searchService);
   const handleAuthApi = createAuthApiHandler({ authService });
@@ -46,33 +51,114 @@ export function createRequestHandler(
     githubSetupFlow,
     hostedWorkspaceService,
   });
-  const handleGitApiQuery = createGitApiQueryHandler({ gitService });
-  const handleGitApiCommand = createGitApiCommandHandler({
-    authService,
-    gitService,
-    workspaceMutationCoordinator,
-  });
-  const handleVaultApiQuery = createVaultApiQueryHandler({
-    baseQueryService,
-    backlinkIndex,
-    config,
-    searchService,
-    vaultFileStore,
-    workspaceMutationCoordinator,
-  });
-  const handleVaultApiCommand = createVaultApiCommandHandler({
-    backlinkIndex,
-    maxPdfUploadBytes: config.maxPdfUploadBytes,
-    renderDocx,
-    roomRegistry,
-    vaultFileStore,
-    workspaceMutationCoordinator,
-  });
+  // ponytail: one builder for legacy primary paths and scoped vaults; only the parts differ
+  const vaultHandlerCache = new Map();
+  function getVaultHandlers(id, parts) {
+    let handlers = vaultHandlerCache.get(id);
+    if (!handlers) {
+      handlers = {
+        command: createVaultApiCommandHandler({
+          backlinkIndex: parts.backlinkIndex,
+          maxPdfUploadBytes: config.maxPdfUploadBytes,
+          renderDocx,
+          roomRegistry: parts.roomRegistry,
+          vaultFileStore: parts.vaultFileStore,
+          workspaceMutationCoordinator: parts.workspaceMutationCoordinator,
+        }),
+        gitCommand: createGitApiCommandHandler({
+          authService,
+          gitService: parts.gitService,
+          workspaceMutationCoordinator: parts.workspaceMutationCoordinator,
+        }),
+        gitQuery: createGitApiQueryHandler({ gitService: parts.gitService }),
+        query: createVaultApiQueryHandler({
+          baseQueryService: parts.baseQueryService,
+          backlinkIndex: parts.backlinkIndex,
+          config,
+          searchService: parts.searchService,
+          vaultFileStore: parts.vaultFileStore,
+          workspaceMutationCoordinator: parts.workspaceMutationCoordinator,
+        }),
+      };
+      vaultHandlerCache.set(id, handlers);
+    }
+    return handlers;
+  }
+  const primaryHandlers = getVaultHandlers(
+    vaultRegistry?.getPrimaryContext?.()?.def.id ?? '__primary__',
+    { backlinkIndex, baseQueryService, gitService, roomRegistry, searchService, vaultFileStore, workspaceMutationCoordinator },
+  );
   const handlePlantUmlApi = createPlantUmlApiHandler({ plantUmlRenderer });
   const handleStructurizrApi = createStructurizrApiHandler({
     basePath: config.basePath,
     service: structurizrWorkspaceService,
   });
+  const agentToolRateLimiter = createAgentToolRateLimiter(config.agentAccess.requestsPerMinute);
+  const handleAgentApi = createAgentApiHandler({
+    agentConnectionService: agentIntegration?.connectionService,
+    agentContentService: agentIntegration?.contentService,
+    authService,
+    config,
+    rateLimiter: agentToolRateLimiter,
+  });
+  const handleAgentMcp = config.agentAccess.enabled && agentIntegration
+    ? createAgentMcpHandler({
+        agentConnectionService: agentIntegration.connectionService,
+        agentContentService: agentIntegration.contentService,
+        config,
+        rateLimiter: agentToolRateLimiter,
+      })
+    : async () => false;
+
+  function parseVaultScope(pathname) {
+    if (!pathname.startsWith('/api/v/')) {
+      return null;
+    }
+    const rest = pathname.slice('/api/v/'.length);
+    const slashIndex = rest.indexOf('/');
+    if (slashIndex === -1) {
+      return null;
+    }
+    const vaultId = rest.slice(0, slashIndex);
+    if (!vaultId) {
+      return null;
+    }
+    return { subPath: `/api${rest.slice(slashIndex)}`, vaultId };
+  }
+
+  async function handleVaultScopedApi(req, res, requestUrl) {
+    const scope = parseVaultScope(requestUrl.pathname);
+    if (!scope || !vaultRegistry) {
+      return false;
+    }
+    let context;
+    try {
+      context = await vaultRegistry.getOrCreateContextAsync(scope.vaultId);
+    } catch (error) {
+      jsonResponse(req, res, error?.statusCode || 500, { error: error?.message || 'Vault unavailable' });
+      return true;
+    }
+    const subUrl = new URL(requestUrl.toString());
+    subUrl.pathname = scope.subPath;
+    const handlers = getVaultHandlers(context.def.id, context);
+    if (await handlers.query(req, res, subUrl)) {
+      return true;
+    }
+    if (await handlers.command(req, res, subUrl)) {
+      return true;
+    }
+    if (subUrl.pathname.startsWith('/api/git')) {
+      if (await handlers.gitQuery(req, res, subUrl)) {
+        return true;
+      }
+      if (await handlers.gitCommand(req, res, subUrl)) {
+        return true;
+      }
+      jsonResponse(req, res, 404, { error: 'Git API endpoint not found' });
+      return true;
+    }
+    return false;
+  }
 
   function handleBasePathRedirect(req, res, originalRequestUrl) {
     if (
@@ -182,6 +268,10 @@ export function createRequestHandler(
       return;
     }
 
+    if (await handleAgentMcp(req, res, requestUrl)) {
+      return;
+    }
+
     if (requestUrl.pathname.startsWith('/api/') || handleStructurizrApi.requiresAuthorization(requestUrl)) {
       const authorization = authService.authorizeApiRequest(req);
       if (!authorization.ok) {
@@ -198,15 +288,22 @@ export function createRequestHandler(
       }
     }
 
+    if (await handleAgentApi(req, res, requestUrl)) {
+      return;
+    }
+
     if (await handleStructurizrApi(req, res, requestUrl)) {
       return;
     }
 
     if (requestUrl.pathname.startsWith('/api/')) {
-      if (await handleVaultApiQuery(req, res, requestUrl)) {
+      if (await handleVaultScopedApi(req, res, requestUrl)) {
+        return;
+      }
+      if (await primaryHandlers.query(req, res, requestUrl)) {
         return;
       }
-      if (await handleVaultApiCommand(req, res, requestUrl)) {
+      if (await primaryHandlers.command(req, res, requestUrl)) {
         return;
       }
       if (await handlePlantUmlApi(req, res, requestUrl)) {
@@ -219,10 +316,10 @@ export function createRequestHandler(
         jsonResponse(req, res, 503, { error: 'Git integration is not configured' });
         return;
       }
-      if (await handleGitApiQuery(req, res, requestUrl)) {
+      if (await primaryHandlers.gitQuery(req, res, requestUrl)) {
         return;
       }
-      if (await handleGitApiCommand(req, res, requestUrl)) {
+      if (await primaryHandlers.gitCommand(req, res, requestUrl)) {
         return;
       }
       jsonResponse(req, res, 404, { error: 'Git API endpoint not found' });

package/src/server/infrastructure/http/create-static-handler.js

@@ -45,6 +45,7 @@ function getStaticCacheControl(pathname = '', extension = '') {
 }
 
 function buildRuntimeConfig({
+  agentAccess,
   auth,
   basePath,
   build,
@@ -57,8 +58,15 @@ function buildRuntimeConfig({
   structurizr,
   wikiLinkAutoCreate,
   wsBasePath,
+  vaults,
 }) {
   return `window.__COLLABMD_CONFIG__ = ${JSON.stringify({
+    activeVault: vaults?.[0]?.id ?? '',
+    agentAccess: {
+      enabled: Boolean(agentAccess?.enabled),
+      endpoint: agentAccess?.endpoint || '',
+      managed: Boolean(agentAccess?.enabled && auth?.strategy !== 'none'),
+    },
     auth,
     basePath,
     build,
@@ -73,6 +81,7 @@ function buildRuntimeConfig({
     structurizrEnabled: Boolean(structurizr?.enabled ?? structurizr?.serverUrl),
     wikiLinkAutoCreate,
     wsBasePath,
+    vaults: (vaults ?? []).map(({ id }) => ({ id })),
   })};\n`;
 }
 

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

@@ -274,14 +274,20 @@ async function handleFileTree(req, res, _requestUrl, { vaultFileStore, workspace
   }
 }
 
-async function handleCommentOverview(req, res, _requestUrl, { vaultFileStore }) {
+async function handleCommentOverview(req, res, _requestUrl, {
+  vaultFileStore,
+  workspaceMutationCoordinator,
+}) {
   try {
     if (typeof vaultFileStore.readCommentOverview !== 'function') {
       jsonResponse(req, res, 503, { error: 'Comment overview is unavailable' });
       return;
     }
 
-    const overview = await vaultFileStore.readCommentOverview();
+    const workspaceState = await workspaceMutationCoordinator.getWorkspaceStateSnapshot();
+    const overview = await vaultFileStore.readCommentOverview({
+      filePaths: workspaceState.filePaths,
+    });
     jsonResponse(req, res, 200, { overview });
   } catch (error) {
     console.error('[api] Failed to read comment overview:', error.message);
@@ -486,6 +492,12 @@ async function handleSearch(req, res, requestUrl, { searchService }) {
   }
 }
 
+async function handleVaultList(req, res, _requestUrl, { config }) {
+  // ponytail: ids only — absolute vault dirs are operator internals
+  const vaults = (config?.vaults ?? []).map(({ id }) => ({ id }));
+  jsonResponse(req, res, 200, { activeVault: vaults[0]?.id ?? null, vaults });
+}
+
 // --- Route table ---
 
 function createRouteTable(context) {
@@ -494,6 +506,7 @@ function createRouteTable(context) {
     { method: 'POST', path: '/api/base/property-values', handler: handleBasePropertyValues },
     { method: 'POST', path: '/api/base/transform', handler: handleBaseTransform },
     { method: 'POST', path: '/api/base/export', handler: handleBaseExport },
+    { method: 'GET', path: '/api/vaults', handler: handleVaultList },
     { method: 'GET', path: '/api/files', handler: handleFileTree },
     { method: 'GET', path: '/api/comments/overview', handler: handleCommentOverview },
     { method: 'GET', path: '/api/file', handler: handleFileRead },