collabmd 0.1.34 → 0.1.36

package/src/server/domain/markdown-reference-extractor.js

@@ -0,0 +1,233 @@
+import {
+  getVaultFileExtension,
+  isImageAttachmentFilePath,
+  isMarkdownFilePath,
+} from '../../domain/file-kind.js';
+import { resolveWikiTargetWithIndex } from '../../domain/wiki-link-resolver.js';
+
+const INTERNAL_LINK_RE = /(!)?\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|[^\]]+)?\]\]/g;
+const MARKDOWN_IMAGE_OPEN_RE = /!\[[^\]\n]*\]\(/g;
+
+function isAbsoluteOrExternalUrl(source = '') {
+  const normalized = String(source ?? '').trim();
+  return (
+    !normalized
+    || normalized.startsWith('data:')
+    || normalized.startsWith('blob:')
+    || normalized.startsWith('#')
+    || normalized.startsWith('//')
+    || /^[a-zA-Z][a-zA-Z\d+.-]*:/u.test(normalized)
+    || normalized.startsWith('/')
+  );
+}
+
+function normalizePathSegments(pathValue = '') {
+  return String(pathValue ?? '')
+    .replace(/\\/g, '/')
+    .split('/')
+    .filter(Boolean);
+}
+
+function resolveVaultRelativePath(fromFilePath = '', relativePath = '') {
+  const sourceSegments = normalizePathSegments(fromFilePath);
+  const targetSegments = String(relativePath ?? '')
+    .split('/')
+    .map((segment) => {
+      try {
+        return decodeURIComponent(segment);
+      } catch {
+        return segment;
+      }
+    });
+
+  if (targetSegments.length === 0) {
+    return '';
+  }
+
+  sourceSegments.pop();
+  const resolvedSegments = [...sourceSegments];
+
+  for (const rawSegment of targetSegments) {
+    const segment = String(rawSegment ?? '').trim();
+    if (!segment || segment === '.') {
+      continue;
+    }
+
+    if (segment === '..') {
+      if (resolvedSegments.length === 0) {
+        return '';
+      }
+      resolvedSegments.pop();
+      continue;
+    }
+
+    resolvedSegments.push(segment);
+  }
+
+  return resolvedSegments.join('/');
+}
+
+function parseMarkdownImageDestination(sourceText = '') {
+  const text = String(sourceText ?? '');
+  let index = 0;
+  while (/\s/u.test(text[index] ?? '')) {
+    index += 1;
+  }
+
+  if (text[index] === '<') {
+    const endIndex = text.indexOf('>', index + 1);
+    if (endIndex < 0 || text.indexOf(')', endIndex + 1) < 0) {
+      return '';
+    }
+    return text.slice(index + 1, endIndex).trim();
+  }
+
+  const startIndex = index;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === ')' || /\s/u.test(char)) {
+      break;
+    }
+    index += 1;
+  }
+
+  if (startIndex === index || text.indexOf(')', index) < 0) {
+    return '';
+  }
+
+  return text.slice(startIndex, index).trim();
+}
+
+function resolveMarkdownImageTargetPath(sourceFilePath = '', imageSource = '') {
+  const source = String(imageSource ?? '').trim();
+  if (isAbsoluteOrExternalUrl(source)) {
+    return '';
+  }
+
+  const resolvedPath = resolveVaultRelativePath(sourceFilePath, source);
+  return isImageAttachmentFilePath(resolvedPath) ? resolvedPath : '';
+}
+
+function resolveAliasedTargetPath(targetPath = '', wikiTargetIndex = null, targetPathAliases = new Map()) {
+  const candidates = [
+    String(targetPath ?? '').trim(),
+    normalizeReferenceTargetKey(targetPath),
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    const aliasedPath = targetPathAliases?.get?.(candidate);
+    if (aliasedPath && wikiTargetIndex?.exactPaths?.has?.(aliasedPath)) {
+      return aliasedPath;
+    }
+  }
+
+  return null;
+}
+
+export function normalizeReferenceTargetKey(target = '') {
+  const normalizedTarget = String(target ?? '').trim();
+  if (!normalizedTarget) {
+    return '';
+  }
+
+  return getVaultFileExtension(normalizedTarget)
+    ? normalizedTarget
+    : `${normalizedTarget}.md`;
+}
+
+export function collectReferenceTargetKeysForFilePath(filePath = '') {
+  const normalizedPath = String(filePath ?? '').trim();
+  if (!normalizedPath) {
+    return [];
+  }
+
+  const segments = normalizedPath.split('/').filter(Boolean);
+  const keys = [];
+  for (let index = 0; index < segments.length; index += 1) {
+    keys.push(segments.slice(index).join('/'));
+  }
+
+  if (isMarkdownFilePath(normalizedPath)) {
+    const rawSegments = normalizedPath.replace(/\.md$/i, '').split('/').filter(Boolean);
+    for (let index = 0; index < rawSegments.length; index += 1) {
+      keys.push(rawSegments.slice(index).join('/'));
+    }
+  }
+
+  return [...new Set(keys)];
+}
+
+export function createReferenceTargetAliasMap(renamedEntries = []) {
+  const aliases = new Map();
+
+  renamedEntries.forEach((entry) => {
+    const oldPath = Array.isArray(entry) ? entry[0] : entry?.oldPath;
+    const newPath = Array.isArray(entry) ? entry[1] : entry?.newPath;
+    if (!oldPath || !newPath) {
+      return;
+    }
+
+    aliases.set(oldPath, newPath);
+    collectReferenceTargetKeysForFilePath(oldPath).forEach((targetKey) => {
+      aliases.set(targetKey, newPath);
+    });
+  });
+
+  return aliases;
+}
+
+export function collectMarkdownReferences(markdownText = '', {
+  sourceFilePath = '',
+  targetPathAliases = new Map(),
+  wikiTargetIndex = null,
+} = {}) {
+  const references = [];
+  const lines = String(markdownText ?? '').split('\n');
+
+  for (const line of lines) {
+    const context = line.trim();
+
+    INTERNAL_LINK_RE.lastIndex = 0;
+    let linkMatch;
+    while ((linkMatch = INTERNAL_LINK_RE.exec(line)) !== null) {
+      const rawTarget = String(linkMatch[2] ?? '').trim();
+      if (!rawTarget) {
+        continue;
+      }
+
+      const resolvedPath = resolveWikiTargetWithIndex(rawTarget, wikiTargetIndex)
+        || resolveAliasedTargetPath(rawTarget, wikiTargetIndex, targetPathAliases);
+      references.push({
+        context,
+        isEmbed: Boolean(linkMatch[1]),
+        rawTarget,
+        rawTargetKey: normalizeReferenceTargetKey(rawTarget),
+        resolvedPath,
+        targetPath: resolvedPath || rawTarget,
+      });
+    }
+
+    MARKDOWN_IMAGE_OPEN_RE.lastIndex = 0;
+    while (MARKDOWN_IMAGE_OPEN_RE.exec(line) !== null) {
+      const rawTarget = parseMarkdownImageDestination(line.slice(MARKDOWN_IMAGE_OPEN_RE.lastIndex));
+      const targetPath = resolveMarkdownImageTargetPath(sourceFilePath, rawTarget);
+      if (!targetPath) {
+        continue;
+      }
+
+      const resolvedPath = wikiTargetIndex?.exactPaths?.has?.(targetPath)
+        ? targetPath
+        : resolveAliasedTargetPath(targetPath, wikiTargetIndex, targetPathAliases);
+      references.push({
+        context,
+        isEmbed: true,
+        rawTarget,
+        rawTargetKey: normalizeReferenceTargetKey(targetPath),
+        resolvedPath,
+        targetPath,
+      });
+    }
+  }
+
+  return references;
+}

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

