ocean-brain 0.11.1 → 0.12.1

package/server/dist/features/search/sqlite-vector-index.js

@@ -1,7 +1,8 @@
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { setImmediate as yieldToEventLoop } from "node:timers/promises";
 import { getLoadablePath } from "sqlite-vec";
-import sqlite3 from "sqlite3";
 const SEMANTIC_INDEX_SCHEMA_VERSION = 2;
 const SEARCH_DATABASE_SCHEMA_VERSION = 1;
 const SEARCH_DATABASE_SCHEMA_SQL = `
@@ -50,69 +51,27 @@ const openDatabase = async (filePath) => {
   if (filePath !== ":memory:") {
     await mkdir(path.dirname(filePath), { recursive: true });
   }
-  const database = await new Promise((resolve, reject) => {
-    const db = new sqlite3.Database(filePath, (error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve(db);
-    });
-  });
-  await new Promise((resolve, reject) => {
-    database.loadExtension(getLoadablePath(), (error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
-  return database;
+  const database = new DatabaseSync(filePath, { allowExtension: true });
+  try {
+    database.loadExtension(getLoadablePath());
+    database.enableLoadExtension(false);
+    return database;
+  } catch (error) {
+    database.close();
+    throw error;
+  }
 };
 const run = (database, sql, parameters = []) => {
-  return new Promise((resolve, reject) => {
-    database.run(sql, parameters, function onRun(error) {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve(this);
-    });
-  });
+  return database.prepare(sql).run(...parameters);
 };
 const get = (database, sql, parameters = []) => {
-  return new Promise((resolve, reject) => {
-    database.get(sql, parameters, (error, row) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve(row);
-    });
-  });
+  return database.prepare(sql).get(...parameters);
 };
 const all = (database, sql, parameters = []) => {
-  return new Promise((resolve, reject) => {
-    database.all(sql, parameters, (error, rows) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve(rows);
-    });
-  });
+  return database.prepare(sql).all(...parameters);
 };
 const exec = (database, sql) => {
-  return new Promise((resolve, reject) => {
-    database.exec(sql, (error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
+  database.exec(sql);
 };
 const initializeSearchDatabase = async (database) => {
   await exec(
@@ -134,19 +93,35 @@ const initializeSearchDatabase = async (database) => {
   await exec(database, `PRAGMA user_version = ${SEARCH_DATABASE_SCHEMA_VERSION};`);
 };
 const close = (database) => {
-  return new Promise((resolve, reject) => {
-    database.close((error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
+  database.close();
 };
 const serializeEmbedding = (embedding) => {
   return Buffer.from(Float32Array.from(embedding).buffer);
 };
+const INSERT_YIELD_INTERVAL = 250;
+const insertChunks = async (database, chunks) => {
+  const statement = database.prepare(`
+        INSERT INTO search_chunks (
+            note_id,
+            chunk_index,
+            source_hash,
+            text,
+            embedding
+        ) VALUES (?, ?, ?, ?, ?)
+    `);
+  for (const [index, chunk] of chunks.entries()) {
+    statement.run(
+      chunk.noteId,
+      chunk.chunkIndex,
+      chunk.sourceHash,
+      chunk.text,
+      serializeEmbedding(chunk.embedding)
+    );
+    if ((index + 1) % INSERT_YIELD_INTERVAL === 0 && index + 1 < chunks.length) {
+      await yieldToEventLoop();
+    }
+  }
+};
 const isSemanticIndexProfile = (value) => {
   if (!value || typeof value !== "object") {
     return false;
@@ -217,27 +192,7 @@ class SqliteSemanticVectorIndex {
       try {
         await run(database, "DELETE FROM search_chunks");
         await run(database, "DELETE FROM search_index_state");
-        for (const chunk of chunks) {
-          await run(
-            database,
-            `
-                            INSERT INTO search_chunks (
-                                note_id,
-                                chunk_index,
-                                source_hash,
-                                text,
-                                embedding
-                            ) VALUES (?, ?, ?, ?, ?)
-                        `,
-            [
-              chunk.noteId,
-              chunk.chunkIndex,
-              chunk.sourceHash,
-              chunk.text,
-              serializeEmbedding(chunk.embedding)
-            ]
-          );
-        }
+        await insertChunks(database, chunks);
         await run(
           database,
           `
