collabmd 0.1.18

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

@@ -0,0 +1,94 @@
+export class RoomRegistry {
+  constructor({ createRoom }) {
+    this.createRoom = createRoom;
+    this.rooms = new Map();
+  }
+
+  get(name) {
+    return this.rooms.get(name);
+  }
+
+  getOrCreate(name) {
+    const existingRoom = this.rooms.get(name);
+    if (!existingRoom || existingRoom.isDeleted?.()) {
+      const room = this.createRoom({
+        name,
+        onEmpty: (roomName) => {
+          if (this.rooms.get(roomName) === room) {
+            this.rooms.delete(roomName);
+          }
+        },
+      });
+
+      this.rooms.set(name, room);
+    }
+
+    return this.rooms.get(name);
+  }
+
+  rename(oldName, newName) {
+    if (!oldName || !newName || oldName === newName) {
+      return false;
+    }
+
+    const room = this.rooms.get(oldName);
+    if (!room) {
+      return false;
+    }
+
+    if (this.rooms.has(newName)) {
+      return false;
+    }
+
+    this.rooms.delete(oldName);
+    room.rename?.(newName);
+    this.rooms.set(newName, room);
+    return true;
+  }
+
+  delete(name) {
+    return this.rooms.delete(name);
+  }
+
+  async reset() {
+    await Promise.allSettled(
+      Array.from(this.rooms.values(), (room) => room.destroy?.()),
+    );
+    this.rooms.clear();
+  }
+
+  async reconcileWorkspaceChange(workspaceChange = {}) {
+    const deletedPaths = new Set(workspaceChange.deletedPaths ?? []);
+    const renamedPaths = Array.isArray(workspaceChange.renamedPaths) ? workspaceChange.renamedPaths : [];
+    const renamedOldPaths = new Set(renamedPaths.map((entry) => entry?.oldPath).filter(Boolean));
+
+    await Promise.allSettled(
+      [...deletedPaths, ...renamedOldPaths].map(async (pathValue) => {
+        const room = this.rooms.get(pathValue);
+        if (!room) {
+          return;
+        }
+
+        room.markDeleted?.();
+        await room.destroy?.();
+        if (this.rooms.get(pathValue) === room) {
+          this.rooms.delete(pathValue);
+        }
+      }),
+    );
+
+    const blockedPaths = new Set([...deletedPaths, ...renamedOldPaths]);
+    await Promise.allSettled(
+      Array.from(new Set(workspaceChange.changedPaths ?? []))
+        .filter((pathValue) => pathValue && !blockedPaths.has(pathValue))
+        .map(async (pathValue) => {
+          const room = this.rooms.get(pathValue);
+          if (!room || room.isDeleted?.()) {
+            return;
+          }
+
+          await room.reloadFromDisk?.();
+        }),
+    );
+  }
+}

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

@@ -0,0 +1 @@
+export { GitService } from '../infrastructure/git/git-service.js';

package/src/server/domain/plantuml-encoder.js

@@ -0,0 +1,49 @@
+import { deflateRawSync } from 'node:zlib';
+
+function encode6bit(value) {
+  if (value < 10) {
+    return String.fromCharCode(48 + value);
+  }
+
+  if (value < 36) {
+    return String.fromCharCode(55 + value);
+  }
+
+  if (value < 62) {
+    return String.fromCharCode(61 + value);
+  }
+
+  if (value === 62) {
+    return '-';
+  }
+
+  if (value === 63) {
+    return '_';
+  }
+
+  return '?';
+}
+
+function append3bytes(byte1, byte2, byte3) {
+  const c1 = byte1 >> 2;
+  const c2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
+  const c3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);
+  const c4 = byte3 & 0x3f;
+
+  return `${encode6bit(c1 & 0x3f)}${encode6bit(c2 & 0x3f)}${encode6bit(c3 & 0x3f)}${encode6bit(c4 & 0x3f)}`;
+}
+
+export function encodePlantUmlText(source = '') {
+  const compressed = deflateRawSync(Buffer.from(String(source), 'utf-8'));
+  let encoded = '';
+
+  for (let index = 0; index < compressed.length; index += 3) {
+    encoded += append3bytes(
+      compressed[index] ?? 0,
+      compressed[index + 1] ?? 0,
+      compressed[index + 2] ?? 0,
+    );
+  }
+
+  return encoded;
+}

