collabmd 0.1.18

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

@@ -0,0 +1,108 @@
+const STATUS_MAP = {
+  A: { code: 'A', label: 'added', status: 'added' },
+  C: { code: 'C', label: 'copied', status: 'copied' },
+  D: { code: 'D', label: 'deleted', status: 'deleted' },
+  M: { code: 'M', label: 'modified', status: 'modified' },
+  R: { code: 'R', label: 'renamed', status: 'renamed' },
+  T: { code: 'T', label: 'type change', status: 'type-changed' },
+  U: { code: 'U', label: 'conflicted', status: 'conflicted' },
+  '?': { code: 'U', label: 'untracked', status: 'untracked' },
+};
+
+export function createStatusInfo(symbol) {
+  return STATUS_MAP[symbol] ?? { code: symbol || 'M', label: 'modified', status: 'modified' };
+}
+
+export function createEmptyStats() {
+  return {
+    additions: 0,
+    deletions: 0,
+  };
+}
+
+export function createEmptySummary() {
+  return {
+    additions: 0,
+    changedFiles: 0,
+    deletions: 0,
+    staged: 0,
+    untracked: 0,
+    workingTree: 0,
+  };
+}
+
+export function createEmptyBranchStatus() {
+  return {
+    ahead: 0,
+    behind: 0,
+    detached: false,
+    hasCommits: false,
+    name: null,
+    upstream: null,
+  };
+}
+
+export function createEmptyWorkspaceChange() {
+  return {
+    changedPaths: [],
+    deletedPaths: [],
+    refreshExplorer: true,
+    renamedPaths: [],
+  };
+}
+
+export function createEmptyStatusResponse() {
+  return {
+    branch: createEmptyBranchStatus(),
+    isGitRepo: false,
+    sections: [
+      { files: [], key: 'staged', label: 'Staged Changes' },
+      { files: [], key: 'working-tree', label: 'Changes' },
+      { files: [], key: 'untracked', label: 'Untracked' },
+    ],
+    summary: createEmptySummary(),
+  };
+}
+
+export function createDiffResponse({
+  files = [],
+  isGitRepo = true,
+  metaOnly = false,
+  path = null,
+  scope = 'working-tree',
+  summary = {
+    additions: 0,
+    deletions: 0,
+    filesChanged: 0,
+  },
+} = {}) {
+  return {
+    files,
+    isGitRepo,
+    metaOnly,
+    path,
+    scope,
+    summary,
+  };
+}
+
+export function createWorkspaceChange({
+  changedPaths = [],
+  deletedPaths = [],
+  refreshExplorer = true,
+  renamedPaths = [],
+} = {}) {
+  return {
+    changedPaths: Array.from(new Set((changedPaths ?? []).filter(Boolean))),
+    deletedPaths: Array.from(new Set((deletedPaths ?? []).filter(Boolean))),
+    refreshExplorer: Boolean(refreshExplorer),
+    renamedPaths: Array.from(new Map(
+      (renamedPaths ?? [])
+        .filter((entry) => entry?.oldPath && entry?.newPath && entry.oldPath !== entry.newPath)
+        .map((entry) => [`${entry.oldPath}:${entry.newPath}`, {
+          newPath: entry.newPath,
+          oldPath: entry.oldPath,
+        }]),
+    ).values()),
+  };
+}

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

