collabmd 0.1.18

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

@@ -0,0 +1,62 @@
+import { getRequestErrorStatusCode } from './http-errors.js';
+import { jsonResponse } from './http-response.js';
+
+function resolveDiffScope(requestUrl) {
+  const scope = String(requestUrl.searchParams.get('scope') || '').trim().toLowerCase();
+  if (scope === 'staged' || scope === 'all' || scope === 'working-tree') {
+    return scope;
+  }
+
+  if (requestUrl.searchParams.get('staged') === 'true') {
+    return 'staged';
+  }
+
+  return 'working-tree';
+}
+
+function isTruthyParam(value) {
+  return value === '1' || value === 'true';
+}
+
+function handleGitError(req, res, error, message, fallback) {
+  const statusCode = getRequestErrorStatusCode(error);
+  if (statusCode) {
+    jsonResponse(req, res, statusCode, { error: error.message });
+    return true;
+  }
+
+  console.error(message, error.message);
+  jsonResponse(req, res, 500, { error: fallback });
+  return true;
+}
+
+export function createGitApiQueryHandler({ gitService }) {
+  return async function handleGitApiQuery(req, res, requestUrl) {
+    if (requestUrl.pathname === '/api/git/status' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, await gitService.getStatus({
+          force: isTruthyParam(requestUrl.searchParams.get('force')),
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read git status:', 'Failed to read git status');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/diff' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, await gitService.getDiff({
+          allowLargePatch: isTruthyParam(requestUrl.searchParams.get('allowLargePatch')),
+          metaOnly: isTruthyParam(requestUrl.searchParams.get('metaOnly')),
+          path: requestUrl.searchParams.get('path'),
+          scope: resolveDiffScope(requestUrl),
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read git diff:', 'Failed to read git diff');
+      }
+      return true;
+    }
+
+    return false;
+  };
+}

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

@@ -0,0 +1,43 @@
+import { getRequestErrorStatusCode } from './http-errors.js';
+import { jsonResponse } from './http-response.js';
+import { parseJsonBody } from './request-body.js';
+
+export function createPlantUmlApiHandler({ plantUmlRenderer = null }) {
+  return async function handlePlantUmlApi(req, res, requestUrl) {
+    if (!(requestUrl.pathname === '/api/plantuml/render' && req.method === 'POST')) {
+      return false;
+    }
+
+    try {
+      const body = await parseJsonBody(req);
+      if (typeof body.source !== 'string') {
+        jsonResponse(req, res, 400, { error: 'Missing PlantUML source' });
+        return true;
+      }
+
+      if (!plantUmlRenderer) {
+        jsonResponse(req, res, 503, { error: 'PlantUML renderer is not configured' });
+        return true;
+      }
+
+      jsonResponse(req, res, 200, {
+        ok: true,
+        svg: await plantUmlRenderer.renderSvg(body.source),
+      });
+    } catch (error) {
+      const handledStatusCode = getRequestErrorStatusCode(error);
+      if (handledStatusCode) {
+        jsonResponse(req, res, handledStatusCode, { error: error.message });
+        return true;
+      }
+
+      const statusCode = Number.isInteger(error?.statusCode) ? error.statusCode : 502;
+      console.error('[api] Failed to render PlantUML:', error.message);
+      jsonResponse(req, res, statusCode, {
+        error: error instanceof Error ? error.message : 'Failed to render PlantUML',
+      });
+    }
+
+    return true;
+  };
+}

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

@@ -0,0 +1,138 @@
+import { createAuthApiHandler } from './create-auth-api-handler.js';
+import { createGitApiHandler } from './create-git-api-handler.js';
+import { createEsmProxyHandler } from './create-esm-proxy-handler.js';
+import { createStaticHandler } from './create-static-handler.js';
+import { createVaultApiHandler } from './create-vault-api-handler.js';
+import {
+  applyCorsHeaders,
+  jsonResponse,
+  SECURITY_HEADERS,
+  setHeaders,
+  isSameOriginWriteRequest,
+  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,
+  vaultFileStore,
+  backlinkIndex,
+  roomRegistry = null,
+  plantUmlRenderer = null,
+  gitService = null,
+) {
+  const handleEsmProxy = createEsmProxyHandler();
+  const handleStaticRequest = createStaticHandler(config, authService);
+  const handleAuthApi = createAuthApiHandler({ authService });
+  const handleGitApi = createGitApiHandler({
+    backlinkIndex,
+    gitService,
+    roomRegistry,
+    vaultFileStore,
+  });
+  const handleVaultApi = createVaultApiHandler({
+    backlinkIndex,
+    plantUmlRenderer,
+    roomRegistry,
+    vaultFileStore,
+  });
+
+  return async function handleRequest(req, res) {
+    const originalRequestUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+    if (
+      config.basePath
+      && (req.method === 'GET' || req.method === 'HEAD')
+      && originalRequestUrl.pathname === config.basePath
+    ) {
+      const location = `${config.basePath}/${originalRequestUrl.search}`;
+      res.writeHead(308, { Location: location });
+      res.end();
+      return;
+    }
+
+    const requestUrl = createRequestUrlWithPathname(
+      originalRequestUrl,
+      stripBasePath(originalRequestUrl.pathname, config.basePath),
+    );
+    const isSameOriginWrite = isSameOriginWriteRequest(req, requestUrl);
+
+    setHeaders(res, SECURITY_HEADERS);
+
+    if (req.method === 'OPTIONS') {
+      const requestedMethod = String(req.headers['access-control-request-method'] || '').toUpperCase();
+      const preflightTargetsWrite = WRITE_METHODS.has(requestedMethod);
+      if (preflightTargetsWrite && !isSameOriginWrite) {
+        jsonResponse(req, res, 403, { error: 'Cross-origin write requests are not allowed' });
+        return;
+      }
+
+      if (isSameOriginWrite) {
+        applyCorsHeaders(res, req.headers.origin);
+      }
+
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (WRITE_METHODS.has(req.method) && !isSameOriginWrite) {
+      jsonResponse(req, res, 403, { error: 'Cross-origin write requests are not allowed' });
+      return;
+    }
+
+    if (config.nodeEnv === 'test' && requestUrl.pathname === '/api/test/reset-state' && req.method === 'POST') {
+      await roomRegistry?.reset?.();
+      await backlinkIndex?.build?.();
+      jsonResponse(req, res, 200, { ok: true });
+      return;
+    }
+
+    if (await handleAuthApi(req, res, requestUrl)) {
+      return;
+    }
+
+    if (await handleEsmProxy(req, res, requestUrl)) {
+      return;
+    }
+
+    if (requestUrl.pathname.startsWith('/api/')) {
+      const authorization = authService.authorizeApiRequest(req);
+      if (!authorization.ok) {
+        jsonResponse(req, res, authorization.statusCode, authorization.body);
+        return;
+      }
+    }
+
+    if (await handleVaultApi(req, res, requestUrl)) {
+      return;
+    }
+
+    if (await handleGitApi(req, res, requestUrl)) {
+      return;
+    }
+
+    await handleStaticRequest(req, res, requestUrl);
+  };
+}

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

@@ -0,0 +1,167 @@
+import { readFile } from 'fs/promises';
+import { extname, normalize, resolve } from 'path';
+
+import { sendResponse, textResponse } from './http-response.js';
+
+const CONTENT_TYPES = {
+  '.css': 'text/css; charset=utf-8',
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.svg': 'image/svg+xml',
+};
+
+function isVersionedAssetPath(pathname = '') {
+  return /-[A-Z0-9]{8,}\.(?:css|js|woff2?|ttf|svg)$/iu.test(pathname);
+}
+
+function getStaticCacheControl(pathname = '', extension = '') {
+  if (pathname === '/' || pathname.endsWith('.html')) {
+    return 'no-store';
+  }
+
+  if (pathname === '/app-config.js') {
+    return 'no-store';
+  }
+
+  if (pathname.startsWith('/assets/')) {
+    if (
+      pathname.startsWith('/assets/vendor/modules/chunks/')
+      || pathname.startsWith('/assets/js/chunks/')
+      || isVersionedAssetPath(pathname)
+    ) {
+      return 'public, max-age=31536000, immutable';
+    }
+
+    if (extension === '.css' || extension === '.js') {
+      return 'public, max-age=0, must-revalidate';
+    }
+
+    return 'public, max-age=300, stale-while-revalidate=3600';
+  }
+
+  return 'public, max-age=300';
+}
+
+function buildRuntimeConfig({
+  auth,
+  basePath,
+  gitEnabled,
+  nodeEnv,
+  publicWsBaseUrl,
+  wsBasePath,
+}) {
+  return `window.__COLLABMD_CONFIG__ = ${JSON.stringify({
+    auth,
+    basePath,
+    environment: nodeEnv,
+    gitEnabled,
+    publicWsBaseUrl,
+    wsBasePath,
+  })};\n`;
+}
+
+function createStaticFileReader({ cacheEnabled = true } = {}) {
+  const cache = new Map();
+
+  return async function readStaticFile(filePath) {
+    if (!cacheEnabled) {
+      return readFile(filePath);
+    }
+
+    if (!cache.has(filePath)) {
+      cache.set(filePath, readFile(filePath).catch((error) => {
+        cache.delete(filePath);
+        throw error;
+      }));
+    }
+
+    return cache.get(filePath);
+  };
+}
+
+function resolvePublicFile(publicDir, pathname) {
+  const requestedPath = pathname === '/' ? '/index.html' : pathname;
+  const safePath = normalize(requestedPath).replace(/^(\.\.[/\\])+/, '');
+  const absolutePath = resolve(publicDir, `.${safePath}`);
+  const publicRoot = publicDir.endsWith('/') ? publicDir : `${publicDir}/`;
+
+  if (!absolutePath.startsWith(publicRoot) && absolutePath !== resolve(publicDir, 'index.html')) {
+    return null;
+  }
+
+  return absolutePath;
+}
+
+export function createStaticHandler(config, authService = null) {
+  const readStaticFile = createStaticFileReader({
+    cacheEnabled: config.nodeEnv === 'production',
+  });
+
+  return async function handleStaticRequest(req, res, requestUrl) {
+    if (requestUrl.pathname === '/health') {
+      textResponse(req, res, 200, 'ok');
+      return true;
+    }
+
+    if (requestUrl.pathname === '/app-config.js') {
+      const body = buildRuntimeConfig({
+        ...config,
+        auth: authService?.getClientConfig?.() ?? {
+          enabled: false,
+          implemented: true,
+          requiresLogin: false,
+          strategy: 'none',
+        },
+      });
+      sendResponse(req, res, {
+        body,
+        headers: {
+          'Cache-Control': 'no-store',
+          'Content-Type': 'text/javascript; charset=utf-8',
+        },
+        statusCode: 200,
+      });
+      return true;
+    }
+
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      textResponse(req, res, 405, 'Method Not Allowed');
+      return true;
+    }
+
+    let filePath = resolvePublicFile(config.publicDir, requestUrl.pathname);
+    if (!filePath && !extname(requestUrl.pathname)) {
+      filePath = resolve(config.publicDir, 'index.html');
+    }
+
+    if (!filePath) {
+      textResponse(req, res, 404, 'Not Found');
+      return true;
+    }
+
+    try {
+      const file = await readStaticFile(filePath);
+      const extension = extname(filePath);
+
+      sendResponse(req, res, {
+        body: file,
+        headers: {
+          'Cache-Control': getStaticCacheControl(requestUrl.pathname, extension),
+          'Content-Type': CONTENT_TYPES[extension] || 'application/octet-stream',
+        },
+        statusCode: 200,
+      });
+    } catch (error) {
+      if (error?.code === 'ENOENT') {
+        textResponse(req, res, 404, 'Not Found');
+        return true;
+      }
+
+      console.error(`[http] Failed to serve "${requestUrl.pathname}":`, error.message);
+      textResponse(req, res, 500, 'Internal Server Error');
+    }
+
+    return true;
+  };
+}

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

@@ -0,0 +1,161 @@
+import {
+  isExcalidrawFilePath,
+  isMermaidFilePath,
+  isPlantUmlFilePath,
+} from '../../../domain/file-kind.js';
+import { getRequestErrorStatusCode } from './http-errors.js';
+import { jsonResponse } from './http-response.js';
+import { parseJsonBody } from './request-body.js';
+
+function selectWriteOperation(vaultFileStore, filePath, content) {
+  if (isExcalidrawFilePath(filePath)) {
+    return vaultFileStore.writeExcalidrawFile(filePath, content);
+  }
+
+  if (isMermaidFilePath(filePath)) {
+    return vaultFileStore.writeMermaidFile(filePath, content);
+  }
+
+  if (isPlantUmlFilePath(filePath)) {
+    return vaultFileStore.writePlantUmlFile(filePath, content);
+  }
+
+  return vaultFileStore.writeMarkdownFile(filePath, content);
+}
+
+function handleVaultError(req, res, error, logMessage, fallbackMessage) {
+  const statusCode = getRequestErrorStatusCode(error);
+  if (statusCode) {
+    jsonResponse(req, res, statusCode, { error: error.message });
+    return true;
+  }
+
+  console.error(logMessage, error.message);
+  jsonResponse(req, res, 500, { error: fallbackMessage });
+  return true;
+}
+
+export function createVaultApiCommandHandler({
+  backlinkIndex,
+  roomRegistry = null,
+  vaultFileStore,
+}) {
+  return async function handleVaultApiCommand(req, res, requestUrl) {
+    if (requestUrl.pathname === '/api/file' && req.method === 'PUT') {
+      try {
+        const body = await parseJsonBody(req);
+        if (!body.path || typeof body.content !== 'string') {
+          jsonResponse(req, res, 400, { error: 'Missing path or content' });
+          return true;
+        }
+
+        const result = await selectWriteOperation(vaultFileStore, body.path, body.content);
+        if (!result.ok) {
+          jsonResponse(req, res, 400, { error: result.error });
+          return true;
+        }
+
+        jsonResponse(req, res, 200, { ok: true });
+      } catch (error) {
+        handleVaultError(req, res, error, '[api] Failed to write file:', 'Failed to write file');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/file' && req.method === 'POST') {
+      try {
+        const body = await parseJsonBody(req);
+        if (!body.path) {
+          jsonResponse(req, res, 400, { error: 'Missing path' });
+          return true;
+        }
+
+        const result = await vaultFileStore.createFile(body.path, body.content || '');
+        if (!result.ok) {
+          jsonResponse(req, res, 409, { error: result.error });
+          return true;
+        }
+
+        backlinkIndex?.onFileCreated(body.path, body.content || '');
+        jsonResponse(req, res, 201, { ok: true, path: body.path });
+      } catch (error) {
+        handleVaultError(req, res, error, '[api] Failed to create file:', 'Failed to create file');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/file' && req.method === 'DELETE') {
+      const filePath = requestUrl.searchParams.get('path');
+      if (!filePath) {
+        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+        return true;
+      }
+
+      const activeRoom = roomRegistry?.get(filePath);
+      try {
+        activeRoom?.markDeleted?.();
+        const result = await vaultFileStore.deleteFile(filePath);
+        if (!result.ok) {
+          activeRoom?.unmarkDeleted?.();
+          jsonResponse(req, res, 400, { error: result.error });
+          return true;
+        }
+
+        roomRegistry?.delete?.(filePath);
+        backlinkIndex?.onFileDeleted(filePath);
+        jsonResponse(req, res, 200, { ok: true });
+      } catch (error) {
+        activeRoom?.unmarkDeleted?.();
+        console.error('[api] Failed to delete file:', error.message);
+        jsonResponse(req, res, 500, { error: 'Failed to delete file' });
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/file' && req.method === 'PATCH') {
+      try {
+        const body = await parseJsonBody(req);
+        if (!body.oldPath || !body.newPath) {
+          jsonResponse(req, res, 400, { error: 'Missing oldPath or newPath' });
+          return true;
+        }
+
+        const result = await vaultFileStore.renameFile(body.oldPath, body.newPath);
+        if (!result.ok) {
+          jsonResponse(req, res, 400, { error: result.error });
+          return true;
+        }
+
+        roomRegistry?.rename(body.oldPath, body.newPath);
+        backlinkIndex?.onFileRenamed(body.oldPath, 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');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/directory' && req.method === 'POST') {
+      try {
+        const body = await parseJsonBody(req);
+        if (!body.path) {
+          jsonResponse(req, res, 400, { error: 'Missing path' });
+          return true;
+        }
+
+        const result = await vaultFileStore.createDirectory(body.path);
+        if (!result.ok) {
+          jsonResponse(req, res, 400, { error: result.error });
+          return true;
+        }
+
+        jsonResponse(req, res, 201, { ok: true });
+      } catch (error) {
+        handleVaultError(req, res, error, '[api] Failed to create directory:', 'Failed to create directory');
+      }
+      return true;
+    }
+
+    return false;
+  };
+}

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

@@ -0,0 +1,43 @@
+import { createPlantUmlApiHandler } from './create-plantuml-api-handler.js';
+import { createVaultApiCommandHandler } from './create-vault-api-command-handler.js';
+import { createVaultApiQueryHandler } from './create-vault-api-query-handler.js';
+
+export function createVaultApiHandler({
+  backlinkIndex,
+  plantUmlRenderer = null,
+  roomRegistry = null,
+  vaultFileStore,
+}) {
+  const handleVaultApiQuery = createVaultApiQueryHandler({
+    backlinkIndex,
+    vaultFileStore,
+  });
+  const handleVaultApiCommand = createVaultApiCommandHandler({
+    backlinkIndex,
+    roomRegistry,
+    vaultFileStore,
+  });
+  const handlePlantUmlApi = createPlantUmlApiHandler({
+    plantUmlRenderer,
+  });
+
+  return async function handleVaultApi(req, res, requestUrl) {
+    if (!requestUrl.pathname.startsWith('/api/')) {
+      return false;
+    }
+
+    if (await handleVaultApiQuery(req, res, requestUrl)) {
+      return true;
+    }
+
+    if (await handleVaultApiCommand(req, res, requestUrl)) {
+      return true;
+    }
+
+    if (await handlePlantUmlApi(req, res, requestUrl)) {
+      return true;
+    }
+
+    return false;
+  };
+}

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

@@ -0,0 +1,82 @@
+import {
+  isExcalidrawFilePath,
+  isMermaidFilePath,
+  isPlantUmlFilePath,
+} from '../../../domain/file-kind.js';
+import { jsonResponse } from './http-response.js';
+
+function selectReadOperation(vaultFileStore, filePath) {
+  if (isExcalidrawFilePath(filePath)) {
+    return vaultFileStore.readExcalidrawFile(filePath);
+  }
+
+  if (isMermaidFilePath(filePath)) {
+    return vaultFileStore.readMermaidFile(filePath);
+  }
+
+  if (isPlantUmlFilePath(filePath)) {
+    return vaultFileStore.readPlantUmlFile(filePath);
+  }
+
+  return vaultFileStore.readMarkdownFile(filePath);
+}
+
+export function createVaultApiQueryHandler({
+  backlinkIndex,
+  vaultFileStore,
+}) {
+  return async function handleVaultApiQuery(req, res, requestUrl) {
+    if (requestUrl.pathname === '/api/files' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, { tree: await vaultFileStore.tree() });
+      } catch (error) {
+        console.error('[api] Failed to read file tree:', error.message);
+        jsonResponse(req, res, 500, { error: 'Failed to read file tree' });
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/file' && req.method === 'GET') {
+      const filePath = requestUrl.searchParams.get('path');
+      if (!filePath) {
+        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+        return true;
+      }
+
+      try {
+        const content = await selectReadOperation(vaultFileStore, filePath);
+        if (content === null) {
+          jsonResponse(req, res, 404, { error: 'File not found' });
+          return true;
+        }
+
+        jsonResponse(req, res, 200, { path: filePath, content });
+      } catch (error) {
+        console.error('[api] Failed to read file:', error.message);
+        jsonResponse(req, res, 500, { error: 'Failed to read file' });
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/backlinks' && req.method === 'GET') {
+      const filePath = requestUrl.searchParams.get('file');
+      if (!filePath) {
+        jsonResponse(req, res, 400, { error: 'Missing file parameter' });
+        return true;
+      }
+
+      try {
+        jsonResponse(req, res, 200, {
+          backlinks: backlinkIndex ? await backlinkIndex.getBacklinks(filePath) : [],
+          file: filePath,
+        });
+      } catch (error) {
+        console.error('[api] Failed to get backlinks:', error.message);
+        jsonResponse(req, res, 500, { error: 'Failed to get backlinks' });
+      }
+      return true;
+    }
+
+    return false;
+  };
+}