package/src/server/domain/plantuml-renderer.js

@@ -0,0 +1 @@
+export { PlantUmlRenderer } from '../infrastructure/plantuml/plantuml-renderer.js';

package/src/server/index.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import { loadConfig } from './config/env.js';
+import { createAppServer } from './create-app-server.js';
+import { prepareConfigForStartup } from './startup/git-remote-bootstrap.js';
+
+let shutdownPromise = null;
+const config = loadConfig();
+
+try {
+  await prepareConfigForStartup(config);
+} catch (error) {
+  console.error('[server] Failed to prepare git-backed vault:', error.message);
+  process.exit(1);
+}
+
+const server = createAppServer(config);
+
+function shutdown(signal) {
+  if (shutdownPromise) {
+    return shutdownPromise;
+  }
+
+  console.log(`[server] Received ${signal}, shutting down`);
+
+  const forceExitTimer = setTimeout(() => {
+    console.error('[server] Forced shutdown after timeout');
+    process.exit(1);
+  }, 5000);
+  forceExitTimer.unref?.();
+
+  shutdownPromise = server.close()
+    .then(() => {
+      clearTimeout(forceExitTimer);
+      process.exit(0);
+    })
+    .catch((error) => {
+      clearTimeout(forceExitTimer);
+      console.error('[server] Shutdown error:', error.message);
+      process.exit(1);
+    });
+
+  return shutdownPromise;
+}
+
+process.once('SIGINT', () => {
+  void shutdown('SIGINT');
+});
+process.once('SIGTERM', () => {
+  void shutdown('SIGTERM');
+});
+
+server.listen().then(({ host, port, wsPath }) => {
+  console.log('');
+  console.log('  CollabMD Vault Server');
+  console.log(`  http://${host}:${port}`);
+  console.log(`  ws route: ${wsPath}`);
+  console.log(`  vault: ${server.config.vaultDir}`);
+  console.log(`  files: ${server.vaultFileCount} vault files`);
+  if (server.config.auth.strategy === 'password') {
+    console.log(`  auth: password (${server.config.auth.password})`);
+  } else if (server.config.auth.strategy === 'oidc') {
+    console.log('  auth: oidc (not implemented yet)');
+  } else {
+    console.log('  auth: none');
+  }
+  console.log('');
+}).catch(async (error) => {
+  await config.git?.cleanup?.();
+  console.error('[server] Failed to start:', error.message);
+  process.exit(1);
+});

package/src/server/infrastructure/git/command-runner.js

