collabmd 0.1.21 → 0.1.25

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

@@ -86,6 +86,79 @@ export function createDiffResponse({
   };
 }
 
+export function createHistoryResponse({
+  commits = [],
+  hasMore = false,
+  isGitRepo = true,
+  limit = 30,
+  offset = 0,
+} = {}) {
+  return {
+    commits,
+    hasMore,
+    isGitRepo,
+    limit,
+    offset,
+  };
+}
+
+export function createFileHistoryResponse({
+  commits = [],
+  hasMore = false,
+  isGitRepo = true,
+  limit = 30,
+  offset = 0,
+  path = null,
+} = {}) {
+  return {
+    commits,
+    hasMore,
+    isGitRepo,
+    limit,
+    offset,
+    path,
+  };
+}
+
+export function createCommitDiffResponse({
+  commit = null,
+  files = [],
+  isGitRepo = true,
+  metaOnly = false,
+  path = null,
+  summary = {
+    additions: 0,
+    deletions: 0,
+    filesChanged: 0,
+  },
+} = {}) {
+  return {
+    commit,
+    files,
+    isGitRepo,
+    metaOnly,
+    path,
+    source: 'commit',
+    summary,
+  };
+}
+
+export function createFileSnapshotResponse({
+  content = '',
+  fileKind = null,
+  hash = null,
+  isGitRepo = true,
+  path = null,
+} = {}) {
+  return {
+    content,
+    fileKind,
+    hash,
+    isGitRepo,
+    path,
+  };
+}
+
 export function createWorkspaceChange({
   changedPaths = [],
   deletedPaths = [],

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

@@ -7,6 +7,14 @@ function applyAuthResponse(req, res, result) {
     res.setHeader('Set-Cookie', result.setCookie);
   }
 
+  if (result?.redirectTo) {
+    res.writeHead(result?.statusCode ?? 302, {
+      Location: result.redirectTo,
+    });
+    res.end();
+    return true;
+  }
+
   jsonResponse(req, res, result?.statusCode ?? 200, result?.body ?? { ok: true });
   return true;
 }
@@ -21,10 +29,30 @@ export function createAuthApiHandler({ authService }) {
       return applyAuthResponse(req, res, authService.getStatus(req));
     }
 
+    if (requestUrl.pathname === '/api/auth/oidc/login' && req.method === 'GET') {
+      try {
+        return applyAuthResponse(req, res, await authService.beginOidcLogin(req, requestUrl));
+      } catch (error) {
+        console.error('[api] Failed to start OIDC login:', error.message);
+        jsonResponse(req, res, 500, { error: 'Failed to start OIDC login' });
+        return true;
+      }
+    }
+
+    if (requestUrl.pathname === '/api/auth/oidc/callback' && req.method === 'GET') {
+      try {
+        return applyAuthResponse(req, res, await authService.completeOidcLogin(req, requestUrl));
+      } catch (error) {
+        console.error('[api] Failed to complete OIDC login:', error.message);
+        jsonResponse(req, res, 500, { error: 'Failed to complete OIDC login' });
+        return true;
+      }
+    }
+
     if (requestUrl.pathname === '/api/auth/session' && req.method === 'POST') {
       try {
         const body = await parseJsonBody(req);
-        return applyAuthResponse(req, res, authService.createSession(req, body));
+        return applyAuthResponse(req, res, await authService.createSession(req, body));
       } catch (error) {
         const statusCode = getRequestErrorStatusCode(error);
         if (statusCode) {
@@ -39,7 +67,7 @@ export function createAuthApiHandler({ authService }) {
     }
 
     if (requestUrl.pathname === '/api/auth/session' && req.method === 'DELETE') {
-      return applyAuthResponse(req, res, authService.clearSession(req));
+      return applyAuthResponse(req, res, await authService.clearSession(req));
     }
 
     jsonResponse(req, res, 404, { error: 'Auth endpoint not found' });

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

@@ -58,6 +58,7 @@ async function applyWorkspaceMutationEffects({
 }
 
 export function createGitApiCommandHandler({
+  authService = null,
   gitService,
   workspaceMutationCoordinator = null,
 }) {
@@ -116,6 +117,7 @@ export function createGitApiCommandHandler({
           req,
           responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
             () => gitService.commitStaged({
+              author: authService?.getAuthenticatedUser?.(req) ?? null,
               message: body.message,
             }),
           ),

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

@@ -3,6 +3,7 @@ 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,
@@ -11,6 +12,7 @@ export function createGitApiHandler({
 }) {
   const handleGitApiQuery = createGitApiQueryHandler({ gitService });
   const handleGitApiCommand = createGitApiCommandHandler({
+    authService,
     backlinkIndex,
     gitService,
     roomRegistry,

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

@@ -18,6 +18,16 @@ function isTruthyParam(value) {
   return value === '1' || value === 'true';
 }
 
+function readHistoryLimit(value) {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  return Number.isFinite(parsed) ? parsed : 30;
+}
+
+function readHistoryOffset(value) {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
 function handleGitError(req, res, error, message, fallback) {
   const statusCode = getRequestErrorStatusCode(error);
   if (statusCode) {
@@ -61,6 +71,57 @@ export function createGitApiQueryHandler({ gitService }) {
       return true;
     }
 
+    if (requestUrl.pathname === '/api/git/history' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, await gitService.getHistory({
+          limit: readHistoryLimit(requestUrl.searchParams.get('limit')),
+          offset: readHistoryOffset(requestUrl.searchParams.get('offset')),
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read git history:', 'Failed to read git history');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/file-history' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, await gitService.getFileHistory({
+          limit: readHistoryLimit(requestUrl.searchParams.get('limit')),
+          offset: readHistoryOffset(requestUrl.searchParams.get('offset')),
+          path: requestUrl.searchParams.get('path'),
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read git file history:', 'Failed to read git file history');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/commit' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, await gitService.getCommit({
+          allowLargePatch: isTruthyParam(requestUrl.searchParams.get('allowLargePatch')),
+          hash: requestUrl.searchParams.get('hash'),
+          metaOnly: isTruthyParam(requestUrl.searchParams.get('metaOnly')),
+          path: requestUrl.searchParams.get('path'),
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read git commit:', 'Failed to read git commit');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/file-snapshot' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, await gitService.getFileSnapshot({
+          hash: requestUrl.searchParams.get('hash'),
+          path: requestUrl.searchParams.get('path'),
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read git file snapshot:', 'Failed to read git file snapshot');
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/git/pull-backups' && req.method === 'GET') {
       try {
         jsonResponse(req, res, 200, {

package/src/server/infrastructure/http/create-request-handler.js

@@ -3,6 +3,7 @@ import { createGitApiHandler } from './create-git-api-handler.js';
 import { createEsmProxyHandler } from './create-esm-proxy-handler.js';
 import { createStaticHandler } from './create-static-handler.js';
 import { createVaultApiHandler } from './create-vault-api-handler.js';
+import { parseJsonBody } from './request-body.js';
 import {
   applyCorsHeaders,
   jsonResponse,
@@ -42,6 +43,7 @@ export function createRequestHandler(
   roomRegistry = null,
   plantUmlRenderer = null,
   gitService = null,
+  testControls = { wsRoomHydrateDelayMs: 0 },
   workspaceMutationCoordinator = null,
   fileSystemSyncService = null,
 ) {
@@ -49,6 +51,7 @@ export function createRequestHandler(
   const handleStaticRequest = createStaticHandler(config, authService);
   const handleAuthApi = createAuthApiHandler({ authService });
   const handleGitApi = createGitApiHandler({
+    authService,
     backlinkIndex,
     gitService,
     roomRegistry,
@@ -116,6 +119,18 @@ export function createRequestHandler(
       return;
     }
 
+    if (config.nodeEnv === 'test' && requestUrl.pathname === '/api/test/hydrate-delay' && req.method === 'POST') {
+      const body = await parseJsonBody(req).catch(() => ({}));
+      testControls.wsRoomHydrateDelayMs = Math.max(0, Number(body?.delayMs) || 0);
+      await fileSystemSyncService?.resetForExternalStateChange?.();
+      await roomRegistry?.reset?.();
+      await backlinkIndex?.build?.();
+      await workspaceMutationCoordinator?.initialize?.();
+      await fileSystemSyncService?.resetForExternalStateChange?.();
+      jsonResponse(req, res, 200, { delayMs: testControls.wsRoomHydrateDelayMs, ok: true });
+      return;
+    }
+
     if (await handleAuthApi(req, res, requestUrl)) {
       return;
     }

package/src/server/infrastructure/http/create-static-handler.js

@@ -1,7 +1,7 @@
 import { readFile } from 'fs/promises';
 import { extname, normalize, resolve } from 'path';
 
-import { sendResponse, textResponse } from './http-response.js';
+import { jsonResponse, sendResponse, textResponse } from './http-response.js';
 
 const CONTENT_TYPES = {
   '.css': 'text/css; charset=utf-8',
@@ -12,7 +12,7 @@ const CONTENT_TYPES = {
 };
 
 function isVersionedAssetPath(pathname = '') {
-  return /-[A-Z0-9]{8,}\.(?:css|js|woff2?|ttf|svg)$/iu.test(pathname);
+  return /-[A-Za-z0-9_-]{8,}\.(?:css|js|woff2?|ttf|svg)$/u.test(pathname);
 }
 
 function getStaticCacheControl(pathname = '', extension = '') {
@@ -46,6 +46,7 @@ function getStaticCacheControl(pathname = '', extension = '') {
 function buildRuntimeConfig({
   auth,
   basePath,
+  build,
   gitEnabled,
   nodeEnv,
   publicWsBaseUrl,
@@ -54,6 +55,7 @@ function buildRuntimeConfig({
   return `window.__COLLABMD_CONFIG__ = ${JSON.stringify({
     auth,
     basePath,
+    build,
     environment: nodeEnv,
     gitEnabled,
     publicWsBaseUrl,
@@ -125,6 +127,13 @@ export function createStaticHandler(config, authService = null) {
       return true;
     }
 
+    if (requestUrl.pathname === '/version.json') {
+      jsonResponse(req, res, 200, {
+        build: config.build ?? { id: '', packageVersion: '' },
+      });
+      return true;
+    }
+
     if (req.method !== 'GET' && req.method !== 'HEAD') {
       textResponse(req, res, 405, 'Method Not Allowed');
       return true;

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

@@ -54,6 +54,10 @@ function handleVaultError(req, res, error, logMessage, fallbackMessage) {
   return true;
 }
 
+function getDirectoryDeleteStatusCode(message = '') {
+  return String(message).includes('Directory is not empty') ? 409 : 400;
+}
+
 export function createVaultApiCommandHandler({
   vaultFileStore,
   workspaceMutationCoordinator = null,
@@ -246,6 +250,69 @@ export function createVaultApiCommandHandler({
       return true;
     }
 
+    if (requestUrl.pathname === '/api/directory' && req.method === 'PATCH') {
+      try {
+        const body = await parseJsonBody(req);
+        if (!body.oldPath || !body.newPath) {
+          jsonResponse(req, res, 400, { error: 'Missing oldPath or newPath' });
+          return true;
+        }
+
+        const workspaceChange = await workspaceMutationCoordinator?.createDirectoryRenameWorkspaceChange?.(body.oldPath, body.newPath);
+        const result = await vaultFileStore.renameDirectory(body.oldPath, body.newPath);
+        if (!result.ok) {
+          jsonResponse(req, res, 400, { error: result.error });
+          return true;
+        }
+
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'rename-directory',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: workspaceChange ?? {
+            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 directory:', 'Failed to rename directory');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/directory' && req.method === 'DELETE') {
+      const dirPath = requestUrl.searchParams.get('path');
+      const recursive = requestUrl.searchParams.get('recursive') === '1';
+      if (!dirPath) {
+        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+        return true;
+      }
+
+      try {
+        const workspaceChange = await workspaceMutationCoordinator?.createDirectoryDeleteWorkspaceChange?.(dirPath);
+        const result = await vaultFileStore.deleteDirectory(dirPath, { recursive });
+        if (!result.ok) {
+          jsonResponse(req, res, getDirectoryDeleteStatusCode(result.error), { error: result.error });
+          return true;
+        }
+
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'delete-directory',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: workspaceChange ?? {
+            deletedPaths: [dirPath],
+          },
+        });
+
+        jsonResponse(req, res, 200, { ok: true });
+      } catch (error) {
+        handleVaultError(req, res, error, '[api] Failed to delete directory:', 'Failed to delete directory');
+      }
+      return true;
+    }
+
     return false;
   };
 }

package/src/server/infrastructure/persistence/path-utils.js

@@ -58,6 +58,17 @@ export function resolveVaultDirectoryPath(vaultDir, requestedPath) {
   return { absolute, error: null };
 }
 
+export function resolveVaultDirectoryRenamePaths(vaultDir, oldPath, newPath) {
+  const absoluteOld = sanitizeVaultPath(vaultDir, oldPath);
+  const absoluteNew = sanitizeVaultPath(vaultDir, newPath);
+
+  if (!absoluteOld || !absoluteNew) {
+    return { absoluteNew: null, absoluteOld: null, error: INVALID_DIRECTORY_PATH_ERROR };
+  }
+
+  return { absoluteNew, absoluteOld, error: null };
+}
+
 export function resolveVaultRenamePaths(vaultDir, oldPath, newPath) {
   const absoluteOld = sanitizeVaultPath(vaultDir, oldPath);
   const absoluteNew = sanitizeVaultPath(vaultDir, newPath);

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'fs/promises';
+import { mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from 'fs/promises';
 import { basename, dirname, extname, join, relative, resolve } from 'path';
 
 import {
@@ -12,6 +12,7 @@ import {
   INVALID_VAULT_FILE_PATH_ERROR,
   isIgnoredVaultEntry,
   resolveVaultDirectoryPath,
+  resolveVaultDirectoryRenamePaths,
   resolveVaultFilePath,
   resolveVaultRenamePaths,
   sanitizeVaultPath,
@@ -73,6 +74,26 @@ function createWorkspaceEntry(relativePath, type) {
   };
 }
 
+function replacePathPrefix(pathValue, oldPrefix, newPrefix) {
+  if (pathValue === oldPrefix) {
+    return newPrefix;
+  }
+
+  return `${newPrefix}${pathValue.slice(oldPrefix.length)}`;
+}
+
+function sortWorkspacePaths(paths = [], direction = 'asc') {
+  const factor = direction === 'desc' ? -1 : 1;
+  return [...paths].sort((left, right) => {
+    const depthDelta = left.split('/').length - right.split('/').length;
+    if (depthDelta !== 0) {
+      return depthDelta * factor;
+    }
+
+    return left.localeCompare(right, undefined, { sensitivity: 'base' }) * factor;
+  });
+}
+
 async function cleanupPaths(paths = []) {
   await Promise.allSettled(paths.filter(Boolean).map((pathValue) => rm(pathValue, { force: true })));
 }
@@ -550,6 +571,58 @@ export class VaultFileStore {
     return { ok: true };
   }
 
+  async listWorkspacePathsUnder(pathValue) {
+    const normalizedRoot = String(pathValue ?? '').replace(/\\/g, '/').trim();
+    if (!normalizedRoot) {
+      return [];
+    }
+
+    const { absolute } = resolveVaultDirectoryPath(this.vaultDir, normalizedRoot);
+    if (!absolute) {
+      return [];
+    }
+
+    try {
+      const info = await stat(absolute);
+      if (!info.isDirectory()) {
+        return [];
+      }
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return [];
+      }
+
+      throw error;
+    }
+
+    const paths = [normalizedRoot];
+    const visitDirectory = async (directoryPath) => {
+      const dirEntries = await readdir(directoryPath, { withFileTypes: true });
+      const sortedEntries = dirEntries.sort((left, right) => left.name.localeCompare(right.name, undefined, { sensitivity: 'base' }));
+
+      for (const entry of sortedEntries) {
+        if (isIgnoredVaultEntry(entry.name)) {
+          continue;
+        }
+
+        const childAbsolutePath = join(directoryPath, entry.name);
+        const relativePath = toVaultRelativePath(this.vaultDir, childAbsolutePath).replace(/\\/g, '/');
+        if (entry.isDirectory()) {
+          paths.push(relativePath);
+          await visitDirectory(childAbsolutePath);
+          continue;
+        }
+
+        if (isVaultFilePath(entry.name)) {
+          paths.push(relativePath);
+        }
+      }
+    };
+
+    await visitDirectory(absolute);
+    return sortWorkspacePaths(paths);
+  }
+
   async deleteFile(filePath) {
     const { absolute, error } = resolveVaultFilePath(this.vaultDir, filePath);
     if (!absolute) {
@@ -573,6 +646,14 @@ export class VaultFileStore {
       return { ok: false, error };
     }
 
+    if (absoluteOld === absoluteNew) {
+      return { ok: true };
+    }
+
+    if (await pathExists(absoluteNew)) {
+      return { ok: false, error: 'Target path already exists' };
+    }
+
     try {
       await this.runManagedWrite([oldPath, newPath], async () => {
         await mkdir(dirname(absoluteNew), { recursive: true });
@@ -599,6 +680,82 @@ export class VaultFileStore {
     }
   }
 
+  async renameDirectory(oldPath, newPath) {
+    const { absoluteNew, absoluteOld, error } = resolveVaultDirectoryRenamePaths(this.vaultDir, oldPath, newPath);
+    if (!absoluteOld || !absoluteNew) {
+      return { ok: false, error };
+    }
+
+    if (absoluteOld === absoluteNew) {
+      return { ok: true };
+    }
+
+    if (await pathExists(absoluteNew)) {
+      return { ok: false, error: 'Target path already exists' };
+    }
+
+    const managedPaths = await this.listWorkspacePathsUnder(oldPath);
+    const nextManagedPaths = managedPaths.map((pathValue) => replacePathPrefix(pathValue, oldPath, newPath));
+
+    try {
+      await this.runManagedWrite([oldPath, newPath, ...managedPaths, ...nextManagedPaths], async () => {
+        await mkdir(dirname(absoluteNew), { recursive: true });
+        await rename(absoluteOld, absoluteNew);
+        await Promise.all(
+          managedPaths.map((pathValue, index) => this.sidecarStore.renameAllForFile(pathValue, nextManagedPaths[index])),
+        );
+      });
+      return { ok: true };
+    } catch (renameError) {
+      return { ok: false, error: renameError.message };
+    }
+  }
+
+  async deleteDirectory(dirPath, { recursive = false } = {}) {
+    const { absolute, error } = resolveVaultDirectoryPath(this.vaultDir, dirPath);
+    if (!absolute) {
+      return { ok: false, error };
+    }
+
+    const managedPaths = await this.listWorkspacePathsUnder(dirPath);
+
+    try {
+      const info = await stat(absolute);
+      if (!info.isDirectory()) {
+        return { ok: false, error: 'Path is not a directory' };
+      }
+    } catch (statError) {
+      if (statError.code === 'ENOENT') {
+        return { ok: true };
+      }
+
+      return { ok: false, error: statError.message };
+    }
+
+    try {
+      if (!recursive) {
+        const contents = await readdir(absolute);
+        if (contents.length > 0) {
+          return { ok: false, error: 'Directory is not empty' };
+        }
+      }
+
+      await this.runManagedWrite([dirPath, ...managedPaths], async () => {
+        if (recursive) {
+          await rm(absolute, { force: true, recursive: true });
+        } else {
+          await rmdir(absolute);
+        }
+        await Promise.all(
+          managedPaths.map((pathValue) => this.sidecarStore.deleteAllForFile(pathValue)),
+        );
+      });
+      return { ok: true };
+    } catch (deleteError) {
+      return { ok: false, error: deleteError.message };
+    }
+  }
+
   async countVaultFiles() {
     return this.countFilesInDir(this.vaultDir);
   }
@@ -623,12 +780,10 @@ 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(