collabmd 0.1.43 → 0.1.45

package/src/server/index.js

@@ -1,74 +0,0 @@
-#!/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 (${server.config.auth.oidc.provider})`);
-    console.log(`  public: ${server.config.auth.oidc.publicBaseUrl}`);
-    console.log(`  callback: ${server.config.auth.oidc.callbackUrl}`);
-  } 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

@@ -1,49 +0,0 @@
-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, { env = null } = {}) {
-    const result = await this.execFileImpl('git', ['-c', 'core.quotepath=false', ...args], {
-      cwd: this.vaultDir,
-      encoding: 'utf8',
-      env: {
-        ...process.env,
-        ...(this.commandEnv ?? {}),
-        ...(env ?? {}),
-      },
-      maxBuffer: 5 * 1024 * 1024,
-      timeout: 10_000,
-    });
-
-    return String(result.stdout ?? '');
-  }
-}

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

@@ -1,19 +0,0 @@
-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/errors.js

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

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

@@ -1,130 +0,0 @@
-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-handler.js

@@ -1,44 +0,0 @@
-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({
-  authService = null,
-  backlinkIndex = null,
-  gitService = null,
-  roomRegistry = null,
-  vaultFileStore = null,
-  workspaceMutationCoordinator = null,
-}) {
-  const handleGitApiQuery = createGitApiQueryHandler({ gitService });
-  const handleGitApiCommand = createGitApiCommandHandler({
-    authService,
-    backlinkIndex,
-    gitService,
-    roomRegistry,
-    vaultFileStore,
-    workspaceMutationCoordinator,
-  });
-
-  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;
-  };
-}

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

@@ -1,54 +0,0 @@
-import { createPlantUmlApiHandler } from './create-plantuml-api-handler.js';
-import { createVaultApiCommandHandler } from './create-vault-api-command-handler.js';
-import { createVaultApiQueryHandler } from './create-vault-api-query-handler.js';
-
-export function createVaultApiHandler({
-  baseQueryService = null,
-  backlinkIndex,
-  config = {},
-  docxExporter = null,
-  plantUmlRenderer = null,
-  roomRegistry = null,
-  searchService = null,
-  vaultFileStore,
-  workspaceMutationCoordinator = null,
-}) {
-  const handleVaultApiQuery = createVaultApiQueryHandler({
-    baseQueryService,
-    backlinkIndex,
-    config,
-    searchService,
-    vaultFileStore,
-    workspaceMutationCoordinator,
-  });
-  const handleVaultApiCommand = createVaultApiCommandHandler({
-    backlinkIndex,
-    docxExporter,
-    roomRegistry,
-    vaultFileStore,
-    workspaceMutationCoordinator,
-  });
-  const handlePlantUmlApi = createPlantUmlApiHandler({
-    plantUmlRenderer,
-  });
-
-  return async function handleVaultApi(req, res, requestUrl) {
-    if (!requestUrl.pathname.startsWith('/api/')) {
-      return false;
-    }
-
-    if (await handleVaultApiQuery(req, res, requestUrl)) {
-      return true;
-    }
-
-    if (await handleVaultApiCommand(req, res, requestUrl)) {
-      return true;
-    }
-
-    if (await handlePlantUmlApi(req, res, requestUrl)) {
-      return true;
-    }
-
-    return false;
-  };
-}

package/src/server/infrastructure/persistence/vault-content-adapter.js

@@ -1,61 +0,0 @@
-import {
-  isBaseFilePath,
-  isDrawioFilePath,
-  isExcalidrawFilePath,
-  isMarkdownFilePath,
-  isMermaidFilePath,
-  isPlantUmlFilePath,
-} from '../../../domain/file-kind.js';
-
-export class EditableVaultContentKind {
-  constructor({
-    invalidPathError,
-    kind,
-    matches,
-  }) {
-    this.invalidPathError = invalidPathError;
-    this.kind = kind;
-    this.matches = matches;
-  }
-
-  supports(filePath) {
-    return this.matches(filePath);
-  }
-}
-
-const adapters = [
-  new EditableVaultContentKind({
-    invalidPathError: 'Invalid file path',
-    kind: 'markdown',
-    matches: isMarkdownFilePath,
-  }),
-  new EditableVaultContentKind({
-    invalidPathError: 'Invalid file path — must end in .base',
-    kind: 'base',
-    matches: isBaseFilePath,
-  }),
-  new EditableVaultContentKind({
-    invalidPathError: 'Invalid file path — must end in .excalidraw',
-    kind: 'excalidraw',
-    matches: isExcalidrawFilePath,
-  }),
-  new EditableVaultContentKind({
-    invalidPathError: 'Invalid file path — must end in .drawio',
-    kind: 'drawio',
-    matches: isDrawioFilePath,
-  }),
-  new EditableVaultContentKind({
-    invalidPathError: 'Invalid file path — must end in .mmd or .mermaid',
-    kind: 'mermaid',
-    matches: isMermaidFilePath,
-  }),
-  new EditableVaultContentKind({
-    invalidPathError: 'Invalid file path — must end in .puml or .plantuml',
-    kind: 'plantuml',
-    matches: isPlantUmlFilePath,
-  }),
-];
-
-export function getEditableVaultContentKind(filePath) {
-  return adapters.find((adapter) => adapter.supports(filePath)) ?? null;
-}

package/src/server/infrastructure/workspace/workspace-mutation-coordinator.js

@@ -1,20 +0,0 @@
-import { WorkspaceReconciliation } from '../../application/workspace-reconciliation.js';
-import { createWorkspaceStateFileSystemAdapter } from './workspace-state-file-system-adapter.js';
-
-export class WorkspaceMutationCoordinator extends WorkspaceReconciliation {
-  constructor({
-    vaultFileStore,
-    workspaceStateAdapter = createWorkspaceStateFileSystemAdapter({
-      vaultDir: vaultFileStore?.vaultDir,
-    }),
-    ...options
-  }) {
-    super({
-      ...options,
-      vaultFileStore,
-      workspaceStateAdapter,
-    });
-  }
-}
-
-export { WorkspaceReconciliation };