collabmd 0.1.19 → 0.1.20

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

@@ -16,7 +16,11 @@ async function parseRequiredBody(req, res, fieldName) {
 function handleGitError(req, res, error, logMessage, fallbackMessage) {
   const statusCode = getRequestErrorStatusCode(error);
   if (statusCode) {
-    jsonResponse(req, res, statusCode, { error: error.message });
+    const payload = { error: error.message };
+    if (typeof error?.requestCode === 'string') {
+      payload.code = error.requestCode;
+    }
+    jsonResponse(req, res, statusCode, payload);
     return true;
   }
 
@@ -47,6 +51,7 @@ async function applyWorkspaceMutationEffects({
   }
 
   await vaultFileStore?.reconcileSidecars?.(workspaceChange);
+  await vaultFileStore?.reconcileCollaborationSnapshots?.(workspaceChange);
   await backlinkIndex?.build?.();
   await roomRegistry?.reconcileWorkspaceChange?.(workspaceChange);
   return responsePayload;

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

@@ -21,7 +21,11 @@ function isTruthyParam(value) {
 function handleGitError(req, res, error, message, fallback) {
   const statusCode = getRequestErrorStatusCode(error);
   if (statusCode) {
-    jsonResponse(req, res, statusCode, { error: error.message });
+    const payload = { error: error.message };
+    if (typeof error?.requestCode === 'string') {
+      payload.code = error.requestCode;
+    }
+    jsonResponse(req, res, statusCode, payload);
     return true;
   }
 
@@ -57,6 +61,17 @@ export function createGitApiQueryHandler({ gitService }) {
       return true;
     }
 
+    if (requestUrl.pathname === '/api/git/pull-backups' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, {
+          backups: await gitService.listPullBackups(),
+        });
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read pull backups:', 'Failed to read pull backups');
+      }
+      return true;
+    }
+
     return false;
   };
 }

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

@@ -582,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;