collabmd 0.1.51 → 0.1.52

package/src/server/application/agent-content-service.js

@@ -16,6 +16,7 @@ import {
 } from '../../domain/excalidraw-agent-scene.js';
 import { inspectAgentExcalidrawScene, renderAgentExcalidrawSvg } from '../../domain/excalidraw-agent-verification.js';
 import { getVaultFileKind, isBaseFilePath } from '../../domain/file-kind.js';
+import { collectMarkdownOutline } from '../../domain/markdown-outline.js';
 import { isWholeWordMatch } from '../../domain/literal-text-search.js';
 import { createWikiTargetIndex } from '../../domain/wiki-link-resolver.js';
 import {
@@ -27,6 +28,7 @@ import {
   collectMarkdownImageSources,
   collectMarkdownReferences,
 } from '../domain/markdown-reference-extractor.js';
+import { searchExcalidrawSceneText } from '../domain/ripgrep-search-service.js';
 import { compareWorkspacePaths, normalizeWorkspacePath } from '../domain/workspace-state.js';
 
 const MAX_DOCUMENT_CHARACTERS = 200_000;
@@ -337,8 +339,8 @@ export class AgentContentService {
 
   async searchVault(actor, {
     kinds = [],
-    limit = 50,
-    maxSnippetsPerFile = 5,
+    limit = 10,
+    maxSnippetsPerFile = 2,
     prefix = '',
     query = '',
     wholeWord = false,
@@ -348,85 +350,124 @@ export class AgentContentService {
     const normalizedQuery = String(query ?? '').trim().slice(0, 500);
     const normalizedPrefix = normalizeWorkspacePath(prefix);
     const kindFilter = new Set(Array.isArray(kinds) ? kinds : []);
-    const snippetLimit = clampInteger(maxSnippetsPerFile, 5, 1, 10);
-    const result = await this.searchService.search({
-      kinds: [...kindFilter],
-      limit,
-      maxSnippetsPerFile: snippetLimit,
-      prefix: normalizedPrefix,
-      query: normalizedQuery,
-      wholeWord,
-      signal,
-    });
-    if (normalizedQuery.length < 2) return result;
-
+    const snippetLimit = clampInteger(maxSnippetsPerFile, 2, 1, 10);
+    const pageSize = clampInteger(limit, 10, 1, 50);
+    const livePaths = new Set();
+    let liveIncomplete = false;
     const liveFiles = [];
-    for (const [path, room] of this.roomRegistry?.getRooms?.() ?? []) {
+    for (const [path, room] of normalizedQuery.length >= 2 ? this.roomRegistry?.getRooms?.() ?? [] : []) {
       const kind = getVaultFileKind(path);
       if (
         !isAgentReadablePath(path)
-        || !room.isHydrated?.()
         || (normalizedPrefix && path !== normalizedPrefix && !path.startsWith(`${normalizedPrefix}/`))
         || (kindFilter.size > 0 && !kindFilter.has(kind))
       ) continue;
-      const content = room.readEditableContent?.();
-      if (content === null || content === undefined) continue;
-      if (content.length > MAX_AGENT_READ_SOURCE_CHARACTERS) continue;
-      const live = searchLiveText(content, normalizedQuery, snippetLimit, wholeWord);
+      livePaths.add(path);
+      const content = room.isHydrated?.()
+        ? room.readEditableContent?.() ?? room.getPersistedContent?.()
+        : null;
+      if (content == null || content.length > MAX_AGENT_READ_SOURCE_CHARACTERS) {
+        liveIncomplete = true;
+        continue;
+      }
+      signal?.throwIfAborted();
+      let live;
+      if (kind === 'excalidraw') {
+        let scene;
+        try {
+          scene = JSON.parse(content);
+        } catch {
+          liveIncomplete = true;
+          continue;
+        }
+        live = searchExcalidrawSceneText(scene, {
+          query: normalizedQuery, maxSnippetsPerFile: snippetLimit, wholeWord,
+        });
+      } else {
+        live = searchLiveText(content, normalizedQuery, snippetLimit, wholeWord);
+      }
       if (live.matchCount > 0) {
         liveFiles.push({ file: path, kind, ...live });
       }
     }
-    if (liveFiles.length === 0) return result;
-
-    const livePaths = new Set(liveFiles.map(({ file }) => file));
-    const files = [...result.files.filter(({ file }) => !livePaths.has(file)), ...liveFiles]
-      .sort((left, right) => compareWorkspacePaths(left.file, right.file))
-      .slice(0, clampInteger(limit, 50, 1, 50));
+    const result = await this.searchService.search({
+      excludedPaths: [...livePaths],
+      kinds: [...kindFilter],
+      limit: pageSize,
+      maxSnippetsPerFile: snippetLimit,
+      prefix: normalizedPrefix,
+      query: normalizedQuery,
+      wholeWord,
+      signal,
+    });
+    const candidates = [...result.files.filter(({ file }) => !livePaths.has(file)), ...liveFiles]
+      .sort((left, right) => compareWorkspacePaths(left.file, right.file));
+    const files = candidates.slice(0, pageSize);
     return {
       ...result,
       files,
       matchCount: files.reduce((sum, file) => sum + file.matchCount, 0),
-      truncated: result.truncated || files.length < result.files.length + liveFiles.length,
+      truncated: result.truncated || liveIncomplete || candidates.length > files.length
+        || files.some((file) => file.truncated),
     };
   }
 
-  async readDocument(actor, { lineCount = MAX_READ_LINES, path, startLine = 1 } = {}) {
+  async readDocument(actor, { lineCount = 80, mode = 'content', path, startLine = 1 } = {}) {
     requireScope(actor, 'vault:read');
     const normalizedPath = normalizeWorkspacePath(path);
+    const kind = getVaultFileKind(normalizedPath);
     if (!isAgentReadablePath(normalizedPath)) {
       throw createAgentContentError('AGENT_UNSUPPORTED_DOCUMENT', 'Document type is not readable by agents', 400);
     }
+    if (!['content', 'outline'].includes(mode) || (mode === 'outline' && kind !== 'markdown')) {
+      throw createAgentContentError('AGENT_INPUT_INVALID', 'Outline mode requires a Markdown document', 400);
+    }
     const content = await this.readCurrentContent(normalizedPath);
     if (content.length > MAX_AGENT_READ_SOURCE_CHARACTERS) {
       throw createAgentContentError('AGENT_DOCUMENT_TOO_LARGE', 'Document is too large for agent reading', 413);
     }
     const lines = content.split('\n');
     const start = clampInteger(startLine, 1, 1, Math.max(lines.length, 1));
-    const count = clampInteger(lineCount, MAX_READ_LINES, 1, MAX_READ_LINES);
-    let selected = lines.slice(start - 1, start - 1 + count).join('\n');
-    let characterTruncated = false;
-    let endLine = Math.min(start + count - 1, lines.length);
-    if (selected.length > MAX_READ_CHARACTERS) {
-      selected = selected.slice(0, MAX_READ_CHARACTERS);
-      characterTruncated = true;
-      let returnedLineCount = 1;
-      for (let index = 0; index < selected.length; index += 1) {
-        if (selected.charCodeAt(index) === 10) returnedLineCount += 1;
-      }
-      if (selected.endsWith('\n')) returnedLineCount -= 1;
-      endLine = Math.min(start + Math.max(returnedLineCount, 1) - 1, lines.length);
-    }
-    return {
-      content: selected,
-      endLine,
-      kind: getVaultFileKind(normalizedPath),
+    const count = clampInteger(lineCount, 80, 1, MAX_READ_LINES);
+    const result = {
+      content: '',
+      endLine: lines.length,
+      kind,
+      nextStartLine: null,
       path: normalizedPath,
       revision: await createEditableContentRevision(content),
       startLine: start,
       totalLines: lines.length,
-      truncated: characterTruncated || endLine < lines.length,
+      truncated: false,
     };
+    if (mode === 'outline') {
+      const headings = collectMarkdownOutline(content).filter(({ line }) => line >= start);
+      result.headings = headings.slice(0, count);
+      if (headings.length > count) {
+        result.endLine = result.headings.at(-1).line;
+        result.nextStartLine = headings[count].line;
+        result.truncated = true;
+      }
+      return result;
+    }
+    const selected = [];
+    let characters = 0;
+    for (const line of lines.slice(start - 1, start - 1 + count)) {
+      const size = line.length + (selected.length ? 1 : 0);
+      if (characters + size > MAX_READ_CHARACTERS) {
+        if (selected.length === 0) {
+          throw createAgentContentError('AGENT_DOCUMENT_LINE_TOO_LARGE', 'This line exceeds the 100000-character read limit; read a different line or use Markdown outline mode', 413);
+        }
+        break;
+      }
+      selected.push(line);
+      characters += size;
+    }
+    result.content = selected.join('\n');
+    result.endLine = start + selected.length - 1;
+    result.truncated = result.endLine < lines.length;
+    result.nextStartLine = result.truncated ? result.endLine + 1 : null;
+    return result;
   }
   async inspectDocumentReferences(actor, { path } = {}) {
     requireScope(actor, 'vault:read');
@@ -438,13 +479,22 @@ export class AgentContentService {
     if (content.length > MAX_AGENT_READ_SOURCE_CHARACTERS) {
       throw createAgentContentError('AGENT_DOCUMENT_TOO_LARGE', 'Document is too large for agent inspection', 413);
     }
+    return {
+      ...this.inspectMarkdownContent(normalizedPath, content),
+      backlinks: await this.backlinkIndex?.getBacklinks?.(normalizedPath) ?? [],
+      path: normalizedPath,
+      revision: await createEditableContentRevision(content),
+    };
+  }
+
+  inspectMarkdownContent(normalizedPath, content) {
     const entries = Array.from(this.workspaceMutationCoordinator?.workspaceState?.entries?.values?.() ?? []);
     const filePaths = entries
       .filter((entry) => entry.nodeType !== 'directory')
       .map((entry) => entry.path);
     const references = collectMarkdownReferences(content, {
       sourceFilePath: normalizedPath,
-      wikiTargetIndex: createWikiTargetIndex(filePaths),
+      wikiTargetIndex: createWikiTargetIndex([...filePaths, normalizedPath]),
     });
     const toPublicReference = (reference) => ({
       exists: Boolean(reference.resolvedPath),
@@ -468,10 +518,7 @@ export class AgentContentService {
         };
       });
     return {
-      backlinks: await this.backlinkIndex?.getBacklinks?.(normalizedPath) ?? [],
       embeds: references.filter(({ isEmbed }) => isEmbed).map(toPublicReference),
-      path: normalizedPath,
-      revision: await createEditableContentRevision(content),
       videos,
       wikiLinks: references.filter(({ isEmbed }) => !isEmbed).map(toPublicReference),
     };
@@ -479,6 +526,10 @@ export class AgentContentService {
 
   async validateDocument(actor, { path } = {}) {
     const inspected = await this.inspectDocumentReferences(actor, { path });
+    return { ...this.validateMarkdownReferences(inspected), path: inspected.path, revision: inspected.revision };
+  }
+
+  validateMarkdownReferences(inspected) {
     const issues = [];
     inspected.wikiLinks.filter(({ exists }) => !exists).forEach((reference) => {
       issues.push({
@@ -506,8 +557,6 @@ export class AgentContentService {
     });
     return {
       issues,
-      path: inspected.path,
-      revision: inspected.revision,
       valid: issues.length === 0,
     };
   }
@@ -587,12 +636,13 @@ export class AgentContentService {
   }
 
 
-  async applyTextEdits(actor, { path, replacements, revision } = {}) {
+  async applyTextEdits(actor, { path, replacements, revision, validate = false } = {}) {
     requireScope(actor, 'vault:edit');
     const normalizedPath = normalizeWorkspacePath(path);
     if (!isAgentEditablePath(normalizedPath)) {
       throw createAgentContentError('AGENT_UNSUPPORTED_DOCUMENT', 'Document type is not editable by agents', 400);
     }
+    this.requireMarkdownValidation(normalizedPath, validate);
     return this.runForPath(normalizedPath, async () => {
       const content = await this.readCurrentContent(normalizedPath);
       if (content.length > MAX_DOCUMENT_CHARACTERS) {
@@ -619,7 +669,13 @@ export class AgentContentService {
       const nextContent = applyExactTextChanges(content, changes);
       assertValidAgentBaseContent(normalizedPath, nextContent);
       const room = this.roomRegistry?.get?.(normalizedPath);
+      const validation = validate
+        ? this.validateMarkdownReferences(this.inspectMarkdownContent(normalizedPath, nextContent))
+        : null;
       if (room) {
+        if (room.readEditableContent() !== content) {
+          throw createAgentContentError('AGENT_REVISION_CONFLICT', 'Document changed; read it again before editing', 409);
+        }
         room.applyExactTextChanges(changes, {
           origin: createCollaborationOrigin(actor),
         });
@@ -636,7 +692,8 @@ export class AgentContentService {
       return {
         path: normalizedPath,
         replacementCount: changes.length,
-        revision: await createEditableContentRevision(room ? room.readEditableContent() : nextContent),
+        revision: await createEditableContentRevision(nextContent),
+        ...(validation ? { validation } : {}),
       };
     });
   }
@@ -795,18 +852,22 @@ export class AgentContentService {
     });
   }
 
-  async createDocument(actor, { content = '', path } = {}) {
+  async createDocument(actor, { content = '', path, validate = false } = {}) {
     requireScope(actor, 'vault:edit');
     const normalizedPath = normalizeWorkspacePath(path);
     if (!isAgentCreatablePath(normalizedPath)) {
       throw createAgentContentError('AGENT_UNSUPPORTED_DOCUMENT', 'Document type cannot be created by agents', 400);
     }
+    this.requireMarkdownValidation(normalizedPath, validate);
     const normalizedContent = normalizeEditableText(content);
     if (normalizedContent.length > MAX_DOCUMENT_CHARACTERS) {
       throw createAgentContentError('AGENT_DOCUMENT_TOO_LARGE', 'Document is too large for agent creation', 413);
     }
     assertValidAgentBaseContent(normalizedPath, normalizedContent);
     return this.runForPath(normalizedPath, async () => {
+      const validation = validate
+        ? this.validateMarkdownReferences(this.inspectMarkdownContent(normalizedPath, normalizedContent))
+        : null;
       const result = await this.workspaceMutationCoordinator.createFile({
         content: normalizedContent,
         origin: getMutationOrigin(actor),
@@ -827,10 +888,17 @@ export class AgentContentService {
         kind: getVaultFileKind(normalizedPath),
         path: normalizedPath,
         revision: await createEditableContentRevision(normalizedContent),
+        ...(validation ? { validation } : {}),
       };
     });
   }
 
+  requireMarkdownValidation(path, validate) {
+    if (validate && getVaultFileKind(path) !== 'markdown') {
+      throw createAgentContentError('AGENT_INPUT_INVALID', 'Reference validation requires a Markdown document', 400);
+    }
+  }
+
   getSyntax(actor, { kind = '' } = {}) {
     requireScope(actor, 'vault:read');
     if (!kind) return { capabilities: listCollabMdContentCapabilities() };

package/src/server/auth/create-auth-service.js

@@ -3,9 +3,6 @@ import {
   AUTH_STRATEGY_NONE,
   AUTH_STRATEGY_OIDC,
   AUTH_STRATEGY_PASSWORD,
-  SUPPORTED_AUTH_STRATEGIES,
-  createRandomAuthPassword,
-  createRandomSessionSecret,
 } from './auth-constants.js';
 import {
   buildClientConfig,
@@ -18,14 +15,27 @@ import {
   createPasswordStrategy,
 } from './auth-strategies.js';
 
-export {
-  AUTH_STRATEGY_NONE,
-  AUTH_STRATEGY_OIDC,
-  AUTH_STRATEGY_PASSWORD,
-  SUPPORTED_AUTH_STRATEGIES,
-  createRandomAuthPassword,
-  createRandomSessionSecret,
-};
+function resolveRequestProtocol(req) {
+  const forwarded = String(req.headers['x-forwarded-proto'] ?? '').split(',')[0].trim().toLowerCase();
+  if (forwarded === 'https' || forwarded === 'http') {
+    return `${forwarded}:`;
+  }
+
+  try {
+    const cfVisitor = JSON.parse(req.headers['cf-visitor'] ?? '');
+    if (String(cfVisitor?.scheme).toLowerCase() === 'https') {
+      return 'https:';
+    }
+  } catch {
+    // Non-Cloudflare requests carry no cf-visitor payload.
+  }
+
+  if (req.socket?.encrypted) {
+    return 'https:';
+  }
+
+  return 'http:';
+}
 
 export function createAuthService(config) {
   const authConfig = config.auth ?? { strategy: AUTH_STRATEGY_NONE };
@@ -72,8 +82,26 @@ export function createAuthService(config) {
     },
 
     authorizeWebSocketRequest(req) {
+      // Browsers always send Origin; clients without it still need authentication.
+      if (req.headers.origin !== undefined) {
+        let allowed = false;
+        try {
+          const protocol = resolveRequestProtocol(req);
+          const expectedOrigin = authConfig.oidc?.publicBaseUrl
+            ? new URL(authConfig.oidc.publicBaseUrl).origin
+            : new URL(`${protocol}//${req.headers.host}`).origin;
+          allowed = req.headers.origin === expectedOrigin;
+        } catch {
+          // Malformed or opaque origins are forbidden.
+        }
+        if (!allowed) {
+          return { ok: false, statusCode: 403, statusMessage: 'Forbidden', body: 'Origin not allowed' };
+        }
+      }
       if (strategy.isAuthenticated(req)) {
-        return { ok: true };
+        const expiresAt = authConfig.strategy === AUTH_STRATEGY_NONE
+          ? null : sessionCookieManager.readSession(req)?.expiresAt;
+        return { ok: true, expiresAt: Number.isFinite(expiresAt) ? expiresAt : null };
       }
 
       return {

package/src/server/auth/session-cookie.js

@@ -1,19 +1,11 @@
 import { createHmac, timingSafeEqual } from 'node:crypto';
 
 function decodeBase64Url(value) {
-  const normalized = String(value ?? '')
-    .replace(/-/g, '+')
-    .replace(/_/g, '/');
-  const paddingLength = (4 - (normalized.length % 4)) % 4;
-  return Buffer.from(`${normalized}${'='.repeat(paddingLength)}`, 'base64');
+  return Buffer.from(String(value ?? ''), 'base64url');
 }
 
 function encodeBase64Url(value) {
-  return Buffer.from(value)
-    .toString('base64')
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=+$/g, '');
+  return Buffer.from(value).toString('base64url');
 }
 
 function parseCookieHeader(headerValue) {
@@ -78,6 +70,44 @@ export function createSignedCookieManager({
   cookiePath = '/',
   secret,
 }) {
+  // Authenticating one request can verify the same cookie several times
+  // (strategy check + expiry read + user lookup). Memoize per request object;
+  // the cookie-header check keeps it correct if headers ever change.
+  const readCache = new WeakMap();
+
+  function readSignedCookie(req) {
+    const token = parseCookieHeader(req.headers.cookie).get(cookieName);
+    if (!token) {
+      return null;
+    }
+
+    const separatorIndex = token.lastIndexOf('.');
+    if (separatorIndex <= 0) {
+      return null;
+    }
+
+    const encodedPayload = token.slice(0, separatorIndex);
+    const encodedSignature = token.slice(separatorIndex + 1);
+
+    try {
+      const expectedSignature = createSignature(encodedPayload, secret);
+      const actualSignature = decodeBase64Url(encodedSignature);
+
+      if (actualSignature.length !== expectedSignature.length) {
+        return null;
+      }
+
+      if (!timingSafeEqual(actualSignature, expectedSignature)) {
+        return null;
+      }
+
+      const payloadBuffer = decodeBase64Url(encodedPayload);
+      const payload = JSON.parse(payloadBuffer.toString('utf8'));
+      return payload && typeof payload === 'object' ? payload : null;
+    } catch {
+      return null;
+    }
+  }
   function createCookieAttributes(req, { expires = null } = {}) {
     const attributes = [
       'HttpOnly',
@@ -115,37 +145,18 @@ export function createSignedCookieManager({
     },
 
     read(req) {
-      const token = parseCookieHeader(req.headers.cookie).get(cookieName);
-      if (!token) {
-        return null;
-      }
-
-      const separatorIndex = token.lastIndexOf('.');
-      if (separatorIndex <= 0) {
-        return null;
-      }
-
-      const encodedPayload = token.slice(0, separatorIndex);
-      const encodedSignature = token.slice(separatorIndex + 1);
-
-      try {
-        const expectedSignature = createSignature(encodedPayload, secret);
-        const actualSignature = decodeBase64Url(encodedSignature);
-
-        if (actualSignature.length !== expectedSignature.length) {
-          return null;
-        }
-
-        if (!timingSafeEqual(actualSignature, expectedSignature)) {
-          return null;
+      if (req && typeof req === 'object') {
+        const cached = readCache.get(req);
+        if (cached !== undefined) {
+          return cached;
         }
 
-        const payloadBuffer = decodeBase64Url(encodedPayload);
-        const payload = JSON.parse(payloadBuffer.toString('utf8'));
-        return payload && typeof payload === 'object' ? payload : null;
-      } catch {
-        return null;
+        const result = readSignedCookie(req);
+        readCache.set(req, result);
+        return result;
       }
+
+      return readSignedCookie(req);
     },
   };
 }

package/src/server/config/env.js

@@ -9,7 +9,7 @@ import {
   SUPPORTED_AUTH_STRATEGIES,
   createRandomAuthPassword,
   createRandomSessionSecret,
-} from '../auth/create-auth-service.js';
+} from '../auth/auth-constants.js';
 import { loadBuildInfo } from './build-info.js';
 import { isPerfLoggingEnabled } from './perf-logging.js';
 

package/src/server/domain/backlink-index.js

@@ -21,16 +21,6 @@ import { mapWithConcurrency } from '../shared/async-utils.js';
 
 const BACKLINK_BUILD_CONCURRENCY = 8;
 
-function createDeferred() {
-  let resolve;
-  let reject;
-  const promise = new Promise((nextResolve, nextReject) => {
-    resolve = nextResolve;
-    reject = nextReject;
-  });
-  return { promise, reject, resolve };
-}
-
 export class BacklinkIndex {
   constructor({
     rebuildDelayMs = 150,
@@ -83,7 +73,7 @@ export class BacklinkIndex {
       this._latestRequestedWorkspaceState = workspaceState;
     }
     if (!this._scheduledBuildDeferred) {
-      this._scheduledBuildDeferred = createDeferred();
+      this._scheduledBuildDeferred = Promise.withResolvers();
     }
 
     if (this._scheduledBuildTimer) {

package/src/server/domain/bases/base-query-results.js

@@ -103,8 +103,12 @@ function createSummaryPayload(columns, rows, summaries, definition, snapshot, th
 
 function createCsv(rows, columns) {
   const escapeCell = (value) => {
-    const text = String(value ?? '');
-    if (/[,"\n]/u.test(text)) {
+    let text = toDisplayText(value);
+    // CSV quoting alone does not prevent spreadsheets from evaluating formulas.
+    if (typeof value !== 'number' && /^[\s\p{Cc}]*[=+@-]|^[\t\r\n]/u.test(text)) {
+      text = `'${text}`;
+    }
+    if (/[,"\r\n]/u.test(text)) {
       return `"${text.replace(/"/g, '""')}"`;
     }
     return text;
@@ -112,7 +116,7 @@ function createCsv(rows, columns) {
 
   const lines = [
     columns.map((column) => escapeCell(column.label)).join(','),
-    ...rows.map((row) => columns.map((column) => escapeCell(toDisplayText(row.rawCells[column.id]))).join(',')),
+    ...rows.map((row) => columns.map((column) => escapeCell(row.rawCells[column.id])).join(',')),
   ];
   return `${lines.join('\n')}\n`;
 }

package/src/server/domain/bases/base-query-service.js

@@ -1,3 +1,4 @@
+import { scheduler } from 'node:timers/promises';
 import {
   buildColumns,
   collectEvaluatedPropertyIds,
@@ -25,12 +26,6 @@ export { serializeBaseDefinition } from './base-definition.js';
 
 const BASE_QUERY_ROW_CHUNK_SIZE = 50;
 
-function yieldToEventLoop() {
-  return new Promise((resolve) => {
-    setImmediate(resolve);
-  });
-}
-
 function buildSortChain(activeView) {
   const entries = [];
   (activeView.sort ?? []).forEach((sortConfig) => {
@@ -292,7 +287,7 @@ export class BaseQueryService {
       }
 
       if (chunkEnd < filePaths.length) {
-        await yieldToEventLoop();
+        await scheduler.yield();
       }
     }