@@ -0,0 +1,99 @@
+import { parseNumstatOutput, parseStatusOutput } from './parsers.js';
+import { createEmptyStatusResponse } from './responses.js';
+
+export class GitStatusService {
+  constructor({
+    commandRunner,
+    statusCacheTtlMs = 2_000,
+    untrackedFileService,
+  }) {
+    this.commandRunner = commandRunner;
+    this.statusCacheTtlMs = statusCacheTtlMs;
+    this.untrackedFileService = untrackedFileService;
+    this.statusCache = {
+      expiresAt: 0,
+      value: null,
+    };
+    this.pendingStatusPromise = null;
+  }
+
+  invalidate() {
+    this.statusCache = {
+      expiresAt: 0,
+      value: null,
+    };
+    this.pendingStatusPromise = null;
+  }
+
+  async getStatus({ force = false } = {}) {
+    const isGitRepo = await this.commandRunner.isGitRepo();
+    if (!isGitRepo) {
+      return createEmptyStatusResponse();
+    }
+
+    const now = Date.now();
+    if (!force && this.statusCache.value && now < this.statusCache.expiresAt) {
+      return this.statusCache.value;
+    }
+
+    if (this.pendingStatusPromise) {
+      return this.pendingStatusPromise;
+    }
+
+    const statusPromise = (async () => {
+      const parsed = parseStatusOutput(
+        await this.commandRunner.execGit(['status', '--porcelain=v1', '--branch', '--untracked-files=all']),
+      );
+      const sections = [
+        { files: parsed.sections.staged, key: 'staged', label: 'Staged Changes' },
+        { files: parsed.sections['working-tree'], key: 'working-tree', label: 'Changes' },
+        { files: parsed.sections.untracked, key: 'untracked', label: 'Untracked' },
+      ];
+      const localSummary = await this.getLocalChangeSummary({
+        hasHeadCommit: parsed.branch.hasCommits,
+        untrackedFiles: parsed.sections.untracked,
+      });
+      const response = {
+        branch: parsed.branch,
+        isGitRepo: true,
+        sections,
+        summary: {
+          ...parsed.summary,
+          additions: localSummary.additions,
+          deletions: localSummary.deletions,
+        },
+      };
+
+      this.statusCache = {
+        expiresAt: Date.now() + this.statusCacheTtlMs,
+        value: response,
+      };
+
+      return response;
+    })();
+
+    this.pendingStatusPromise = statusPromise;
+
+    try {
+      return await statusPromise;
+    } finally {
+      if (this.pendingStatusPromise === statusPromise) {
+        this.pendingStatusPromise = null;
+      }
+    }
+  }
+
+  async getLocalChangeSummary({ hasHeadCommit = false, untrackedFiles = [] } = {}) {
+    const trackedSummary = parseNumstatOutput(
+      await this.commandRunner.execGit(hasHeadCommit
+        ? ['diff', '--numstat', 'HEAD']
+        : ['diff', '--cached', '--numstat']),
+    );
+    const untrackedAdditions = await this.untrackedFileService.countAdditions(untrackedFiles);
+
+    return {
+      additions: trackedSummary.additions + untrackedAdditions,
+      deletions: trackedSummary.deletions,
+    };
+  }
+}

package/src/server/infrastructure/git/untracked-files.js

@@ -0,0 +1,101 @@
+import { createReadStream } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { mapWithConcurrency } from './concurrency.js';
+import { createEmptyStats } from './responses.js';
+import { splitContentLines } from './parsers.js';
+
+async function countFileLines(filePath) {
+  return new Promise((resolve, reject) => {
+    const stream = createReadStream(filePath, { encoding: 'utf8' });
+    let lineCount = 0;
+    let sawData = false;
+    let lastCharacter = '\n';
+
+    stream.on('data', (chunk) => {
+      if (!chunk) {
+        return;
+      }
+
+      sawData = true;
+      lastCharacter = chunk[chunk.length - 1];
+      lineCount += chunk.match(/\n/gu)?.length ?? 0;
+    });
+    stream.on('error', reject);
+    stream.on('end', () => {
+      if (sawData && lastCharacter !== '\n') {
+        lineCount += 1;
+      }
+      resolve(lineCount);
+    });
+  });
+}
+
+function buildSyntheticAddedFileDiff(pathValue, content) {
+  const normalizedContent = String(content ?? '').replace(/\r\n/g, '\n');
+  const file = {
+    code: 'U',
+    hunks: [],
+    isBinary: false,
+    oldPath: null,
+    path: pathValue,
+    stats: createEmptyStats(),
+    status: 'untracked',
+    synthetic: true,
+  };
+  const lines = splitContentLines(normalizedContent);
+
+  if (lines.length === 0) {
+    return file;
+  }
+
+  file.stats.additions = lines.length;
+  file.hunks.push({
+    header: `@@ -0,0 +1,${lines.length} @@`,
+    lines: lines.map((line, index) => ({
+      content: line,
+      newLine: index + 1,
+      oldLine: null,
+      type: 'addition',
+    })),
+    newLines: lines.length,
+    newStart: 1,
+    oldLines: 0,
+    oldStart: 0,
+    section: '',
+  });
+
+  return file;
+}
+
+export class GitUntrackedFileService {
+  constructor({ vaultDir }) {
+    this.vaultDir = vaultDir;
+  }
+
+  async countAdditions(files = []) {
+    const counts = await mapWithConcurrency(files, 4, async (file) => {
+      try {
+        return await countFileLines(join(this.vaultDir, file.path));
+      } catch {
+        return 0;
+      }
+    });
+
+    return counts.reduce((total, count) => total + count, 0);
+  }
+
+  async buildSyntheticDiffs(files = []) {
+    const results = await mapWithConcurrency(files, 2, async (file) => {
+      try {
+        const content = await readFile(join(this.vaultDir, file.path), 'utf8');
+        return buildSyntheticAddedFileDiff(file.path, content);
+      } catch {
+        return null;
+      }
+    });
+
+    return results.filter(Boolean);
+  }
+}

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

