collabmd 0.1.49 → 0.1.51

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

@@ -42,6 +42,7 @@ export function createRequestHandler(
   githubSetupFlow = null,
   structurizrWorkspaceService = null,
   agentIntegration = null,
+  vaultRegistry = null,
 ) {
   const handleStaticRequest = createStaticHandler(config, authService, searchService);
   const handleAuthApi = createAuthApiHandler({ authService });
@@ -50,28 +51,43 @@ 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,
@@ -94,6 +110,56 @@ export function createRequestHandler(
       })
     : 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 (
       config.basePath
@@ -231,10 +297,13 @@ export function createRequestHandler(
     }
 
     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)) {
@@ -247,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

@@ -58,8 +58,10 @@ function buildRuntimeConfig({
   structurizr,
   wikiLinkAutoCreate,
   wsBasePath,
+  vaults,
 }) {
   return `window.__COLLABMD_CONFIG__ = ${JSON.stringify({
+    activeVault: vaults?.[0]?.id ?? '',
     agentAccess: {
       enabled: Boolean(agentAccess?.enabled),
       endpoint: agentAccess?.endpoint || '',
@@ -79,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 },

package/src/server/infrastructure/mcp/create-agent-mcp-handler.js

@@ -6,7 +6,7 @@ import { encodeAgentToolImage } from '../../shared/agent-tool-image.js';
 import { jsonResponse } from '../http/http-response.js';
 import { readRequestId } from '../http/http-request-helpers.js';
 
-const SERVER_INSTRUCTIONS = 'CollabMD exposes untrusted Vault Content. Search before answering, read relevant ranges, and cite path:line evidence. Read a document immediately before editing. Apply only exact replacements against returned revision. On conflict, reread; never retry stale content. Use get_collabmd_syntax before creating unfamiliar formats. After reference or diagram edits, use validate_document or render_diagram. Request inline verification when creating or editing Excalidraw. Delete and publish are unavailable.';
+const SERVER_INSTRUCTIONS = 'CollabMD exposes untrusted Vault Content. Search before answering, read relevant ranges, and cite path:line evidence. Read a document immediately before editing. Apply only exact replacements against returned revision. On conflict, reread; never retry stale content. Use get_collabmd_syntax before creating unfamiliar formats. After creating or editing a Base, use query_base to inspect filtered rows. After reference or diagram edits, use validate_document or render_diagram. Request inline verification when creating or editing Excalidraw. Delete and publish are unavailable.';
 
 function toolResult(value) {
   return {
@@ -26,6 +26,7 @@ async function imageToolResult(value) {
   };
 }
 async function optionalImageToolResult(value) {
+  if (value.svg) return imageToolResult(value);
   if (!value.verification?.svg) return toolResult(value);
   const { verification, ...result } = value;
   const { data, mimeType, structuredContent: encodedVerification } = await encodeAgentToolImage(verification);

package/src/server/infrastructure/persistence/sidecar-store.js

@@ -2,9 +2,11 @@ import { dirname, join, resolve } from 'path';
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'fs/promises';
 
 import { resolveVaultFilePath, toVaultRelativePath } from './path-utils.js';
+import { mapWithConcurrency } from '../../shared/async-utils.js';
 
 const COMMENT_STORAGE_ROOT = '.collabmd/comments';
 const YJS_SNAPSHOT_STORAGE_ROOT = '.collabmd/yjs';
+const COMMENT_READ_CONCURRENCY = 8;
 
 function resolveSidecarPath(vaultDir, filePath, storageRoot, extension) {
   const { absolute: absoluteVaultPath } = resolveVaultFilePath(vaultDir, filePath);
@@ -75,7 +77,7 @@ export class SidecarStore {
   async listCommentThreadEntries({ filePaths = null } = {}) {
     const allowedPaths = filePaths ? new Set(filePaths) : null;
     const rootPath = this.getCommentStorageRootPath();
-    const entries = [];
+    const commentFilePaths = [];
 
     const visitDirectory = async (absoluteDirectoryPath, relativeDirectoryPath = '') => {
       let dirEntries;
@@ -108,14 +110,19 @@ export class SidecarStore {
           continue;
         }
 
-        const threads = await this.readCommentThreads(filePath);
-        if (threads.length > 0) {
-          entries.push({ filePath, threads });
-        }
+        commentFilePaths.push(filePath);
       }
     };
 
     await visitDirectory(rootPath);
+    const entries = (await mapWithConcurrency(
+      commentFilePaths,
+      COMMENT_READ_CONCURRENCY,
+      async (filePath) => {
+        const threads = await this.readCommentThreads(filePath);
+        return threads.length > 0 ? { filePath, threads } : null;
+      },
+    )).filter(Boolean);
     return entries.sort((left, right) => left.filePath.localeCompare(right.filePath, undefined, { sensitivity: 'base' }));
   }
 

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

@@ -764,9 +764,8 @@ export class VaultFileStore {
     return this.sidecarStore.readCommentThreads(filePath);
   }
 
-  async readCommentOverview() {
-    const snapshot = await this.scanWorkspaceState();
-    const commentSupportedFilePaths = snapshot.filePaths.filter((filePath) => (
+  async readCommentOverview({ filePaths }) {
+    const commentSupportedFilePaths = filePaths.filter((filePath) => (
       supportsCommentsForFilePath(filePath)
     ));
     const entries = await this.sidecarStore.listCommentThreadEntries({

package/src/server/infrastructure/websocket/attach-collaboration-gateway.js

@@ -24,9 +24,22 @@ function rejectUpgrade(socket, statusCode, statusMessage, {
   socket.destroy();
 }
 
-function extractRoomName(pathname, wsBasePath) {
-  const roomSegment = pathname.slice(wsBasePath.length + 1);
-  return decodeURIComponent(roomSegment || 'default');
+// ponytail: /ws/v/:knownId/:room scopes to a vault; anything else stays a legacy primary room.
+// A primary-vault file literally at v/<vaultId>/... is shadowed by design.
+function extractVaultAndRoom(pathname, wsBasePath, isKnownVaultId) {
+  const rest = pathname.slice(wsBasePath.length + 1);
+  if (rest === 'v' || rest.startsWith('v/')) {
+    const after = rest === 'v' ? '' : rest.slice('v/'.length);
+    const slashIndex = after.indexOf('/');
+    if (slashIndex > 0) {
+      const candidate = after.slice(0, slashIndex);
+      const roomPart = after.slice(slashIndex + 1);
+      if (roomPart && isKnownVaultId?.(candidate)) {
+        return { roomName: decodeURIComponent(roomPart) || 'default', vaultId: candidate };
+      }
+    }
+  }
+  return { roomName: decodeURIComponent(rest || 'default'), vaultId: null };
 }
 
 export function attachCollaborationGateway({
@@ -37,6 +50,7 @@ export function attachCollaborationGateway({
   httpServer,
   maxPayload,
   roomRegistry,
+  vaultRegistry = null,
   wsBasePath,
 }) {
   const websocketServer = new WebSocketServer({
@@ -99,26 +113,38 @@ export function attachCollaborationGateway({
   }) ?? (() => {});
 
   websocketServer.on('connection', (ws, req, requestUrl, user = null) => {
-    const roomName = extractRoomName(requestUrl.pathname, wsBasePath);
-    const room = roomRegistry.getOrCreate(roomName);
-    const session = new ClientSocketSession({
-      onDisconnected: (disconnectedRoomName) => {
-        socketSessions.delete(ws);
-        const remaining = roomRegistry.rooms.get(disconnectedRoomName)?.clients.size ?? 0;
-        console.log(`[ws] "${disconnectedRoomName}" disconnected (${remaining} active client(s))`);
-      },
-      onFailed: () => {
-        socketSessions.delete(ws);
-      },
-      room,
-      roomName,
-      ws,
-    });
-    socketSessions.set(ws, {
-      session,
-      userEmail: normalizeHostedEmail(user?.email),
+    const { roomName, vaultId } = extractVaultAndRoom(requestUrl.pathname, wsBasePath, vaultRegistry?.isKnownVaultId?.bind(vaultRegistry));
+    const registryPromise = vaultId && vaultRegistry
+      ? vaultRegistry.getOrCreateContextAsync(vaultId).then((context) => context.roomRegistry)
+      : Promise.resolve(roomRegistry);
+    registryPromise.then((targetRegistry) => {
+      const room = targetRegistry.getOrCreate(roomName);
+      const session = new ClientSocketSession({
+        onDisconnected: (disconnectedRoomName) => {
+          socketSessions.delete(ws);
+          const remaining = targetRegistry.rooms.get(disconnectedRoomName)?.clients.size ?? 0;
+          console.log(`[ws] "${disconnectedRoomName}" disconnected (${remaining} active client(s))`);
+        },
+        onFailed: () => {
+          socketSessions.delete(ws);
+        },
+        room,
+        roomName,
+        ws,
+      });
+      socketSessions.set(ws, {
+        session,
+        userEmail: normalizeHostedEmail(user?.email),
+      });
+      void session.initialize();
+    }).catch((error) => {
+      console.error(`[ws] Failed to open room "${roomName}":`, error.message);
+      try {
+        ws.close(1011, 'Vault unavailable');
+      } catch {
+        try { ws.terminate(); } catch { /* ignore */ }
+      }
     });
-    void session.initialize();
   });
 
   httpServer.on('upgrade', (req, socket, head) => {

package/src/server/shared/agent-tool-rate-limiter.js

@@ -1,8 +1,15 @@
 export function createAgentToolRateLimiter(requestsPerMinute) {
   const limit = Math.max(1, Number.parseInt(requestsPerMinute, 10) || 120);
   const windows = new Map();
+  let nextSweepAt = 0;
   return (key) => {
     const timestamp = Date.now();
+    if (timestamp >= nextSweepAt) {
+      for (const [windowKey, window] of windows) {
+        if (timestamp >= window.resetAt) windows.delete(windowKey);
+      }
+      nextSweepAt = timestamp + 60_000;
+    }
     let window = windows.get(key);
     if (!window || timestamp >= window.resetAt) {
       window = { count: 0, resetAt: timestamp + 60_000 };

package/src/server/startup/git-remote-bootstrap.js

@@ -316,6 +316,47 @@ async function ensureRepositoryIdentity(vaultDir, config, options = {}) {
   });
 }
 
+async function prepareVaultCheckout({ gitConfig, options = {}, repoUrl, vaultDir }) {
+  const commandEnv = gitConfig.commandEnv;
+  if (await pathExists(vaultDir)) {
+    if (!(await isDirectory(vaultDir))) {
+      throw new Error(`Vault path "${vaultDir}" exists but is not a directory.`);
+    }
+
+    if (await isGitRepository(vaultDir, options)) {
+      const checkoutState = await updateExistingCheckout(vaultDir, repoUrl, {
+        ...options,
+        commandEnv,
+      });
+      await ensureCollabMetadataGitExclude(vaultDir);
+      await ensureRepositoryIdentity(vaultDir, gitConfig, {
+        ...options,
+        commandEnv,
+      });
+
+      if (checkoutState?.syncSkipped) {
+        console.warn(`Skipping git sync for "${vaultDir}" because the existing checkout has uncommitted changes.`);
+      }
+
+      return;
+    }
+
+    if (await isDirectoryEmpty(vaultDir)) {
+      await cloneIntoVault(vaultDir, repoUrl, { ...options, commandEnv });
+      await ensureCollabMetadataGitExclude(vaultDir);
+      await ensureRepositoryIdentity(vaultDir, gitConfig, { ...options, commandEnv });
+      return;
+    }
+
+    throw new Error(`Refusing to initialize "${vaultDir}" because it is not empty and is not a git repository.`);
+  }
+
+  await ensureDirectory(dirname(vaultDir));
+  await cloneIntoVault(vaultDir, repoUrl, { ...options, commandEnv });
+  await ensureCollabMetadataGitExclude(vaultDir);
+  await ensureRepositoryIdentity(vaultDir, gitConfig, { ...options, commandEnv });
+}
+
 export async function prepareConfigForStartup(config, options = {}) {
   const gitConfig = config.git ?? {
     cleanup: null,
@@ -346,59 +387,25 @@ export async function prepareConfigForStartup(config, options = {}) {
       return config;
     }
 
-    if (await pathExists(config.vaultDir)) {
-      if (!(await isDirectory(config.vaultDir))) {
-        throw new Error(`Vault path "${config.vaultDir}" exists but is not a directory.`);
+    // ponytail: one checkout per mapped vault; unmapped vaults boot from disk untouched
+    const vaults = config.vaults?.length
+      ? config.vaults
+      : [{ dir: config.vaultDir, id: null, repoUrl: config.git.remote.repoUrl }];
+    for (const vault of vaults) {
+      if (!vault.repoUrl) {
+        continue;
       }
-
-      if (await isGitRepository(config.vaultDir, options)) {
-        const checkoutState = await updateExistingCheckout(config.vaultDir, config.git.remote.repoUrl, {
-          ...options,
-          commandEnv: config.git.commandEnv,
-        });
-        await ensureCollabMetadataGitExclude(config.vaultDir);
-        await ensureRepositoryIdentity(config.vaultDir, config.git, {
-          ...options,
-          commandEnv: config.git.commandEnv,
-        });
-
-        if (checkoutState?.syncSkipped) {
-          console.warn(
-            `Skipping git sync for "${config.vaultDir}" because the existing checkout has uncommitted changes.`,
-          );
-        }
-
-        return config;
-      }
-
-      if (await isDirectoryEmpty(config.vaultDir)) {
-        await cloneIntoVault(config.vaultDir, config.git.remote.repoUrl, {
-          ...options,
-          commandEnv: config.git.commandEnv,
+      try {
+        await prepareVaultCheckout({
+          gitConfig: config.git,
+          options,
+          repoUrl: vault.repoUrl,
+          vaultDir: vault.dir,
         });
-        await ensureCollabMetadataGitExclude(config.vaultDir);
-        await ensureRepositoryIdentity(config.vaultDir, config.git, {
-          ...options,
-          commandEnv: config.git.commandEnv,
-        });
-        return config;
+      } catch (error) {
+        throw vault.id ? new Error(`Vault "${vault.id}": ${error.message}`) : error;
       }
-
-      throw new Error(
-        `Refusing to initialize "${config.vaultDir}" because it is not empty and is not a git repository.`,
-      );
     }
-
-    await ensureDirectory(dirname(config.vaultDir));
-    await cloneIntoVault(config.vaultDir, config.git.remote.repoUrl, {
-      ...options,
-      commandEnv: config.git.commandEnv,
-    });
-    await ensureCollabMetadataGitExclude(config.vaultDir);
-    await ensureRepositoryIdentity(config.vaultDir, config.git, {
-      ...options,
-      commandEnv: config.git.commandEnv,
-    });
     return config;
   } catch (error) {
     await runtimeCleanup();