collabmd 0.1.18 → 0.1.20

package/src/server/infrastructure/http/request-body.js

@@ -2,7 +2,7 @@ import { createRequestError } from './http-errors.js';
 
 export const REQUEST_BODY_LIMIT_BYTES = 8_388_608;
 
-export async function readRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
+async function readRequestBuffer(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
   return new Promise((resolve, reject) => {
     const chunks = [];
     let size = 0;
@@ -32,7 +32,7 @@ export async function readRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES)
     };
 
     const onEnd = () => {
-      finish(resolve, Buffer.concat(chunks).toString('utf-8'));
+      finish(resolve, Buffer.concat(chunks));
     };
 
     const onError = (error) => {
@@ -45,6 +45,15 @@ export async function readRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES)
   });
 }
 
+export async function readRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
+  const bodyBuffer = await readRequestBuffer(req, maxBytes);
+  return bodyBuffer.toString('utf-8');
+}
+
+export async function readBinaryRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
+  return readRequestBuffer(req, maxBytes);
+}
+
 export async function parseJsonBody(req) {
   const rawBody = await readRequestBody(req);
 

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

@@ -3,7 +3,7 @@ import { isAbsolute, normalize, relative, resolve } from 'path';
 import { isVaultFilePath } from '../../../domain/file-kind.js';
 
 export const IGNORED_DIRECTORIES = new Set(['.git', '.obsidian', '.trash', 'node_modules', '.DS_Store']);
-export const VAULT_FILE_PATH_REQUIREMENT = '.md, .excalidraw, .mmd, .mermaid, .puml, or .plantuml';
+export const VAULT_FILE_PATH_REQUIREMENT = '.md, .excalidraw, .mmd, .mermaid, .puml, .plantuml, .png, .jpg, .jpeg, .webp, .gif, or .svg';
 export const INVALID_VAULT_FILE_PATH_ERROR = `Invalid file path — must end in ${VAULT_FILE_PATH_REQUIREMENT}`;
 export const INVALID_DIRECTORY_PATH_ERROR = 'Invalid directory path';
 

package/src/server/infrastructure/persistence/pull-backup-store.js

@@ -0,0 +1,283 @@
+import { copyFile, mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+
+import { sanitizeVaultPath } from './path-utils.js';
+
+const PULL_BACKUP_STORAGE_ROOT = '.collabmd/pull-backups';
+const BACKUP_METADATA_PREFIX = '<!-- collabmd-pull-backup ';
+const BACKUP_METADATA_SUFFIX = ' -->';
+
+function normalizeRelativePath(pathValue = '') {
+  return String(pathValue).replace(/\\/g, '/');
+}
+
+function createBackupId(headRef = null, createdAt = new Date().toISOString()) {
+  const timestamp = normalizeRelativePath(createdAt)
+    .replace(/[^0-9T]/g, '')
+    .replace('T', '-')
+    .replace(/Z$/u, '');
+  const shortHead = String(headRef ?? 'workspace').trim().slice(0, 7) || 'workspace';
+  return `${timestamp}-${shortHead}`;
+}
+
+function formatBackupMetadata(metadata = {}) {
+  return `${BACKUP_METADATA_PREFIX}${JSON.stringify(metadata)}${BACKUP_METADATA_SUFFIX}`;
+}
+
+function parseBackupMetadata(content = '') {
+  const firstLine = String(content).split(/\r?\n/u)[0] ?? '';
+  if (!firstLine.startsWith(BACKUP_METADATA_PREFIX) || !firstLine.endsWith(BACKUP_METADATA_SUFFIX)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(firstLine.slice(BACKUP_METADATA_PREFIX.length, -BACKUP_METADATA_SUFFIX.length));
+  } catch {
+    return null;
+  }
+}
+
+function formatSummary({
+  backupEntries = [],
+  backupId,
+  branch = null,
+  createdAt,
+  fileCount = 0,
+  headRef = null,
+  targetRef = null,
+} = {}) {
+  const metadata = formatBackupMetadata({
+    backupId,
+    branch,
+    createdAt,
+    fileCount,
+    headRef,
+    targetRef,
+  });
+  const entryLines = backupEntries.length === 0
+    ? ['No overlapping files could be copied from the worktree.']
+    : backupEntries.flatMap((entry) => {
+      const lines = [`- Original path: \`${entry.path}\``];
+      if (entry.backupPath) {
+        lines.push(`  Saved copy: \`${entry.backupPath}\``);
+      } else {
+        lines.push('  Saved copy: none (the file no longer existed in the worktree at backup time)');
+      }
+      if (entry.stagedPatchPath) {
+        lines.push(`  Staged patch: \`${entry.stagedPatchPath}\``);
+      }
+      if (entry.worktreePatchPath) {
+        lines.push(`  Worktree patch: \`${entry.worktreePatchPath}\``);
+      }
+      return lines;
+    });
+
+  return [
+    metadata,
+    '# Pull Backup',
+    '',
+    `Created: \`${createdAt}\``,
+    `Branch: \`${branch || 'HEAD'}\``,
+    `Base ref: \`${headRef || 'none'}\``,
+    `Pulled to: \`${targetRef || 'none'}\``,
+    `Files backed up: \`${fileCount}\``,
+    '',
+    'This backup was created because local dirty changes overlapped with incoming remote updates.',
+    'The working tree was updated to the remote version so the latest upstream content is visible immediately.',
+    '',
+    '## Saved Files',
+    '',
+    ...entryLines,
+    '',
+    '## Recovery',
+    '',
+    'Compare the current file content against the saved copies above, then manually restore any changes you want to keep.',
+    'Use `git apply --cached <staged patch>` to inspect or restore staged/index-only changes on a safe branch.',
+    'Use `git apply <worktree patch>` to inspect or restore unstaged worktree changes on a safe branch.',
+    '',
+  ].join('\n');
+}
+
+async function ensureLocalGitExclude(vaultDir) {
+  const excludePath = resolve(vaultDir, '.git/info/exclude');
+  let existingContent = '';
+
+  try {
+    existingContent = await readFile(excludePath, 'utf8');
+  } catch (error) {
+    if (error?.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  const lines = existingContent
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  if (lines.includes('.collabmd') || lines.includes('.collabmd/')) {
+    return;
+  }
+
+  const prefix = existingContent.length > 0 && !existingContent.endsWith('\n')
+    ? '\n'
+    : '';
+  await writeFile(excludePath, `${existingContent}${prefix}.collabmd/\n`, 'utf8');
+}
+
+export class PullBackupStore {
+  constructor({ vaultDir }) {
+    this.vaultDir = resolve(vaultDir);
+  }
+
+  getStorageRoot() {
+    return resolve(this.vaultDir, PULL_BACKUP_STORAGE_ROOT);
+  }
+
+  getBackupPath(backupId) {
+    return resolve(this.getStorageRoot(), backupId);
+  }
+
+  getSummaryPath(backupId) {
+    return `${PULL_BACKUP_STORAGE_ROOT}/${backupId}/summary.md`;
+  }
+
+  async createBackup({
+    branch = null,
+    createdAt = new Date().toISOString(),
+    entries = [],
+    headRef = null,
+    targetRef = null,
+  } = {}) {
+    await ensureLocalGitExclude(this.vaultDir);
+
+    const backupId = createBackupId(headRef, createdAt);
+    const backupDir = this.getBackupPath(backupId);
+    const filesRoot = join(backupDir, 'files');
+    const patchesRoot = join(backupDir, 'patches');
+    const backupEntries = [];
+
+    await mkdir(filesRoot, { recursive: true });
+    await mkdir(patchesRoot, { recursive: true });
+
+    for (const entry of entries) {
+      const normalizedPath = normalizeRelativePath(entry?.path);
+      if (!normalizedPath) {
+        continue;
+      }
+
+      const absoluteSourcePath = sanitizeVaultPath(this.vaultDir, normalizedPath);
+      const relativeBackupPath = `${PULL_BACKUP_STORAGE_ROOT}/${backupId}/files/${normalizedPath}`;
+      const relativeStagedPatchPath = entry?.stagedPatchContent
+        ? `${PULL_BACKUP_STORAGE_ROOT}/${backupId}/patches/${normalizedPath}.staged.patch`
+        : null;
+      const relativeWorktreePatchPath = entry?.worktreePatchContent
+        ? `${PULL_BACKUP_STORAGE_ROOT}/${backupId}/patches/${normalizedPath}.worktree.patch`
+        : null;
+      let backupPath = null;
+
+      if (absoluteSourcePath) {
+        try {
+          await stat(absoluteSourcePath);
+          const absoluteBackupPath = resolve(this.vaultDir, relativeBackupPath);
+          await mkdir(dirname(absoluteBackupPath), { recursive: true });
+          await copyFile(absoluteSourcePath, absoluteBackupPath);
+          backupPath = normalizeRelativePath(relativeBackupPath);
+        } catch (error) {
+          if (error?.code !== 'ENOENT') {
+            throw error;
+          }
+        }
+      }
+
+      if (relativeStagedPatchPath) {
+        const absolutePatchPath = resolve(this.vaultDir, relativeStagedPatchPath);
+        await mkdir(dirname(absolutePatchPath), { recursive: true });
+        await writeFile(absolutePatchPath, entry.stagedPatchContent, 'utf8');
+      }
+
+      if (relativeWorktreePatchPath) {
+        const absolutePatchPath = resolve(this.vaultDir, relativeWorktreePatchPath);
+        await mkdir(dirname(absolutePatchPath), { recursive: true });
+        await writeFile(absolutePatchPath, entry.worktreePatchContent, 'utf8');
+      }
+
+      backupEntries.push({
+        backupPath,
+        oldPath: normalizeRelativePath(entry?.oldPath ?? ''),
+        path: normalizedPath,
+        stagedPatchPath: relativeStagedPatchPath ? normalizeRelativePath(relativeStagedPatchPath) : null,
+        worktreePatchPath: relativeWorktreePatchPath ? normalizeRelativePath(relativeWorktreePatchPath) : null,
+      });
+    }
+
+    const fileCount = backupEntries.filter((entry) => (
+      entry.backupPath
+      || entry.stagedPatchPath
+      || entry.worktreePatchPath
+    )).length;
+    const summaryPath = this.getSummaryPath(backupId);
+    await writeFile(
+      resolve(this.vaultDir, summaryPath),
+      formatSummary({
+        backupEntries,
+        backupId,
+        branch,
+        createdAt,
+        fileCount,
+        headRef,
+        targetRef,
+      }),
+      'utf8',
+    );
+
+    return {
+      branch,
+      createdAt,
+      fileCount,
+      id: backupId,
+      summaryPath,
+    };
+  }
+
+  async listBackups() {
+    let entries = [];
+    try {
+      entries = await readdir(this.getStorageRoot(), { withFileTypes: true });
+    } catch (error) {
+      if (error?.code === 'ENOENT') {
+        return [];
+      }
+      throw error;
+    }
+
+    const backups = await Promise.all(entries
+      .filter((entry) => entry.isDirectory())
+      .map(async (entry) => {
+        const summaryPath = this.getSummaryPath(entry.name);
+        try {
+          const content = await readFile(resolve(this.vaultDir, summaryPath), 'utf8');
+          const metadata = parseBackupMetadata(content);
+          if (!metadata) {
+            return null;
+          }
+
+          return {
+            branch: metadata.branch ?? null,
+            createdAt: metadata.createdAt ?? null,
+            fileCount: Number(metadata.fileCount ?? 0) || 0,
+            id: entry.name,
+            summaryPath,
+          };
+        } catch (error) {
+          if (error?.code === 'ENOENT') {
+            return null;
+          }
+          throw error;
+        }
+      }));
+
+    return backups
+      .filter(Boolean)
+      .sort((left, right) => String(right.createdAt || '').localeCompare(String(left.createdAt || '')));
+  }
+}

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -1,7 +1,12 @@
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'fs/promises';
-import { dirname, join, resolve } from 'path';
+import { basename, dirname, extname, join, relative, resolve } from 'path';
 
-import { getVaultTreeNodeType, isVaultFilePath } from '../../../domain/file-kind.js';
+import {
+  getVaultTreeNodeType,
+  isImageAttachmentFilePath,
+  isMarkdownFilePath,
+  isVaultFilePath,
+} from '../../../domain/file-kind.js';
 import { getVaultContentAdapter } from './vault-content-adapter.js';
 import {
   INVALID_VAULT_FILE_PATH_ERROR,
@@ -14,6 +19,23 @@ import {
 } from './path-utils.js';
 import { SidecarStore } from './sidecar-store.js';
 
+const IMAGE_EXTENSION_TO_MIME_TYPE = Object.freeze({
+  '.gif': 'image/gif',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+});
+
+const MIME_TYPE_TO_IMAGE_EXTENSION = Object.freeze({
+  'image/gif': '.gif',
+  'image/jpeg': '.jpg',
+  'image/png': '.png',
+  'image/svg+xml': '.svg',
+  'image/webp': '.webp',
+});
+
 function createTransactionalPath(targetPath, label) {
   return `${targetPath}.collabmd-${label}-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
 }
@@ -42,6 +64,88 @@ async function cleanupPaths(paths = []) {
   await Promise.allSettled(paths.filter(Boolean).map((pathValue) => rm(pathValue, { force: true })));
 }
 
+function normalizeAttachmentMimeType(value) {
+  return String(value ?? '').split(';')[0].trim().toLowerCase();
+}
+
+function sanitizeAttachmentStem(value, fallback = 'image') {
+  const normalized = String(value ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized || fallback;
+}
+
+function padAttachmentTimestamp(value) {
+  return String(value).padStart(2, '0');
+}
+
+function createAttachmentTimestamp(date = new Date()) {
+  return [
+    date.getFullYear(),
+    padAttachmentTimestamp(date.getMonth() + 1),
+    padAttachmentTimestamp(date.getDate()),
+  ].join('')
+    + '-'
+    + [
+      padAttachmentTimestamp(date.getHours()),
+      padAttachmentTimestamp(date.getMinutes()),
+      padAttachmentTimestamp(date.getSeconds()),
+    ].join('');
+}
+
+function createDocumentAttachmentDirectoryPath(documentPath) {
+  const normalizedPath = String(documentPath ?? '').replace(/\\/g, '/');
+  const documentDir = dirname(normalizedPath).replace(/\\/g, '/');
+  const documentStem = basename(normalizedPath, extname(normalizedPath));
+  return documentDir === '.'
+    ? `${documentStem}.assets`
+    : `${documentDir}/${documentStem}.assets`;
+}
+
+function createAttachmentAltText(originalFileName = '') {
+  const stem = basename(String(originalFileName ?? ''), extname(String(originalFileName ?? '')))
+    .replace(/[_-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return stem || 'Image';
+}
+
+function escapeMarkdownText(value = '') {
+  return String(value)
+    .replace(/\\/g, '\\\\')
+    .replace(/\[/g, '\\[')
+    .replace(/\]/g, '\\]')
+    .replace(/\r?\n/g, ' ');
+}
+
+function encodeMarkdownPath(pathValue = '') {
+  return String(pathValue)
+    .split('/')
+    .map((segment) => encodeURIComponent(segment))
+    .join('/');
+}
+
+function resolveAttachmentExtension({ mimeType, originalFileName }) {
+  const normalizedMimeType = normalizeAttachmentMimeType(mimeType);
+  const extensionFromName = extname(String(originalFileName ?? '')).toLowerCase();
+  if (extensionFromName && IMAGE_EXTENSION_TO_MIME_TYPE[extensionFromName]) {
+    const expectedMimeType = IMAGE_EXTENSION_TO_MIME_TYPE[extensionFromName];
+    if (!normalizedMimeType || expectedMimeType === normalizedMimeType) {
+      return extensionFromName;
+    }
+  }
+
+  return MIME_TYPE_TO_IMAGE_EXTENSION[normalizedMimeType] ?? '';
+}
+
+function createAttachmentMarkdownSnippet({ altText, documentPath, storedPath }) {
+  const relativePath = relative(dirname(documentPath), storedPath).replace(/\\/g, '/');
+  const encodedRelativePath = encodeMarkdownPath(relativePath || basename(storedPath));
+  return `![${escapeMarkdownText(altText)}](${encodedRelativePath})`;
+}
+
 export class VaultFileStore {
   constructor({ vaultDir }) {
     this.vaultDir = resolve(vaultDir);
@@ -174,6 +278,28 @@ export class VaultFileStore {
     return this.readContentFile(filePath, 'plantuml');
   }
 
+  async readImageAttachmentFile(filePath) {
+    const absolute = this.resolveContentPath(filePath, { requireVaultFile: false });
+    if (!absolute || !isImageAttachmentFilePath(filePath)) {
+      return null;
+    }
+
+    try {
+      const content = await readFile(absolute);
+      return {
+        content,
+        mimeType: IMAGE_EXTENSION_TO_MIME_TYPE[extname(filePath).toLowerCase()] || 'application/octet-stream',
+        path: filePath,
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+
+      throw error;
+    }
+  }
+
   async writeMarkdownFile(filePath, content, options = {}) {
     return this.writeContentFile(filePath, content, 'markdown', options);
   }
@@ -190,6 +316,65 @@ export class VaultFileStore {
     return this.writeContentFile(filePath, content, 'plantuml', options);
   }
 
+  async writeImageAttachmentForDocument(sourceDocumentPath, {
+    content,
+    mimeType,
+    originalFileName = '',
+    now = new Date(),
+  } = {}) {
+    if (!Buffer.isBuffer(content) || content.byteLength === 0) {
+      return { ok: false, error: 'Missing attachment content' };
+    }
+
+    if (!isMarkdownFilePath(sourceDocumentPath)) {
+      return { ok: false, error: 'Source document must be a markdown file' };
+    }
+
+    const extension = resolveAttachmentExtension({ mimeType, originalFileName });
+    if (!extension) {
+      return { ok: false, error: 'Unsupported image type' };
+    }
+
+    const stemSource = basename(String(originalFileName ?? ''), extname(String(originalFileName ?? '')));
+    const attachmentStem = sanitizeAttachmentStem(stemSource, 'image');
+    const attachmentDirPath = createDocumentAttachmentDirectoryPath(sourceDocumentPath);
+    const timestamp = createAttachmentTimestamp(now);
+    const baseFileName = `${attachmentStem}-${timestamp}`;
+    let collisionIndex = 0;
+    let storedPath = '';
+    let absolutePath = '';
+
+    do {
+      const suffix = collisionIndex > 0 ? `-${collisionIndex + 1}` : '';
+      storedPath = `${attachmentDirPath}/${baseFileName}${suffix}${extension}`;
+      absolutePath = this.resolveContentPath(storedPath, { requireVaultFile: false });
+      collisionIndex += 1;
+    } while (absolutePath && await pathExists(absolutePath));
+
+    if (!absolutePath || !isImageAttachmentFilePath(storedPath)) {
+      return { ok: false, error: INVALID_VAULT_FILE_PATH_ERROR };
+    }
+
+    try {
+      await mkdir(dirname(absolutePath), { recursive: true });
+      await writeFile(absolutePath, content);
+    } catch (error) {
+      return { ok: false, error: error.message };
+    }
+
+    const altText = createAttachmentAltText(originalFileName);
+    return {
+      ok: true,
+      altText,
+      markdownSnippet: createAttachmentMarkdownSnippet({
+        altText,
+        documentPath: sourceDocumentPath,
+        storedPath,
+      }),
+      path: storedPath,
+    };
+  }
+
   async persistCollaborationState(filePath, {
     commentThreads = [],
     content = '',
@@ -397,6 +582,22 @@ export class VaultFileStore {
     ]);
   }
 
+  async reconcileCollaborationSnapshots({
+    changedPaths = [],
+    deletedPaths = [],
+    renamedPaths = [],
+  } = {}) {
+    const affectedPaths = new Set([
+      ...(changedPaths ?? []).filter(Boolean),
+      ...(deletedPaths ?? []).filter(Boolean),
+      ...((renamedPaths ?? []).flatMap((entry) => [entry?.oldPath, entry?.newPath]).filter(Boolean)),
+    ]);
+
+    await Promise.allSettled(
+      Array.from(affectedPaths, (filePath) => this.deleteCollaborationSnapshot(filePath)),
+    );
+  }
+
   async countFilesInDir(dirPath) {
     let count = 0;
 

package/public/assets/js/chunks/chunk-BBHPYU2R.js

@@ -1 +0,0 @@
-function o(e){let t=String(e??"").trim();return t?t.endsWith(".md")?t:`${t}.md`:null}function i(e,t){let r=o(e);if(!r||!Array.isArray(t)||t.length===0)return null;let a=String(e??"").trim();return t.find(n=>n===r||n.endsWith(`/${r}`)||n.replace(/\.md$/i,"")===a)??null}function u(e){return String(e).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#39;")}function l(e,t){return i(e,t)??void 0}function f(e,t,r){return Math.min(Math.max(e,t),r)}export{u as a,l as b,f as c};