collabmd 0.1.49 → 0.1.52

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

@@ -1,5 +1,6 @@
 import { createReadStream } from 'fs';
 import { copyFile, mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from 'fs/promises';
+import { randomUUID } from 'node:crypto';
 import { basename, dirname, extname, join, relative, resolve } from 'path';
 import sharp from 'sharp';
 
@@ -76,7 +77,7 @@ const TEXT_FILE_MIME_TYPES = Object.freeze({
 });
 
 function createTransactionalPath(targetPath, label) {
-  return `${targetPath}.collabmd-${label}-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
+  return `${targetPath}.collabmd-${label}-${process.pid}-${Date.now()}-${randomUUID()}`;
 }
 
 function createCommentThreadsPayload(threads = []) {
@@ -345,7 +346,7 @@ export class VaultFileStore {
     });
 
     for (const entry of sorted) {
-      if (isIgnoredVaultEntry(entry.name)) {
+      if (isIgnoredVaultEntry(entry.name) || entry.isSymbolicLink()) {
         continue;
       }
 
@@ -417,7 +418,15 @@ export class VaultFileStore {
     return this.readContentFile(filePath);
   }
 
-  async writeResolvedContentFile(resolved, filePath, content, { invalidateCollaborationSnapshot = true } = {}) {
+  async writeEditableVaultContent(filePath, content, { invalidateCollaborationSnapshot = true } = {}) {
+    const resolved = this.resolveAdapter(filePath);
+    if (!resolved) {
+      return {
+        ok: false,
+        error: getEditableVaultContentKind(filePath)?.invalidPathError ?? INVALID_VAULT_FILE_PATH_ERROR,
+      };
+    }
+
     try {
       await this.runManagedWrite([filePath], async () => {
         await mkdir(dirname(resolved.absolute), { recursive: true });
@@ -432,22 +441,6 @@ export class VaultFileStore {
     }
   }
 
-  async writeContentFile(filePath, content, expectedKind = null, { invalidateCollaborationSnapshot = true } = {}) {
-    const resolved = this.resolveAdapter(filePath);
-    if (!resolved || (expectedKind && resolved.adapter.kind !== expectedKind)) {
-      return {
-        ok: false,
-        error: resolved?.adapter?.invalidPathError ?? getEditableVaultContentKind(filePath)?.invalidPathError ?? INVALID_VAULT_FILE_PATH_ERROR,
-      };
-    }
-
-    return this.writeResolvedContentFile(resolved, filePath, content, { invalidateCollaborationSnapshot });
-  }
-
-  async writeEditableVaultContent(filePath, content, { invalidateCollaborationSnapshot = true } = {}) {
-    return this.writeContentFile(filePath, content, null, { invalidateCollaborationSnapshot });
-  }
-
   async readMarkdownFile(filePath) {
     return this.readContentFile(filePath, 'markdown');
   }
@@ -508,14 +501,6 @@ export class VaultFileStore {
     }
   }
 
-  async writeMarkdownFile(filePath, content, options = {}) {
-    return this.writeContentFile(filePath, content, 'markdown', options);
-  }
-
-  async writeBaseFile(filePath, content, options = {}) {
-    return this.writeContentFile(filePath, content, 'base', options);
-  }
-
   async writeImageAttachmentForDocument(sourceDocumentPath, {
     content,
     mimeType,
@@ -581,36 +566,6 @@ export class VaultFileStore {
     };
   }
 
-  async readDownloadFile(filePath) {
-    const normalizedPath = String(filePath ?? '').replace(/\\/g, '/').trim();
-    if (!normalizedPath || !isVaultFilePath(normalizedPath)) {
-      return null;
-    }
-
-    if (isImageAttachmentFilePath(normalizedPath)) {
-      return this.readImageAttachmentFile(normalizedPath);
-    }
-
-    const absolute = this.resolveContentPath(normalizedPath, { requireVaultFile: false });
-    if (!absolute) {
-      return null;
-    }
-
-    try {
-      return {
-        content: await readFile(absolute),
-        mimeType: getDownloadMimeType(normalizedPath),
-        path: normalizedPath,
-      };
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        return null;
-      }
-
-      throw error;
-    }
-  }
-
   async openDownloadFileStream(filePath, { maxBytes = Infinity } = {}) {
     const normalizedPath = String(filePath ?? '').replace(/\\/g, '/').trim();
     if (!normalizedPath || !isVaultFilePath(normalizedPath)) {
@@ -664,16 +619,22 @@ export class VaultFileStore {
       };
     }
 
+    const commentPath = this.sidecarStore.getCommentThreadPath(filePath);
+    const snapshotPath = this.sidecarStore.getSnapshotPath(filePath);
+    if (!commentPath || !snapshotPath) {
+      return { ok: false, error: 'Invalid collaboration state path' };
+    }
+
     const operations = [
       {
         kind: Array.isArray(commentThreads) && commentThreads.length > 0 ? 'write' : 'delete',
-        targetPath: this.sidecarStore.getCommentThreadPath(filePath),
+        targetPath: commentPath,
         value: createCommentThreadsPayload(commentThreads),
         writeOptions: 'utf-8',
       },
       {
         kind: snapshot ? 'write' : 'delete',
-        targetPath: this.sidecarStore.getSnapshotPath(filePath),
+        targetPath: snapshotPath,
         value: snapshot ? Buffer.from(snapshot) : null,
       },
       includeContent ? {
@@ -764,9 +725,8 @@ export class VaultFileStore {
     return this.sidecarStore.readCommentThreads(filePath);
   }
 
-  async readCommentOverview() {
-    const snapshot = await this.scanWorkspaceState();
-    const commentSupportedFilePaths = snapshot.filePaths.filter((filePath) => (
+  async readCommentOverview({ filePaths }) {
+    const commentSupportedFilePaths = filePaths.filter((filePath) => (
       supportsCommentsForFilePath(filePath)
     ));
     const entries = await this.sidecarStore.listCommentThreadEntries({
@@ -844,7 +804,7 @@ export class VaultFileStore {
       const sortedEntries = dirEntries.sort((left, right) => left.name.localeCompare(right.name, undefined, { sensitivity: 'base' }));
 
       for (const entry of sortedEntries) {
-        if (isIgnoredVaultEntry(entry.name)) {
+        if (isIgnoredVaultEntry(entry.name) || entry.isSymbolicLink()) {
           continue;
         }
 
@@ -866,68 +826,6 @@ export class VaultFileStore {
     return sortWorkspacePaths(paths);
   }
 
-  async listDirectoryEntriesForDownload(dirPath) {
-    const normalizedPath = String(dirPath ?? '').replace(/\\/g, '/').trim();
-    const { absolute, error } = resolveVaultDirectoryPath(this.vaultDir, normalizedPath);
-    if (!absolute) {
-      return { ok: false, error };
-    }
-
-    try {
-      const info = await stat(absolute);
-      if (!info.isDirectory()) {
-        return { ok: false, error: 'Directory not found' };
-      }
-    } catch (statError) {
-      if (statError.code === 'ENOENT') {
-        return { ok: false, error: 'Directory not found' };
-      }
-
-      throw statError;
-    }
-
-    const entries = [];
-    const visitDirectory = async (directoryAbsolutePath, relativeDirectoryPath = '') => {
-      const dirEntries = sortDirectoryEntries(await readdir(directoryAbsolutePath, { withFileTypes: true }))
-        .filter((entry) => !isIgnoredVaultEntry(entry.name));
-
-      if (dirEntries.length === 0) {
-        entries.push({
-          path: relativeDirectoryPath,
-          type: 'directory',
-        });
-        return;
-      }
-
-      for (const entry of dirEntries) {
-        const childAbsolutePath = join(directoryAbsolutePath, entry.name);
-        const childRelativePath = relativeDirectoryPath
-          ? `${relativeDirectoryPath}/${entry.name}`
-          : entry.name;
-
-        if (entry.isDirectory()) {
-          await visitDirectory(childAbsolutePath, childRelativePath);
-          continue;
-        }
-
-        if (isVaultFilePath(entry.name)) {
-          entries.push({
-            absolutePath: childAbsolutePath,
-            path: childRelativePath,
-            type: 'file',
-          });
-        }
-      }
-    };
-
-    await visitDirectory(absolute);
-    return {
-      entries,
-      ok: true,
-      rootName: basename(normalizedPath),
-    };
-  }
-
   async resolveDirectoryDownloadRoot(dirPath) {
     const normalizedPath = String(dirPath ?? '').replace(/\\/g, '/').trim();
     const { absolute, error } = resolveVaultDirectoryPath(this.vaultDir, normalizedPath);
@@ -955,21 +853,28 @@ export class VaultFileStore {
     };
   }
 
-  async countDirectoryDownloadEntries(directoryAbsolutePath, { maxEntries = Infinity } = {}) {
+  async collectDirectoryDownloadEntries(directoryAbsolutePath, { maxEntries = Infinity } = {}) {
+    const entries = [];
     let count = 0;
-    const visitDirectory = async (currentDirectoryPath) => {
+    const visitDirectory = async (currentDirectoryPath, relativeDirectoryPath = '') => {
       const dirEntries = sortDirectoryEntries(await readdir(currentDirectoryPath, { withFileTypes: true }))
         .filter((entry) => !isIgnoredVaultEntry(entry.name));
 
       if (dirEntries.length === 0) {
         count += 1;
-        return count <= maxEntries;
+        if (count > maxEntries) {
+          return false;
+        }
+
+        entries.push({ kind: 'directory', relativePath: relativeDirectoryPath });
+        return true;
       }
 
       for (const entry of dirEntries) {
         const childAbsolutePath = join(currentDirectoryPath, entry.name);
+        const childRelativePath = relativeDirectoryPath ? `${relativeDirectoryPath}/${entry.name}` : entry.name;
         if (entry.isDirectory()) {
-          const withinLimit = await visitDirectory(childAbsolutePath);
+          const withinLimit = await visitDirectory(childAbsolutePath, childRelativePath);
           if (!withinLimit) {
             return false;
           }
@@ -981,6 +886,12 @@ export class VaultFileStore {
           if (count > maxEntries) {
             return false;
           }
+
+          entries.push({
+            absolutePath: childAbsolutePath,
+            kind: 'file',
+            relativePath: childRelativePath,
+          });
         }
       }
 
@@ -989,7 +900,7 @@ export class VaultFileStore {
 
     const withinLimit = await visitDirectory(directoryAbsolutePath);
     return {
-      count,
+      entries,
       withinLimit,
     };
   }
@@ -1017,6 +928,14 @@ export class VaultFileStore {
       return { ok: false, error };
     }
 
+    try {
+      if (!(await stat(absoluteOld)).isFile()) {
+        return { ok: false, error: 'Path is not a file' };
+      }
+    } catch {
+      return { ok: false, error: 'File not found' };
+    }
+
     if (absoluteOld === absoluteNew) {
       return { ok: true };
     }
@@ -1057,6 +976,14 @@ export class VaultFileStore {
       return { ok: false, error };
     }
 
+    try {
+      if (!(await stat(absoluteOld)).isDirectory()) {
+        return { ok: false, error: 'Path is not a directory' };
+      }
+    } catch {
+      return { ok: false, error: 'Directory not found' };
+    }
+
     if (absoluteOld === absoluteNew) {
       return { ok: true };
     }
@@ -1127,11 +1054,6 @@ export class VaultFileStore {
     }
   }
 
-  async countVaultFiles() {
-    const snapshot = await this.scanWorkspaceState();
-    return snapshot.vaultFileCount;
-  }
-
   async reconcileSidecars({
     deletedPaths = [],
     renamedPaths = [],
@@ -1163,42 +1085,6 @@ export class VaultFileStore {
     );
   }
 
-  async countFilesInDir(dirPath) {
-    let count = 0;
-
-    let entries;
-    try {
-      entries = await readdir(dirPath, { withFileTypes: true });
-    } catch {
-      return 0;
-    }
-
-    for (const entry of entries) {
-      if (isIgnoredVaultEntry(entry.name)) {
-        continue;
-      }
-
-      const fullPath = join(dirPath, entry.name);
-      if (entry.isDirectory()) {
-        count += await this.countFilesInDir(fullPath);
-      } else if (isVaultFilePath(entry.name)) {
-        count += 1;
-      }
-    }
-
-    return count;
-  }
-
-  resolveWikiLink(linkTarget) {
-    const normalized = linkTarget.endsWith('.md') ? linkTarget : `${linkTarget}.md`;
-    const absolute = this.resolveContentPath(normalized, { requireVaultFile: false });
-    if (!absolute) {
-      return null;
-    }
-
-    return toVaultRelativePath(this.vaultDir, absolute);
-  }
-
   async scanWorkspaceState() {
     return scanWorkspaceStateFromAdapter(createWorkspaceStateFileSystemAdapter({
       vaultDir: this.vaultDir,

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

@@ -18,13 +18,45 @@ function normalizeSvgPayload(body = '') {
   return normalized;
 }
 
+const SVG_CACHE_LIMIT = 50;
+
 export class PlantUmlRenderer {
   constructor({ fetchImpl = fetch, serverUrl } = {}) {
     this.fetchImpl = fetchImpl;
     this.serverUrl = normalizeServerUrl(serverUrl);
+    this.svgCache = new Map();
+    this.inflightRequests = new Map();
   }
 
   async renderSvg(source = '') {
+    const cacheKey = String(source);
+    const cached = this.svgCache.get(cacheKey);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    if (this.inflightRequests.has(cacheKey)) {
+      return this.inflightRequests.get(cacheKey);
+    }
+
+    const request = this.fetchSvg(cacheKey).finally(() => {
+      this.inflightRequests.delete(cacheKey);
+    });
+    this.inflightRequests.set(cacheKey, request);
+    return request;
+  }
+
+  storeSvg(source, svgMarkup) {
+    if (this.svgCache.has(source)) {
+      this.svgCache.delete(source);
+    }
+    while (this.svgCache.size >= SVG_CACHE_LIMIT) {
+      this.svgCache.delete(this.svgCache.keys().next().value);
+    }
+    this.svgCache.set(source, svgMarkup);
+  }
+
+  async fetchSvg(source = '') {
     const encoded = encodePlantUmlText(source);
     const requestUrl = `${this.serverUrl}/svg/${encoded}`;
 
@@ -51,6 +83,7 @@ export class PlantUmlRenderer {
       throw error;
     }
 
+    this.storeSvg(source, normalizedSvg);
     return normalizedSvg;
   }
 }

package/src/server/infrastructure/structurizr/structurizr-workspace-service.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { mkdir, readFile, readdir, realpath, rm, stat, utimes, writeFile } from 'node:fs/promises';
-import { basename, dirname, join, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
 
 import {
   isStructurizrFilePath,
@@ -21,6 +22,14 @@ function createServiceError(message, statusCode, code) {
   return error;
 }
 
+function resolveMirrorPath(mirrorDir, pathValue) {
+  const absolute = sanitizeVaultPath(mirrorDir, pathValue, { allowIgnored: true });
+  if (!absolute) {
+    throw createServiceError('Invalid Structurizr mirror path.', 400, 'STRUCTURIZR_MIRROR_INVALID');
+  }
+  return absolute;
+}
+
 function normalizeWorkspaceRootPath(pathValue) {
   const normalized = String(pathValue ?? '').trim().replace(/\\/g, '/');
   if (!normalized || normalized.startsWith('/') || normalized.split('/').some((segment) => !segment || segment === '.' || segment === '..')) {
@@ -117,7 +126,9 @@ async function collectMirrorPaths(directoryPath, prefix = '') {
 async function readManifest(manifestPath) {
   try {
     const parsed = JSON.parse(await readFile(manifestPath, 'utf8'));
-    return Array.isArray(parsed?.paths) ? parsed.paths : [];
+    return Array.isArray(parsed?.paths)
+      ? parsed.paths.filter((pathValue) => typeof pathValue === 'string' && sanitizeVaultPath(dirname(manifestPath), pathValue))
+      : [];
   } catch (error) {
     if (error.code === 'ENOENT' || error instanceof SyntaxError) {
       return [];
@@ -128,14 +139,14 @@ async function readManifest(manifestPath) {
 
 async function writeMirrorFiles(mirrorDir, files) {
   await Promise.all(Array.from(files, async ([relativePath, content]) => {
-    const targetPath = join(mirrorDir, relativePath);
+    const targetPath = resolveMirrorPath(mirrorDir, relativePath);
     await mkdir(dirname(targetPath), { recursive: true });
     await writeFile(targetPath, content);
   }));
 }
 
 async function removeMirrorPaths(mirrorDir, paths) {
-  await Promise.all(paths.map((relativePath) => rm(join(mirrorDir, relativePath), {
+  await Promise.all(paths.map((relativePath) => rm(resolveMirrorPath(mirrorDir, relativePath), {
     force: true,
     recursive: true,
   })));
@@ -145,7 +156,7 @@ async function snapshotMirror(mirrorDir) {
   const paths = await collectMirrorPaths(mirrorDir);
   const files = new Map();
   await Promise.all(paths.map(async (relativePath) => {
-    files.set(relativePath, await readFile(join(mirrorDir, relativePath)));
+    files.set(relativePath, await readFile(resolveMirrorPath(mirrorDir, relativePath)));
   }));
   return files;
 }
@@ -209,6 +220,10 @@ export class StructurizrWorkspaceService {
   }
 
   async syncWorkspace({ content, rootPath }) {
+    const mirrorRelativePath = relative(this.vaultDir, this.mirrorDir);
+    if (!isAbsolute(mirrorRelativePath) && !mirrorRelativePath.startsWith('..')) {
+      resolveMirrorPath(this.vaultDir, mirrorRelativePath);
+    }
     const normalizedRootPath = normalizeWorkspaceRootPath(rootPath);
     if (!isStructurizrFilePath(normalizedRootPath)) {
       throw createServiceError('Structurizr previews require a workspace.dsl root file.', 400, 'STRUCTURIZR_ROOT_REQUIRED');
@@ -262,7 +277,7 @@ export class StructurizrWorkspaceService {
 
     await mkdir(this.mirrorDir, { recursive: true });
     const snapshot = await snapshotMirror(this.mirrorDir);
-    const previousManifest = await readManifest(join(this.mirrorDir, MANIFEST_FILE_NAME));
+    const previousManifest = await readManifest(resolveMirrorPath(this.mirrorDir, MANIFEST_FILE_NAME));
     const sourcePaths = Array.from(files.keys());
     const stalePaths = previousManifest.filter((pathValue) => !files.has(pathValue));
 
@@ -270,7 +285,7 @@ export class StructurizrWorkspaceService {
       await removeMirrorPaths(this.mirrorDir, stalePaths);
       await writeMirrorFiles(this.mirrorDir, files);
       // Local caches workspace.json; an old mtime makes it parse the DSL without a delete race.
-      const workspaceJsonPath = join(this.mirrorDir, WORKSPACE_JSON_FILE_NAME);
+      const workspaceJsonPath = resolveMirrorPath(this.mirrorDir, WORKSPACE_JSON_FILE_NAME);
       try {
         await utimes(workspaceJsonPath, new Date(0), new Date(0));
       } catch (error) {
@@ -285,7 +300,7 @@ export class StructurizrWorkspaceService {
         ]));
       }
       await writeFile(
-        join(this.mirrorDir, MANIFEST_FILE_NAME),
+        resolveMirrorPath(this.mirrorDir, MANIFEST_FILE_NAME),
         `${JSON.stringify({ paths: sourcePaths }, null, 2)}\n`,
         'utf8',
       );
@@ -327,7 +342,7 @@ export class StructurizrWorkspaceService {
       const isTransientStartupFailure = response.status >= 500
         && /(?:No workspace|FileNotFoundException|workspace\.json)/iu.test(message);
       if (isTransientStartupFailure && attempt < 7) {
-        await new Promise((resolvePromise) => setTimeout(resolvePromise, 250));
+        await delay(250);
         continue;
       }
 
@@ -397,4 +412,3 @@ export class StructurizrWorkspaceService {
     };
   }
 }
-

package/src/server/infrastructure/websocket/attach-collaboration-gateway.js

@@ -24,9 +24,22 @@ function rejectUpgrade(socket, statusCode, statusMessage, {
   socket.destroy();
 }
 
-function extractRoomName(pathname, wsBasePath) {
-  const roomSegment = pathname.slice(wsBasePath.length + 1);
-  return decodeURIComponent(roomSegment || 'default');
+// ponytail: /ws/v/:knownId/:room scopes to a vault; anything else stays a legacy primary room.
+// A primary-vault file literally at v/<vaultId>/... is shadowed by design.
+function extractVaultAndRoom(pathname, wsBasePath, isKnownVaultId) {
+  const rest = pathname.slice(wsBasePath.length + 1);
+  if (rest === 'v' || rest.startsWith('v/')) {
+    const after = rest === 'v' ? '' : rest.slice('v/'.length);
+    const slashIndex = after.indexOf('/');
+    if (slashIndex > 0) {
+      const candidate = after.slice(0, slashIndex);
+      const roomPart = after.slice(slashIndex + 1);
+      if (roomPart && isKnownVaultId?.(candidate)) {
+        return { roomName: decodeURIComponent(roomPart) || 'default', vaultId: candidate };
+      }
+    }
+  }
+  return { roomName: decodeURIComponent(rest || 'default'), vaultId: null };
 }
 
 export function attachCollaborationGateway({
@@ -37,12 +50,15 @@ export function attachCollaborationGateway({
   httpServer,
   maxPayload,
   roomRegistry,
+  vaultRegistry = null,
   wsBasePath,
 }) {
   const websocketServer = new WebSocketServer({
     maxPayload,
     noServer: true,
-    perMessageDeflate: false,
+    // Compress large frames (initial sync, pastes); small Yjs updates fall
+    // under the default 1024-byte threshold and skip compression.
+    perMessageDeflate: true,
   });
   const socketSessions = new Map();
   let isShuttingDown = false;
@@ -98,27 +114,41 @@ export function attachCollaborationGateway({
     });
   }) ?? (() => {});
 
-  websocketServer.on('connection', (ws, req, requestUrl, user = null) => {
-    const roomName = extractRoomName(requestUrl.pathname, wsBasePath);
-    const room = roomRegistry.getOrCreate(roomName);
-    const session = new ClientSocketSession({
-      onDisconnected: (disconnectedRoomName) => {
-        socketSessions.delete(ws);
-        const remaining = roomRegistry.rooms.get(disconnectedRoomName)?.clients.size ?? 0;
-        console.log(`[ws] "${disconnectedRoomName}" disconnected (${remaining} active client(s))`);
-      },
-      onFailed: () => {
-        socketSessions.delete(ws);
-      },
-      room,
-      roomName,
-      ws,
-    });
-    socketSessions.set(ws, {
-      session,
-      userEmail: normalizeHostedEmail(user?.email),
+  websocketServer.on('connection', (ws, req, requestUrl, user = null, expiresAt = null) => {
+    const { roomName, vaultId } = extractVaultAndRoom(requestUrl.pathname, wsBasePath, vaultRegistry?.isKnownVaultId?.bind(vaultRegistry));
+    const registryPromise = vaultId && vaultRegistry
+      ? vaultRegistry.getOrCreateContextAsync(vaultId).then((context) => context.roomRegistry)
+      : Promise.resolve(roomRegistry);
+    registryPromise.then((targetRegistry) => {
+      if (ws.readyState !== ws.OPEN) return;
+      const room = targetRegistry.getOrCreate(roomName);
+      const session = new ClientSocketSession({
+        expiresAt,
+        onDisconnected: (disconnectedRoomName) => {
+          socketSessions.delete(ws);
+          const remaining = targetRegistry.rooms.get(disconnectedRoomName)?.clients.size ?? 0;
+          console.log(`[ws] "${disconnectedRoomName}" disconnected (${remaining} active client(s))`);
+        },
+        onFailed: () => {
+          socketSessions.delete(ws);
+        },
+        room,
+        roomName,
+        ws,
+      });
+      socketSessions.set(ws, {
+        session,
+        userEmail: normalizeHostedEmail(user?.email),
+      });
+      void session.initialize();
+    }).catch((error) => {
+      console.error(`[ws] Failed to open room "${roomName}":`, error.message);
+      try {
+        ws.close(1011, 'Vault unavailable');
+      } catch {
+        try { ws.terminate(); } catch { /* ignore */ }
+      }
     });
-    void session.initialize();
   });
 
   httpServer.on('upgrade', (req, socket, head) => {
@@ -161,7 +191,7 @@ export function attachCollaborationGateway({
       }
 
       websocketServer.handleUpgrade(req, socket, head, (ws) => {
-        websocketServer.emit('connection', ws, req, requestUrl, authenticatedUser);
+        websocketServer.emit('connection', ws, req, requestUrl, authenticatedUser, authResult.expiresAt);
       });
     }).catch((error) => {
       console.error('[ws] Hosted workspace authorization failed:', error.message);