ocean-brain 0.13.3 → 0.14.0

package/server/dist/features/note/services/properties.js

@@ -525,9 +525,41 @@ const validateNotePropertiesPatchValues = async (patch, tx = models) => {
   }
   return normalizedPatch;
 };
-const listNoteProperties = async (noteId) => {
+const setNotePropertyValues = async (tx, id, patch) => {
+  const normalizedPatch = normalizePatch(patch);
+  for (const item of normalizedPatch.set) {
+    const definition = await tx.propertyDefinition.findUnique({ where: { key: item.key } });
+    if (!definition) {
+      throw new InvalidNotePropertyInputError(
+        `Property ${item.key} is not defined. Create it in property settings first.`
+      );
+    }
+    if (definition.valueType !== item.valueType) {
+      throw new InvalidNotePropertyInputError(
+        `Property ${item.key} already uses ${definition.valueType} values.`
+      );
+    }
+    const valueData = await buildTypedValueData(item, definition.id, tx);
+    await tx.noteProperty.upsert({
+      where: {
+        noteId_propertyDefinitionId: {
+          noteId: id,
+          propertyDefinitionId: definition.id
+        }
+      },
+      create: {
+        noteId: id,
+        propertyDefinitionId: definition.id,
+        ...valueData
+      },
+      update: valueData
+    });
+  }
+};
+const listNoteProperties = async (noteId, keys) => {
+  if (keys?.length === 0) return [];
   const properties = await models.noteProperty.findMany({
-    where: { noteId },
+    where: { noteId, ...keys ? { definition: { key: { in: keys.map(normalizePropertyKey) } } } : {} },
     include: { definition: true, option: true },
     orderBy: [{ definition: { key: "asc" } }]
   });
@@ -813,34 +845,7 @@ const updateNotePropertiesWithVersionGuardAndSnapshot = async ({
           optionColor: property.option?.color ?? null
         }))
       };
