collabmd 0.1.51 → 0.1.52

package/src/server/domain/ripgrep-search-service.js

@@ -143,12 +143,14 @@ function createRipgrepArgs(query, {
 }
 
 export function parseRipgrepJson(stdout, {
+  excludedPaths = [],
   kinds = [],
   maxFiles = DEFAULT_MAX_FILES,
   maxSnippetsPerFile = DEFAULT_MAX_SNIPPETS_PER_FILE,
   prefix = '',
   query = '',
 } = {}) {
+  const excluded = new Set(excludedPaths);
   const kindFilter = new Set(Array.isArray(kinds) ? kinds : []);
   const files = [];
   const filesByPath = new Map();
@@ -176,6 +178,7 @@ export function parseRipgrepJson(stdout, {
     const kind = getVaultFileKind(filePath) ?? 'text';
     if (
       !filePath
+      || excluded.has(filePath)
       || (prefix && filePath !== prefix && !filePath.startsWith(`${prefix}/`))
       || (kindFilter.size > 0 && !kindFilter.has(kind))
     ) {
@@ -237,7 +240,38 @@ export function parseRipgrepJson(stdout, {
   };
 }
 
+export function searchExcalidrawSceneText(scene, { query, maxSnippetsPerFile = 5, wholeWord = false }) {
+  const normalizedQuery = query.toLocaleLowerCase();
+  const snippets = [];
+  let matchCount = 0;
+  for (const element of Array.isArray(scene?.elements) ? scene.elements : []) {
+    if (element?.isDeleted || element?.type !== 'text' || typeof element.text !== 'string') continue;
+    const text = element.text;
+    const normalizedText = text.toLocaleLowerCase();
+    let matchStart = normalizedText.indexOf(normalizedQuery);
+    while (matchStart >= 0) {
+      if (!wholeWord || isWholeWordMatch(normalizedText, matchStart, matchStart + normalizedQuery.length)) {
+        matchCount += 1;
+        if (snippets.length < maxSnippetsPerFile) {
+          const snippet = createSnippet(text, matchStart, matchStart + query.length);
+          snippets.push({
+            column: matchStart + 1,
+            line: 1,
+            matchEnd: snippet.matchEnd,
+            matchStart: snippet.matchStart,
+            text: snippet.text,
+          });
+        }
+      }
+      matchStart = normalizedText.indexOf(normalizedQuery, matchStart + Math.max(query.length, 1));
+    }
+  }
+
+  return { matchCount, snippets, truncated: matchCount > snippets.length };
+}
+
 async function searchExcalidrawText({
+  excludedPaths = [],
   kinds = [],
   maxFileSize,
   maxFiles,
@@ -248,6 +282,7 @@ async function searchExcalidrawText({
   signal,
   vaultDir,
 }) {
+  const excluded = new Set(excludedPaths);
   const kindFilter = new Set(Array.isArray(kinds) ? kinds : []);
   if (kindFilter.size > 0 && !kindFilter.has('excalidraw')) {
     return { files: [], matchCount: 0, truncated: false };
@@ -255,7 +290,6 @@ async function searchExcalidrawText({
   const files = [];
   let matchCount = 0;
   let truncated = false;
-  const normalizedQuery = query.toLocaleLowerCase();
   const paths = glob('**/*.excalidraw', {
     cwd: vaultDir,
     exclude: ['**/.*', '**/node_modules/**'],
@@ -263,6 +297,7 @@ async function searchExcalidrawText({
 
   for await (const filePath of paths) {
     const normalizedPath = filePath.replaceAll('\\', '/');
+    if (excluded.has(normalizedPath)) continue;
     if (prefix && normalizedPath !== prefix && !normalizedPath.startsWith(`${prefix}/`)) continue;
     signal?.throwIfAborted?.();
     const absolutePath = join(vaultDir, filePath);
@@ -275,33 +310,10 @@ async function searchExcalidrawText({
       continue;
     }
 
-    const snippets = [];
-    let fileMatchCount = 0;
-    for (const element of Array.isArray(scene?.elements) ? scene.elements : []) {
-      if (element?.isDeleted || element?.type !== 'text' || typeof element.text !== 'string') continue;
-      const text = element.text;
-      const normalizedText = text.toLocaleLowerCase();
-      let matchStart = normalizedText.indexOf(normalizedQuery);
-      while (matchStart >= 0) {
-        if (!wholeWord || isWholeWordMatch(normalizedText, matchStart, matchStart + normalizedQuery.length)) {
-          fileMatchCount += 1;
-          matchCount += 1;
-          if (snippets.length < maxSnippetsPerFile) {
-            const snippet = createSnippet(text, matchStart, matchStart + query.length);
-            snippets.push({
-              column: matchStart + 1,
-              line: 1,
-              matchEnd: snippet.matchEnd,
-              matchStart: snippet.matchStart,
-              text: snippet.text,
-            });
-          } else {
-            truncated = true;
-          }
-        }
-        matchStart = normalizedText.indexOf(normalizedQuery, matchStart + Math.max(query.length, 1));
-      }
-    }
+    const result = searchExcalidrawSceneText(scene, { query, maxSnippetsPerFile, wholeWord });
+    const { matchCount: fileMatchCount, snippets } = result;
+    matchCount += fileMatchCount;
+    truncated ||= result.truncated;
 
     if (fileMatchCount > 0) {
       if (files.length >= maxFiles) {
@@ -383,6 +395,7 @@ export class RipgrepSearchService {
   }
 
   async search({
+    excludedPaths = [],
     kinds = [],
     limit = DEFAULT_MAX_FILES,
     maxSnippetsPerFile = DEFAULT_MAX_SNIPPETS_PER_FILE,
@@ -431,6 +444,7 @@ export class RipgrepSearchService {
         timeout: this.timeoutMs,
       });
       parsed = parseRipgrepJson(result.stdout, {
+        excludedPaths,
         kinds,
         maxFiles,
         maxSnippetsPerFile: snippetLimit,
@@ -446,6 +460,7 @@ export class RipgrepSearchService {
       } else {
         const isMaxBuffer = error?.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';
         parsed = parseRipgrepJson(error?.stdout ?? '', {
+          excludedPaths,
           kinds,
           maxFiles,
           maxSnippetsPerFile: snippetLimit,
@@ -463,6 +478,7 @@ export class RipgrepSearchService {
 
     if (parsed.files.length < maxFiles) {
       const excalidraw = await searchExcalidrawText({
+        excludedPaths,
         kinds,
         maxFileSize: this.maxFileSize,
         maxFiles: maxFiles - parsed.files.length,

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

@@ -142,20 +142,24 @@ export class GitDiffService {
     scope = 'working-tree',
   } = {}) {
     const trackedFiles = files.filter((entry) => entry.status !== 'untracked');
-    const trackedSummary = trackedFiles.length > 0
-      ? parseNumstatOutput(
-        await this.commandRunner.execGit(this.buildDiffCommandArgs({
-          hasHeadCommit,
-          numstat: true,
-          path,
-          scope,
-        })),
-      )
-      : createEmptyStats();
-    const untrackedAdditions = await this.untrackedFileService.countAdditions(
+    // The diff spawn and the untracked file scan are independent: overlap them.
+    const trackedSummaryPromise = trackedFiles.length > 0
+      ? this.commandRunner.execGit(this.buildDiffCommandArgs({
+        hasHeadCommit,
+        numstat: true,
+        path,
+        scope,
+      })).then((output) => parseNumstatOutput(output))
+      : Promise.resolve(createEmptyStats());
+    const untrackedAdditionsPromise = this.untrackedFileService.countAdditions(
       files.filter((entry) => entry.status === 'untracked'),
     );
 
+    const [trackedSummary, untrackedAdditions] = await Promise.all([
+      trackedSummaryPromise,
+      untrackedAdditionsPromise,
+    ]);
+
     return {
       additions: trackedSummary.additions + untrackedAdditions,
       deletions: trackedSummary.deletions,

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

@@ -127,6 +127,10 @@ export class GitService {
     return this.statusService.getStatus(options);
   }
 
+  async readPullBackupSummary(backupId) {
+    return this.pullBackupStore.readSummary(backupId);
+  }
+
   async listPullBackups() {
     if (!(await this.isGitRepo())) {
       return [];

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

@@ -1,3 +1,5 @@
+import { extname } from 'node:path';
+
 const IMAGE_MIME_TYPES = Object.freeze({
   '.gif': 'image/gif',
   '.jpeg': 'image/jpeg',
@@ -8,7 +10,6 @@ const IMAGE_MIME_TYPES = Object.freeze({
 });
 
 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';
+  const extension = extname(String(filePath ?? '').toLowerCase());
+  return IMAGE_MIME_TYPES[extension] ?? 'application/octet-stream';
 }

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

@@ -84,12 +84,16 @@ export class GitStatusService {
   }
 
   async getLocalChangeSummary({ hasHeadCommit = false, untrackedFiles = [] } = {}) {
-    const trackedSummary = parseNumstatOutput(
-      await this.commandRunner.execGit(hasHeadCommit
-        ? ['diff', '--numstat', 'HEAD']
-        : ['diff', '--cached', '--numstat']),
-    );
-    const untrackedAdditions = await this.untrackedFileService.countAdditions(untrackedFiles);
+    // The diff spawn and the untracked file scan are independent: overlap them.
+    const trackedSummaryPromise = this.commandRunner.execGit(hasHeadCommit
+      ? ['diff', '--numstat', 'HEAD']
+      : ['diff', '--cached', '--numstat']).then((output) => parseNumstatOutput(output));
+    const untrackedAdditionsPromise = this.untrackedFileService.countAdditions(untrackedFiles);
+
+    const [trackedSummary, untrackedAdditions] = await Promise.all([
+      trackedSummaryPromise,
+      untrackedAdditionsPromise,
+    ]);
 
     return {
       additions: trackedSummary.additions + untrackedAdditions,

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

@@ -6,6 +6,7 @@ import {
   encodeContentDispositionFilename,
   jsonResponse,
   sendResponse,
+  SVG_ATTACHMENT_CSP,
 } from './http-response.js';
 
 function resolveDiffScope(requestUrl) {
@@ -127,6 +128,7 @@ export function createGitApiQueryHandler({ gitService }) {
             'Content-Disposition': `inline; filename="${createSafeAsciiFilename(fileName)}"; filename*=UTF-8''${encodeContentDispositionFilename(fileName)}`,
             'Content-Type': attachment.mimeType || 'application/octet-stream',
             'X-Content-Type-Options': 'nosniff',
+            ...(attachment.mimeType === 'image/svg+xml' ? { 'Content-Security-Policy': SVG_ATTACHMENT_CSP } : {}),
           },
           statusCode: 200,
         });
@@ -136,6 +138,29 @@ export function createGitApiQueryHandler({ gitService }) {
       return true;
     }
 
+    if (requestUrl.pathname === '/api/git/pull-backup-summary' && req.method === 'GET') {
+      try {
+        const content = await gitService.readPullBackupSummary(requestUrl.searchParams.get('id'));
+        if (content === null) {
+          jsonResponse(req, res, 404, { error: 'Pull backup summary not found' });
+        } else {
+          sendResponse(req, res, {
+            body: content,
+            headers: {
+              'Cache-Control': 'no-store',
+              'Content-Type': 'text/plain; charset=utf-8',
+              'Content-Security-Policy': "default-src 'none'; sandbox",
+              'X-Content-Type-Options': 'nosniff',
+            },
+            statusCode: 200,
+          });
+        }
+      } catch (error) {
+        handleApiError(req, res, error, '[api] Failed to read pull backup summary:', 'Failed to read pull backup summary');
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/git/pull-backups' && req.method === 'GET') {
       try {
         jsonResponse(req, res, 200, {

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

@@ -1,10 +1,7 @@
 import { ZipArchive } from 'archiver';
-import { readdir } from 'node:fs/promises';
 import { basename } from 'node:path';
-import { join } from 'node:path';
 
 import { getVaultFileKind, isImageAttachmentFilePath } from '../../../domain/file-kind.js';
-import { isIgnoredVaultEntry } from '../persistence/path-utils.js';
 import { parseJsonBody } from './request-body.js';
 import {
   createSafeAsciiFilename,
@@ -12,10 +9,10 @@ import {
   jsonResponse,
   sendResponse,
   sendStreamResponse,
+  SVG_ATTACHMENT_CSP,
 } 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;
 
@@ -75,8 +72,7 @@ function createDownloadHeaders(fileName, contentType, { inline = false } = {}) {
 }
 
 async function streamDirectoryArchive(req, res, {
-  maxEntries = 10_000,
-  rootAbsolutePath = '',
+  entries = [],
   rootName = 'archive',
 } = {}) {
   const archive = new ZipArchive({
@@ -97,55 +93,20 @@ async function streamDirectoryArchive(req, res, {
     stream: archive,
   });
 
-  let entryCount = 0;
-  const appendEntry = () => {
-    entryCount += 1;
-    if (entryCount > maxEntries) {
-      throw new Error(`Directory archive exceeds ${maxEntries} entries`);
-    }
-  };
-
   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();
+    for (const entry of entries) {
+      if (entry.kind === 'directory') {
         archive.append('', {
-          name: relativeDirectoryPath ? `${rootName}/${relativeDirectoryPath}/` : `${rootName}/`,
+          name: entry.relativePath ? `${rootName}/${entry.relativePath}/` : `${rootName}/`,
         });
-        return;
+        continue;
       }
 
-      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}`,
-        });
-      }
-    };
+      archive.file(entry.absolutePath, {
+        name: `${rootName}/${entry.relativePath}`,
+      });
+    }
 
-    await visitDirectory(rootAbsolutePath);
     await archive.finalize();
     await responsePromise;
   } catch (error) {
@@ -365,17 +326,16 @@ async function handleDirectoryDownload(req, res, requestUrl, { config, vaultFile
       return;
     }
     const maxArchiveEntries = config.maxArchiveEntries ?? DEFAULT_MAX_ARCHIVE_ENTRIES;
-    const entryCount = await vaultFileStore.countDirectoryDownloadEntries(result.absolute, {
+    const collected = await vaultFileStore.collectDirectoryDownloadEntries(result.absolute, {
       maxEntries: maxArchiveEntries,
     });
-    if (!entryCount.withinLimit) {
+    if (!collected.withinLimit) {
       jsonResponse(req, res, 413, { error: `Directory archive exceeds ${maxArchiveEntries} entries` });
       return;
     }
 
     await streamDirectoryArchive(req, res, {
-      maxEntries: maxArchiveEntries,
-      rootAbsolutePath: result.absolute,
+      entries: collected.entries,
       rootName: result.rootName || 'archive',
     });
   } catch (error) {

package/src/server/infrastructure/http/http-response.js

@@ -7,6 +7,8 @@ import {
 const COMPRESSIBLE_CONTENT_TYPE_PATTERN = /^(?:text\/|application\/(?:javascript|json|xml)|image\/svg\+xml)/i;
 const MIN_COMPRESSIBLE_BYTES = 1024;
 
+export const SVG_ATTACHMENT_CSP = "default-src 'none'; img-src 'self' data: blob:; style-src 'unsafe-inline'; sandbox";
+
 export function encodeContentDispositionFilename(fileName) {
   return encodeURIComponent(String(fileName ?? ''))
     .replace(/['()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);

package/src/server/infrastructure/persistence/hosted-metadata-store.js

@@ -1,7 +1,7 @@
 import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 
-import { HOSTED_ROLE_ADMIN } from '../../domain/hosted-workspace-contract.js';
+import { createHostedError, HOSTED_ROLE_ADMIN } from '../../domain/hosted-workspace-contract.js';
 
 function rowToTeam(row) {
   if (!row) {
@@ -343,7 +343,7 @@ export class HostedMetadataStore {
     ).get(email));
   }
 
-  async getMembershipById(id) {
+  getMembershipById(id) {
     return rowToMembership(this.prepare(
       'getMembershipById',
       'SELECT * FROM memberships WHERE id = ?',
@@ -357,18 +357,18 @@ export class HostedMetadataStore {
     ).all(HOSTED_ROLE_ADMIN).map(rowToMembership);
   }
 
-  async updateMembership(membership) {
+  updateMembership(membership) {
     this.prepare(
       'updateMembership',
       'UPDATE memberships SET name = ?, picture = ?, role = ?, updated_at = ? WHERE id = ?',
     ).run(membership.name, membership.picture, membership.role, membership.updatedAt, membership.id);
   }
 
-  async deleteMembership(id) {
+  deleteMembership(id) {
     this.prepare('deleteMembership', 'DELETE FROM memberships WHERE id = ?').run(id);
   }
 
-  async countAdminsExcept(email) {
+  countAdminsExcept(email) {
     const row = this.prepare(
       'countAdminsExcept',
       'SELECT COUNT(*) AS count FROM memberships WHERE role = ? AND email != ?',
@@ -376,6 +376,43 @@ export class HostedMetadataStore {
     return Number(row?.count ?? 0);
   }
 
+  async changeMembership({ actorId, membershipId, auditEvent, role = null, requireAdmin = true }) {
+    return this.transaction(() => {
+      const actor = this.getMembershipById(actorId);
+      if (!actor) {
+        throw createHostedError(403, 'Team membership is required.', 'HOSTED_MEMBERSHIP_REQUIRED');
+      }
+      const isSelfLeave = !requireAdmin && actorId === membershipId && role === null;
+      if (!isSelfLeave && actor.role !== HOSTED_ROLE_ADMIN) {
+        throw createHostedError(403, 'Team Admin role is required.', 'HOSTED_ADMIN_REQUIRED');
+      }
+
+      const membership = this.getMembershipById(membershipId);
+      if (!membership) {
+        throw createHostedError(404, 'Membership was not found.', 'HOSTED_MEMBERSHIP_NOT_FOUND');
+      }
+      if (membership.role === HOSTED_ROLE_ADMIN && role !== HOSTED_ROLE_ADMIN
+        && this.countAdminsExcept(membership.email) < 1) {
+        throw createHostedError(409, 'A team must always have at least one Team Admin.', 'HOSTED_LAST_ADMIN');
+      }
+
+      const updated = role === null ? membership : { ...membership, role, updatedAt: auditEvent.createdAt };
+      if (role === null) {
+        this.deleteMembership(membershipId);
+      } else {
+        this.updateMembership(updated);
+      }
+      this.insertAuditEvent({
+        ...auditEvent,
+        actorEmail: actor.email,
+        actorName: actor.name,
+        targetEmail: membership.email,
+        targetRole: updated.role,
+      });
+      return updated;
+    });
+  }
+
   async upsertPendingInvitation(invitation) {
     this.prepare(
       'upsertPendingInvitation',

package/src/server/infrastructure/persistence/path-utils.js

@@ -1,4 +1,5 @@
-import { isAbsolute, normalize, relative, resolve } from 'path';
+import { lstatSync } from 'node:fs';
+import { isAbsolute, join, normalize, relative, resolve } from 'path';
 
 import { isVaultFilePath } from '../../../domain/file-kind.js';
 
@@ -8,7 +9,7 @@ export const INVALID_VAULT_FILE_PATH_ERROR = `Invalid file path — must end in
 export const INVALID_DIRECTORY_PATH_ERROR = 'Invalid directory path';
 
 export function isIgnoredVaultEntry(name) {
-  return IGNORED_DIRECTORIES.has(name) || name.startsWith('.');
+  return IGNORED_DIRECTORIES.has(name.toLowerCase()) || name.startsWith('.');
 }
 
 function normalizeRequestedPath(requestedPath) {
@@ -16,6 +17,7 @@ function normalizeRequestedPath(requestedPath) {
   const segments = value.split('/');
   if (
     !value
+    || value.includes('\0')
     || isAbsolute(value)
     || segments.some((segment) => segment === '.' || segment === '..')
   ) {
@@ -26,7 +28,7 @@ function normalizeRequestedPath(requestedPath) {
   return normalized === '.' ? '' : normalized;
 }
 
-export function sanitizeVaultPath(vaultDir, requestedPath) {
+export function sanitizeVaultPath(vaultDir, requestedPath, { allowIgnored = false } = {}) {
   const normalized = normalizeRequestedPath(requestedPath);
   if (!normalized) {
     return null;
@@ -34,15 +36,33 @@ export function sanitizeVaultPath(vaultDir, requestedPath) {
 
   const absolute = resolve(vaultDir, normalized);
   const relativePath = relative(vaultDir, absolute);
+  const segments = relativePath.split(/[\\/]/u);
 
   if (
     relativePath.startsWith('..')
     || relativePath === '..'
     || isAbsolute(relativePath)
+    || (!allowIgnored && segments.some(isIgnoredVaultEntry))
   ) {
     return null;
   }
 
+  // The configured root may be a symlink; content below it must never be one.
+  let currentPath = resolve(vaultDir);
+  for (const segment of segments) {
+    currentPath = join(currentPath, segment);
+    try {
+      if (lstatSync(currentPath).isSymbolicLink()) {
+        return null;
+      }
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        break;
+      }
+      return null;
+    }
+  }
+
   return absolute;
 }