@@ -0,0 +1,48 @@
+import { getRequestErrorStatusCode } from './http-errors.js';
+import { jsonResponse } from './http-response.js';
+import { parseJsonBody } from './request-body.js';
+
+function applyAuthResponse(req, res, result) {
+  if (result?.setCookie) {
+    res.setHeader('Set-Cookie', result.setCookie);
+  }
+
+  jsonResponse(req, res, result?.statusCode ?? 200, result?.body ?? { ok: true });
+  return true;
+}
+
+export function createAuthApiHandler({ authService }) {
+  return async function handleAuthApi(req, res, requestUrl) {
+    if (!(requestUrl.pathname === '/api/auth' || requestUrl.pathname.startsWith('/api/auth/'))) {
+      return false;
+    }
+
+    if (requestUrl.pathname === '/api/auth/status' && req.method === 'GET') {
+      return applyAuthResponse(req, res, authService.getStatus(req));
+    }
+
+    if (requestUrl.pathname === '/api/auth/session' && req.method === 'POST') {
+      try {
+        const body = await parseJsonBody(req);
+        return applyAuthResponse(req, res, authService.createSession(req, body));
+      } catch (error) {
+        const statusCode = getRequestErrorStatusCode(error);
+        if (statusCode) {
+          jsonResponse(req, res, statusCode, { error: error.message });
+          return true;
+        }
+
+        console.error('[api] Failed to create auth session:', error.message);
+        jsonResponse(req, res, 500, { error: 'Failed to create auth session' });
+        return true;
+      }
+    }
+
+    if (requestUrl.pathname === '/api/auth/session' && req.method === 'DELETE') {
+      return applyAuthResponse(req, res, authService.clearSession(req));
+    }
+
+    jsonResponse(req, res, 404, { error: 'Auth endpoint not found' });
+    return true;
+  };
+}

package/src/server/infrastructure/http/create-esm-proxy-handler.js