-      for (const item of normalizedPatch.set) {
-        const definition = await tx.propertyDefinition.findUnique({ where: { key: item.key } });
-        if (!definition) {
-          throw new InvalidNotePropertyInputError(
-            `Property ${item.key} is not defined. Create it in property settings first.`
-          );
-        }
-        if (definition.valueType !== item.valueType) {
-          throw new InvalidNotePropertyInputError(
-            `Property ${item.key} already uses ${definition.valueType} values.`
-          );
-        }
-        const valueData = await buildTypedValueData(item, definition.id, tx);
-        await tx.noteProperty.upsert({
-          where: {
-            noteId_propertyDefinitionId: {
-              noteId: id,
-              propertyDefinitionId: definition.id
-            }
-          },
-          create: {
-            noteId: id,
-            propertyDefinitionId: definition.id,
-            ...valueData
-          },
-          update: valueData
-        });
-      }
+      await setNotePropertyValues(tx, id, normalizedPatch);
       if (normalizedPatch.deleteKeys.length > 0) {
         const definitions = await tx.propertyDefinition.findMany({
           where: { key: { in: normalizedPatch.deleteKeys } },
@@ -909,6 +914,7 @@ export {
   resolveNotePropertiesPatchValueTypes,
   serializeNoteProperties,
   serializeNoteProperty,
+  setNotePropertyValues,
   updateNotePropertiesWithVersionGuard,
   updateNotePropertiesWithVersionGuardAndSnapshot,
   updateNotePropertyDefinition,

package/server/dist/features/note/services/search.js

@@ -144,6 +144,22 @@ const NOTE_CONTENT_PREVIEW_MAX_LENGTH = 100;
 const buildNoteContentPreview = (content) => {
   return extractVisibleSearchTextFromContent(content).slice(0, NOTE_CONTENT_PREVIEW_MAX_LENGTH);
 };
+const buildNoteSearchExcerpt = (note, query) => {
+  const terms = parseNoteSearchQuery(query).included;
+  const text = extractVisibleSearchTextFromContent(note.content);
+  for (const [source, value] of [
+    ["body", text],
+    ["title", note.title]
+  ]) {
+    const positions = terms.map((term) => new RegExp(term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "iu").exec(value)?.index ?? -1).filter((index) => index >= 0);
+    if (!positions.length) continue;
+    const matchStart = Math.min(...positions);
+    const start = Math.max(0, matchStart - 80);
+    const end = Math.min(value.length, Math.max(start + 240, matchStart + 80));
+    return { text: value.slice(start, end), source, start, end };
+  }
+  return null;
+};
 const matchesNoteSearchQuery = (note, query) => {
   const parsedQuery = typeof query === "string" ? parseNoteSearchQuery(query) : query;
   if (!parsedQuery.hasFilters) {
@@ -171,6 +187,7 @@ export {
   NOTE_SEARCH_PASS_THROUGH_NODE_TYPES,
   NOTE_SEARCH_TEXT_SCHEMA_VERSION,
   buildNoteContentPreview,
+  buildNoteSearchExcerpt,
   buildNoteSearchProjection,
   buildNoteSearchText,
   extractVisibleSearchTextFromContent,

package/server/dist/features/search/graphql/resolver.js

@@ -1,13 +1,22 @@
+import { buildNoteSearchExcerpt } from "../../../features/note/services/search.js";
 import { searchNotesHybrid } from "../hybrid-search.js";
 import { searchRelatedNotes } from "../related-notes.js";
 const createSearchNotesResolver = (search = searchNotesHybrid) => {
   return async (_, { query, pagination, mode = "HYBRID" }) => {
-    return search({
+    const result = await search({
       query,
       limit: Math.min(50, Math.max(0, pagination.limit)),
       offset: Math.max(0, pagination.offset),
       mode: mode.toLowerCase()
     });
+    const notes = new Map(result.notes.map((note) => [note.id, note]));
+    return {
+      ...result,
+      matches: result.matches.map((match) => {
+        const note = notes.get(match.noteId);
+        return { ...match, excerpt: match.lexical && note ? buildNoteSearchExcerpt(note, query) : null };
+      })
+    };
   };
 };
 const createSearchRelatedNotesResolver = (findRelatedNotes = searchRelatedNotes) => {

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

@@ -10,8 +10,11 @@ const searchTypeDefs = gql`
         noteId: ID!
         lexical: Boolean!
         semantic: Boolean!
+        excerpt: SearchNoteExcerpt
     }
 
+    type SearchNoteExcerpt { text: String!, source: String!, start: Int!, end: Int! }
+
     type SearchRelatedNote {
         id: ID!
         title: String!

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

@@ -1,4 +1,5 @@
 import models from "../../../models.js";
+import { normalizeTagName } from "../services/organization.js";
 const TAG_SORT_FIELDS = /* @__PURE__ */ new Set(["referenceCount", "name"]);
 const normalizeSortBy = (sortBy) => {
   return TAG_SORT_FIELDS.has(sortBy) ? sortBy : "referenceCount";
@@ -13,6 +14,15 @@ const getTagOrderBy = (sortBy, sortOrder) => {
   return { [sortBy]: sortOrder };
 };
 const tagQueryResolvers = {
+  tagsByNames: async (_, { names }) => {
+    if (names.length > 100) {
+      throw new Error("At most 100 tag names may be resolved at once.");
+    }
+    return models.tag.findMany({
+      where: { name: { in: [...new Set(names.map(normalizeTagName))] } },
+      orderBy: { name: "asc" }
+    });
+  },
   allTags: async (_, {
     searchFilter,
     pagination

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

@@ -27,6 +27,7 @@ const tagType = gql`
 const tagQuery = gql`
     type Query {
         allTags(searchFilter: SearchFilterInput, pagination: PaginationInput): Tags!
+        tagsByNames(names: [String!]!): [Tag!]!
     }
 `;
 const tagMutation = gql`

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

@@ -0,0 +1,22 @@
+import { GraphQLError } from "graphql";
+import { InvalidNotePropertyInputError } from "../../../features/note/services/properties.js";
+import { listViewSections, readViewSection } from "../services/mcp-read.js";
+import { getNotesByQuery } from "../services/workspace.js";
+const queryResult = async (read) => {
+  try {
+    return await read();
+  } catch (error) {
+    if (error instanceof InvalidNotePropertyInputError) {
+      throw new GraphQLError(error.message, { extensions: { code: "INVALID_NOTE_PROPERTY_INPUT" } });
+    }
+    throw error;
+  }
+};
+const mcpViewQueryResolvers = {
+  notesByQuery: (_, { input, pagination }) => queryResult(() => getNotesByQuery(input, pagination)),
+  viewSections: (_, { query, pagination }) => queryResult(() => listViewSections(query, pagination)),
+  readViewSection: (_, input) => queryResult(() => readViewSection(input))
+};
+export {
+  mcpViewQueryResolvers
+};

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

@@ -8,6 +8,7 @@ import {
   getViewSectionNotes,
   getViewWorkspace
 } from "../../../features/view/services/workspace.js";
+import { mcpViewQueryResolvers } from "./mcp.query.resolver.js";
 const createViewQueryResolvers = (deps = {
   getNotesByProperties,
   getViewSectionBoardColumn,
@@ -16,6 +17,7 @@ const createViewQueryResolvers = (deps = {
   getViewSectionNotes,
   getViewWorkspace
 }) => ({
+  ...mcpViewQueryResolvers,
   viewWorkspace: async () => {
     return deps.getViewWorkspace();
   },

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

@@ -1,5 +1,29 @@
 import { gql } from "../../../modules/graphql.js";
 const viewType = gql`
+    type NotesQueryConditions {
+        tagNames: [String!]!
+        mode: TagMatchMode!
+        propertyFilters: [ViewPropertyFilter!]!
+        sortBy: ViewSortBy!
+        sortOrder: ViewSortOrder!
+    }
+
+    type NotesQueryResult {
+        query: NotesQueryConditions!
+        totalCount: Int!
+        notes: [Note!]!
+    }
+
+    type ViewSectionListing { section: ViewSection!, tabTitle: String! }
+    type ViewSectionListings { totalCount: Int!, sections: [ViewSectionListing!]! }
+    type ViewReadRow { note: Note!, groupValue: String, calendarDate: String }
+    type ViewGroupProperty { key: String!, name: String!, options: [NotePropertyOption!]! }
+    type ViewReadResult {
+        section: ViewSection!
+        totalCount: Int!
+        rows: [ViewReadRow!]!
+        groupProperty: ViewGroupProperty
+    }
     type ViewWorkspace {
         activeTabId: ID
         tabs: [ViewTab!]!
@@ -140,6 +164,9 @@ const viewType = gql`
 `;
 const viewQuery = gql`
     type Query {
+        notesByQuery(input: NotesByPropertiesInput!, pagination: PaginationInput): NotesQueryResult!
+        viewSections(query: String, pagination: PaginationInput): ViewSectionListings!
+        readViewSection(id: ID!, pagination: PaginationInput, propertyKeys: [String!], groupValue: String, dateRange: DateRangeInput): ViewReadResult!
         viewWorkspace: ViewWorkspace!
         viewSection(id: ID!): ViewSection
         viewSectionNotes(

package/server/dist/features/view/services/mcp-read.js

@@ -0,0 +1,142 @@
+import { InvalidNotePropertyInputError } from "../../../features/note/services/properties.js";
+import models from "../../../models.js";
+import {
+  buildViewBoardColumnWhere,
+  buildViewSectionCalendarWhere,
+  buildViewSectionWhere,
+  getViewSectionById,
+  normalizeViewCalendarDateRange,
+  normalizeViewNotesPagination,
+  serializeViewSection
+} from "./workspace.js";
+const listViewSections = async (query = "", pagination) => {
+  const { limit, offset } = normalizeViewNotesPagination(pagination);
+  const where = query.trim() ? { OR: [{ title: { contains: query.trim() } }, { tab: { title: { contains: query.trim() } } }] } : {};
+  const [totalCount, sections] = await Promise.all([
+    models.viewSection.count({ where }),
+    models.viewSection.findMany({
+      where,
+      include: { tab: true, tags: { orderBy: { name: "asc" } } },
+      orderBy: [{ tab: { order: "asc" } }, { tabId: "asc" }, { order: "asc" }, { id: "asc" }],
+      take: limit,
+      skip: offset
+    })
+  ]);
+  return {
+    totalCount,
+    sections: sections.map((section) => ({ section: serializeViewSection(section), tabTitle: section.tab.title }))
+  };
+};
+const readViewSection = async ({
+  id,
+  pagination,
+  groupValue,
+  dateRange,
+  propertyKeys
+}) => {
+  const section = await getViewSectionById(id);
+  if (!section) throw new InvalidNotePropertyInputError("View section not found. Use list_views to find its ID.");
+  if (groupValue !== void 0 && section.displayType !== "board") {
+    throw new InvalidNotePropertyInputError("groupValue is only valid for a board.");
+  }
+  if (dateRange && section.displayType !== "calendar") {
+    throw new InvalidNotePropertyInputError("dateRange is only valid for a calendar.");
+  }
+  const { limit, offset } = normalizeViewNotesPagination(pagination);
+  const selectedPropertyKeys = propertyKeys ?? (section.displayType === "table" ? section.displayOptions.tablePropertyKeys : []);
+  const withPropertyKeys = (note) => ({ ...note, selectedPropertyKeys });
+  if (section.displayType === "calendar") {
+    if (!dateRange)
+      throw new InvalidNotePropertyInputError(
+        "Calendar views require dateRange (start inclusive, end exclusive; at most 32 days)."
+      );
+    const range = normalizeViewCalendarDateRange(dateRange);
+    const field = section.displayOptions.calendarDateField;
+    if (field === "property") {
+      const key2 = section.displayOptions.calendarDatePropertyKey;
+      const definition = key2 ? await models.propertyDefinition.findUnique({ where: { key: key2 } }) : null;
+      if (!definition || definition.valueType !== "date") {
+        throw new InvalidNotePropertyInputError("The calendar date property is unavailable.");
+      }
+      const where3 = {
+        propertyDefinitionId: definition.id,
+        dateValue: { gte: range.start, lt: range.end },
+        note: buildViewSectionWhere(section)
+      };
+      const [totalCount3, values] = await Promise.all([
+        models.noteProperty.count({ where: where3 }),
+        models.noteProperty.findMany({
+          where: where3,
+          include: { note: true },
+          orderBy: [{ dateValue: "asc" }, { noteId: "asc" }],
+          take: limit,
+          skip: offset
+        })
+      ]);
+      return {
+        section,
+        totalCount: totalCount3,
+        rows: values.map((value) => ({
+          note: withPropertyKeys(value.note),
+          calendarDate: value.dateValue?.toISOString().slice(0, 10)
+        })),
+        groupProperty: null
+      };
+    }
+    const where2 = buildViewSectionCalendarWhere(section, range);
+    const [totalCount2, notes2] = await Promise.all([
+      models.note.count({ where: where2 }),
+      models.note.findMany({ where: where2, orderBy: [{ [field]: "asc" }, { id: "asc" }], take: limit, skip: offset })
+    ]);
+    return {
+      section,
+      totalCount: totalCount2,
+      rows: notes2.map((note) => ({ note: withPropertyKeys(note), calendarDate: note[field].toISOString() })),
+      groupProperty: null
+    };
+  }
+  const key = section.displayOptions.boardGroupByPropertyKey;
+  const groupProperty = section.displayType === "board" && key ? await models.propertyDefinition.findUnique({
+    where: { key },
+    include: { options: { orderBy: [{ order: "asc" }, { id: "asc" }] } }
+  }) : null;
+  let where = buildViewSectionWhere(section);
+  if (section.displayType === "board") {
+    if (!groupProperty || groupProperty.valueType !== "select") {
+      throw new InvalidNotePropertyInputError("The board grouping property is unavailable.");
+    }
+    if (groupValue !== void 0) {
+      const option = groupValue === null ? null : groupProperty.options.find(
+        (candidate) => candidate.value === groupValue.trim().toLowerCase().replace(/\s+/g, "-")
+      );
+      if (groupValue !== null && !option)
+        throw new InvalidNotePropertyInputError(`Property ${key} option ${groupValue} is not defined.`);
+      where = buildViewBoardColumnWhere(section, groupProperty.id, option?.id ?? null);
+    }
+  }
+  const [totalCount, notes] = await Promise.all([
+    models.note.count({ where }),
+    models.note.findMany({
+      where,
+      orderBy: [{ [section.sortBy]: section.sortOrder }, { id: "asc" }],
+      take: limit,
+      skip: offset,
+      include: {
+        properties: { where: { propertyDefinitionId: groupProperty?.id ?? -1 }, include: { option: true } }
+      }
+    })
+  ]);
+  return {
+    section,
+    totalCount,
+    rows: notes.map((note) => ({
+      note: withPropertyKeys(note),
+      groupValue: note.properties[0]?.option?.value ?? null
+    })),
+    groupProperty
+  };
+};
+export {
+  listViewSections,
+  readViewSection
+};

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

@@ -762,11 +762,8 @@ const getViewSectionBoardColumn = async (id, optionValue, pagination) => {
   ]);
   return { totalCount, notes };
 };
-const getNotesByPropertiesWithDb = async (db, input, pagination) => {
+const getNotesByQueryWithDb = async (db, input, pagination) => {
   const normalizedQuery = normalizeViewNotesQueryInput(input);
-  if (normalizedQuery.propertyFilters.length === 0) {
-    throw new InvalidNotePropertyInputError("At least one property filter is required.");
-  }
   const query = {
     ...normalizedQuery,
     propertyFilters: await hydratePropertyFilters(db, normalizedQuery.propertyFilters, {
@@ -785,10 +782,18 @@ const getNotesByPropertiesWithDb = async (db, input, pagination) => {
     })
   ]);
   return {
+    query,
     totalCount,
     notes
   };
 };
+const getNotesByPropertiesWithDb = async (db, input, pagination) => {
+  if (!input.propertyFilters?.length) {
+    throw new InvalidNotePropertyInputError("At least one property filter is required.");
+  }
+  return getNotesByQueryWithDb(db, input, pagination);
+};
+const getNotesByQuery = (input, pagination) => getNotesByQueryWithDb(models, input, pagination);
 const getNotesByProperties = async (input, pagination) => {
   return getNotesByPropertiesWithDb(models, input, pagination);
 };
@@ -1008,6 +1013,8 @@ export {
   deleteViewTab,
   getNotesByProperties,
   getNotesByPropertiesWithDb,
+  getNotesByQuery,
+  getNotesByQueryWithDb,
   getViewSectionBoardColumn,
   getViewSectionById,
   getViewSectionCalendarNotes,
@@ -1028,6 +1035,7 @@ export {
   pickNextActiveViewTabId,
   reorderViewSections,
   reorderViewTabs,
+  serializeViewSection,
   setActiveViewTab,
   updateViewSection,
   updateViewTab

package/server/dist/modules/auth-guard.js

@@ -19,7 +19,30 @@ const issueCsrfToken = (authConfig, reply) => {
 };
 const createCsrfProtection = (authConfig) => {
   if (authConfig.mode !== "password") {
-    return (_request, _reply, done) => done();
+    return (request, reply, done) => {
+      if (request.method === "GET" || request.method === "HEAD" || request.method === "OPTIONS") {
+        done();
+        return;
+      }
+      const origin = request.headers.origin;
+      if (origin) {
+        let sameHost = false;
+        try {
+          const url = new URL(origin);
+          sameHost = ["http:", "https:"].includes(url.protocol) && url.host === request.headers.host;
+        } catch {
+          sameHost = false;
+        }
+        if (!sameHost) {
+          void reply.status(403).send({
+            code: "FORBIDDEN_ORIGIN",
+            message: "Owner writes require the Ocean Brain page origin."
+          });
+          return;
+        }
+      }
+      done();
+    };
   }
   return (request, reply, done) => {
     if (request.method === "GET" || request.method === "HEAD" || request.method === "OPTIONS") {

package/server/dist/modules/integration-token.js

@@ -0,0 +1,27 @@
+import crypto from "crypto";
+const TOKEN_BYTE_LENGTH = 32;
+const HASH_ALGORITHM = "sha256";
+const toTokenHash = (token) => {
+  return crypto.createHash(HASH_ALGORITHM).update(token, "utf8").digest("hex");
+};
+const issueIntegrationToken = () => {
+  const plaintext = crypto.randomBytes(TOKEN_BYTE_LENGTH).toString("base64url");
+  const hash = toTokenHash(plaintext);
+  return {
+    plaintext,
+    hash
+  };
+};
+const verifyIntegrationToken = (storedHash, presentedToken) => {
+  const presentedHash = toTokenHash(presentedToken);
+  const storedBuffer = Buffer.from(storedHash, "utf8");
+  const presentedBuffer = Buffer.from(presentedHash, "utf8");
+  if (storedBuffer.length !== presentedBuffer.length) {
+    return false;
+  }
+  return crypto.timingSafeEqual(storedBuffer, presentedBuffer);
+};
+export {
+  issueIntegrationToken,
+  verifyIntegrationToken
+};

package/server/dist/modules/mcp-auth.js

@@ -43,7 +43,7 @@ const readBearerToken = (authorizationHeader) => {
   }
   return authorizationHeader.slice("Bearer ".length).trim() || void 0;
 };
-const createMcpAuthMiddleware = (_authConfig, mcpAdminAuth) => {
+const createMcpAuthMiddleware = (_authConfig, mcpAdminAuth, permission = "notes:read") => {
   return async (req, reply) => {
     const status = await mcpAdminAuth.getStatus();
     if (!status.enabled) {
@@ -76,30 +76,20 @@ const createMcpAuthMiddleware = (_authConfig, mcpAdminAuth) => {
       });
       return;
     }
-    const versionInfo = getOceanBrainVersionInfo();
-    const mcpCompatibilityVersion = readMcpCompatibilityVersion(req);
-    const mcpClientVersion = readMcpClientVersion(req);
-    if (!mcpCompatibilityVersion || !isMcpVersionCompatible(versionInfo.mcp.compatibilityVersion, mcpCompatibilityVersion)) {
-      await reply.status(426).headers(JSON_HEADERS).send({
-        code: "MCP_VERSION_INCOMPATIBLE",
-        message: createMcpVersionCompatibilityMessage({
-          serverVersion: versionInfo.version,
-          requiredMcpCompatibilityVersion: versionInfo.mcp.compatibilityRequirement,
-          mcpCompatibilityVersion,
-          mcpClientVersion
-        }),
-        serverVersion: versionInfo.version,
-        mcpVersion: mcpClientVersion ?? mcpCompatibilityVersion ?? null,
-        mcpClientVersion: mcpClientVersion ?? null,
-        mcpCompatibilityVersion: mcpCompatibilityVersion ?? null,
-        requiredMcpVersion: versionInfo.mcpVersionRequirement,
-        requiredMcpCompatibilityVersion: versionInfo.mcp.compatibilityRequirement,
-        releaseUrl: versionInfo.releaseUrl
-      });
+    if (!validation.permissions.includes(permission)) {
+      await reply.status(403).send({ code: "INTEGRATION_PERMISSION_DENIED", message: `Permission required: ${permission}` });
+      return;
     }
+    req.integration = {
+      connectionId: "mcp",
+      integrationId: "ocean-brain.mcp",
+      native: true,
+      permissions: validation.permissions
+    };
+    await enforceMcpCompatibility(req, reply);
   };
 };
-const createReadOnlyMcpValidationRule = () => {
+const createReadOnlyMcpValidationRule = (message = "MCP endpoint is read-only") => {
   return (context) => {
     return {
       OperationDefinition(node) {
@@ -107,7 +97,7 @@ const createReadOnlyMcpValidationRule = () => {
           return;
         }
         context.reportError(
-          new GraphQLError("MCP endpoint is read-only", {
+          new GraphQLError(message, {
             nodes: [node],
             extensions: { code: "FORBIDDEN" }
           })
@@ -116,9 +106,33 @@ const createReadOnlyMcpValidationRule = () => {
     };
   };
 };
+const enforceMcpCompatibility = async (req, reply) => {
+  const versionInfo = getOceanBrainVersionInfo();
+  const mcpCompatibilityVersion = readMcpCompatibilityVersion(req);
+  const mcpClientVersion = readMcpClientVersion(req);
+  if (!mcpCompatibilityVersion || !isMcpVersionCompatible(versionInfo.mcp.compatibilityVersion, mcpCompatibilityVersion)) {
+    await reply.status(426).headers(JSON_HEADERS).send({
+      code: "MCP_VERSION_INCOMPATIBLE",
+      message: createMcpVersionCompatibilityMessage({
+        serverVersion: versionInfo.version,
+        requiredMcpCompatibilityVersion: versionInfo.mcp.compatibilityRequirement,
+        mcpCompatibilityVersion,
+        mcpClientVersion
+      }),
+      serverVersion: versionInfo.version,
+      mcpVersion: mcpClientVersion ?? mcpCompatibilityVersion ?? null,
+      mcpClientVersion: mcpClientVersion ?? null,
+      mcpCompatibilityVersion: mcpCompatibilityVersion ?? null,
+      requiredMcpVersion: versionInfo.mcpVersionRequirement,
+      requiredMcpCompatibilityVersion: versionInfo.mcp.compatibilityRequirement,
+      releaseUrl: versionInfo.releaseUrl
+    });
+  }
+};
 export {
   OCEAN_BRAIN_MCP_VERSION_HEADER,
   createMcpAuthMiddleware,
   createReadOnlyMcpValidationRule,
+  enforceMcpCompatibility,
   isMcpVersionCompatible
 };

package/server/dist/modules/mcp-token.js

@@ -1,27 +1,8 @@
-import crypto from "crypto";
-const TOKEN_BYTE_LENGTH = 32;
-const HASH_ALGORITHM = "sha256";
-const toTokenHash = (token) => {
-  return crypto.createHash(HASH_ALGORITHM).update(token, "utf8").digest("hex");
-};
-const issueMcpToken = () => {
-  const plaintext = crypto.randomBytes(TOKEN_BYTE_LENGTH).toString("base64url");
-  const hash = toTokenHash(plaintext);
-  return {
-    plaintext,
-    hash
-  };
-};
-const verifyMcpToken = (storedHash, presentedToken) => {
-  const presentedHash = toTokenHash(presentedToken);
-  const storedBuffer = Buffer.from(storedHash, "utf8");
-  const presentedBuffer = Buffer.from(presentedHash, "utf8");
-  if (storedBuffer.length !== presentedBuffer.length) {
-    return false;
-  }
-  return crypto.timingSafeEqual(storedBuffer, presentedBuffer);
-};
+import {
+  issueIntegrationToken,
+  verifyIntegrationToken
+} from "./integration-token.js";
 export {
-  issueMcpToken,
-  verifyMcpToken
+  issueIntegrationToken as issueMcpToken,
+  verifyIntegrationToken as verifyMcpToken
 };

package/server/dist/routes/api.js

@@ -16,6 +16,7 @@ import {
 import { createCsrfProtection, requireSessionForWrite } from "../modules/auth-guard.js";
 import { createAuthAttemptRateLimit, createSessionAccessRateLimit } from "../modules/rate-limit.js";
 import { createServerEventsHandler } from "../modules/server-events-handler.js";
+import { createIntegrationRouter } from "./integrations.js";
 import { createMcpRouter } from "./mcp.js";
 const createApiRouter = (authConfig, mcpAdminService) => {
   return async (app) => {
@@ -23,6 +24,7 @@ const createApiRouter = (authConfig, mcpAdminService) => {
     const requireSession = requireSessionForWrite(authConfig);
     const sessionAccessRateLimit = app.rateLimit(createSessionAccessRateLimit());
     app.register(createMcpRouter(authConfig, mcpAdminService), { prefix: "/mcp" });
+    app.register(createIntegrationRouter(authConfig));
     app.get("/auth/session", createSessionStatusHandler(authConfig));
     app.post(
       "/auth/login",