@@ -472,37 +427,35 @@ class SqliteSemanticVectorIndex {
   async getNoteSyncQueueStatus() {
     return this.runExclusive(async () => {
       const database = await this.getDatabase();
-      const [queue, state, latestError] = await Promise.all([
-        get(
-          database,
-          `
-                        SELECT
-                            COUNT(*) AS pendingNoteCount,
-                            MIN(first_queued_at) AS oldestQueuedAt
-                        FROM search_note_sync_queue
-                    `
-        ),
-        get(
-          database,
-          `
-                        SELECT
-                            last_synced_at AS lastSyncedAt,
-                            last_reconciled_at AS lastReconciledAt
-                        FROM search_note_sync_state
-                        WHERE id = 1
-                    `
-        ),
-        get(
-          database,
-          `
-                        SELECT last_error AS error
-                        FROM search_note_sync_queue
-                        WHERE last_error IS NOT NULL
-                        ORDER BY next_attempt_at DESC, note_id ASC
-                        LIMIT 1
-                    `
-        )
-      ]);
+      const queue = get(
+        database,
+        `
+                    SELECT
+                        COUNT(*) AS pendingNoteCount,
+                        MIN(first_queued_at) AS oldestQueuedAt
+                    FROM search_note_sync_queue
+                `
+      );
+      const state = get(
+        database,
+        `
+                    SELECT
+                        last_synced_at AS lastSyncedAt,
+                        last_reconciled_at AS lastReconciledAt
+                    FROM search_note_sync_state
+                    WHERE id = 1
+                `
+      );
+      const latestError = get(
+        database,
+        `
+                    SELECT last_error AS error
+                    FROM search_note_sync_queue
+                    WHERE last_error IS NOT NULL
+                    ORDER BY next_attempt_at DESC, note_id ASC
+                    LIMIT 1
+                `
+      );
       return {
         pendingNoteCount: queue?.pendingNoteCount ?? 0,
         oldestQueuedAt: queue?.oldestQueuedAt === null || queue?.oldestQueuedAt === void 0 ? null : new Date(queue.oldestQueuedAt).toISOString(),
@@ -526,27 +479,7 @@ class SqliteSemanticVectorIndex {
       await exec(database, "BEGIN IMMEDIATE;");
       try {
         await run(database, "DELETE FROM search_chunks WHERE note_id = ?", [noteId]);
-        for (const chunk of chunks) {
-          await run(
-            database,
-            `
-                            INSERT INTO search_chunks (
-                                note_id,
-                                chunk_index,
-                                source_hash,
-                                text,
-                                embedding
-                            ) VALUES (?, ?, ?, ?, ?)
-                        `,
-            [
-              chunk.noteId,
-              chunk.chunkIndex,
-              chunk.sourceHash,
-              chunk.text,
-              serializeEmbedding(chunk.embedding)
-            ]
-          );
-        }
+        await insertChunks(database, chunks);
         await this.refreshIndexCounts(database);
         await exec(database, "COMMIT;");
       } catch (error) {

package/server/dist/features/view/graphql/view.query.resolver.js

@@ -2,6 +2,7 @@ import { GraphQLError } from "graphql";
 import { InvalidNotePropertyInputError } from "../../../features/note/services/properties.js";
 import {
   getNotesByProperties,
+  getViewSectionBoardColumn,
   getViewSectionById,
   getViewSectionNotes,
   getViewWorkspace
@@ -18,17 +19,51 @@ const viewQueryResolvers = {
     pagination = {
       limit: 25,
       offset: 0
-    }
+    },
+    sortBy,
+    sortOrder
   }) => {
-    const sectionNotes = await getViewSectionNotes(id, {
-      limit: Number(pagination.limit),
-      offset: Number(pagination.offset)
-    });
+    const sectionNotes = await getViewSectionNotes(
+      id,
+      {
+        limit: Number(pagination.limit),
+        offset: Number(pagination.offset)
+      },
+      { sortBy, sortOrder }
+    );
     if (!sectionNotes) {
       throw "NOT FOUND";
     }
     return sectionNotes;
   },
+  viewSectionBoardColumn: async (_, {
+    id,
+    optionValue = null,
+    pagination = {
+      limit: 5,
+      offset: 0
+    }
+  }) => {
+    try {
+      const columnNotes = await getViewSectionBoardColumn(id, optionValue, {
+        limit: Number(pagination.limit),
+        offset: Number(pagination.offset)
+      });
+      if (!columnNotes) {
+        throw "NOT FOUND";
+      }
+      return columnNotes;
+    } catch (error) {
+      if (error instanceof InvalidNotePropertyInputError) {
+        throw new GraphQLError(error.message, {
+          extensions: {
+            code: "INVALID_NOTE_PROPERTY_INPUT"
+          }
+        });
+      }
+      throw error;
+    }
+  },
   notesByProperties: async (_, {
     input,
     pagination = {

package/server/dist/features/view/graphql/view.type-defs.js

@@ -37,11 +37,25 @@ const viewType = gql`
 
     type ViewDisplayOptions {
         tableColumns: [ViewTableColumn!]!
+        tablePropertyKeys: [String!]!
+        boardGroupByPropertyKey: String
+    }
+
+    type ViewBoardNote {
+        id: ID!
+        title: String!
+        updatedAt: String!
+    }
+
+    type ViewBoardColumnNotes {
+        totalCount: Int!
+        notes: [ViewBoardNote!]!
     }
 
     enum ViewDisplayType {
         list
         table
+        board
         calendar
     }
 
@@ -84,6 +98,8 @@ const viewType = gql`
 
     input ViewDisplayOptionsInput {
         tableColumns: [ViewTableColumn!]
+        tablePropertyKeys: [String!]
+        boardGroupByPropertyKey: String
     }
 
     input ViewSectionInput {
@@ -110,7 +126,13 @@ const viewQuery = gql`
     type Query {
         viewWorkspace: ViewWorkspace!
         viewSection(id: ID!): ViewSection
-        viewSectionNotes(id: ID!, pagination: PaginationInput): Notes!
+        viewSectionNotes(
+            id: ID!
+            pagination: PaginationInput
+            sortBy: ViewSortBy
+            sortOrder: ViewSortOrder
+        ): Notes!
+        viewSectionBoardColumn(id: ID!, optionValue: String, pagination: PaginationInput): ViewBoardColumnNotes!
         notesByProperties(input: NotesByPropertiesInput!, pagination: PaginationInput): Notes!
     }
 `;

package/server/dist/features/view/services/workspace.js

@@ -12,6 +12,7 @@ const MAX_VIEW_SECTION_LIMIT = 20;
 const DEFAULT_VIEW_NOTES_QUERY_LIMIT = 20;
 const MAX_VIEW_NOTES_QUERY_LIMIT = 50;
 const MAX_VIEW_PROPERTY_FILTERS = 10;
+const MAX_VIEW_TABLE_PROPERTY_COLUMNS = 6;
 const DEFAULT_VIEW_DISPLAY_TYPE = "list";
 const DEFAULT_VIEW_SORT_BY = "updatedAt";
 const DEFAULT_VIEW_SORT_ORDER = "desc";
@@ -54,7 +55,7 @@ const isViewTableColumn = (value) => {
   return value === "title" || value === "tags" || value === "properties" || value === "createdAt" || value === "updatedAt";
 };
 const normalizeViewDisplayType = (value) => {
-  if (value === "table" || value === "calendar") {
+  if (value === "table" || value === "board" || value === "calendar") {
     return value;
   }
   return DEFAULT_VIEW_DISPLAY_TYPE;
@@ -73,9 +74,12 @@ const normalizeViewTableColumns = (columns) => {
   }
   return uniqueColumns.includes("title") ? uniqueColumns : ["title", ...uniqueColumns];
 };
+const normalizeViewTablePropertyKeys = (keys) => Array.from(new Set((keys ?? []).map(normalizePropertyKey))).slice(0, MAX_VIEW_TABLE_PROPERTY_COLUMNS);
 const normalizeViewDisplayOptions = (options) => {
   return {
-    tableColumns: normalizeViewTableColumns(options?.tableColumns)
+    tableColumns: normalizeViewTableColumns(options?.tableColumns),
+    tablePropertyKeys: normalizeViewTablePropertyKeys(options?.tablePropertyKeys),
+    boardGroupByPropertyKey: options?.boardGroupByPropertyKey ? normalizePropertyKey(options.boardGroupByPropertyKey) : null
   };
 };
 const normalizeFilterValue = ({
@@ -207,9 +211,16 @@ const normalizeViewSectionInput = (input) => {
   const sortBy = normalizeViewSortBy(input.sortBy);
   const sortOrder = normalizeViewSortOrder(input.sortOrder);
   const displayOptions = normalizeViewDisplayOptions(input.displayOptions);
+  const displayType = normalizeViewDisplayType(input.displayType);
+  if (displayType === "board" && !displayOptions.boardGroupByPropertyKey) {
+    throw new InvalidNotePropertyInputError("Board sections require a grouping property.");
+  }
+  if (displayType === "board" && propertyFilters.some((filter) => filter.key === displayOptions.boardGroupByPropertyKey)) {
+    throw new InvalidNotePropertyInputError("A board grouping property cannot also be used as a section filter.");
+  }
   return {
     title: trimmedTitle || buildDefaultSectionTitle(tagNames, propertyFilters),
-    displayType: normalizeViewDisplayType(input.displayType),
+    displayType,
     displayOptions,
     tagNames,
     mode: input.mode === "or" ? "or" : "and",
@@ -358,6 +369,23 @@ const hydratePropertyFilters = async (db, filters, options = {}) => {
 };
 const buildStoredViewQuery = async (db, section) => {
   const propertyFilters = await hydratePropertyFilters(db, section.propertyFilters, { validateSelectOptions: true });
+  if (section.displayType === "board") {
+    const groupingProperty = await db.propertyDefinition.findUnique({
+      where: { key: section.displayOptions.boardGroupByPropertyKey ?? "" },
+      select: { valueType: true, options: { select: { id: true }, take: 1 } }
+    });
+    if (!groupingProperty) {
+      throw new InvalidNotePropertyInputError(
+        `Property ${section.displayOptions.boardGroupByPropertyKey ?? ""} is not defined.`
+      );
+    }
+    if (groupingProperty.valueType !== "select") {
+      throw new InvalidNotePropertyInputError("Board sections can only group by a select property.");
+    }
+    if (groupingProperty.options.length === 0) {
+      throw new InvalidNotePropertyInputError("Board grouping properties require at least one option.");
+    }
+  }
   return serializeStoredViewQuery({
     propertyFilters,
     sortBy: section.sortBy,
@@ -521,13 +549,26 @@ const buildViewNotesWhere = (query) => {
 const buildViewSectionWhere = (section) => {
   return buildViewNotesWhere(section);
 };
+const buildViewBoardColumnWhere = (section, propertyDefinitionId, optionId) => {
+  const sectionWhere = buildViewSectionWhere(section);
+  const columnWhere = optionId === null ? {
+    properties: {
+      none: { propertyDefinitionId }
+    }
+  } : {
+    properties: {
+      some: { propertyDefinitionId, optionId }
+    }
+  };
+  return Object.keys(sectionWhere).length === 0 ? columnWhere : { AND: [sectionWhere, columnWhere] };
+};
 const buildViewNotesOrderBy = (query) => {
   return [{ [query.sortBy]: query.sortOrder }, { id: "asc" }];
 };
 const buildViewSectionOrderBy = (section) => {
   return buildViewNotesOrderBy(section);
 };
-const getViewSectionNotes = async (id, pagination) => {
+const getViewSectionNotes = async (id, pagination, sort = {}) => {
   const section = await models.viewSection.findUnique({
     where: { id: parseViewId(id) },
     include: orderedViewSectionTagsInclude
@@ -537,10 +578,14 @@ const getViewSectionNotes = async (id, pagination) => {
   }
   const serializedSection = serializeViewSection(section);
   const where = buildViewSectionWhere(serializedSection);
+  const effectiveSort = {
+    sortBy: sort.sortBy ?? serializedSection.sortBy,
+    sortOrder: sort.sortOrder ?? serializedSection.sortOrder
+  };
   const [totalCount, notes] = await Promise.all([
     models.note.count({ where }),
     models.note.findMany({
-      orderBy: buildViewSectionOrderBy(serializedSection),
+      orderBy: buildViewNotesOrderBy(effectiveSort),
       where,
       take: Number(pagination.limit),
       skip: Number(pagination.offset)
@@ -551,6 +596,61 @@ const getViewSectionNotes = async (id, pagination) => {
     notes
   };
 };
+const getViewSectionBoardColumn = async (id, optionValue, pagination) => {
+  const section = await models.viewSection.findUnique({
+    where: { id: parseViewId(id) },
+    include: orderedViewSectionTagsInclude
+  });
+  if (!section) {
+    return null;
+  }
+  const serializedSection = serializeViewSection(section);
+  if (serializedSection.displayType !== "board") {
+    throw new InvalidNotePropertyInputError("This section is not configured as a board.");
+  }
+  const groupingPropertyKey = serializedSection.displayOptions.boardGroupByPropertyKey;
+  if (!groupingPropertyKey) {
+    throw new InvalidNotePropertyInputError("Board sections require a grouping property.");
+  }
+  const groupingProperty = await models.propertyDefinition.findUnique({
+    where: { key: groupingPropertyKey },
+    select: {
+      id: true,
+      valueType: true,
+      options: {
+        orderBy: [{ order: "asc" }, { id: "asc" }],
+        select: { id: true, value: true }
+      }
+    }
+  });
+  if (!groupingProperty || groupingProperty.valueType !== "select") {
+    throw new InvalidNotePropertyInputError("The board grouping property is unavailable.");
+  }
+  const normalizedOptionValue = optionValue === null ? null : normalizeSelectFilterValue(optionValue);
+  const option = normalizedOptionValue === null ? null : groupingProperty.options.find((candidate) => candidate.value === normalizedOptionValue);
+  if (normalizedOptionValue !== null && !option) {
+    throw new InvalidNotePropertyInputError(
+      `Property ${groupingPropertyKey} option ${normalizedOptionValue} is not defined.`
+    );
+  }
+  const normalizedPagination = normalizeViewNotesPagination(pagination);
+  const where = buildViewBoardColumnWhere(serializedSection, groupingProperty.id, option?.id ?? null);
+  const [totalCount, notes] = await Promise.all([
+    models.note.count({ where }),
+    models.note.findMany({
+      orderBy: buildViewSectionOrderBy(serializedSection),
+      where,
+      take: normalizedPagination.limit,
+      skip: normalizedPagination.offset,
+      select: {
+        id: true,
+        title: true,
+        updatedAt: true
+      }
+    })
+  ]);
+  return { totalCount, notes };
+};
 const getNotesByPropertiesWithDb = async (db, input, pagination) => {
   const normalizedQuery = normalizeViewNotesQueryInput(input);
   if (normalizedQuery.propertyFilters.length === 0) {
@@ -786,6 +886,7 @@ export {
   MAX_VIEW_SECTION_LIMIT,
   MIN_VIEW_SECTION_LIMIT,
   buildPropertyFilterWhere,
+  buildViewBoardColumnWhere,
   buildViewNotesWhere,
   buildViewSectionWhere,
   clampViewSectionLimit,
@@ -795,6 +896,7 @@ export {
   deleteViewTab,
   getNotesByProperties,
   getNotesByPropertiesWithDb,
+  getViewSectionBoardColumn,
   getViewSectionById,
   getViewSectionNotes,
   getViewWorkspace,
@@ -806,6 +908,7 @@ export {
   normalizeViewSectionInput,
   normalizeViewTabTitle,
   normalizeViewTableColumns,
+  normalizeViewTablePropertyKeys,
   normalizeViewTagNames,
   pickNextActiveViewTabId,
   reorderViewSections,

package/server/dist/main.js

@@ -1,38 +1,4 @@
-import { createApp } from "./app.js";
-import { ensureNoteReferenceIndex } from "./features/note/services/note-reference-index.js";
-import { getDefaultSemanticSearchManager } from "./features/search/search-manager.js";
-import { logAuthConfig, resolveAuthConfig } from "./modules/auth-mode.js";
-import { startDataMaintenanceScheduler } from "./modules/data-maintenance.js";
-const PORT = Number(process.env.PORT || 6683);
-const HOST = process.env.HOST || "0.0.0.0";
-const startServer = async () => {
-  const authConfig = resolveAuthConfig(process.env);
-  logAuthConfig(authConfig);
-  const app = createApp(authConfig);
-  getDefaultSemanticSearchManager();
-  const rebuiltReferenceCount = await ensureNoteReferenceIndex();
-  if (rebuiltReferenceCount > 0) {
-    process.stdout.write(`[maintenance] Rebuilt ${rebuiltReferenceCount} note reference rows
-`);
-  }
-  app.listen(PORT, HOST, () => {
-    process.stdout.write(`http server listen on ${HOST}:${PORT} (auth: ${authConfig.mode})
-`);
-    startDataMaintenanceScheduler({
-      onResults: (results) => {
-        for (const result of results) {
-          process.stdout.write(`[maintenance] Reconciled ${result.processedCount} rows for ${result.key}
-`);
-        }
-      },
-      onError: (error) => {
-        const message = error instanceof Error ? error.message : "Unknown data maintenance error";
-        process.stderr.write(`[maintenance] Background run failed: ${message}
-`);
-      }
-    });
-  });
-};
+import { startServer } from "./server.js";
 startServer().catch((error) => {
   const message = error instanceof Error ? error.message : "Unknown auth configuration error";
   process.stderr.write(`[auth] Startup failed: ${message}

package/server/dist/routes/api.js

@@ -83,7 +83,12 @@ const createApiRouter = (authConfig, mcpAdminService) => {
     requireSession,
     csrfProtection,
     useAsync(createSearchAdminReindexHandler())
-  ).post("/image", sessionAccessRateLimit, requireSession, csrfProtection, useAsync(createUploadImageHandler())).get("/events", sessionAccessRateLimit, requireSession, csrfProtection, createServerEventsHandler());
+  ).post("/image", sessionAccessRateLimit, requireSession, csrfProtection, useAsync(createUploadImageHandler())).get("/events", sessionAccessRateLimit, requireSession, csrfProtection, createServerEventsHandler()).use((_req, res) => {
+    res.status(404).json({
+      code: "API_ROUTE_NOT_FOUND",
+      message: "The requested API route was not found."
+    }).end();
+  });
 };
 export {
   createApiRouter

package/server/dist/routes/client.js

@@ -4,6 +4,9 @@ import path from "path";
 import { createCsrfProtection, isAuthenticatedRequest } from "../modules/auth-guard.js";
 import { paths } from "../paths.js";
 const IMAGE_ASSET_RATE_LIMIT_MESSAGE = "Too many image asset requests. Please try again later.";
+const isClientDocumentRequest = (req) => {
+  return req.method === "GET" && Boolean(req.headers.accept?.includes("text/html")) && path.extname(req.path) === "";
+};
 const shouldBlockClientRoute = (authConfig, requestPath, authenticated) => {
   if (authConfig.mode !== "password" || authenticated) {
     return false;
@@ -52,7 +55,17 @@ const createClientRouteCsrfTokenMiddleware = (authConfig) => {
     csrfProtection(req, res, next);
   };
 };
-const createClientRouter = (authConfig) => Router().use(
+const createProductionClientContentRouter = () => Router().use(express.static(paths.clientDist, { extensions: ["html"] })).get(/.*/, (req, res, next) => {
+  if (!isClientDocumentRequest(req)) {
+    next();
+    return;
+  }
+  res.sendFile("index.html", { root: paths.clientDist });
+}).use((_req, res) => {
+  res.setHeader("X-Content-Type-Options", "nosniff");
+  res.status(404).end();
+});
+const createClientRouter = (authConfig, clientContentMiddleware = createProductionClientContentRouter()) => Router().use(
   "/assets/images",
   createImageAssetAuthRateLimit(authConfig),
   createProtectedImageAssetsMiddleware(authConfig),
@@ -78,9 +91,7 @@ const createClientRouter = (authConfig) => Router().use(
     return;
   }
   next();
-}).use(createClientRouteCsrfTokenMiddleware(authConfig)).use(express.static(paths.clientDist, { extensions: ["html"] })).get(/.*/, (_req, res) => {
-  res.sendFile("index.html", { root: paths.clientDist });
-});
+}).use(createClientRouteCsrfTokenMiddleware(authConfig)).use(clientContentMiddleware);
 export {
   createClientRouter
 };