collabmd 0.1.45 → 0.1.47

package/src/server/domain/bases/base-index-snapshot-store.js

@@ -12,6 +12,7 @@ import {
   createReferenceTargetAliasMap,
 } from '../markdown-reference-extractor.js';
 import { mapWithConcurrency } from '../../shared/async-utils.js';
+import { isPlainObject } from './base-definition.js';
 import { createLinkValue, dedupeLinkValues } from './base-expression-runtime.js';
 
 const INLINE_TAG_RE = /(^|[\s(])#([A-Za-z0-9/_-]+)/g;
@@ -39,10 +40,6 @@ function createRowCacheKey(filePath, workspaceState, fileSetSignature) {
   ].join('\0');
 }
 
-function isPlainObject(value) {
-  return Object.prototype.toString.call(value) === '[object Object]';
-}
-
 function normalizeTags(value) {
   if (Array.isArray(value)) {
     return value

package/src/server/domain/bases/base-transform.js

@@ -2,15 +2,12 @@ import { dump as dumpYaml } from 'js-yaml';
 
 import {
   findView,
+  isPlainObject,
   normalizeBaseDefinition,
   normalizeRawDefinitionForWrite,
   parseBaseSource,
 } from './base-definition.js';
 
-function isPlainObject(value) {
-  return Object.prototype.toString.call(value) === '[object Object]';
-}
-
 function cloneRawSource(source = '') {
   const parsed = parseBaseSource(source);
   return isPlainObject(parsed) ? parsed : {};

package/src/server/domain/collaboration/collaboration-room.js

@@ -6,9 +6,9 @@ import * as decoding from 'lib0/decoding';
 
 import { MSG_AWARENESS, MSG_SYNC } from './protocol.js';
 import { CollaborationDocumentStore } from './collaboration-document-store.js';
-import { RoomPersistenceController } from './room-persistence-controller.js';
 import { logPerfEvent } from '../../config/perf-logging.js';
 import { populateCommentThreads, serializeCommentThreads } from '../../../domain/comment-threads.js';
+import { getVaultFileKind } from '../../../domain/file-kind.js';
 import {
   EXCALIDRAW_APP_STATE_KEY,
   EXCALIDRAW_ELEMENTS_KEY,
@@ -123,7 +123,7 @@ function readAwarenessEntries(update) {
 }
 
 function isExcalidrawRoom(name) {
-  return typeof name === 'string' && name.endsWith('.excalidraw');
+  return getVaultFileKind(name) === 'excalidraw';
 }
 
 function isWorkspaceRoom(name) {
@@ -214,15 +214,10 @@ export class CollaborationRoom {
       lastHydrate: null,
       lastInitialSyncAt: 0,
     };
-    this.persistence = new RoomPersistenceController({
-      idleGraceMs: this.idleGraceMs,
-      onDestroy: () => {
-        this.awareness.destroy();
-        this.doc.destroy();
-        this.onEmpty?.(this.name);
-      },
-      onPersist: () => this.persist(),
-    });
+    this.persistTimer = null;
+    this.destroyTimer = null;
+    this.finalizePromise = null;
+    this.shutdownGeneration = 0;
 
     this.awareness.setLocalState(null);
     this.registerDocListeners();
@@ -475,11 +470,12 @@ export class CollaborationRoom {
       return;
     }
 
-    this.persistence.schedulePersist(async () => {
+    clearTimeout(this.persistTimer);
+    this.persistTimer = setTimeout(() => {
       this.persist().catch((error) => {
         console.error(`[room:${this.name}] Failed to persist document:`, error.message);
       });
-    });
+    }, 500);
   }
 
   async persist() {
@@ -620,9 +616,17 @@ export class CollaborationRoom {
     this.documentStore?.rename(nextName);
   }
 
+  cancelPersistenceTimers() {
+    this.shutdownGeneration += 1;
+    clearTimeout(this.persistTimer);
+    clearTimeout(this.destroyTimer);
+    this.persistTimer = null;
+    this.destroyTimer = null;
+  }
+
   markDeleted() {
     this.deleted = true;
-    this.persistence.cancelAll();
+    this.cancelPersistenceTimers();
     if (this.clients.size === 0) {
       this.finalizeIfIdle();
     }
@@ -669,7 +673,9 @@ export class CollaborationRoom {
   }
 
   async addClient(ws, { sendInitialSync: shouldSendInitialSync = true } = {}) {
-    this.persistence.markActivity();
+    this.shutdownGeneration += 1;
+    clearTimeout(this.destroyTimer);
+    this.destroyTimer = null;
     await this.hydrate();
 
     this.ensureClientState(ws);
@@ -721,9 +727,9 @@ export class CollaborationRoom {
     }
 
     this.destroyed = true;
-    this.persistence.cancelAll();
+    this.cancelPersistenceTimers();
     await Promise.allSettled([
-      this.persistence.finalizePromise,
+      this.finalizePromise,
       this.activePersistPromise,
     ]);
 
@@ -745,12 +751,40 @@ export class CollaborationRoom {
   }
 
   finalizeIfIdle() {
-    return this.persistence.finalizeIfIdle({
-      isIdle: () => this.clients.size === 0,
-      onPersistError: (error) => {
+    if (this.clients.size > 0 || this.finalizePromise) {
+      return;
+    }
+
+    const generation = ++this.shutdownGeneration;
+    this.finalizePromise = (async () => {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+
+      try {
+        await this.persist();
+      } catch (error) {
         console.error(`[room:${this.name}] Failed to persist final room state:`, error.message);
-      },
+      }
+
+      if (this.clients.size > 0 || generation !== this.shutdownGeneration) {
+        return;
+      }
+
+      this.destroyTimer = setTimeout(() => {
+        if (this.clients.size > 0 || generation !== this.shutdownGeneration) {
+          return;
+        }
+
+        this.awareness.destroy();
+        this.doc.destroy();
+        this.onEmpty?.(this.name);
+      }, this.idleGraceMs);
+      this.destroyTimer.unref?.();
+    })().finally(() => {
+      this.finalizePromise = null;
     });
+
+    return this.finalizePromise;
   }
 
   clearEphemeralExcalidrawHistory() {

package/src/server/domain/comment-overview.js

@@ -39,10 +39,16 @@ function createThreadSummary(thread) {
   }
 
   const id = asString(thread.id);
+  const anchorKind = asString(thread.anchorKind) || 'line';
+  const isDiagramElementAnchor = anchorKind === 'diagram-element';
   const anchorStartLine = asFiniteNumber(thread.anchorStartLine);
   const anchorEndLine = asFiniteNumber(thread.anchorEndLine);
   const messages = asArray(thread.messages);
-  if (!id || anchorStartLine === null || anchorEndLine === null || messages.length === 0) {
+  if (
+    !id
+    || messages.length === 0
+    || (!isDiagramElementAnchor && (anchorStartLine === null || anchorEndLine === null))
+  ) {
     return null;
   }
 
@@ -53,10 +59,14 @@ function createThreadSummary(thread) {
 
   return {
     anchor: {
-      endLine: Math.max(anchorEndLine, anchorStartLine),
-      kind: asString(thread.anchorKind) || 'line',
-      quote: asString(thread.anchorQuote),
-      startLine: Math.max(anchorStartLine, 1),
+      ...(isDiagramElementAnchor
+        ? {}
+        : {
+          endLine: Math.max(anchorEndLine, anchorStartLine),
+          startLine: Math.max(anchorStartLine, 1),
+        }),
+      kind: anchorKind,
+      quote: asString(thread.anchorQuote) || (isDiagramElementAnchor ? 'Diagram element' : ''),
     },
     createdAt: asFiniteNumber(thread.createdAt) ?? latestActivityAt,
     createdByColor: asString(thread.createdByColor),

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

@@ -22,7 +22,9 @@ const TEXT_SEARCH_GLOBS = Object.freeze([
   '*.mermaid',
   '*.puml',
   '*.plantuml',
+  '*.dsl',
   '*.drawio',
+  '*.excalidraw',
 ]);
 
 function normalizePositiveInt(value, fallback, { min = 1, max = Number.MAX_SAFE_INTEGER } = {}) {
@@ -278,6 +280,7 @@ export class RipgrepSearchService {
   async search({
     limit = DEFAULT_MAX_FILES,
     query = '',
+    signal = null,
   } = {}) {
     const normalizedQuery = String(query ?? '').trim();
     const maxFiles = normalizePositiveInt(limit, this.maxFiles, {
@@ -310,6 +313,7 @@ export class RipgrepSearchService {
         cwd: this.vaultDir,
         encoding: 'utf8',
         maxBuffer: this.maxBufferBytes,
+        ...(signal ? { signal } : {}),
         timeout: this.timeoutMs,
       });
       const parsed = parseRipgrepJson(result.stdout, {

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

@@ -1,5 +1,6 @@
 import { countPatchLines, parseNumstatOutput, parseUnifiedDiff } from './parsers.js';
 import { createEmptyStats } from './responses.js';
+import { getVaultFileKind } from '../../../domain/file-kind.js';
 
 function createSectionMap(sections = []) {
   return new Map(sections.map((section) => [section.key, section]));
@@ -33,6 +34,7 @@ function mergeScopedFile(existingFile, nextFile, scope) {
     return {
       ...nextFile,
       ...nextFlags,
+      fileKind: nextFile.fileKind || getVaultFileKind(nextFile.path),
       scope,
       stats: createEmptyStats(),
     };
@@ -44,6 +46,7 @@ function mergeScopedFile(existingFile, nextFile, scope) {
     return {
       ...existingFile,
       ...nextFile,
+      fileKind: existingFile.fileKind || getVaultFileKind(nextFile.path),
       hasStagedChanges: existingFile.hasStagedChanges || nextFlags.hasStagedChanges,
       hasUntrackedChanges: existingFile.hasUntrackedChanges || nextFlags.hasUntrackedChanges,
       hasWorkingTreeChanges: existingFile.hasWorkingTreeChanges || nextFlags.hasWorkingTreeChanges,
@@ -54,6 +57,7 @@ function mergeScopedFile(existingFile, nextFile, scope) {
 
   return {
     ...existingFile,
+    fileKind: existingFile.fileKind || getVaultFileKind(nextFile.path),
     hasStagedChanges: existingFile.hasStagedChanges || nextFlags.hasStagedChanges,
     hasUntrackedChanges: existingFile.hasUntrackedChanges || nextFlags.hasUntrackedChanges,
     hasWorkingTreeChanges: existingFile.hasWorkingTreeChanges || nextFlags.hasWorkingTreeChanges,
@@ -372,6 +376,7 @@ export class GitDiffService {
       return {
         ...file,
         ...detail,
+        fileKind: file.fileKind || detail.fileKind || getVaultFileKind(file.path),
         canLoadFullPatch: false,
         patchLineCount,
         tooLarge: false,

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({
@@ -186,7 +203,7 @@ export class GitService {
     };
   }
 
-  async pullBranch() {
+  async pullBranch({ author = null } = {}) {
     const status = await this.getStatus({ force: true });
     if (status.branch?.detached) {
       throw createGitRequestError(409, 'Cannot pull from a detached HEAD');
@@ -203,16 +220,22 @@ export class GitService {
       throw createGitRequestError(409, 'Unable to resolve upstream branch for pull');
     }
 
-    if (!(await this.canFastForwardTo(targetRef))) {
+    const mergeBaseRef = beforeRef
+      ? await this.resolveMergeBase(beforeRef, targetRef)
+      : null;
+    if (beforeRef && !mergeBaseRef) {
+      throw createGitRequestError(409, 'Cannot pull because local and remote histories are unrelated');
+    }
+    if (beforeRef && !(await this.canMergeWith(targetRef))) {
       throw createGitRequestError(
         409,
-        'Cannot pull because local and remote commits have diverged; fast-forward only pull is not possible.',
-        { requestCode: 'pull_diverged_ff_only' },
+        'Cannot pull automatically because local and remote commits conflict.',
+        { requestCode: 'pull_conflicted_commits' },
       );
     }
 
     const dirtyEntries = this.collectDirtyEntries(status);
-    const upstreamWorkspaceChange = await this.createWorkspaceChangeFromRefs(beforeRef, targetRef);
+    const upstreamWorkspaceChange = await this.createWorkspaceChangeFromRefs(mergeBaseRef, targetRef);
     const overlappingEntries = this.findOverlappingDirtyEntries({
       dirtyEntries,
       workspaceChange: upstreamWorkspaceChange,
@@ -230,7 +253,9 @@ export class GitService {
 
     let output;
     try {
-      output = await this.commandRunner.execGit(['pull', '--ff-only', '--autostash']);
+      output = await this.commandRunner.execGit(['merge', '--no-edit', '--autostash', targetRef], {
+        env: buildAuthorEnv(author),
+      });
     } catch (error) {
       throw await this.classifyPullError(error);
     }
@@ -293,6 +318,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}`]);
@@ -318,14 +347,18 @@ export class GitService {
       : ['fetch', '--prune']);
   }
 
-  async canFastForwardTo(targetRef) {
-    const headRef = await this.resolveRef('HEAD');
-    if (!headRef || !targetRef || headRef === targetRef) {
-      return true;
+  async resolveMergeBase(leftRef, rightRef) {
+    try {
+      const output = await this.commandRunner.execGit(['merge-base', leftRef, rightRef]);
+      return output.trim() || null;
+    } catch {
+      return null;
     }
+  }
 
+  async canMergeWith(targetRef) {
     try {
-      await this.commandRunner.execGit(['merge-base', '--is-ancestor', headRef, targetRef]);
+      await this.commandRunner.execGit(['merge-tree', '--write-tree', '--quiet', 'HEAD', targetRef]);
       return true;
     } catch (error) {
       if (error?.code === 1) {

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-command-handler.js

@@ -130,7 +130,9 @@ export function createGitApiCommandHandler({
           action: 'pull',
           req,
           responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
-            () => gitService.pullBranch(),
+            () => gitService.pullBranch({
+              author: authService?.getAuthenticatedUser?.(req) ?? null,
+            }),
           ),
           workspaceMutationCoordinator,
         }));

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, {