ocean-brain 0.14.0 → 0.15.0

package/server/dist/features/integration/note-sync.js

@@ -0,0 +1,156 @@
+import { createHash } from "node:crypto";
+import { subscribeNoteChanges } from "../../features/note/services/change-events.js";
+import models from "../../models.js";
+import { createAppError } from "../../modules/error-handler.js";
+import { subscribeIntegrationAccessChanges } from "./access-events.js";
+const DEFAULT_PAGE_SIZE = 100;
+const MAX_PAGE_SIZE = 500;
+const KEEP_ALIVE_INTERVAL_MS = 3e4;
+const MAX_STREAMS_PER_CONNECTION = 2;
+const MAX_NOTE_ID = 2147483647;
+const activeStreamsByConnection = /* @__PURE__ */ new Map();
+const resolvePageSize = (value) => {
+  if (value === void 0) return DEFAULT_PAGE_SIZE;
+  if (!Number.isInteger(value) || Number(value) < 1 || Number(value) > MAX_PAGE_SIZE) {
+    throw createAppError(
+      400,
+      "INVALID_NOTE_CATALOG_PAGE_SIZE",
+      `limit must be an integer between 1 and ${MAX_PAGE_SIZE}.`
+    );
+  }
+  return Number(value);
+};
+const resolveAfterId = (value) => {
+  if (value === void 0) return 0;
+  const normalized = typeof value === "number" && Number.isSafeInteger(value) ? String(value) : value;
+  if (typeof normalized !== "string" || !/^(0|[1-9]\d*)$/.test(normalized)) {
+    throw createAppError(400, "INVALID_NOTE_CATALOG_CURSOR", "afterId must be a nonnegative integer.");
+  }
+  const parsed = Number(normalized);
+  if (!Number.isSafeInteger(parsed) || parsed > MAX_NOTE_ID) {
+    throw createAppError(400, "INVALID_NOTE_CATALOG_CURSOR", "afterId exceeds the supported range.");
+  }
+  return parsed;
+};
+const createIntegrationNoteCatalogHandler = () => {
+  return async (request, reply) => {
+    const limit = resolvePageSize(request.body?.limit);
+    const afterId = resolveAfterId(request.body?.afterId);
+    const [rows, propertySchema] = await Promise.all([
+      models.note.findMany({
+        where: { id: { gt: afterId } },
+        orderBy: { id: "asc" },
+        take: limit + 1,
+        select: { id: true, updatedAt: true }
+      }),
+      afterId === 0 ? models.propertyDefinition.findMany({
+        orderBy: { key: "asc" },
+        select: {
+          key: true,
+          name: true,
+          valueType: true,
+          updatedAt: true,
+          options: {
+            orderBy: [{ order: "asc" }, { id: "asc" }],
+            select: {
+              id: true,
+              label: true,
+              value: true,
+              color: true,
+              order: true,
+              updatedAt: true
+            }
+          }
+        }
+      }) : Promise.resolve(null)
+    ]);
+    const hasMore = rows.length > limit;
+    const page = hasMore ? rows.slice(0, limit) : rows;
+    return reply.status(200).send({
+      notes: page.map((note) => ({ id: String(note.id), updatedAt: note.updatedAt.toISOString() })),
+      ...propertySchema ? { propertySchemaHash: createHash("sha256").update(JSON.stringify(propertySchema)).digest("hex") } : {},
+      hasMore,
+      nextAfterId: hasMore ? String(page.at(-1)?.id) : null
+    });
+  };
+};
+const serializeIntegrationNoteEvent = (event) => {
+  const data = {
+    type: event.type,
+    noteId: String(event.noteId),
+    occurredAt: event.occurredAt
+  };
+  return `event: ${event.type}
+data: ${JSON.stringify(data)}
+
+`;
+};
+const createIntegrationNoteEventsHandler = (subscribe = subscribeNoteChanges) => {
+  return async (request, reply) => {
+    const connectionId = request.integration?.connectionId;
+    if (!connectionId) {
+      throw createAppError(401, "UNAUTHORIZED", "An authenticated integration connection is required.");
+    }
+    const activeStreamCount = activeStreamsByConnection.get(connectionId) ?? 0;
+    if (activeStreamCount >= MAX_STREAMS_PER_CONNECTION) {
+      throw createAppError(
+        429,
+        "INTEGRATION_EVENT_STREAM_LIMIT",
+        `A connection can open at most ${MAX_STREAMS_PER_CONNECTION} event streams.`
+      );
+    }
+    reply.hijack();
+    const response = reply.raw;
+    response.statusCode = 200;
+    response.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+    response.setHeader("Cache-Control", "no-cache, no-transform");
+    response.setHeader("Connection", "keep-alive");
+    response.setHeader("X-Accel-Buffering", "no");
+    response.flushHeaders();
+    response.write(": connected\n\n");
+    activeStreamsByConnection.set(connectionId, activeStreamCount + 1);
+    let cleanedUp = false;
+    let keepAliveTimer = null;
+    let unsubscribeNoteChanges = () => void 0;
+    let unsubscribeAccessChanges = () => void 0;
+    const cleanup = () => {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      if (keepAliveTimer) clearInterval(keepAliveTimer);
+      unsubscribeNoteChanges();
+      unsubscribeAccessChanges();
+      const remainingStreams = (activeStreamsByConnection.get(connectionId) ?? 1) - 1;
+      if (remainingStreams > 0) activeStreamsByConnection.set(connectionId, remainingStreams);
+      else activeStreamsByConnection.delete(connectionId);
+    };
+    const endStream = () => {
+      cleanup();
+      if (!response.writableEnded) {
+        try {
+          response.end();
+        } catch {
+        }
+      }
+    };
+    const write = (chunk) => {
+      try {
+        if (!response.write(chunk)) endStream();
+      } catch {
+        endStream();
+      }
+    };
+    unsubscribeNoteChanges = subscribe((event) => write(serializeIntegrationNoteEvent(event)));
+    unsubscribeAccessChanges = subscribeIntegrationAccessChanges((changedConnectionId) => {
+      if (changedConnectionId === connectionId) endStream();
+    });
+    keepAliveTimer = setInterval(() => write(": keepalive\n\n"), KEEP_ALIVE_INTERVAL_MS);
+    keepAliveTimer.unref?.();
+    request.raw.on("close", cleanup);
+    response.on("close", cleanup);
+  };
+};
+export {
+  createIntegrationNoteCatalogHandler,
+  createIntegrationNoteEventsHandler,
+  serializeIntegrationNoteEvent
+};