@@ -0,0 +1,48 @@
+import { execFile as execFileCallback } from 'node:child_process';
+import { access } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFile = promisify(execFileCallback);
+
+export class GitCommandRunner {
+  constructor({
+    commandEnv = null,
+    enabled = true,
+    execFileImpl = execFile,
+    vaultDir,
+  }) {
+    this.commandEnv = commandEnv;
+    this.enabled = enabled;
+    this.execFileImpl = execFileImpl;
+    this.vaultDir = vaultDir;
+  }
+
+  async isGitRepo() {
+    if (!this.enabled) {
+      return false;
+    }
+
+    try {
+      await access(join(this.vaultDir, '.git'));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async execGit(args) {
+    const result = await this.execFileImpl('git', ['-c', 'core.quotepath=false', ...args], {
+      cwd: this.vaultDir,
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        ...(this.commandEnv ?? {}),
+      },
+      maxBuffer: 5 * 1024 * 1024,
+      timeout: 10_000,
+    });
+
+    return String(result.stdout ?? '');
+  }
+}

package/src/server/infrastructure/git/concurrency.js

@@ -0,0 +1,19 @@
+export async function mapWithConcurrency(items, limit, iteratee) {
+  if (items.length === 0) {
+    return [];
+  }
+
+  const results = new Array(items.length);
+  let cursor = 0;
+  const workerCount = Math.max(1, Math.min(limit, items.length));
+
+  await Promise.all(Array.from({ length: workerCount }, async () => {
+    while (cursor < items.length) {
+      const currentIndex = cursor;
+      cursor += 1;
+      results[currentIndex] = await iteratee(items[currentIndex], currentIndex);
+    }
+  }));
+
+  return results;
+}

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

@@ -0,0 +1,389 @@
+import { countPatchLines, parseNumstatOutput, parseUnifiedDiff } from './parsers.js';
+import { createDiffResponse, createEmptyStats } from './responses.js';
+
+function createSectionMap(sections = []) {
+  return new Map(sections.map((section) => [section.key, section]));
+}
+
+function getStatusPriority(status) {
+  switch (status) {
+    case 'deleted':
+      return 5;
+    case 'added':
+    case 'untracked':
+      return 4;
+    case 'renamed':
+      return 3;
+    default:
+      return 2;
+  }
+}
+
+function createScopeFlags(scope) {
+  return {
+    hasStagedChanges: scope === 'staged',
+    hasUntrackedChanges: scope === 'untracked',
+    hasWorkingTreeChanges: scope === 'working-tree',
+  };
+}
+
+function mergeScopedFile(existingFile, nextFile, scope) {
+  const nextFlags = createScopeFlags(nextFile.scope);
+  if (!existingFile) {
+    return {
+      ...nextFile,
+      ...nextFlags,
+      scope,
+      stats: createEmptyStats(),
+    };
+  }
+
+  const nextPriority = getStatusPriority(nextFile.status);
+  const currentPriority = getStatusPriority(existingFile.status);
+  if (nextPriority > currentPriority) {
+    return {
+      ...existingFile,
+      ...nextFile,
+      hasStagedChanges: existingFile.hasStagedChanges || nextFlags.hasStagedChanges,
+      hasUntrackedChanges: existingFile.hasUntrackedChanges || nextFlags.hasUntrackedChanges,
+      hasWorkingTreeChanges: existingFile.hasWorkingTreeChanges || nextFlags.hasWorkingTreeChanges,
+      scope,
+      stats: existingFile.stats ?? createEmptyStats(),
+    };
+  }
+
+  return {
+    ...existingFile,
+    hasStagedChanges: existingFile.hasStagedChanges || nextFlags.hasStagedChanges,
+    hasUntrackedChanges: existingFile.hasUntrackedChanges || nextFlags.hasUntrackedChanges,
+    hasWorkingTreeChanges: existingFile.hasWorkingTreeChanges || nextFlags.hasWorkingTreeChanges,
+  };
+}
+
+export class GitDiffService {
+  constructor({
+    commandRunner,
+    maxInitialPatchBytes = 250_000,
+    maxInitialPatchLines = 1_500,
+    statusService,
+    untrackedFileService,
+  }) {
+    this.commandRunner = commandRunner;
+    this.maxInitialPatchBytes = maxInitialPatchBytes;
+    this.maxInitialPatchLines = maxInitialPatchLines;
+    this.statusService = statusService;
+    this.untrackedFileService = untrackedFileService;
+    this.pendingDiffRequests = new Map();
+  }
+
+  invalidate() {
+    this.pendingDiffRequests.clear();
+  }
+
+  buildDiffCommandArgs({ hasHeadCommit = true, numstat = false, path = null, scope = 'working-tree' } = {}) {
+    const args = numstat
+      ? ['diff', '--numstat']
+      : ['diff', '--no-color', '--no-ext-diff', '--find-renames'];
+
+    if (scope === 'staged') {
+      args.push('--cached');
+    } else if (scope === 'all') {
+      if (hasHeadCommit) {
+        args.push('HEAD');
+      } else {
+        args.push('--cached');
+      }
+    }
+
+    if (path) {
+      args.push('--', path);
+    }
+
+    return args;
+  }
+
+  getScopedFiles(status, scope = 'working-tree', path = null) {
+    const orderedFiles = [];
+    const fileMap = new Map();
+    const sectionMap = createSectionMap(status.sections);
+    const candidateSections = scope === 'staged'
+      ? ['staged']
+      : scope === 'all'
+        ? ['staged', 'working-tree', 'untracked']
+        : ['working-tree', 'untracked'];
+
+    for (const sectionKey of candidateSections) {
+      const section = sectionMap.get(sectionKey);
+      for (const file of section?.files ?? []) {
+        if (path && file.path !== path) {
+          continue;
+        }
+
+        const existing = fileMap.get(file.path) ?? null;
+        const merged = mergeScopedFile(existing, file, scope);
+        fileMap.set(file.path, merged);
+        if (!existing) {
+          orderedFiles.push(merged);
+        }
+      }
+    }
+
+    return orderedFiles;
+  }
+
+  async getScopeSummary({
+    files = [],
+    hasHeadCommit = false,
+    path = null,
+    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(
+      files.filter((entry) => entry.status === 'untracked'),
+    );
+
+    return {
+      additions: trackedSummary.additions + untrackedAdditions,
+      deletions: trackedSummary.deletions,
+      filesChanged: files.length,
+    };
+  }
+
+  async getDiff({ allowLargePatch = false, metaOnly = false, path = null, scope = 'working-tree' } = {}) {
+    const isGitRepo = await this.commandRunner.isGitRepo();
+    if (!isGitRepo) {
+      return createDiffResponse({
+        files: [],
+        isGitRepo: false,
+        metaOnly,
+        scope,
+      });
+    }
+
+    const resolvedScope = scope === 'staged' || scope === 'all'
+      ? scope
+      : 'working-tree';
+    const requestKey = JSON.stringify({
+      allowLargePatch: Boolean(allowLargePatch),
+      metaOnly: Boolean(metaOnly),
+      path,
+      scope: resolvedScope,
+    });
+
+    if (this.pendingDiffRequests.has(requestKey)) {
+      return this.pendingDiffRequests.get(requestKey);
+    }
+
+    const requestPromise = this.getDiffUncached({
+      allowLargePatch,
+      metaOnly,
+      path,
+      scope: resolvedScope,
+    });
+    this.pendingDiffRequests.set(requestKey, requestPromise);
+
+    try {
+      return await requestPromise;
+    } finally {
+      if (this.pendingDiffRequests.get(requestKey) === requestPromise) {
+        this.pendingDiffRequests.delete(requestKey);
+      }
+    }
+  }
+
+  async getDiffUncached({ allowLargePatch = false, metaOnly = false, path = null, scope = 'working-tree' } = {}) {
+    const status = await this.statusService.getStatus();
+    const scopedFiles = this.getScopedFiles(status, scope, path);
+    const hasHeadCommit = Boolean(status.branch?.hasCommits);
+
+    if (metaOnly) {
+      const scopeSummary = await this.getScopeSummary({
+        files: scopedFiles,
+        hasHeadCommit,
+        path,
+        scope,
+      });
+
+      return createDiffResponse({
+        files: scopedFiles,
+        metaOnly: true,
+        path,
+        scope,
+        summary: scopeSummary,
+      });
+    }
+
+    const isSinglePathRequest = Boolean(path);
+    const currentFile = isSinglePathRequest ? scopedFiles[0] ?? null : null;
+    if (currentFile?.status === 'untracked') {
+      const fileLineCount = await this.untrackedFileService.countAdditions([currentFile]);
+      const summary = {
+        additions: fileLineCount,
+        deletions: 0,
+        filesChanged: scopedFiles.length,
+      };
+
+      if (!allowLargePatch && fileLineCount > this.maxInitialPatchLines) {
+        return createDiffResponse({
+          files: [{
+            ...currentFile,
+            canLoadFullPatch: true,
+            hunks: [],
+            patchLineCount: fileLineCount,
+            stats: {
+              additions: fileLineCount,
+              deletions: 0,
+            },
+            tooLarge: true,
+          }],
+          metaOnly: false,
+          path,
+          scope,
+          summary,
+        });
+      }
+
+      const syntheticFiles = await this.untrackedFileService.buildSyntheticDiffs([currentFile]);
+      const detail = syntheticFiles[0] ?? {
+        ...currentFile,
+        hunks: [],
+        stats: {
+          additions: fileLineCount,
+          deletions: 0,
+        },
+      };
+
+      return createDiffResponse({
+        files: [{
+          ...currentFile,
+          ...detail,
+          canLoadFullPatch: false,
+          patchLineCount: countPatchLines(detail),
+          tooLarge: false,
+        }],
+        metaOnly: false,
+        path,
+        scope,
+        summary,
+      });
+    }
+
+    let singleFileSummary = null;
+    if (isSinglePathRequest) {
+      singleFileSummary = await this.getScopeSummary({
+        files: scopedFiles,
+        hasHeadCommit,
+        path,
+        scope,
+      });
+
+      if (
+        currentFile
+        && !allowLargePatch
+        && singleFileSummary.filesChanged > 0
+        && (singleFileSummary.additions + singleFileSummary.deletions) > this.maxInitialPatchLines
+      ) {
+        return createDiffResponse({
+          files: [{
+            ...currentFile,
+            canLoadFullPatch: true,
+            hunks: [],
+            patchLineCount: singleFileSummary.additions + singleFileSummary.deletions,
+            stats: {
+              additions: singleFileSummary.additions,
+              deletions: singleFileSummary.deletions,
+            },
+            tooLarge: true,
+          }],
+          metaOnly: false,
+          path,
+          scope,
+          summary: singleFileSummary,
+        });
+      }
+    }
+
+    const diffText = await this.commandRunner.execGit(this.buildDiffCommandArgs({
+      hasHeadCommit,
+      path,
+      scope,
+    }));
+    const parsedFiles = parseUnifiedDiff(diffText);
+
+    if (scope !== 'staged') {
+      const untrackedFiles = this.getScopedFiles(status, 'working-tree', path)
+        .filter((file) => file.status === 'untracked');
+      const trackedPathSet = new Set(parsedFiles.map((entry) => entry.path));
+      const missingUntrackedFiles = untrackedFiles.filter((file) => !trackedPathSet.has(file.path));
+      parsedFiles.push(...await this.untrackedFileService.buildSyntheticDiffs(missingUntrackedFiles));
+    }
+
+    const parsedFileMap = new Map(parsedFiles.map((file) => [file.path, file]));
+    const mergedFiles = scopedFiles.map((file) => {
+      const detail = parsedFileMap.get(file.path) ?? null;
+      if (!detail) {
+        return {
+          ...file,
+          hunks: [],
+          stats: file.stats ?? createEmptyStats(),
+        };
+      }
+
+      const patchLineCount = countPatchLines(detail);
+      if (
+        isSinglePathRequest
+        && !allowLargePatch
+        && (
+          patchLineCount > this.maxInitialPatchLines
+          || diffText.length > this.maxInitialPatchBytes
+        )
+      ) {
+        return {
+          ...file,
+          byteLength: diffText.length,
+          canLoadFullPatch: true,
+          hunks: [],
+          patchLineCount,
+          stats: detail.stats,
+          tooLarge: true,
+        };
+      }
+
+      return {
+        ...file,
+        ...detail,
+        canLoadFullPatch: false,
+        patchLineCount,
+        tooLarge: false,
+      };
+    });
+
+    const summary = parsedFiles.reduce((accumulator, file) => ({
+      additions: accumulator.additions + (file.stats?.additions ?? 0),
+      deletions: accumulator.deletions + (file.stats?.deletions ?? 0),
+      filesChanged: accumulator.filesChanged + 1,
+    }), {
+      additions: 0,
+      deletions: 0,
+      filesChanged: 0,
+    });
+
+    return createDiffResponse({
+      files: mergedFiles,
+      metaOnly: false,
+      path,
+      scope,
+      summary: isSinglePathRequest ? singleFileSummary ?? summary : summary,
+    });
+  }
+}

package/src/server/infrastructure/git/errors.js

@@ -0,0 +1,5 @@
+export function createGitRequestError(statusCode, message) {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  return error;
+}