collabmd 0.1.20 → 0.1.23

package/src/server/infrastructure/http/http-response.js

@@ -1,4 +1,8 @@
-import { brotliCompressSync, constants as zlibConstants, gzipSync } from 'node:zlib';
+import {
+  brotliCompress,
+  constants as zlibConstants,
+  gzip,
+} from 'node:zlib';
 
 const COMPRESSIBLE_CONTENT_TYPE_PATTERN = /^(?:text\/|application\/(?:javascript|json|xml)|image\/svg\+xml)/i;
 const MIN_COMPRESSIBLE_BYTES = 1024;
@@ -41,9 +45,9 @@ function resolveCompressionEncoding(acceptEncodingHeader) {
   return null;
 }
 
-function maybeCompressBody(req, body, contentType) {
+function prepareBody(req, body, contentType) {
   if (body === undefined || body === null) {
-    return { body: null, compressed: false, encoding: null };
+    return { body: null, encoding: null };
   }
 
   const bodyBuffer = Buffer.isBuffer(body)
@@ -54,27 +58,48 @@ function maybeCompressBody(req, body, contentType) {
     bodyBuffer.byteLength < MIN_COMPRESSIBLE_BYTES
     || !COMPRESSIBLE_CONTENT_TYPE_PATTERN.test(String(contentType || ''))
   ) {
-    return { body: bodyBuffer, compressed: false, encoding: null };
+    return { body: bodyBuffer, encoding: null };
   }
 
   const encoding = resolveCompressionEncoding(req.headers['accept-encoding']);
   if (!encoding) {
-    return { body: bodyBuffer, compressed: false, encoding: null };
+    return { body: bodyBuffer, encoding: null };
   }
 
-  const compressedBody = encoding === 'br'
-    ? brotliCompressSync(bodyBuffer, {
+  return { body: bodyBuffer, encoding };
+}
+
+function compressBody(bodyBuffer, encoding, callback) {
+  if (encoding === 'br') {
+    brotliCompress(bodyBuffer, {
       params: {
         [zlibConstants.BROTLI_PARAM_QUALITY]: 5,
       },
-    })
-    : gzipSync(bodyBuffer, { level: 6 });
+    }, callback);
+    return;
+  }
+
+  gzip(bodyBuffer, { level: 6 }, callback);
+}
+
+function writeResponseHead(res, statusCode, headers, bodyBuffer) {
+  const responseHeaders = { ...headers };
+  if (bodyBuffer) {
+    responseHeaders['Content-Length'] = String(bodyBuffer.byteLength);
+  }
 
-  if (compressedBody.byteLength >= bodyBuffer.byteLength) {
-    return { body: bodyBuffer, compressed: false, encoding: null };
+  res.writeHead(statusCode, responseHeaders);
+}
+
+function writePreparedBody(req, res, statusCode, headers, bodyBuffer) {
+  writeResponseHead(res, statusCode, headers, bodyBuffer);
+
+  if (req.method === 'HEAD' || statusCode === 204 || statusCode === 304) {
+    res.end();
+    return;
   }
 
-  return { body: compressedBody, compressed: true, encoding };
+  res.end(bodyBuffer ?? undefined);
 }
 
 export function setHeaders(res, headers) {
@@ -116,30 +141,42 @@ export function sendResponse(req, res, {
   statusCode = 200,
 } = {}) {
   const contentType = headers['Content-Type'] || headers['content-type'] || '';
-  const prepared = maybeCompressBody(req, body, contentType);
+  const prepared = prepareBody(req, body, contentType);
 
   if (body !== null) {
     appendVaryHeader(res, 'Accept-Encoding');
   }
 
-  const responseHeaders = { ...headers };
-
-  if (prepared.compressed && prepared.encoding) {
-    responseHeaders['Content-Encoding'] = prepared.encoding;
-  }
-
-  if (prepared.body) {
-    responseHeaders['Content-Length'] = String(prepared.body.byteLength);
-  }
-
-  res.writeHead(statusCode, responseHeaders);
-
-  if (req.method === 'HEAD' || statusCode === 204 || statusCode === 304) {
-    res.end();
+  if (!prepared.body || !prepared.encoding || req.method === 'HEAD' || statusCode === 204 || statusCode === 304) {
+    writePreparedBody(req, res, statusCode, headers, prepared.body);
     return;
   }
 
-  res.end(prepared.body ?? undefined);
+  compressBody(prepared.body, prepared.encoding, (error, compressedBody) => {
+    if (res.writableEnded || res.destroyed) {
+      return;
+    }
+
+    if (error) {
+      console.error('[http] Failed to compress response body:', error.message);
+      if (!res.headersSent) {
+        writePreparedBody(req, res, statusCode, headers, prepared.body);
+        return;
+      }
+      res.destroy(error);
+      return;
+    }
+
+    if (!compressedBody || compressedBody.byteLength >= prepared.body.byteLength) {
+      writePreparedBody(req, res, statusCode, headers, prepared.body);
+      return;
+    }
+
+    writePreparedBody(req, res, statusCode, {
+      ...headers,
+      'Content-Encoding': prepared.encoding,
+    }, compressedBody);
+  });
 }
 
 export function jsonResponse(req, res, statusCode, data) {

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

@@ -60,6 +60,19 @@ async function pathExists(pathValue) {
   }
 }
 
+function createWorkspaceEntry(relativePath, type) {
+  return {
+    fileKind: type === 'directory' ? null : getVaultTreeNodeType(relativePath),
+    name: basename(relativePath),
+    nodeType: type,
+    parentPath: dirname(relativePath).replace(/\\/g, '/') === '.'
+      ? ''
+      : dirname(relativePath).replace(/\\/g, '/'),
+    path: relativePath,
+    type: type === 'directory' ? 'directory' : getVaultTreeNodeType(relativePath),
+  };
+}
+
 async function cleanupPaths(paths = []) {
   await Promise.allSettled(paths.filter(Boolean).map((pathValue) => rm(pathValue, { force: true })));
 }
@@ -150,6 +163,19 @@ export class VaultFileStore {
   constructor({ vaultDir }) {
     this.vaultDir = resolve(vaultDir);
     this.sidecarStore = new SidecarStore({ vaultDir: this.vaultDir });
+    this.managedWriteTracker = null;
+  }
+
+  setManagedWriteTracker(tracker) {
+    this.managedWriteTracker = tracker ?? null;
+  }
+
+  async runManagedWrite(paths, operation) {
+    if (!this.managedWriteTracker?.runManagedWrite) {
+      return operation();
+    }
+
+    return this.managedWriteTracker.runManagedWrite(paths, operation);
   }
 
   async tree() {
@@ -251,11 +277,13 @@ export class VaultFileStore {
     }
 
     try {
-      await mkdir(dirname(resolved.absolute), { recursive: true });
-      await writeFile(resolved.absolute, content, 'utf-8');
-      if (invalidateCollaborationSnapshot) {
-        await this.deleteCollaborationSnapshot(filePath);
-      }
+      await this.runManagedWrite([filePath], async () => {
+        await mkdir(dirname(resolved.absolute), { recursive: true });
+        await writeFile(resolved.absolute, content, 'utf-8');
+        if (invalidateCollaborationSnapshot) {
+          await this.deleteCollaborationSnapshot(filePath);
+        }
+      });
       return { ok: true };
     } catch (error) {
       return { ok: false, error: error.message };
@@ -356,8 +384,10 @@ export class VaultFileStore {
     }
 
     try {
-      await mkdir(dirname(absolutePath), { recursive: true });
-      await writeFile(absolutePath, content);
+      await this.runManagedWrite([storedPath], async () => {
+        await mkdir(dirname(absolutePath), { recursive: true });
+        await writeFile(absolutePath, content);
+      });
     } catch (error) {
       return { ok: false, error: error.message };
     }
@@ -412,49 +442,51 @@ export class VaultFileStore {
     const committedOperations = [];
 
     try {
-      for (const operation of operations) {
-        if (operation.kind !== 'write') {
-          continue;
-        }
+      await this.runManagedWrite([filePath], async () => {
+        for (const operation of operations) {
+          if (operation.kind !== 'write') {
+            continue;
+          }
 
-        const tempPath = createTransactionalPath(operation.targetPath, 'tmp');
-        await mkdir(dirname(operation.targetPath), { recursive: true });
-        await writeFile(tempPath, operation.value, operation.writeOptions);
-        operation.tempPath = tempPath;
-        stagedWrites.push(tempPath);
-      }
+          const tempPath = createTransactionalPath(operation.targetPath, 'tmp');
+          await mkdir(dirname(operation.targetPath), { recursive: true });
+          await writeFile(tempPath, operation.value, operation.writeOptions);
+          operation.tempPath = tempPath;
+          stagedWrites.push(tempPath);
+        }
 
-      for (const operation of operations) {
-        const hadExistingTarget = await pathExists(operation.targetPath);
-        const backupPath = hadExistingTarget
-          ? createTransactionalPath(operation.targetPath, 'bak')
-          : null;
+        for (const operation of operations) {
+          const hadExistingTarget = await pathExists(operation.targetPath);
+          const backupPath = hadExistingTarget
+            ? createTransactionalPath(operation.targetPath, 'bak')
+            : null;
 
-        if (backupPath) {
-          await rename(operation.targetPath, backupPath);
-        }
+          if (backupPath) {
+            await rename(operation.targetPath, backupPath);
+          }
 
-        try {
-          if (operation.kind === 'write') {
-            await rename(operation.tempPath, operation.targetPath);
-            const stagedIndex = stagedWrites.indexOf(operation.tempPath);
-            if (stagedIndex >= 0) {
-              stagedWrites.splice(stagedIndex, 1);
+          try {
+            if (operation.kind === 'write') {
+              await rename(operation.tempPath, operation.targetPath);
+              const stagedIndex = stagedWrites.indexOf(operation.tempPath);
+              if (stagedIndex >= 0) {
+                stagedWrites.splice(stagedIndex, 1);
+              }
             }
+          } catch (error) {
+            if (backupPath) {
+              await rename(backupPath, operation.targetPath);
+            }
+            throw error;
           }
-        } catch (error) {
-          if (backupPath) {
-            await rename(backupPath, operation.targetPath);
-          }
-          throw error;
-        }
 
-        committedOperations.push({
-          backupPath,
-          kind: operation.kind,
-          targetPath: operation.targetPath,
-        });
-      }
+          committedOperations.push({
+            backupPath,
+            kind: operation.kind,
+            targetPath: operation.targetPath,
+          });
+        }
+      });
 
       await cleanupPaths(committedOperations.map((operation) => operation.backupPath));
       return { ok: true };
@@ -510,9 +542,11 @@ export class VaultFileStore {
       }
     }
 
-    await mkdir(dirname(absolute), { recursive: true });
-    await writeFile(absolute, content, 'utf-8');
-    await this.deleteCollaborationSnapshot(filePath);
+    await this.runManagedWrite([filePath], async () => {
+      await mkdir(dirname(absolute), { recursive: true });
+      await writeFile(absolute, content, 'utf-8');
+      await this.deleteCollaborationSnapshot(filePath);
+    });
     return { ok: true };
   }
 
@@ -523,8 +557,10 @@ export class VaultFileStore {
     }
 
     try {
-      await rm(absolute, { force: true });
-      await this.sidecarStore.deleteAllForFile(filePath);
+      await this.runManagedWrite([filePath], async () => {
+        await rm(absolute, { force: true });
+        await this.sidecarStore.deleteAllForFile(filePath);
+      });
       return { ok: true };
     } catch (error) {
       return { ok: false, error: error.message };
@@ -538,9 +574,11 @@ export class VaultFileStore {
     }
 
     try {
-      await mkdir(dirname(absoluteNew), { recursive: true });
-      await rename(absoluteOld, absoluteNew);
-      await this.sidecarStore.renameAllForFile(oldPath, newPath);
+      await this.runManagedWrite([oldPath, newPath], async () => {
+        await mkdir(dirname(absoluteNew), { recursive: true });
+        await rename(absoluteOld, absoluteNew);
+        await this.sidecarStore.renameAllForFile(oldPath, newPath);
+      });
       return { ok: true };
     } catch (error) {
       return { ok: false, error: error.message };
@@ -554,7 +592,7 @@ export class VaultFileStore {
     }
 
     try {
-      await mkdir(absolute, { recursive: true });
+      await this.runManagedWrite([dirPath], () => mkdir(absolute, { recursive: true }));
       return { ok: true };
     } catch (error) {
       return { ok: false, error: error.message };
@@ -633,4 +671,77 @@ export class VaultFileStore {
 
     return toVaultRelativePath(this.vaultDir, absolute);
   }
+
+  async scanWorkspaceState() {
+    const entries = new Map();
+    const metadata = new Map();
+
+    const visitDirectory = async (dirPath) => {
+      let dirEntries;
+      try {
+        dirEntries = await readdir(dirPath, { withFileTypes: true });
+      } catch {
+        return;
+      }
+
+      const sorted = dirEntries.sort((left, right) => {
+        if (left.isDirectory() && !right.isDirectory()) return -1;
+        if (!left.isDirectory() && right.isDirectory()) return 1;
+        return left.name.localeCompare(right.name, undefined, { sensitivity: 'base' });
+      });
+
+      for (const entry of sorted) {
+        if (isIgnoredVaultEntry(entry.name)) {
+          continue;
+        }
+
+        const fullPath = join(dirPath, entry.name);
+        const relativePath = toVaultRelativePath(this.vaultDir, fullPath).replace(/\\/g, '/');
+
+        if (entry.isDirectory()) {
+          entries.set(relativePath, createWorkspaceEntry(relativePath, 'directory'));
+          try {
+            const info = await stat(fullPath);
+            metadata.set(relativePath, {
+              inode: Number(info.ino || 0),
+              mtimeMs: Number(info.mtimeMs || 0),
+              path: relativePath,
+              size: 0,
+              type: 'directory',
+            });
+          } catch {
+            // Ignore transient directories that disappear during scans.
+          }
+          await visitDirectory(fullPath);
+          continue;
+        }
+
+        if (!isVaultFilePath(entry.name)) {
+          continue;
+        }
+
+        entries.set(relativePath, createWorkspaceEntry(relativePath, 'file'));
+        try {
+          const info = await stat(fullPath);
+          metadata.set(relativePath, {
+            inode: Number(info.ino || 0),
+            mtimeMs: Number(info.mtimeMs || 0),
+            path: relativePath,
+            size: Number(info.size || 0),
+            type: 'file',
+          });
+        } catch {
+          // Ignore transient files that disappear during scans.
+        }
+      }
+    };
+
+    await visitDirectory(this.vaultDir);
+
+    return {
+      entries,
+      metadata,
+      scannedAt: Date.now(),
+    };
+  }
 }