package/server/dist/features/integration/service.js

@@ -2,13 +2,16 @@ import { createHash } from "node:crypto";
 import models from "../../models.js";
 import { createAppError } from "../../modules/error-handler.js";
 import { issueIntegrationToken } from "../../modules/integration-token.js";
+import { emitIntegrationAccessChanged } from "./access-events.js";
 import {
   MCP_CONNECTION_ID,
   NATIVE_INTEGRATIONS,
+  parseIntegrationProxyUrl,
   parseManifest,
   parsePermissions,
   validateGrants
 } from "./manifest.js";
+import { parseStatusUpdate, readStatusReport } from "./status-report.js";
 const resolveManifest = (row) => {
   if (row.native) {
     const definition = NATIVE_INTEGRATIONS.find((integration) => integration.connectionId === row.id);
@@ -20,18 +23,31 @@ const toConnection = (row) => ({
   id: row.id,
   native: row.native,
   manifest: resolveManifest(row),
+  proxyConfigured: row.proxyUrl !== null,
   grantedPermissions: parsePermissions(JSON.parse(row.grantedPermissions)),
   enabled: row.enabled,
   pinned: row.pinned,
   createdAt: row.createdAt.toISOString(),
   updatedAt: row.updatedAt.toISOString(),
+  statusReport: readStatusReport(row.credential?.statusReport ?? null),
   token: row.credential ? {
     id: row.credential.id,
     createdAt: row.credential.createdAt.toISOString(),
     lastUsedAt: row.credential.lastUsedAt?.toISOString() ?? null
   } : null
 });
-const credentialSummary = { select: { id: true, createdAt: true, lastUsedAt: true } };
+const credentialSummary = { select: { id: true, createdAt: true, lastUsedAt: true, statusReport: true } };
+const parseConnectionProxyUrl = (manifest, value) => {
+  if (manifest.launch?.mode === "proxied") return parseIntegrationProxyUrl(value);
+  if (value !== void 0) {
+    throw createAppError(
+      400,
+      "UNEXPECTED_INTEGRATION_PROXY_URL",
+      "A private app URL can only be configured for proxied launches."
+    );
+  }
+  return null;
+};
 const createIntegrationService = (db = models) => {
   const get = async (id) => {
     const row = await db.integrationConnection.findUnique({
@@ -75,10 +91,12 @@ const createIntegrationService = (db = models) => {
           "The ocean-brain namespace is reserved for native integrations."
         );
       const grantedPermissions = validateGrants(input.grantedPermissions ?? [], manifest);
+      const proxyUrl = parseConnectionProxyUrl(manifest, input.proxyUrl);
       const row = await db.integrationConnection.create({
         data: {
           integrationId: manifest.id,
           manifest: JSON.stringify(manifest),
+          proxyUrl,
           grantedPermissions: JSON.stringify(grantedPermissions)
         },
         include: { credential: credentialSummary }
@@ -86,7 +104,7 @@ const createIntegrationService = (db = models) => {
       return toConnection(row);
     },
     async update(id, input) {
-      return db.$transaction(async (tx) => {
+      const connection = await db.$transaction(async (tx) => {
         const current = await tx.integrationConnection.findUnique({ where: { id } });
         if (!current)
           throw createAppError(404, "INTEGRATION_NOT_FOUND", "The integration connection was not found.");
@@ -96,21 +114,50 @@ const createIntegrationService = (db = models) => {
             "NATIVE_INTEGRATION_MANIFEST",
             "Native integration manifests are managed by Ocean Brain."
           );
-        const manifest = input.manifest === void 0 ? resolveManifest(current) : parseManifest(input.manifest);
+        for (const key of ["enabled", "pinned"]) {
+          if (input[key] !== void 0 && typeof input[key] !== "boolean")
+            throw createAppError(400, "INVALID_INTEGRATION_SETTING", `${key} must be a boolean.`);
+        }
+        const currentManifest = resolveManifest(current);
+        const manifest = input.manifest === void 0 ? currentManifest : parseManifest(input.manifest);
         if (manifest.id !== current.integrationId)
           throw createAppError(400, "INTEGRATION_ID_CHANGED", "An upgrade cannot change the integration id.");
         const previousGrants = parsePermissions(JSON.parse(current.grantedPermissions)).filter(
           (permission) => manifest.permissions.includes(permission)
         );
         const grantedPermissions = validateGrants(input.grantedPermissions ?? previousGrants, manifest);
-        for (const key of ["enabled", "pinned"]) {
-          if (input[key] !== void 0 && typeof input[key] !== "boolean")
-            throw createAppError(400, "INVALID_INTEGRATION_SETTING", `${key} must be a boolean.`);
+        let proxyUrl = current.proxyUrl;
+        if (manifest.launch?.mode === "proxied") {
+          if (input.proxyUrl !== void 0) proxyUrl = parseIntegrationProxyUrl(input.proxyUrl);
+          const enteringProxiedMode = input.manifest !== void 0 && currentManifest.launch?.mode !== "proxied";
+          if ((enteringProxiedMode || input.enabled === true) && !proxyUrl) {
+            throw createAppError(
+              400,
+              "INTEGRATION_PROXY_URL_REQUIRED",
+              "Configure a private app URL before enabling a proxied integration."
+            );
+          }
+        } else {
+          if (input.proxyUrl !== void 0) {
+            throw createAppError(
+              400,
+              "UNEXPECTED_INTEGRATION_PROXY_URL",
+              "A private app URL can only be configured for proxied launches."
+            );
+          }
+          proxyUrl = null;
+        }
+        if (input.enabled !== void 0 || input.grantedPermissions !== void 0 || input.manifest !== void 0 || input.proxyUrl !== void 0) {
+          await tx.integrationCredential.updateMany({
+            where: { connectionId: id },
+            data: { statusReport: null }
+          });
         }
         const row = await tx.integrationConnection.update({
           where: { id },
           data: {
             manifest: JSON.stringify(manifest),
+            proxyUrl,
             grantedPermissions: JSON.stringify(grantedPermissions),
             ...typeof input.enabled === "boolean" ? { enabled: input.enabled } : {},
             ...typeof input.pinned === "boolean" ? { pinned: input.pinned } : {}
@@ -119,6 +166,10 @@ const createIntegrationService = (db = models) => {
         });
         return toConnection(row);
       });
+      if (input.enabled !== void 0 || input.grantedPermissions !== void 0 || input.manifest !== void 0) {
+        emitIntegrationAccessChanged(id);
+      }
+      return connection;
     },
     async disconnect(id) {
       const connection = await get(id);
@@ -129,6 +180,7 @@ const createIntegrationService = (db = models) => {
           "Native integrations can be disabled, but cannot be disconnected."
         );
       await db.integrationConnection.delete({ where: { id } });
+      emitIntegrationAccessChanged(id);
     },
     async rotateToken(id) {
       await get(id);
@@ -136,13 +188,34 @@ const createIntegrationService = (db = models) => {
       await db.integrationCredential.upsert({
         where: { connectionId: id },
         create: { connectionId: id, tokenHash: token.hash },
-        update: { tokenHash: token.hash, createdAt: /* @__PURE__ */ new Date(), lastUsedAt: null }
+        update: { tokenHash: token.hash, createdAt: /* @__PURE__ */ new Date(), lastUsedAt: null, statusReport: null }
       });
+      emitIntegrationAccessChanged(id);
       return { token: token.plaintext };
     },
     async revokeToken(id) {
       await get(id);
       await db.integrationCredential.deleteMany({ where: { connectionId: id } });
+      emitIntegrationAccessChanged(id);
+    },
+    async reportStatus(token, input) {
+      const update = parseStatusUpdate(input);
+      const tokenHash = createHash("sha256").update(token, "utf8").digest("hex");
+      return db.$transaction(async (tx) => {
+        const credential = await tx.integrationCredential.findUnique({
+          where: { tokenHash },
+          include: { connection: true }
+        });
+        if (!credential?.connection.enabled || !parsePermissions(JSON.parse(credential.connection.grantedPermissions)).includes("notes:read") || !resolveManifest(credential.connection).permissions.includes("notes:read")) {
+          throw createAppError(403, "INTEGRATION_ACCESS_DENIED", "This connection cannot report activity.");
+        }
+        const report = { ...update, reportedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        await tx.integrationCredential.update({
+          where: { tokenHash },
+          data: { statusReport: JSON.stringify(report) }
+        });
+        return report;
+      });
     },
     async authenticate(token) {
       const tokenHash = createHash("sha256").update(token, "utf8").digest("hex");

package/server/dist/features/integration/status-report.js

@@ -0,0 +1,22 @@
+import { createAppError } from "../../modules/error-handler.js";
+import { isRecord } from "./manifest.js";
+function parseStatusUpdate(value) {
+  if (!isRecord(value) || value.state !== "running" && value.state !== "succeeded" && value.state !== "failed" || typeof value.message !== "string" || !value.message.trim() || value.message.length > 300 || [...value.message].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)) {
+    throw createAppError(
+      400,
+      "INVALID_INTEGRATION_STATUS",
+      "Provide a running, succeeded, or failed state and a message of 1\u2013300 characters without control characters."
+    );
+  }
+  return { state: value.state, message: value.message.trim() };
+}
+function readStatusReport(value) {
+  if (!value) return null;
+  const report = JSON.parse(value);
+  if (!isRecord(report) || typeof report.reportedAt !== "string") return null;
+  return { ...parseStatusUpdate(report), reportedAt: report.reportedAt };
+}
+export {
+  parseStatusUpdate,
+  readStatusReport
+};

package/server/dist/features/note/graphql/note.mutation.resolver.js

@@ -1,4 +1,5 @@
 import { GraphQLError } from "graphql";
+import { emitNoteChange } from "../../../features/note/services/change-events.js";
 import { extractBlocksByType, parseNoteContent } from "../../../features/note/services/content-blocks.js";
 import { replaceNoteReferences } from "../../../features/note/services/note-reference-index.js";
 import {
@@ -18,7 +19,6 @@ import {
   isMissingNoteVersionError,
   isNoteVersionConflictError
 } from "../../../features/note/services/write-conflict.js";
-import { notifySemanticSearchNoteChanged } from "../../../features/search/note-change.js";
 import models from "../../../models.js";
 const PLACEHOLDER_PREFIX = "{%";
 const PLACEHOLDER_SUFFIX = "%}";
@@ -83,7 +83,7 @@ const noteMutationResolvers = {
       await replaceNoteReferences(tx, createdNote.id, replacedContent);
       return noteResult2;
     });
-    notifySemanticSearchNoteChanged(noteResult.id);
+    emitNoteChange({ type: "note.created", noteId: noteResult.id });
     return noteResult;
   },
   updateNote: async (_, {
@@ -112,7 +112,7 @@ const noteMutationResolvers = {
       if (!updatedNote) {
         throw "NOT FOUND";
       }
-      notifySemanticSearchNoteChanged(updatedNote.id);
+      emitNoteChange({ type: "note.updated", noteId: updatedNote.id });
       return updatedNote;
     } catch (error) {
       if (isNoteVersionConflictError(error)) {
@@ -146,7 +146,7 @@ const noteMutationResolvers = {
     if (!trashedNote) {
       throw "NOT FOUND";
     }
-    notifySemanticSearchNoteChanged(Number(id));
+    emitNoteChange({ type: "note.deleted", noteId: Number(id) });
     return true;
   },
   restoreNoteSnapshot: async (_, { id, expectedUpdatedAt }, context) => {
@@ -158,7 +158,7 @@ const noteMutationResolvers = {
       if (!note) {
         throw "NOT FOUND";
       }
-      notifySemanticSearchNoteChanged(note.id);
+      emitNoteChange({ type: "note.updated", noteId: note.id });
       return note;
     } catch (error) {
       if (isNoteVersionConflictError(error)) {
@@ -185,7 +185,7 @@ const noteMutationResolvers = {
     if (!note) {
       throw "NOT FOUND";
     }
-    notifySemanticSearchNoteChanged(note.id);
+    emitNoteChange({ type: "note.created", noteId: note.id });
     return note;
   },
   purgeTrashedNote: async (_, { id }) => {
@@ -193,7 +193,6 @@ const noteMutationResolvers = {
     if (!purgedNote) {
       throw "NOT FOUND";
     }
-    notifySemanticSearchNoteChanged(Number(id));
     return true;
   },
   createNotePropertyKey: async (_, { input }) => {
@@ -272,6 +271,7 @@ const noteMutationResolvers = {
       if (!note) {
         throw "NOT FOUND";
       }
+      emitNoteChange({ type: "note.updated", noteId: note.id, affectsSearchIndex: false });
       return note;
     } catch (error) {
       if (error instanceof InvalidNotePropertyInputError) {
@@ -307,10 +307,14 @@ const noteMutationResolvers = {
       throw error;
     }
   },
-  pinNote: (_, { id, pinned }) => models.note.update({
-    where: { id: Number(id) },
-    data: { pinned: Boolean(pinned) }
-  }),
+  pinNote: async (_, { id, pinned }) => {
+    const note = await models.note.update({
+      where: { id: Number(id) },
+      data: { pinned: Boolean(pinned) }
+    });
+    emitNoteChange({ type: "note.updated", noteId: note.id, affectsSearchIndex: false });
+    return note;
+  },
   reorderNotes: async (_, { notes }) => {
     const updatePromises = notes.map(
       ({ id, order }) => models.note.update({
@@ -318,7 +322,11 @@ const noteMutationResolvers = {
         data: { order }
       })
     );
-    return Promise.all(updatePromises);
+    const updatedNotes = await Promise.all(updatePromises);
+    for (const note of updatedNotes) {
+      emitNoteChange({ type: "note.updated", noteId: note.id, affectsSearchIndex: false });
+    }
+    return updatedNotes;
   }
 };
 export {

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

@@ -1,3 +1,4 @@
+import { emitNoteChange } from "../../../features/note/services/change-events.js";
 import { getNoteCleanupPreview, listNoteCleanupCandidates } from "../../../features/note/services/cleanup.js";
 import {
   buildNoteGraph,
@@ -293,7 +294,7 @@ const createNoteQueryResolver = (deps = {
       return note;
     }
     try {
-      return await deps.updateNoteContent({
+      const updatedNote = await deps.updateNoteContent({
         id: note.id,
         updatedAt: note.updatedAt,
         content: newContent,
@@ -302,6 +303,8 @@ const createNoteQueryResolver = (deps = {
           content: newContent
         })
       });
+      emitNoteChange({ type: "note.updated", noteId: updatedNote.id });
+      return updatedNote;
     } catch (error) {
       if (deps.isRecordNotFoundError(error)) {
         return note;

package/server/dist/features/note/services/change-events.js

@@ -0,0 +1,26 @@
+import { EventEmitter } from "node:events";
+const NOTE_CHANGE_CHANNEL = "note-change";
+const noteChangeEmitter = new EventEmitter();
+noteChangeEmitter.setMaxListeners(0);
+const emitNoteChange = (input) => {
+  if (!Number.isInteger(input.noteId) || input.noteId <= 0) {
+    return null;
+  }
+  const event = {
+    ...input,
+    occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    affectsSearchIndex: input.affectsSearchIndex ?? true
+  };
+  noteChangeEmitter.emit(NOTE_CHANGE_CHANNEL, event);
+  return event;
+};
+const subscribeNoteChanges = (listener) => {
+  noteChangeEmitter.on(NOTE_CHANGE_CHANNEL, listener);
+  return () => {
+    noteChangeEmitter.off(NOTE_CHANGE_CHANNEL, listener);
+  };
+};
+export {
+  emitNoteChange,
+  subscribeNoteChanges
+};

package/server/dist/features/search/search-manager.js

@@ -1,5 +1,5 @@
+import { subscribeNoteChanges } from "../../features/note/services/change-events.js";
 import models from "../../models.js";
-import { subscribeServerEvents } from "../../modules/server-events.js";
 import { paths } from "../../paths.js";
 import {
   createEmbeddingApiKeyFingerprint,
@@ -9,7 +9,6 @@ import {
   createOpenAiCompatibleEmbeddingClient,
   listOpenAiCompatibleEmbeddingModels
 } from "./embedding-client.js";
-import { subscribeSemanticSearchNoteChanges } from "./note-change.js";
 import {
   buildNoteEmbeddingChunks,
   NOTE_EMBEDDING_TEXT_SCHEMA_VERSION
@@ -432,11 +431,9 @@ const getDefaultSemanticSearchManager = () => {
       apiKeyStore: new FileEmbeddingApiKeyStore(paths.embeddingApiKey)
     });
     defaultSemanticSearchUnsubscribers = [
-      subscribeServerEvents((event) => {
-        void defaultSemanticSearchManager?.scheduleNoteSync(Number(event.noteId)).catch(() => void 0);
-      }),
-      subscribeSemanticSearchNoteChanges((noteId) => {
-        void defaultSemanticSearchManager?.scheduleNoteSync(noteId).catch(() => void 0);
+      subscribeNoteChanges((event) => {
+        if (!event.affectsSearchIndex) return;
+        void defaultSemanticSearchManager?.scheduleNoteSync(event.noteId).catch(() => void 0);
       })
     ];
     defaultSemanticSearchManager.startBackgroundSync();

package/server/dist/modules/server-events.js

@@ -1,4 +1,5 @@
 import { EventEmitter } from "node:events";
+import { emitNoteChange } from "../features/note/services/change-events.js";
 const SERVER_EVENT_CHANNEL = "server-event";
 const serverEventEmitter = new EventEmitter();
 serverEventEmitter.setMaxListeners(0);
@@ -9,6 +10,8 @@ const emitServerEvent = (event) => {
     ...event
   };
   serverEventEmitter.emit(SERVER_EVENT_CHANNEL, nextEvent);
+  const type = event.type.replace(/^(mcp|integration)\./, "");
+  emitNoteChange({ type, noteId: Number(event.noteId) });
   return nextEvent;
 };
 const subscribeServerEvents = (listener) => {