@@ -0,0 +1,130 @@
+import { createRequestError } from './http-errors.js';
+import { sendResponse, textResponse } from './http-response.js';
+
+const ESM_PROXY_PREFIX = '/_esm/';
+const ESM_UPSTREAM_ORIGIN = 'https://esm.sh';
+const ESM_TEXT_CONTENT_TYPE_PATTERN = /\b(?:javascript|ecmascript|css|json|text\/plain|text\/css)\b/i;
+
+function rewriteEsmText(body) {
+  return body
+    .replace(/((?:from|import)\s*(?:\(\s*)?["'])\/(?!_esm\/)/g, '$1/_esm/')
+    .replace(/((?:import|url)\(\s*["']?)\/(?!_esm\/)/g, '$1/_esm/')
+    .replace(/(@import\s+["'])\/(?!_esm\/)/g, '$1/_esm/');
+}
+
+function looksLikeHtmlDocument(body) {
+  const trimmed = body.trimStart();
+  return trimmed.startsWith('<!DOCTYPE html')
+    || trimmed.startsWith('<!doctype html')
+    || trimmed.startsWith('<html')
+    || trimmed.startsWith('<HTML')
+    || trimmed.startsWith('<?xml');
+}
+
+function isEsmProxyPath(pathname) {
+  return pathname === '/_esm' || pathname.startsWith(ESM_PROXY_PREFIX);
+}
+
+function resolveEsmUpstreamUrl(requestUrl) {
+  const proxiedPath = requestUrl.pathname === '/_esm'
+    ? ''
+    : requestUrl.pathname.slice(ESM_PROXY_PREFIX.length);
+
+  if (!proxiedPath) {
+    throw createRequestError(400, 'Missing esm.sh module path');
+  }
+
+  return new URL(`${proxiedPath}${requestUrl.search}`, `${ESM_UPSTREAM_ORIGIN}/`).toString();
+}
+
+export function createEsmProxyHandler() {
+  const esmAssetCache = new Map();
+
+  async function fetchEsmAsset(upstreamUrl) {
+    if (!globalThis.fetch) {
+      throw createRequestError(500, 'Global fetch is unavailable for esm proxy');
+    }
+
+    if (!esmAssetCache.has(upstreamUrl)) {
+      esmAssetCache.set(upstreamUrl, (async () => {
+        let lastError = null;
+
+        for (let attempt = 1; attempt <= 3; attempt += 1) {
+          try {
+            const response = await globalThis.fetch(upstreamUrl, {
+              headers: {
+                Accept: 'text/javascript, application/javascript, text/css;q=0.9, */*;q=0.5',
+              },
+              redirect: 'follow',
+            });
+
+            if (!response.ok) {
+              throw createRequestError(502, `esm.sh responded with ${response.status}`);
+            }
+
+            const contentType = response.headers.get('content-type') || 'application/octet-stream';
+            const cacheControl = response.headers.get('cache-control') || 'public, max-age=300';
+
+            if (ESM_TEXT_CONTENT_TYPE_PATTERN.test(contentType)) {
+              const text = await response.text();
+              if (looksLikeHtmlDocument(text)) {
+                throw createRequestError(502, 'esm.sh returned HTML for a module asset');
+              }
+
+              return {
+                body: rewriteEsmText(text),
+                cacheControl,
+                contentType,
+              };
+            }
+
+            return {
+              body: Buffer.from(await response.arrayBuffer()),
+              cacheControl,
+              contentType,
+            };
+          } catch (error) {
+            lastError = error;
+          }
+        }
+
+        throw lastError || createRequestError(502, 'Failed to fetch esm.sh asset');
+      })().catch((error) => {
+        esmAssetCache.delete(upstreamUrl);
+        throw error;
+      }));
+    }
+
+    return esmAssetCache.get(upstreamUrl);
+  }
+
+  return async function handleEsmProxy(req, res, requestUrl) {
+    if (!isEsmProxyPath(requestUrl.pathname)) {
+      return false;
+    }
+
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      textResponse(req, res, 405, 'Method Not Allowed');
+      return true;
+    }
+
+    try {
+      const upstreamUrl = resolveEsmUpstreamUrl(requestUrl);
+      const asset = await fetchEsmAsset(upstreamUrl);
+      sendResponse(req, res, {
+        body: asset.body,
+        headers: {
+          'Cache-Control': asset.cacheControl,
+          'Content-Type': asset.contentType,
+        },
+        statusCode: 200,
+      });
+    } catch (error) {
+      const statusCode = Number.isInteger(error?.statusCode) ? error.statusCode : 502;
+      console.error(`[http] Failed to proxy "${requestUrl.pathname}":`, error.message);
+      textResponse(req, res, statusCode, 'Bad Gateway', { 'Cache-Control': 'no-store' });
+    }
+
+    return true;
+  };
+}

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

@@ -0,0 +1,170 @@
+import { getRequestErrorStatusCode } from './http-errors.js';
+import { jsonResponse } from './http-response.js';
+import { parseJsonBody } from './request-body.js';
+import { createEmptyWorkspaceChange } from '../git/responses.js';
+
+async function parseRequiredBody(req, res, fieldName) {
+  const body = await parseJsonBody(req);
+  if (!body?.[fieldName]) {
+    jsonResponse(req, res, 400, { error: `Missing ${fieldName}` });
+    return null;
+  }
+
+  return body;
+}
+
+function handleGitError(req, res, error, logMessage, fallbackMessage) {
+  const statusCode = getRequestErrorStatusCode(error);
+  if (statusCode) {
+    jsonResponse(req, res, statusCode, { error: error.message });
+    return true;
+  }
+
+  console.error(logMessage, error.message);
+  jsonResponse(req, res, 500, { error: fallbackMessage });
+  return true;
+}
+
+function hasWorkspaceMutation(workspaceChange = {}) {
+  return Boolean(
+    (workspaceChange.changedPaths?.length ?? 0) > 0
+    || (workspaceChange.deletedPaths?.length ?? 0) > 0
+    || (workspaceChange.renamedPaths?.length ?? 0) > 0,
+  );
+}
+
+async function applyWorkspaceMutationEffects({
+  backlinkIndex,
+  responsePayload,
+  roomRegistry,
+  vaultFileStore,
+}) {
+  const workspaceChange = responsePayload?.workspaceChange ?? createEmptyWorkspaceChange();
+  responsePayload.workspaceChange = workspaceChange;
+
+  if (!hasWorkspaceMutation(workspaceChange)) {
+    return responsePayload;
+  }
+
+  await vaultFileStore?.reconcileSidecars?.(workspaceChange);
+  await backlinkIndex?.build?.();
+  await roomRegistry?.reconcileWorkspaceChange?.(workspaceChange);
+  return responsePayload;
+}
+
+export function createGitApiCommandHandler({
+  backlinkIndex = null,
+  gitService,
+  roomRegistry = null,
+  vaultFileStore = null,
+}) {
+  return async function handleGitApiCommand(req, res, requestUrl) {
+    if (requestUrl.pathname === '/api/git/stage' && req.method === 'POST') {
+      try {
+        const body = await parseRequiredBody(req, res, 'path');
+        if (!body) {
+          return true;
+        }
+
+        jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
+          backlinkIndex,
+          responsePayload: await gitService.stageFile(body.path),
+          roomRegistry,
+          vaultFileStore,
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to stage git file:', 'Failed to stage git file');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/unstage' && req.method === 'POST') {
+      try {
+        const body = await parseRequiredBody(req, res, 'path');
+        if (!body) {
+          return true;
+        }
+
+        jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
+          backlinkIndex,
+          responsePayload: await gitService.unstageFile(body.path),
+          roomRegistry,
+          vaultFileStore,
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to unstage git file:', 'Failed to unstage git file');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/commit' && req.method === 'POST') {
+      try {
+        const body = await parseRequiredBody(req, res, 'message');
+        if (!body) {
+          return true;
+        }
+
+        jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
+          backlinkIndex,
+          responsePayload: await gitService.commitStaged({
+            message: body.message,
+          }),
+          roomRegistry,
+          vaultFileStore,
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to commit staged changes:', 'Failed to commit staged changes');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/push' && req.method === 'POST') {
+      try {
+        jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
+          backlinkIndex,
+          responsePayload: await gitService.pushBranch(),
+          roomRegistry,
+          vaultFileStore,
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to push git branch:', 'Failed to push git branch');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/pull' && req.method === 'POST') {
+      try {
+        jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
+          backlinkIndex,
+          responsePayload: await gitService.pullBranch(),
+          roomRegistry,
+          vaultFileStore,
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to pull git branch:', 'Failed to pull git branch');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/reset-file' && req.method === 'POST') {
+      try {
+        const body = await parseRequiredBody(req, res, 'path');
+        if (!body) {
+          return true;
+        }
+
+        jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
+          backlinkIndex,
+          responsePayload: await gitService.resetFileToHead(body.path),
+          roomRegistry,
+          vaultFileStore,
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to reset git file:', 'Failed to reset git file');
+      }
+      return true;
+    }
+
+    return false;
+  };
+}

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

@@ -0,0 +1,40 @@
+import { jsonResponse } from './http-response.js';
+import { createGitApiCommandHandler } from './create-git-api-command-handler.js';
+import { createGitApiQueryHandler } from './create-git-api-query-handler.js';
+
+export function createGitApiHandler({
+  backlinkIndex = null,
+  gitService = null,
+  roomRegistry = null,
+  vaultFileStore = null,
+}) {
+  const handleGitApiQuery = createGitApiQueryHandler({ gitService });
+  const handleGitApiCommand = createGitApiCommandHandler({
+    backlinkIndex,
+    gitService,
+    roomRegistry,
+    vaultFileStore,
+  });
+
+  return async function handleGitApi(req, res, requestUrl) {
+    if (!requestUrl.pathname.startsWith('/api/git')) {
+      return false;
+    }
+
+    if (!gitService) {
+      jsonResponse(req, res, 503, { error: 'Git integration is not configured' });
+      return true;
+    }
+
+    if (await handleGitApiQuery(req, res, requestUrl)) {
+      return true;
+    }
+
+    if (await handleGitApiCommand(req, res, requestUrl)) {
+      return true;
+    }
+
+    jsonResponse(req, res, 404, { error: 'Git API endpoint not found' });
+    return true;
+  };
+}