@@ -63,6 +63,7 @@ export function createRequestHandler(
   const handleVaultApi = createVaultApiHandler({
     baseQueryService,
     backlinkIndex,
+    config,
     docxExporter,
     plantUmlRenderer,
     roomRegistry,

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

@@ -5,6 +5,7 @@ import { createVaultApiQueryHandler } from './create-vault-api-query-handler.js'
 export function createVaultApiHandler({
   baseQueryService = null,
   backlinkIndex,
+  config = {},
   docxExporter = null,
   plantUmlRenderer = null,
   roomRegistry = null,
@@ -14,6 +15,7 @@ export function createVaultApiHandler({
   const handleVaultApiQuery = createVaultApiQueryHandler({
     baseQueryService,
     backlinkIndex,
+    config,
     vaultFileStore,
     workspaceMutationCoordinator,
   });

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

@@ -1,5 +1,7 @@
 import archiver from 'archiver';
+import { readdir } from 'node:fs/promises';
 import { basename } from 'node:path';
+import { join } from 'node:path';
 
 import {
   isBaseFilePath,
@@ -9,11 +11,14 @@ import {
   isMermaidFilePath,
   isPlantUmlFilePath,
 } 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';
 
 const SVG_MIME_TYPE = 'image/svg+xml';
 const SVG_ATTACHMENT_CSP = "default-src 'none'; img-src 'self' data: blob:; style-src 'unsafe-inline'; sandbox";
+const DEFAULT_MAX_ARCHIVE_ENTRIES = 10_000;
+const DEFAULT_MAX_DOWNLOAD_FILE_BYTES = 268_435_456;
 
 function encodeContentDispositionFilename(fileName) {
   return encodeURIComponent(String(fileName ?? ''))
@@ -78,7 +83,8 @@ function selectReadOperation(vaultFileStore, filePath) {
 }
 
 async function streamDirectoryArchive(req, res, {
-  entries = [],
+  maxEntries = 10_000,
+  rootAbsolutePath = '',
   rootName = 'archive',
 } = {}) {
   const archive = archiver('zip', {
@@ -99,22 +105,62 @@ async function streamDirectoryArchive(req, res, {
     stream: archive,
   });
 
-  for (const entry of entries) {
-    if (entry.type === 'directory') {
-      const directoryName = entry.path
-        ? `${rootName}/${entry.path}/`
-        : `${rootName}/`;
-      archive.append('', { name: directoryName });
-      continue;
+  let entryCount = 0;
+  const appendEntry = () => {
+    entryCount += 1;
+    if (entryCount > maxEntries) {
+      throw new Error(`Directory archive exceeds ${maxEntries} entries`);
     }
+  };
 
-    archive.file(entry.absolutePath, {
-      name: `${rootName}/${entry.path}`,
-    });
-  }
+  try {
+    const visitDirectory = async (directoryAbsolutePath, relativeDirectoryPath = '') => {
+      const dirEntries = (await readdir(directoryAbsolutePath, { withFileTypes: true }))
+        .filter((entry) => !isIgnoredVaultEntry(entry.name))
+        .sort((left, right) => {
+          if (left.isDirectory() && !right.isDirectory()) return -1;
+          if (!left.isDirectory() && right.isDirectory()) return 1;
+          return left.name.localeCompare(right.name, undefined, { sensitivity: 'base' });
+        });
+
+      if (dirEntries.length === 0) {
+        appendEntry();
+        archive.append('', {
+          name: relativeDirectoryPath ? `${rootName}/${relativeDirectoryPath}/` : `${rootName}/`,
+        });
+        return;
+      }
 
-  await archive.finalize();
-  await responsePromise;
+      for (const entry of dirEntries) {
+        const childAbsolutePath = join(directoryAbsolutePath, entry.name);
+        const childRelativePath = relativeDirectoryPath
+          ? `${relativeDirectoryPath}/${entry.name}`
+          : entry.name;
+
+        if (entry.isDirectory()) {
+          await visitDirectory(childAbsolutePath, childRelativePath);
+          continue;
+        }
+
+        if (!entry.isFile()) {
+          continue;
+        }
+
+        appendEntry();
+        archive.file(childAbsolutePath, {
+          name: `${rootName}/${childRelativePath}`,
+        });
+      }
+    };
+
+    await visitDirectory(rootAbsolutePath);
+    await archive.finalize();
+    await responsePromise;
+  } catch (error) {
+    archive.destroy(error);
+    await responsePromise.catch(() => {});
+    throw error;
+  }
 }
 
 // --- Route handlers ---
@@ -257,7 +303,7 @@ async function handleFileRead(req, res, requestUrl, { vaultFileStore }) {
   }
 }
 
-async function handleFileDownload(req, res, requestUrl, { vaultFileStore }) {
+async function handleFileDownload(req, res, requestUrl, { config, vaultFileStore }) {
   const filePath = requestUrl.searchParams.get('path');
   if (!filePath) {
     jsonResponse(req, res, 400, { error: 'Missing path parameter' });
@@ -265,19 +311,25 @@ async function handleFileDownload(req, res, requestUrl, { vaultFileStore }) {
   }
 
   try {
-    const download = await vaultFileStore.readDownloadFile(filePath);
+    const download = await vaultFileStore.openDownloadFileStream(filePath, {
+      maxBytes: config.maxDownloadFileBytes ?? DEFAULT_MAX_DOWNLOAD_FILE_BYTES,
+    });
     if (!download) {
       jsonResponse(req, res, 404, { error: 'File not found' });
       return;
     }
+    if (download.error) {
+      jsonResponse(req, res, download.statusCode || 400, { error: download.error });
+      return;
+    }
 
-    sendResponse(req, res, {
-      body: download.content,
+    await sendStreamResponse(req, res, {
       headers: createDownloadHeaders(
         basename(String(download.path ?? 'download')),
         download.mimeType || 'application/octet-stream',
       ),
       statusCode: 200,
+      stream: download.stream,
     });
   } catch (error) {
     console.error('[api] Failed to download file:', error.message);
@@ -285,7 +337,7 @@ async function handleFileDownload(req, res, requestUrl, { vaultFileStore }) {
   }
 }
 
-async function handleDirectoryDownload(req, res, requestUrl, { vaultFileStore }) {
+async function handleDirectoryDownload(req, res, requestUrl, { config, vaultFileStore }) {
   const directoryPath = requestUrl.searchParams.get('path');
   if (!directoryPath) {
     jsonResponse(req, res, 400, { error: 'Missing path parameter' });
@@ -293,14 +345,23 @@ async function handleDirectoryDownload(req, res, requestUrl, { vaultFileStore })
   }
 
   try {
-    const result = await vaultFileStore.listDirectoryEntriesForDownload(directoryPath);
+    const result = await vaultFileStore.resolveDirectoryDownloadRoot(directoryPath);
     if (!result.ok) {
       jsonResponse(req, res, result.error === 'Directory not found' ? 404 : 400, { error: result.error });
       return;
     }
+    const maxArchiveEntries = config.maxArchiveEntries ?? DEFAULT_MAX_ARCHIVE_ENTRIES;
+    const entryCount = await vaultFileStore.countDirectoryDownloadEntries(result.absolute, {
+      maxEntries: maxArchiveEntries,
+    });
+    if (!entryCount.withinLimit) {
+      jsonResponse(req, res, 413, { error: `Directory archive exceeds ${maxArchiveEntries} entries` });
+      return;
+    }
 
     await streamDirectoryArchive(req, res, {
-      entries: result.entries,
+      maxEntries: maxArchiveEntries,
+      rootAbsolutePath: result.absolute,
       rootName: result.rootName || 'archive',
     });
   } catch (error) {
@@ -313,7 +374,7 @@ async function handleDirectoryDownload(req, res, requestUrl, { vaultFileStore })
   }
 }
 
-async function handleAttachmentRead(req, res, requestUrl, { vaultFileStore }) {
+async function handleAttachmentRead(req, res, requestUrl, { config, vaultFileStore }) {
   const filePath = requestUrl.searchParams.get('path');
   if (!filePath) {
     jsonResponse(req, res, 400, { error: 'Missing path parameter' });
@@ -326,16 +387,22 @@ async function handleAttachmentRead(req, res, requestUrl, { vaultFileStore }) {
   }
 
   try {
-    const attachment = await vaultFileStore.readImageAttachmentFile(filePath);
+    const attachment = await vaultFileStore.openImageAttachmentReadStream(filePath, {
+      maxBytes: config.maxDownloadFileBytes ?? DEFAULT_MAX_DOWNLOAD_FILE_BYTES,
+    });
     if (!attachment) {
       jsonResponse(req, res, 404, { error: 'Attachment not found' });
       return;
     }
+    if (attachment.error) {
+      jsonResponse(req, res, attachment.statusCode || 400, { error: attachment.error });
+      return;
+    }
 
-    sendResponse(req, res, {
-      body: attachment.content,
+    await sendStreamResponse(req, res, {
       headers: createAttachmentHeaders(attachment),
       statusCode: 200,
+      stream: attachment.stream,
     });
   } catch (error) {
     console.error('[api] Failed to read attachment:', error.message);
@@ -384,10 +451,17 @@ function createRouteTable(context) {
 export function createVaultApiQueryHandler({
   baseQueryService = null,
   backlinkIndex,
+  config = {},
   vaultFileStore,
   workspaceMutationCoordinator = null,
 }) {
-  const context = { baseQueryService, backlinkIndex, vaultFileStore, workspaceMutationCoordinator };
+  const context = {
+    baseQueryService,
+    backlinkIndex,
+    config,
+    vaultFileStore,
+    workspaceMutationCoordinator,
+  };
   const routes = createRouteTable(context);
 
   return async function handleVaultApiQuery(req, res, requestUrl) {