collabmd 0.1.19 → 0.1.21

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

@@ -3,6 +3,7 @@ import {
   isMermaidFilePath,
   isPlantUmlFilePath,
 } from '../../../domain/file-kind.js';
+import { createWorkspaceChange } from '../../../domain/workspace-change.js';
 import { createRequestError, getRequestErrorStatusCode } from './http-errors.js';
 import { jsonResponse } from './http-response.js';
 import { parseJsonBody, readBinaryRequestBody } from './request-body.js';
@@ -36,6 +37,11 @@ function selectWriteOperation(vaultFileStore, filePath, content) {
   return vaultFileStore.writeMarkdownFile(filePath, content);
 }
 
+function readRequestId(req) {
+  const value = String(req.headers['x-collabmd-request-id'] || '').trim();
+  return value ? value.slice(0, 120) : null;
+}
+
 function handleVaultError(req, res, error, logMessage, fallbackMessage) {
   const statusCode = getRequestErrorStatusCode(error);
   if (statusCode) {
@@ -49,9 +55,8 @@ function handleVaultError(req, res, error, logMessage, fallbackMessage) {
 }
 
 export function createVaultApiCommandHandler({
-  backlinkIndex,
-  roomRegistry = null,
   vaultFileStore,
+  workspaceMutationCoordinator = null,
 }) {
   return async function handleVaultApiCommand(req, res, requestUrl) {
     if (requestUrl.pathname === '/api/file' && req.method === 'PUT') {
@@ -68,6 +73,15 @@ export function createVaultApiCommandHandler({
           return true;
         }
 
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'write-file',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            changedPaths: [body.path],
+          }),
+        });
+
         jsonResponse(req, res, 200, { ok: true });
       } catch (error) {
         handleVaultError(req, res, error, '[api] Failed to write file:', 'Failed to write file');
@@ -97,6 +111,15 @@ export function createVaultApiCommandHandler({
           return true;
         }
 
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'upload-attachment',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            changedPaths: [result.path],
+          }),
+        });
+
         jsonResponse(req, res, 201, {
           markdown: result.markdownSnippet,
           ok: true,
@@ -121,8 +144,14 @@ export function createVaultApiCommandHandler({
           jsonResponse(req, res, 409, { error: result.error });
           return true;
         }
-
-        backlinkIndex?.onFileCreated(body.path, body.content || '');
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'create-file',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            changedPaths: [body.path],
+          }),
+        });
         jsonResponse(req, res, 201, { ok: true, path: body.path });
       } catch (error) {
         handleVaultError(req, res, error, '[api] Failed to create file:', 'Failed to create file');
@@ -137,21 +166,22 @@ export function createVaultApiCommandHandler({
         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);
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'delete-file',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            deletedPaths: [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' });
       }
@@ -171,9 +201,14 @@ export function createVaultApiCommandHandler({
           jsonResponse(req, res, 400, { error: result.error });
           return true;
         }
-
-        roomRegistry?.rename(body.oldPath, body.newPath);
-        backlinkIndex?.onFileRenamed(body.oldPath, body.newPath);
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'rename-file',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            renamedPaths: [{ oldPath: body.oldPath, newPath: 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');
@@ -195,6 +230,15 @@ export function createVaultApiCommandHandler({
           return true;
         }
 
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'create-directory',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            changedPaths: [body.path],
+          }),
+        });
+
         jsonResponse(req, res, 201, { ok: true });
       } catch (error) {
         handleVaultError(req, res, error, '[api] Failed to create directory:', 'Failed to create directory');

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

@@ -7,15 +7,18 @@ export function createVaultApiHandler({
   plantUmlRenderer = null,
   roomRegistry = null,
   vaultFileStore,
+  workspaceMutationCoordinator = null,
 }) {
   const handleVaultApiQuery = createVaultApiQueryHandler({
     backlinkIndex,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
   const handleVaultApiCommand = createVaultApiCommandHandler({
     backlinkIndex,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
   const handlePlantUmlApi = createPlantUmlApiHandler({
     plantUmlRenderer,

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

@@ -59,11 +59,13 @@ function selectReadOperation(vaultFileStore, filePath) {
 export function createVaultApiQueryHandler({
   backlinkIndex,
   vaultFileStore,
+  workspaceMutationCoordinator = null,
 }) {
   return async function handleVaultApiQuery(req, res, requestUrl) {
     if (requestUrl.pathname === '/api/files' && req.method === 'GET') {
       try {
-        jsonResponse(req, res, 200, { tree: await vaultFileStore.tree() });
+        const tree = workspaceMutationCoordinator?.getWorkspaceTree?.() ?? await vaultFileStore.tree();
+        jsonResponse(req, res, 200, { tree });
       } catch (error) {
         console.error('[api] Failed to read file tree:', error.message);
         jsonResponse(req, res, 500, { error: 'Failed to read file tree' });

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

@@ -1,4 +1,8 @@
-import { brotliCompressSync, constants as zlibConstants, gzipSync } from 'node:zlib';
+import {
+  brotliCompress,
+  constants as zlibConstants,
+  gzip,
+} from 'node:zlib';
 
 const COMPRESSIBLE_CONTENT_TYPE_PATTERN = /^(?:text\/|application\/(?:javascript|json|xml)|image\/svg\+xml)/i;
 const MIN_COMPRESSIBLE_BYTES = 1024;
@@ -41,9 +45,9 @@ function resolveCompressionEncoding(acceptEncodingHeader) {
   return null;
 }
 
-function maybeCompressBody(req, body, contentType) {
+function prepareBody(req, body, contentType) {
   if (body === undefined || body === null) {
-    return { body: null, compressed: false, encoding: null };
+    return { body: null, encoding: null };
   }
 
   const bodyBuffer = Buffer.isBuffer(body)
@@ -54,27 +58,48 @@ function maybeCompressBody(req, body, contentType) {
     bodyBuffer.byteLength < MIN_COMPRESSIBLE_BYTES
     || !COMPRESSIBLE_CONTENT_TYPE_PATTERN.test(String(contentType || ''))
   ) {
-    return { body: bodyBuffer, compressed: false, encoding: null };
+    return { body: bodyBuffer, encoding: null };
   }
 
   const encoding = resolveCompressionEncoding(req.headers['accept-encoding']);
   if (!encoding) {
-    return { body: bodyBuffer, compressed: false, encoding: null };
+    return { body: bodyBuffer, encoding: null };
   }
 
-  const compressedBody = encoding === 'br'
-    ? brotliCompressSync(bodyBuffer, {
+  return { body: bodyBuffer, encoding };
+}
+
+function compressBody(bodyBuffer, encoding, callback) {
+  if (encoding === 'br') {
+    brotliCompress(bodyBuffer, {
       params: {
         [zlibConstants.BROTLI_PARAM_QUALITY]: 5,
       },
-    })
-    : gzipSync(bodyBuffer, { level: 6 });
+    }, callback);
+    return;
+  }
+
+  gzip(bodyBuffer, { level: 6 }, callback);
+}
+
+function writeResponseHead(res, statusCode, headers, bodyBuffer) {
+  const responseHeaders = { ...headers };
+  if (bodyBuffer) {
+    responseHeaders['Content-Length'] = String(bodyBuffer.byteLength);
+  }
 
-  if (compressedBody.byteLength >= bodyBuffer.byteLength) {
-    return { body: bodyBuffer, compressed: false, encoding: null };
+  res.writeHead(statusCode, responseHeaders);
+}
+
+function writePreparedBody(req, res, statusCode, headers, bodyBuffer) {
+  writeResponseHead(res, statusCode, headers, bodyBuffer);
+
+  if (req.method === 'HEAD' || statusCode === 204 || statusCode === 304) {
+    res.end();
+    return;
   }
 
-  return { body: compressedBody, compressed: true, encoding };
+  res.end(bodyBuffer ?? undefined);
 }
 
 export function setHeaders(res, headers) {
@@ -116,30 +141,42 @@ export function sendResponse(req, res, {
   statusCode = 200,
 } = {}) {
   const contentType = headers['Content-Type'] || headers['content-type'] || '';
-  const prepared = maybeCompressBody(req, body, contentType);
+  const prepared = prepareBody(req, body, contentType);
 
   if (body !== null) {
     appendVaryHeader(res, 'Accept-Encoding');
   }
 
-  const responseHeaders = { ...headers };
-
-  if (prepared.compressed && prepared.encoding) {
-    responseHeaders['Content-Encoding'] = prepared.encoding;
-  }
-
-  if (prepared.body) {
-    responseHeaders['Content-Length'] = String(prepared.body.byteLength);
-  }
-
-  res.writeHead(statusCode, responseHeaders);
-
-  if (req.method === 'HEAD' || statusCode === 204 || statusCode === 304) {
-    res.end();
+  if (!prepared.body || !prepared.encoding || req.method === 'HEAD' || statusCode === 204 || statusCode === 304) {
+    writePreparedBody(req, res, statusCode, headers, prepared.body);
     return;
   }
 
-  res.end(prepared.body ?? undefined);
+  compressBody(prepared.body, prepared.encoding, (error, compressedBody) => {
+    if (res.writableEnded || res.destroyed) {
+      return;
+    }
+
+    if (error) {
+      console.error('[http] Failed to compress response body:', error.message);
+      if (!res.headersSent) {
+        writePreparedBody(req, res, statusCode, headers, prepared.body);
+        return;
+      }
+      res.destroy(error);
+      return;
+    }
+
+    if (!compressedBody || compressedBody.byteLength >= prepared.body.byteLength) {
+      writePreparedBody(req, res, statusCode, headers, prepared.body);
+      return;
+    }
+
+    writePreparedBody(req, res, statusCode, {
+      ...headers,
+      'Content-Encoding': prepared.encoding,
+    }, compressedBody);
+  });
 }
 
 export function jsonResponse(req, res, statusCode, data) {

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 || '')));
+  }
+}