collabmd 0.1.39 → 0.1.41

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

@@ -1,11 +1,3 @@
-import {
-  isBaseFilePath,
-  isDrawioFilePath,
-  isExcalidrawFilePath,
-  isMermaidFilePath,
-  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, sendResponse } from './http-response.js';
@@ -51,30 +43,6 @@ function decodeHeaderMetadata(value) {
   }
 }
 
-function selectWriteOperation(vaultFileStore, filePath, content) {
-  if (isExcalidrawFilePath(filePath)) {
-    return vaultFileStore.writeExcalidrawFile(filePath, content);
-  }
-
-  if (isBaseFilePath(filePath)) {
-    return vaultFileStore.writeBaseFile(filePath, content);
-  }
-
-  if (isDrawioFilePath(filePath)) {
-    return vaultFileStore.writeDrawioFile(filePath, content);
-  }
-
-  if (isMermaidFilePath(filePath)) {
-    return vaultFileStore.writeMermaidFile(filePath, content);
-  }
-
-  if (isPlantUmlFilePath(filePath)) {
-    return vaultFileStore.writePlantUmlFile(filePath, content);
-  }
-
-  return vaultFileStore.writeMarkdownFile(filePath, content);
-}
-
 function readRequestId(req) {
   const value = String(req.headers['x-collabmd-request-id'] || '').trim();
   return value ? value.slice(0, 120) : null;
@@ -125,7 +93,7 @@ async function handleExportDocx({ docxExporter }, req, res) {
   return true;
 }
 
-async function handleWriteFile({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+async function handleWriteFile({ workspaceMutationCoordinator }, req, res) {
   try {
     const body = await parseJsonBody(req);
     if (!body.path || typeof body.content !== 'string') {
@@ -133,21 +101,16 @@ async function handleWriteFile({ vaultFileStore, workspaceMutationCoordinator },
       return true;
     }
 
-    const result = await selectWriteOperation(vaultFileStore, body.path, body.content);
+    const result = await workspaceMutationCoordinator.writeEditableContent({
+      content: body.content,
+      path: body.path,
+      requestId: readRequestId(req),
+    });
     if (!result.ok) {
       jsonResponse(req, res, 400, { error: result.error });
       return true;
     }
 
-    await workspaceMutationCoordinator?.apply?.({
-      action: 'write-file',
-      origin: 'api',
-      requestId: readRequestId(req),
-      workspaceChange: createWorkspaceChange({
-        changedPaths: [body.path],
-      }),
-    });
-
     jsonResponse(req, res, 200, { ok: true });
   } catch (error) {
     handleVaultError(req, res, error, '[api] Failed to write file:', 'Failed to write file');
@@ -155,7 +118,7 @@ async function handleWriteFile({ vaultFileStore, workspaceMutationCoordinator },
   return true;
 }
 
-async function handleUploadAttachment({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+async function handleUploadAttachment({ workspaceMutationCoordinator }, req, res) {
   try {
     const sourceDocumentPath = decodeHeaderMetadata(req.headers['x-collabmd-source-path']);
     const originalFileName = decodeHeaderMetadata(req.headers['x-collabmd-file-name']);
@@ -167,25 +130,18 @@ async function handleUploadAttachment({ vaultFileStore, workspaceMutationCoordin
     }
 
     const content = await readBinaryRequestBody(req);
-    const result = await vaultFileStore.writeImageAttachmentForDocument(sourceDocumentPath, {
+    const result = await workspaceMutationCoordinator.uploadAttachment({
       content,
       mimeType,
       originalFileName,
+      requestId: readRequestId(req),
+      sourceDocumentPath,
     });
     if (!result.ok) {
       jsonResponse(req, res, 400, { error: result.error });
       return true;
     }
 
-    await workspaceMutationCoordinator?.apply?.({
-      action: 'upload-attachment',
-      origin: 'api',
-      requestId: readRequestId(req),
-      workspaceChange: createWorkspaceChange({
-        changedPaths: [result.path],
-      }),
-    });
-
     jsonResponse(req, res, 201, {
       markdown: result.markdownSnippet,
       ok: true,
@@ -197,7 +153,7 @@ async function handleUploadAttachment({ vaultFileStore, workspaceMutationCoordin
   return true;
 }
 
-async function handleCreateFile({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+async function handleCreateFile({ workspaceMutationCoordinator }, req, res) {
   try {
     const body = await parseJsonBody(req);
     if (!body.path) {
@@ -205,19 +161,15 @@ async function handleCreateFile({ vaultFileStore, workspaceMutationCoordinator }
       return true;
     }
 
-    const result = await vaultFileStore.createFile(body.path, body.content || '');
+    const result = await workspaceMutationCoordinator.createFile({
+      content: body.content || '',
+      path: body.path,
+      requestId: readRequestId(req),
+    });
     if (!result.ok) {
       jsonResponse(req, res, 409, { error: result.error });
       return true;
     }
-    await workspaceMutationCoordinator?.apply?.({
-      action: 'create-file',
-      origin: 'api',
-      requestId: readRequestId(req),
-      workspaceChange: createWorkspaceChange({
-        changedPaths: [body.path],
-      }),
-    });
     jsonResponse(req, res, 201, { ok: true, path: body.path });
   } catch (error) {
     handleVaultError(req, res, error, '[api] Failed to create file:', 'Failed to create file');
@@ -225,7 +177,7 @@ async function handleCreateFile({ vaultFileStore, workspaceMutationCoordinator }
   return true;
 }
 
-async function handleDeleteFile({ vaultFileStore, workspaceMutationCoordinator }, req, res, requestUrl) {
+async function handleDeleteFile({ workspaceMutationCoordinator }, req, res, requestUrl) {
   const filePath = requestUrl.searchParams.get('path');
   if (!filePath) {
     jsonResponse(req, res, 400, { error: 'Missing path parameter' });
@@ -233,19 +185,14 @@ async function handleDeleteFile({ vaultFileStore, workspaceMutationCoordinator }
   }
 
   try {
-    const result = await vaultFileStore.deleteFile(filePath);
+    const result = await workspaceMutationCoordinator.deleteFile({
+      path: filePath,
+      requestId: readRequestId(req),
+    });
     if (!result.ok) {
       jsonResponse(req, res, 400, { error: result.error });
       return true;
     }
-    await workspaceMutationCoordinator?.apply?.({
-      action: 'delete-file',
-      origin: 'api',
-      requestId: readRequestId(req),
-      workspaceChange: createWorkspaceChange({
-        deletedPaths: [filePath],
-      }),
-    });
     jsonResponse(req, res, 200, { ok: true });
   } catch (error) {
     console.error('[api] Failed to delete file:', error.message);
@@ -254,7 +201,7 @@ async function handleDeleteFile({ vaultFileStore, workspaceMutationCoordinator }
   return true;
 }
 
-async function handleRenameFile({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+async function handleRenameFile({ workspaceMutationCoordinator }, req, res) {
   try {
     const body = await parseJsonBody(req);
     if (!body.oldPath || !body.newPath) {
@@ -262,19 +209,15 @@ async function handleRenameFile({ vaultFileStore, workspaceMutationCoordinator }
       return true;
     }
 
-    const result = await vaultFileStore.renameFile(body.oldPath, body.newPath);
+    const result = await workspaceMutationCoordinator.renameFile({
+      newPath: body.newPath,
+      oldPath: body.oldPath,
+      requestId: readRequestId(req),
+    });
     if (!result.ok) {
       jsonResponse(req, res, 400, { error: result.error });
       return true;
     }
-    await workspaceMutationCoordinator?.apply?.({
-      action: 'rename-file',
-      origin: 'api',
-      requestId: readRequestId(req),
-      workspaceChange: createWorkspaceChange({
-        renamedPaths: [{ oldPath: body.oldPath, newPath: body.newPath }],
-      }),
-    });
     jsonResponse(req, res, 200, { ok: true, path: body.newPath });
   } catch (error) {
     handleVaultError(req, res, error, '[api] Failed to rename file:', 'Failed to rename file');
@@ -282,7 +225,7 @@ async function handleRenameFile({ vaultFileStore, workspaceMutationCoordinator }
   return true;
 }
 
-async function handleCreateDirectory({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+async function handleCreateDirectory({ workspaceMutationCoordinator }, req, res) {
   try {
     const body = await parseJsonBody(req);
     if (!body.path) {
@@ -290,21 +233,15 @@ async function handleCreateDirectory({ vaultFileStore, workspaceMutationCoordina
       return true;
     }
 
-    const result = await vaultFileStore.createDirectory(body.path);
+    const result = await workspaceMutationCoordinator.createDirectory({
+      path: body.path,
+      requestId: readRequestId(req),
+    });
     if (!result.ok) {
       jsonResponse(req, res, 400, { error: result.error });
       return true;
     }
 
-    await workspaceMutationCoordinator?.apply?.({
-      action: 'create-directory',
-      origin: 'api',
-      requestId: readRequestId(req),
-      workspaceChange: createWorkspaceChange({
-        changedPaths: [body.path],
-      }),
-    });
-
     jsonResponse(req, res, 201, { ok: true });
   } catch (error) {
     handleVaultError(req, res, error, '[api] Failed to create directory:', 'Failed to create directory');
@@ -312,7 +249,7 @@ async function handleCreateDirectory({ vaultFileStore, workspaceMutationCoordina
   return true;
 }
 
-async function handleRenameDirectory({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+async function handleRenameDirectory({ workspaceMutationCoordinator }, req, res) {
   try {
     const body = await parseJsonBody(req);
     if (!body.oldPath || !body.newPath) {
@@ -320,22 +257,16 @@ async function handleRenameDirectory({ vaultFileStore, workspaceMutationCoordina
       return true;
     }
 
-    const workspaceChange = await workspaceMutationCoordinator?.createDirectoryRenameWorkspaceChange?.(body.oldPath, body.newPath);
-    const result = await vaultFileStore.renameDirectory(body.oldPath, body.newPath);
+    const result = await workspaceMutationCoordinator.renameDirectory({
+      newPath: body.newPath,
+      oldPath: body.oldPath,
+      requestId: readRequestId(req),
+    });
     if (!result.ok) {
       jsonResponse(req, res, 400, { error: result.error });
       return true;
     }
 
-    await workspaceMutationCoordinator?.apply?.({
-      action: 'rename-directory',
-      origin: 'api',
-      requestId: readRequestId(req),
-      workspaceChange: workspaceChange ?? {
-        renamedPaths: [{ oldPath: body.oldPath, newPath: body.newPath }],
-      },
-    });
-
     jsonResponse(req, res, 200, { ok: true, path: body.newPath });
   } catch (error) {
     handleVaultError(req, res, error, '[api] Failed to rename directory:', 'Failed to rename directory');
@@ -343,7 +274,7 @@ async function handleRenameDirectory({ vaultFileStore, workspaceMutationCoordina
   return true;
 }
 
-async function handleDeleteDirectory({ vaultFileStore, workspaceMutationCoordinator }, req, res, requestUrl) {
+async function handleDeleteDirectory({ workspaceMutationCoordinator }, req, res, requestUrl) {
   const dirPath = requestUrl.searchParams.get('path');
   const recursive = requestUrl.searchParams.get('recursive') === '1';
   if (!dirPath) {
@@ -352,22 +283,16 @@ async function handleDeleteDirectory({ vaultFileStore, workspaceMutationCoordina
   }
 
   try {
-    const workspaceChange = await workspaceMutationCoordinator?.createDirectoryDeleteWorkspaceChange?.(dirPath);
-    const result = await vaultFileStore.deleteDirectory(dirPath, { recursive });
+    const result = await workspaceMutationCoordinator.deleteDirectory({
+      path: dirPath,
+      recursive,
+      requestId: readRequestId(req),
+    });
     if (!result.ok) {
       jsonResponse(req, res, getDirectoryDeleteStatusCode(result.error), { error: result.error });
       return true;
     }
 
-    await workspaceMutationCoordinator?.apply?.({
-      action: 'delete-directory',
-      origin: 'api',
-      requestId: readRequestId(req),
-      workspaceChange: workspaceChange ?? {
-        deletedPaths: [dirPath],
-      },
-    });
-
     jsonResponse(req, res, 200, { ok: true });
   } catch (error) {
     handleVaultError(req, res, error, '[api] Failed to delete directory:', 'Failed to delete directory');

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

@@ -9,6 +9,7 @@ export function createVaultApiHandler({
   docxExporter = null,
   plantUmlRenderer = null,
   roomRegistry = null,
+  searchService = null,
   vaultFileStore,
   workspaceMutationCoordinator = null,
 }) {
@@ -16,6 +17,7 @@ export function createVaultApiHandler({
     baseQueryService,
     backlinkIndex,
     config,
+    searchService,
     vaultFileStore,
     workspaceMutationCoordinator,
   });

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

@@ -1,16 +1,9 @@
-import archiver from 'archiver';
+import { ZipArchive } from 'archiver';
 import { readdir } from 'node:fs/promises';
 import { basename } from 'node:path';
 import { join } from 'node:path';
 
-import {
-  isBaseFilePath,
-  isDrawioFilePath,
-  isExcalidrawFilePath,
-  isImageAttachmentFilePath,
-  isMermaidFilePath,
-  isPlantUmlFilePath,
-} from '../../../domain/file-kind.js';
+import { isImageAttachmentFilePath } from '../../../domain/file-kind.js';
 import { isIgnoredVaultEntry } from '../persistence/path-utils.js';
 import { parseJsonBody } from './request-body.js';
 import { jsonResponse, sendResponse, sendStreamResponse } from './http-response.js';
@@ -58,36 +51,12 @@ function createDownloadHeaders(fileName, contentType) {
   };
 }
 
-function selectReadOperation(vaultFileStore, filePath) {
-  if (isExcalidrawFilePath(filePath)) {
-    return vaultFileStore.readExcalidrawFile(filePath);
-  }
-
-  if (isBaseFilePath(filePath)) {
-    return vaultFileStore.readBaseFile(filePath);
-  }
-
-  if (isDrawioFilePath(filePath)) {
-    return vaultFileStore.readDrawioFile(filePath);
-  }
-
-  if (isMermaidFilePath(filePath)) {
-    return vaultFileStore.readMermaidFile(filePath);
-  }
-
-  if (isPlantUmlFilePath(filePath)) {
-    return vaultFileStore.readPlantUmlFile(filePath);
-  }
-
-  return vaultFileStore.readMarkdownFile(filePath);
-}
-
 async function streamDirectoryArchive(req, res, {
   maxEntries = 10_000,
   rootAbsolutePath = '',
   rootName = 'archive',
 } = {}) {
-  const archive = archiver('zip', {
+  const archive = new ZipArchive({
     zlib: {
       level: 6,
     },
@@ -282,6 +251,21 @@ async function handleFileTree(req, res, _requestUrl, { vaultFileStore, workspace
   }
 }
 
+async function handleCommentOverview(req, res, _requestUrl, { vaultFileStore }) {
+  try {
+    if (typeof vaultFileStore.readCommentOverview !== 'function') {
+      jsonResponse(req, res, 503, { error: 'Comment overview is unavailable' });
+      return;
+    }
+
+    const overview = await vaultFileStore.readCommentOverview();
+    jsonResponse(req, res, 200, { overview });
+  } catch (error) {
+    console.error('[api] Failed to read comment overview:', error.message);
+    jsonResponse(req, res, 500, { error: 'Failed to read comment overview' });
+  }
+}
+
 async function handleFileRead(req, res, requestUrl, { vaultFileStore }) {
   const filePath = requestUrl.searchParams.get('path');
   if (!filePath) {
@@ -290,7 +274,7 @@ async function handleFileRead(req, res, requestUrl, { vaultFileStore }) {
   }
 
   try {
-    const content = await selectReadOperation(vaultFileStore, filePath);
+    const content = await vaultFileStore.readEditableVaultContent(filePath);
     if (content === null) {
       jsonResponse(req, res, 404, { error: 'File not found' });
       return;
@@ -428,6 +412,39 @@ async function handleBacklinks(req, res, requestUrl, { backlinkIndex }) {
   }
 }
 
+async function handleSearch(req, res, requestUrl, { searchService }) {
+  if (!searchService?.search) {
+    jsonResponse(req, res, 503, {
+      error: 'Global text search is unavailable',
+      ok: false,
+      search: {
+        available: false,
+        backend: 'ripgrep',
+      },
+    });
+    return;
+  }
+
+  try {
+    const result = await searchService.search({
+      limit: requestUrl.searchParams.get('limit') || '',
+      query: requestUrl.searchParams.get('q') || '',
+    });
+    jsonResponse(req, res, 200, result);
+  } catch (error) {
+    const statusCode = Number(error?.statusCode) || 500;
+    console.error('[api] Failed to search vault:', error.message);
+    jsonResponse(req, res, statusCode, {
+      error: error.message || 'Failed to search vault',
+      ok: false,
+      search: error.search ?? searchService?.getClientConfig?.() ?? {
+        available: false,
+        backend: 'ripgrep',
+      },
+    });
+  }
+}
+
 // --- Route table ---
 
 function createRouteTable(context) {
@@ -437,11 +454,13 @@ function createRouteTable(context) {
     { method: 'POST', path: '/api/base/transform', handler: handleBaseTransform },
     { method: 'POST', path: '/api/base/export', handler: handleBaseExport },
     { method: 'GET', path: '/api/files', handler: handleFileTree },
+    { method: 'GET', path: '/api/comments/overview', handler: handleCommentOverview },
     { method: 'GET', path: '/api/file', handler: handleFileRead },
     { method: 'GET', path: '/api/download/file', handler: handleFileDownload },
     { method: 'GET', path: '/api/download/directory', handler: handleDirectoryDownload },
     { method: 'GET', path: '/api/attachment', handler: handleAttachmentRead },
     { method: 'GET', path: '/api/backlinks', handler: handleBacklinks },
+    { method: 'GET', path: '/api/search', handler: handleSearch },
   ].map((route) => ({
     ...route,
     handler: (req, res, requestUrl) => route.handler(req, res, requestUrl, context),
@@ -452,6 +471,7 @@ export function createVaultApiQueryHandler({
   baseQueryService = null,
   backlinkIndex,
   config = {},
+  searchService = null,
   vaultFileStore,
   workspaceMutationCoordinator = null,
 }) {
@@ -459,6 +479,7 @@ export function createVaultApiQueryHandler({
     baseQueryService,
     backlinkIndex,
     config,
+    searchService,
     vaultFileStore,
     workspaceMutationCoordinator,
   };

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

@@ -7,6 +7,7 @@ async function readRequestBuffer(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
     const chunks = [];
     let size = 0;
     let done = false;
+    let limitError = null;
 
     const finish = (callback, value) => {
       if (done) {
@@ -21,10 +22,14 @@ async function readRequestBuffer(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
     };
 
     const onData = (chunk) => {
+      if (limitError) {
+        return;
+      }
+
       size += chunk.length;
       if (size > maxBytes) {
-        req.resume();
-        finish(reject, createRequestError(413, 'Request body too large'));
+        chunks.length = 0;
+        limitError = createRequestError(413, 'Request body too large');
         return;
       }
 
@@ -32,6 +37,11 @@ async function readRequestBuffer(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
     };
 
     const onEnd = () => {
+      if (limitError) {
+        finish(reject, limitError);
+        return;
+      }
+
       finish(resolve, Buffer.concat(chunks));
     };