collabmd 0.1.45 → 0.1.46

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

@@ -70,6 +70,23 @@ export class GitService {
 
         return String(result.stdout ?? '');
       },
+      async execGitBuffer(args, { env = null } = {}) {
+        const result = await gitExecFile('git', ['-c', 'core.quotepath=false', ...args], {
+          cwd: vaultDir,
+          encoding: null,
+          env: {
+            ...process.env,
+            ...(commandEnv ?? {}),
+            ...(env ?? {}),
+          },
+          maxBuffer: 5 * 1024 * 1024,
+          timeout: 10_000,
+        });
+
+        return Buffer.isBuffer(result.stdout)
+          ? result.stdout
+          : Buffer.from(result.stdout ?? '');
+      },
     };
     this.untrackedFileService = new GitUntrackedFileService({ vaultDir });
     this.statusService = new GitStatusService({
@@ -293,6 +310,10 @@ export class GitService {
     return this.historyService.getFileSnapshot({ hash, path });
   }
 
+  async getFileAttachment({ hash, path } = {}) {
+    return this.historyService.getFileAttachment({ hash, path });
+  }
+
   async pathExistsAtRef(ref, path) {
     try {
       await this.commandRunner.execGit(['cat-file', '-e', `${ref}:${path}`]);

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

@@ -1,6 +1,7 @@
 import { createRequestError as createGitRequestError } from '../http/http-errors.js';
 import { getVaultFileKind, isImageAttachmentFilePath } from '../../../domain/file-kind.js';
 import { normalizeRelativeGitPath } from './path-utils.js';
+import { getImageMimeType } from './image-mime.js';
 import {
   countPatchLines,
   parseGitLogHeader,
@@ -308,6 +309,7 @@ export class GitHistoryService {
 
       if (metaOnly) {
         const metaResponse = {
+          baseRef: meta.baseRef,
           commit: meta.commit,
           files: meta.files,
           isGitRepo: true,
@@ -335,6 +337,7 @@ export class GitHistoryService {
         && (fileSummary.additions + fileSummary.deletions) > this.maxInitialPatchLines
       ) {
         const guardedResponse = {
+          baseRef: meta.baseRef,
           commit: meta.commit,
           files: [{
             ...baseFile,
@@ -396,6 +399,7 @@ export class GitHistoryService {
         };
 
       const response = {
+        baseRef: meta.baseRef,
         commit: meta.commit,
         files: [detailedFile],
         isGitRepo: true,
@@ -460,6 +464,46 @@ export class GitHistoryService {
     });
   }
 
+  async getFileAttachment({ hash, path } = {}) {
+    const isGitRepo = await this.commandRunner.isGitRepo();
+    const normalizedHash = this.normalizeAttachmentRef(hash);
+    const normalizedPath = normalizeRelativeGitPath(path);
+
+    if (!isGitRepo) {
+      throw createGitRequestError(404, 'Git repository not found');
+    }
+
+    if (!isImageAttachmentFilePath(normalizedPath)) {
+      throw createGitRequestError(400, 'Unsupported image attachment path');
+    }
+
+    const cacheKey = JSON.stringify({
+      hash: normalizedHash,
+      path: normalizedPath,
+      type: 'file-attachment',
+    });
+    const cached = getCachedValue(this.commitCache, cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    return this.runRequest(cacheKey, async () => {
+      let content;
+      try {
+        content = await this.commandRunner.execGitBuffer(['cat-file', 'blob', `${normalizedHash}:${normalizedPath}`]);
+      } catch {
+        throw createGitRequestError(404, 'Commit image not found');
+      }
+
+      return setCachedValue(this.commitCache, cacheKey, {
+        content,
+        hash: normalizedHash,
+        mimeType: getImageMimeType(normalizedPath),
+        path: normalizedPath,
+      }, this.responseCacheTtlMs);
+    });
+  }
+
   async runRequest(key, callback) {
     if (this.pendingRequests.has(key)) {
       return this.pendingRequests.get(key);
@@ -494,6 +538,14 @@ export class GitHistoryService {
     return normalizedHash;
   }
 
+  normalizeAttachmentRef(hash) {
+    const normalizedHash = String(hash ?? '').trim();
+    if (normalizedHash === 'HEAD') {
+      return normalizedHash;
+    }
+    return this.normalizeCommitHash(normalizedHash);
+  }
+
   parseHistoryChunk(chunk) {
     const [headerLine = '', ...statLines] = String(chunk ?? '')
       .split(/\r?\n/u)
@@ -588,6 +640,7 @@ export class GitHistoryService {
         authoredAt: chunk.authoredAt,
         deletions: Number(numstatEntry?.deletions || 0),
         filesChanged: 1,
+        fileKind: getVaultFileKind(nameStatusEntry?.path),
         hash: chunk.hash,
         isMergeCommit: chunk.isMergeCommit,
         oldPath: nameStatusEntry?.oldPath ?? null,
@@ -679,6 +732,7 @@ export class GitHistoryService {
       const numstatEntry = numstatEntries[index];
       return {
         ...entry,
+        fileKind: getVaultFileKind(entry.path),
         stats: numstatEntry
           ? {
             additions: numstatEntry.additions,

package/src/server/infrastructure/git/image-mime.js

@@ -0,0 +1,14 @@
+const IMAGE_MIME_TYPES = Object.freeze({
+  '.gif': 'image/gif',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+});
+
+export function getImageMimeType(filePath) {
+  const normalizedPath = String(filePath ?? '').toLowerCase();
+  const extension = Object.keys(IMAGE_MIME_TYPES).find((candidate) => normalizedPath.endsWith(candidate));
+  return extension ? IMAGE_MIME_TYPES[extension] : 'application/octet-stream';
+}

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

@@ -2,11 +2,17 @@ import { createReadStream } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
+import { getVaultFileKind, isImageAttachmentFilePath } from '../../../domain/file-kind.js';
 import { mapWithConcurrency } from '../../shared/async-utils.js';
 import { createEmptyStats } from './responses.js';
 import { splitContentLines } from './parsers.js';
+import { getImageMimeType } from './image-mime.js';
 
 async function countFileLines(filePath) {
+  if (isImageAttachmentFilePath(filePath)) {
+    return 0;
+  }
+
   return new Promise((resolve, reject) => {
     const stream = createReadStream(filePath, { encoding: 'utf8' });
     let lineCount = 0;
@@ -36,6 +42,7 @@ function buildSyntheticAddedFileDiff(pathValue, content) {
   const normalizedContent = String(content ?? '').replace(/\r\n/g, '\n');
   const file = {
     code: 'U',
+    fileKind: getVaultFileKind(pathValue),
     hunks: [],
     isBinary: false,
     oldPath: null,
@@ -89,7 +96,27 @@ export class GitUntrackedFileService {
   async buildSyntheticDiffs(files = []) {
     const results = await mapWithConcurrency(files, 2, async (file) => {
       try {
-        const content = await readFile(join(this.vaultDir, file.path), 'utf8');
+        const absolutePath = join(this.vaultDir, file.path);
+        if (isImageAttachmentFilePath(file.path)) {
+          const content = await readFile(absolutePath);
+          return {
+            ...file,
+            binaryMessage: 'Binary image file',
+            byteLength: content.byteLength,
+            code: file.code || 'U',
+            fileKind: 'image',
+            hunks: [],
+            isBinary: true,
+            mimeType: getImageMimeType(file.path),
+            oldPath: file.oldPath ?? null,
+            path: file.path,
+            stats: createEmptyStats(),
+            status: file.status || 'untracked',
+            synthetic: true,
+          };
+        }
+
+        const content = await readFile(absolutePath, 'utf8');
         return buildSyntheticAddedFileDiff(file.path, content);
       } catch {
         return null;

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

@@ -1,5 +1,12 @@
+import { basename } from 'node:path';
+
 import { handleApiError } from './http-request-helpers.js';
-import { jsonResponse } from './http-response.js';
+import {
+  createSafeAsciiFilename,
+  encodeContentDispositionFilename,
+  jsonResponse,
+  sendResponse,
+} from './http-response.js';
 
 function resolveDiffScope(requestUrl) {
   const scope = String(requestUrl.searchParams.get('scope') || '').trim().toLowerCase();
@@ -106,6 +113,29 @@ export function createGitApiQueryHandler({ gitService }) {
       return true;
     }
 
+    if (requestUrl.pathname === '/api/git/file-attachment' && req.method === 'GET') {
+      try {
+        const attachment = await gitService.getFileAttachment({
+          hash: requestUrl.searchParams.get('hash'),
+          path: requestUrl.searchParams.get('path'),
+        });
+        const fileName = basename(String(attachment.path || 'image'));
+        sendResponse(req, res, {
+          body: attachment.content,
+          headers: {
+            'Cache-Control': 'private, max-age=300, stale-while-revalidate=3600',
+            'Content-Disposition': `inline; filename="${createSafeAsciiFilename(fileName)}"; filename*=UTF-8''${encodeContentDispositionFilename(fileName)}`,
+            'Content-Type': attachment.mimeType || 'application/octet-stream',
+            'X-Content-Type-Options': 'nosniff',
+          },
+          statusCode: 200,
+        });
+      } catch (error) {
+        handleApiError(req, res, error, '[api] Failed to read git file attachment:', 'Failed to read git file attachment');
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/git/pull-backups' && req.method === 'GET') {
       try {
         jsonResponse(req, res, 200, {

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

@@ -4,9 +4,14 @@ import { createGitApiQueryHandler } from './create-git-api-query-handler.js';
 import { createHostedApiHandler } from './create-hosted-api-handler.js';
 import { createPlantUmlApiHandler } from './create-plantuml-api-handler.js';
 import { createStaticHandler } from './create-static-handler.js';
+import { createStructurizrApiHandler } from './create-structurizr-api-handler.js';
 import { createVaultApiCommandHandler } from './create-vault-api-command-handler.js';
 import { createVaultApiQueryHandler } from './create-vault-api-query-handler.js';
 import { parseJsonBody } from './request-body.js';
+import {
+  createRequestUrlWithPathname,
+  stripBasePath,
+} from './http-request-helpers.js';
 import {
   applyCorsHeaders,
   jsonResponse,
@@ -16,28 +21,6 @@ import {
   WRITE_METHODS,
 } from './http-response.js';
 
-function stripBasePath(pathname, basePath) {
-  if (!basePath) {
-    return pathname;
-  }
-
-  if (pathname === basePath) {
-    return '/';
-  }
-
-  if (pathname.startsWith(`${basePath}/`)) {
-    return pathname.slice(basePath.length) || '/';
-  }
-
-  return pathname;
-}
-
-function createRequestUrlWithPathname(requestUrl, pathname) {
-  const nextUrl = new URL(requestUrl.toString());
-  nextUrl.pathname = pathname || '/';
-  return nextUrl;
-}
-
 export function createRequestHandler(
   config,
   authService,
@@ -54,6 +37,7 @@ export function createRequestHandler(
   fileSystemSyncService = null,
   hostedWorkspaceService = null,
   githubSetupFlow = null,
+  structurizrWorkspaceService = null,
 ) {
   const handleStaticRequest = createStaticHandler(config, authService, searchService);
   const handleAuthApi = createAuthApiHandler({ authService });
@@ -78,12 +62,17 @@ export function createRequestHandler(
   });
   const handleVaultApiCommand = createVaultApiCommandHandler({
     backlinkIndex,
+    maxPdfUploadBytes: config.maxPdfUploadBytes,
     renderDocx,
     roomRegistry,
     vaultFileStore,
     workspaceMutationCoordinator,
   });
   const handlePlantUmlApi = createPlantUmlApiHandler({ plantUmlRenderer });
+  const handleStructurizrApi = createStructurizrApiHandler({
+    basePath: config.basePath,
+    service: structurizrWorkspaceService,
+  });
 
   function handleBasePathRedirect(req, res, originalRequestUrl) {
     if (
@@ -193,7 +182,7 @@ export function createRequestHandler(
       return;
     }
 
-    if (requestUrl.pathname.startsWith('/api/')) {
+    if (requestUrl.pathname.startsWith('/api/') || handleStructurizrApi.requiresAuthorization(requestUrl)) {
       const authorization = authService.authorizeApiRequest(req);
       if (!authorization.ok) {
         jsonResponse(req, res, authorization.statusCode, authorization.body);
@@ -209,6 +198,10 @@ export function createRequestHandler(
       }
     }
 
+    if (await handleStructurizrApi(req, res, requestUrl)) {
+      return;
+    }
+
     if (requestUrl.pathname.startsWith('/api/')) {
       if (await handleVaultApiQuery(req, res, requestUrl)) {
         return;

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

@@ -7,12 +7,13 @@ const CONTENT_TYPES = {
   '.css': 'text/css; charset=utf-8',
   '.html': 'text/html; charset=utf-8',
   '.js': 'text/javascript; charset=utf-8',
+  '.mjs': 'text/javascript; charset=utf-8',
   '.json': 'application/json; charset=utf-8',
   '.svg': 'image/svg+xml',
 };
 
 function isVersionedAssetPath(pathname = '') {
-  return /-[A-Za-z0-9_-]{8,}\.(?:css|js|woff2?|ttf|svg)$/u.test(pathname);
+  return /-[A-Za-z0-9_-]{8,}\.(?:css|js|mjs|woff2?|ttf|svg)$/u.test(pathname);
 }
 
 function getStaticCacheControl(pathname = '', extension = '') {
@@ -33,7 +34,7 @@ function getStaticCacheControl(pathname = '', extension = '') {
       return 'public, max-age=31536000, immutable';
     }
 
-    if (extension === '.css' || extension === '.js') {
+    if (extension === '.css' || extension === '.js' || extension === '.mjs') {
       return 'public, max-age=0, must-revalidate';
     }
 
@@ -53,6 +54,7 @@ function buildRuntimeConfig({
   nodeEnv,
   publicWsBaseUrl,
   search,
+  structurizr,
   wikiLinkAutoCreate,
   wsBasePath,
 }) {
@@ -68,6 +70,7 @@ function buildRuntimeConfig({
     },
     publicWsBaseUrl,
     search,
+    structurizrEnabled: Boolean(structurizr?.enabled ?? structurizr?.serverUrl),
     wikiLinkAutoCreate,
     wsBasePath,
   })};\n`;

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

@@ -0,0 +1,145 @@
+import { readFile } from 'node:fs/promises';
+
+import { getRequestErrorStatusCode } from './http-errors.js';
+import { jsonResponse, sendResponse, textResponse } from './http-response.js';
+import { parseJsonBody } from './request-body.js';
+
+const EMBED_STYLESHEET_PATH = new URL('../structurizr/structurizr-embed.css', import.meta.url);
+
+function isSyncRequest(requestUrl, req) {
+  return requestUrl.pathname === '/api/structurizr/sync' && req.method === 'POST';
+}
+
+function isEmbedStylesheetRequest(requestUrl) {
+  return requestUrl.pathname === '/api/structurizr/embed.css';
+}
+
+function rewriteBasePath(body, contentType, basePath, { injectEmbedStylesheet = false } = {}) {
+  if (!/(?:text\/(?:html|css)|javascript|ecmascript)/iu.test(contentType)) {
+    return body;
+  }
+
+  let source = body.toString('utf8');
+  if (basePath) {
+    source = source.replace(
+      /(["'`(=])\/(static|workspace|api\/workspace)(?=[/"'`?#)])/gu,
+      `$1${basePath}/$2`,
+    );
+  }
+
+  if (injectEmbedStylesheet && /text\/html/iu.test(contentType)) {
+    const normalizedBasePath = String(basePath || '').replace(/\/+$/u, '');
+    const stylesheetPath = `${normalizedBasePath}/api/structurizr/embed.css`;
+    source = source.replace(
+      /<head(?:\s[^>]*)?>/iu,
+      (head) => `${head}\n<link rel="stylesheet" href="${stylesheetPath}">`,
+    );
+  }
+
+  return Buffer.from(source);
+}
+
+export function createStructurizrApiHandler({ basePath = '', service = null } = {}) {
+  async function handleRequest(req, res, requestUrl) {
+    if (isSyncRequest(requestUrl, req)) {
+      try {
+        const body = await parseJsonBody(req);
+        if (!body || typeof body.path !== 'string') {
+          jsonResponse(req, res, 400, { error: 'Missing Structurizr workspace path' });
+          return true;
+        }
+
+        if (!service?.isEnabled()) {
+          jsonResponse(req, res, 503, { error: 'Structurizr renderer is not configured' });
+          return true;
+        }
+
+        jsonResponse(req, res, 200, await service.sync({
+          content: body.source,
+          rootPath: body.path,
+        }));
+      } catch (error) {
+        const statusCode = getRequestErrorStatusCode(error) || Number(error?.statusCode) || 502;
+        if (statusCode >= 500) {
+          console.error('[api] Failed to sync Structurizr workspace:', error.message);
+        }
+        jsonResponse(req, res, statusCode, {
+          code: error?.requestCode,
+          error: error instanceof Error ? error.message : 'Failed to sync Structurizr workspace',
+        });
+      }
+      return true;
+    }
+
+    if (isEmbedStylesheetRequest(requestUrl)) {
+      if (!service?.isEnabled()) {
+        return false;
+      }
+
+      if (req.method !== 'GET' && req.method !== 'HEAD') {
+        textResponse(req, res, 405, 'Method Not Allowed', { Allow: 'GET, HEAD' });
+        return true;
+      }
+
+      try {
+        sendResponse(req, res, {
+          body: await readFile(EMBED_STYLESHEET_PATH),
+          headers: {
+            'Cache-Control': 'no-store',
+            'Content-Type': 'text/css; charset=utf-8',
+          },
+          statusCode: 200,
+        });
+      } catch (error) {
+        console.error('[http] Failed to serve Structurizr embed stylesheet:', error.message);
+        textResponse(req, res, 500, 'Internal Server Error');
+      }
+      return true;
+    }
+
+    if (!service?.isProxyPath(requestUrl.pathname)) {
+      return false;
+    }
+
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      textResponse(req, res, 405, 'Method Not Allowed', { Allow: 'GET, HEAD' });
+      return true;
+    }
+
+    try {
+      const response = await service.proxy(requestUrl, {
+        headers: req.headers,
+        method: req.method,
+      });
+      if (!response) {
+        return false;
+      }
+
+      sendResponse(req, res, {
+        body: rewriteBasePath(response.body, response.contentType, basePath, {
+          injectEmbedStylesheet: requestUrl.pathname === '/workspace/1/diagrams',
+        }),
+        headers: {
+          'Cache-Control': requestUrl.pathname.startsWith('/static/')
+            ? 'public, max-age=31536000, immutable'
+            : 'no-store',
+          'Content-Type': response.contentType,
+        },
+        statusCode: response.statusCode,
+      });
+    } catch (error) {
+      const statusCode = getRequestErrorStatusCode(error) || Number(error?.statusCode) || 502;
+      console.error('[http] Failed to proxy Structurizr request:', error.message);
+      textResponse(req, res, statusCode, error.message || 'Structurizr renderer unavailable');
+    }
+
+    return true;
+  }
+
+  handleRequest.requiresAuthorization = (requestUrl) => (
+    Boolean(service?.isProxyPath(requestUrl.pathname))
+    && !requestUrl.pathname.startsWith('/api/')
+  );
+
+  return handleRequest;
+}

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

@@ -1,4 +1,5 @@
 import { basename } from 'node:path';
+import { isPdfFilePath } from '../../../domain/file-kind.js';
 import { createRequestError } from './http-errors.js';
 import { handleApiError, readRequestId } from './http-request-helpers.js';
 import {
@@ -7,10 +8,15 @@ import {
   jsonResponse,
   sendResponse,
 } from './http-response.js';
-import { parseJsonBody, readBinaryRequestBody } from './request-body.js';
+import {
+  parseJsonBody,
+  readBinaryRequestBody,
+  REQUEST_BODY_LIMIT_BYTES,
+} from './request-body.js';
 
 const DOCX_EXPORT_REQUEST_LIMIT_BYTES = 33_554_432;
 const DOCX_MIME_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+const PDF_SIGNATURE = Buffer.from('%PDF-');
 
 function createDocxDownloadHeaders(filePath) {
   const fileName = basename(String(filePath ?? 'document')).replace(/\.[^.]+$/u, '') || 'document';
@@ -23,7 +29,7 @@ function createDocxDownloadHeaders(filePath) {
   };
 }
 
-function decodeHeaderMetadata(value) {
+function decodeHeaderMetadata(value, label = 'attachment') {
   const normalized = String(value ?? '').trim();
   if (!normalized) {
     return '';
@@ -32,7 +38,7 @@ function decodeHeaderMetadata(value) {
   try {
     return decodeURIComponent(normalized);
   } catch {
-    throw createRequestError(400, 'Invalid attachment metadata header encoding');
+    throw createRequestError(400, `Invalid ${label} metadata header encoding`);
   }
 }
 
@@ -129,6 +135,55 @@ async function handleUploadAttachment({ workspaceMutationCoordinator }, req, res
   return true;
 }
 
+async function handleUploadFile({ maxPdfUploadBytes, workspaceMutationCoordinator }, req, res) {
+  try {
+    const filePath = decodeHeaderMetadata(req.headers['x-collabmd-file-path'], 'file upload');
+    if (!filePath) {
+      jsonResponse(req, res, 400, { error: 'Missing file path' });
+      return true;
+    }
+
+    if (typeof workspaceMutationCoordinator?.createFile !== 'function') {
+      jsonResponse(req, res, 503, { error: 'File upload is unavailable' });
+      return true;
+    }
+
+    const isPdfUpload = isPdfFilePath(filePath);
+    if (isPdfUpload) {
+      const contentType = String(req.headers['content-type'] || '')
+        .split(';', 1)[0]
+        .trim()
+        .toLowerCase();
+      if (contentType !== 'application/pdf') {
+        jsonResponse(req, res, 400, { error: 'PDF uploads must use application/pdf' });
+        return true;
+      }
+    }
+
+    const maxUploadBytes = isPdfUpload ? maxPdfUploadBytes : REQUEST_BODY_LIMIT_BYTES;
+    const content = await readBinaryRequestBody(req, maxUploadBytes);
+    if (isPdfUpload && !content.subarray(0, PDF_SIGNATURE.length).equals(PDF_SIGNATURE)) {
+      jsonResponse(req, res, 400, { error: 'Invalid PDF file' });
+      return true;
+    }
+
+    const result = await workspaceMutationCoordinator.createFile({
+      content,
+      path: filePath,
+      requestId: readRequestId(req),
+    });
+    if (!result.ok) {
+      jsonResponse(req, res, result.error === 'File already exists' ? 409 : 400, { error: result.error });
+      return true;
+    }
+
+    jsonResponse(req, res, 201, { ok: true, path: filePath });
+  } catch (error) {
+    handleApiError(req, res, error, '[api] Failed to upload file:', 'Failed to upload file');
+  }
+  return true;
+}
+
 async function handleCreateFile({ workspaceMutationCoordinator }, req, res) {
   try {
     const body = await parseJsonBody(req);
@@ -280,6 +335,7 @@ const ROUTE_TABLE = [
   { method: 'POST', path: '/api/export/docx', handler: handleExportDocx },
   { method: 'PUT', path: '/api/file', handler: handleWriteFile },
   { method: 'POST', path: '/api/attachments', handler: handleUploadAttachment },
+  { method: 'POST', path: '/api/file/upload', handler: handleUploadFile },
   { method: 'POST', path: '/api/file', handler: handleCreateFile },
   { method: 'DELETE', path: '/api/file', handler: handleDeleteFile },
   { method: 'PATCH', path: '/api/file', handler: handleRenameFile },
@@ -289,11 +345,17 @@ const ROUTE_TABLE = [
 ];
 
 export function createVaultApiCommandHandler({
+  maxPdfUploadBytes = REQUEST_BODY_LIMIT_BYTES,
   renderDocx = null,
   vaultFileStore,
   workspaceMutationCoordinator = null,
 }) {
-  const context = { renderDocx, vaultFileStore, workspaceMutationCoordinator };
+  const context = {
+    maxPdfUploadBytes,
+    renderDocx,
+    vaultFileStore,
+    workspaceMutationCoordinator,
+  };
 
   return async function handleVaultApiCommand(req, res, requestUrl) {
     for (const route of ROUTE_TABLE) {