ocean-brain 0.13.0 → 0.13.1

package/server/dist/app.js

@@ -1,29 +1,112 @@
-import express from "express";
+import fastifyCookie, { Signer } from "@fastify/cookie";
+import fastifyCsrfProtection from "@fastify/csrf-protection";
+import fastifyFormbody from "@fastify/formbody";
+import fastifyRateLimit from "@fastify/rate-limit";
+import fastifySession from "@fastify/session";
+import Fastify from "fastify";
 import { createMcpAdminService } from "./features/mcp-admin/service.js";
 import { purgeExpiredNoteSnapshots } from "./features/note/services/snapshot.js";
 import { purgeExpiredTrashedNotes } from "./features/note/services/trash.js";
-import { createSessionMiddleware } from "./modules/auth-guard.js";
-import { createErrorHandler } from "./modules/error-handler.js";
-import logger from "./modules/logger.js";
+import { closeDefaultSemanticSearchManager } from "./features/search/search-manager.js";
+import { createAppError, createErrorHandler } from "./modules/error-handler.js";
+import { AUTH_SESSION_IDLE_TIMEOUT_MS, createSessionStore } from "./modules/session-store.js";
 import { createApiRouter, createAuthPagesRouter, createClientRouter, createGraphqlRouter } from "./routes/index.js";
+const MAX_REQUEST_BODY_BYTES = 50 * 1024 * 1024;
+const isHttpLoggerEnabled = (loggerOption) => loggerOption ?? process.env.OCEAN_BRAIN_HTTP_LOG?.toLowerCase() !== "false";
+const createLoggerOptions = () => ({
+  level: "info",
+  serializers: {
+    req(request) {
+      return {
+        method: request.method,
+        url: request.url,
+        remoteAddress: request.ip,
+        userAgent: request.headers["user-agent"]
+      };
+    },
+    res(reply) {
+      return { statusCode: reply.statusCode };
+    }
+  }
+});
+const createFastifyApplication = (options = {}) => Fastify({
+  bodyLimit: MAX_REQUEST_BODY_BYTES,
+  routerOptions: { ignoreTrailingSlash: true },
+  logger: isHttpLoggerEnabled(options.logger) ? createLoggerOptions() : false
+});
+const registerRequestInfrastructure = (app, authConfig) => {
+  app.addHook("onRequest", (request, _reply, done) => {
+    const contentEncoding = request.headers["content-encoding"];
+    if (contentEncoding && contentEncoding.toLowerCase() !== "identity") {
+      done(createAppError(415, "UNSUPPORTED_CONTENT_ENCODING", "Compressed request bodies are not supported."));
+      return;
+    }
+    done();
+  });
+  app.register(fastifyCookie);
+  app.register(fastifyFormbody);
+  app.register(fastifyRateLimit, {
+    global: false,
+    enableDraftSpec: true
+  });
+  if (authConfig.mode !== "password") {
+    return;
+  }
+  const sessionStore = createSessionStore();
+  app.addHook("onClose", (_instance, done) => {
+    if ("stopPruning" in sessionStore && typeof sessionStore.stopPruning === "function") {
+      sessionStore.stopPruning();
+    }
+    done();
+  });
+  app.register(fastifySession, {
+    // Preserve the configured secret bytes and support legacy secrets shorter than 32 characters.
+    secret: new Signer(authConfig.sessionSecret),
+    cookieName: authConfig.cookieName,
+    cookiePrefix: "s:",
+    store: sessionStore,
+    saveUninitialized: false,
+    rolling: true,
+    cookie: {
+      maxAge: AUTH_SESSION_IDLE_TIMEOUT_MS,
+      httpOnly: true,
+      sameSite: "lax",
+      secure: process.env.NODE_ENV === "production",
+      path: "/"
+    }
+  });
+  app.register(fastifyCsrfProtection, {
+    sessionPlugin: "@fastify/session",
+    logLevel: "debug"
+  });
+};
 const createApp = (authConfig, options = {}) => {
   const mcpAdminService = createMcpAdminService();
   return createAppWithMcpAuth(authConfig, mcpAdminService, options);
 };
 const createAppWithMcpAuth = (authConfig, mcpAdminService, options = {}) => {
-  const app = options.application ?? express();
-  app.locals.authConfig = authConfig;
-  void Promise.all([purgeExpiredNoteSnapshots(), purgeExpiredTrashedNotes()]).catch((error) => {
+  const app = options.application ?? createFastifyApplication(options);
+  const startupCleanup = Promise.all([purgeExpiredNoteSnapshots(), purgeExpiredTrashedNotes()]).catch((error) => {
     const message = error instanceof Error ? error.message : "Unknown recovery cleanup error";
     process.stderr.write(`[recovery] Startup cleanup failed: ${message}
 `);
   });
-  app.use(logger).use(createSessionMiddleware(authConfig)).use(express.urlencoded({ extended: false, inflate: false })).use(express.json({ limit: "50mb", inflate: false })).use("/api", createApiRouter(authConfig, mcpAdminService)).use(createAuthPagesRouter(authConfig)).use("/graphql", createGraphqlRouter(authConfig, mcpAdminService)).use(createClientRouter(authConfig, options.clientContentMiddleware)).use(createErrorHandler());
+  app.addHook("onClose", async () => {
+    await startupCleanup;
+    await closeDefaultSemanticSearchManager();
+  });
+  registerRequestInfrastructure(app, authConfig);
+  app.setErrorHandler(createErrorHandler(authConfig));
+  app.register(createApiRouter(authConfig, mcpAdminService), { prefix: "/api" });
+  app.register(createAuthPagesRouter(authConfig));
+  app.register(createGraphqlRouter(authConfig, mcpAdminService));
+  app.register(createClientRouter(authConfig, options.clientContentHandler));
   return app;
 };
 var app_default = createApp;
 export {
   createApp,
   createAppWithMcpAuth,
+  createFastifyApplication,
   app_default as default
 };

package/server/dist/features/auth/http/api.js

@@ -10,7 +10,7 @@ import {
   setSessionStatusHeaders
 } from "../service.js";
 const createLoginHandler = (authConfig) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const expectedPassword = assertPasswordLoginAvailable(authConfig);
     const password = typeof req.body?.password === "string" ? req.body.password : "";
     if (!password || !compareSharedSecret(expectedPassword, password)) {
@@ -18,22 +18,23 @@ const createLoginHandler = (authConfig) => {
     }
     await regenerateSession(req);
     req.session.authenticated = true;
-    refreshCsrfToken(req);
-    res.status(200).json(buildSessionResponse(authConfig, req)).end();
+    refreshCsrfToken(authConfig, reply);
+    return reply.status(200).send(buildSessionResponse(authConfig, req));
   };
 };
 const createLogoutHandler = (authConfig) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     if (authConfig.mode === "password") {
       await destroySession(req);
     }
-    res.status(200).json(buildAuthSessionResponse(authConfig, false)).end();
+    return reply.status(200).send(buildAuthSessionResponse(authConfig, false));
   };
 };
 const createSessionStatusHandler = (authConfig) => {
-  return async (req, res) => {
-    setSessionStatusHeaders(res);
-    res.status(200).json(buildSessionResponse(authConfig, req)).end();
+  return async (req, reply) => {
+    setSessionStatusHeaders(reply);
+    refreshCsrfToken(authConfig, reply);
+    return reply.status(200).send(buildSessionResponse(authConfig, req));
   };
 };
 export {

package/server/dist/features/auth/http/pages.js

@@ -1,3 +1,4 @@
+import { issueCsrfToken } from "../../../modules/auth-guard.js";
 import {
   compareSharedSecret,
   destroySession,
@@ -7,65 +8,63 @@ import {
   sanitizeRedirectPath
 } from "../service.js";
 import { renderLoginPage } from "./login-page.js";
-const setLoginPageHeaders = (res) => {
-  res.set("Cache-Control", "no-store");
+const setLoginPageHeaders = (reply) => {
+  reply.header("Cache-Control", "no-store");
 };
 const createLoginPageHandler = (authConfig) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     if (authConfig.mode !== "password" || req.session?.authenticated) {
-      setLoginPageHeaders(res);
-      res.redirect(303, sanitizeRedirectPath(req.query.next));
-      return;
+      setLoginPageHeaders(reply);
+      return reply.redirect(sanitizeRedirectPath(req.query.next), 303);
     }
     const nextPath = sanitizeRedirectPath(req.query.next);
-    setLoginPageHeaders(res);
-    res.status(200).type("html").send(
+    const csrfToken = issueCsrfToken(authConfig, reply);
+    setLoginPageHeaders(reply);
+    return reply.status(200).type("text/html; charset=utf-8").send(
       renderLoginPage({
         nextPath,
-        csrfToken: res.locals._csrf,
+        csrfToken,
         sessionGeneration: getSessionGeneration()
       })
-    ).end();
+    );
   };
 };
 const createLoginPageSubmitHandler = (authConfig) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const nextPath = sanitizeRedirectPath(req.body?.next);
     if (authConfig.mode !== "password" || !authConfig.password) {
-      setLoginPageHeaders(res);
-      res.redirect(303, nextPath);
-      return;
+      setLoginPageHeaders(reply);
+      return reply.redirect(nextPath, 303);
     }
     const password = typeof req.body?.password === "string" ? req.body.password : "";
     if (!password || !compareSharedSecret(authConfig.password, password)) {
-      setLoginPageHeaders(res);
-      res.status(401).type("html").send(
+      const csrfToken = issueCsrfToken(authConfig, reply);
+      setLoginPageHeaders(reply);
+      return reply.status(401).type("text/html; charset=utf-8").send(
         renderLoginPage({
           nextPath,
           errorMessage: "Invalid password",
-          csrfToken: res.locals._csrf,
+          csrfToken,
           sessionGeneration: getSessionGeneration()
         })
-      ).end();
-      return;
+      );
     }
     await regenerateSession(req);
     req.session.authenticated = true;
-    refreshCsrfToken(req);
-    setLoginPageHeaders(res);
-    res.redirect(303, nextPath);
+    refreshCsrfToken(authConfig, reply);
+    setLoginPageHeaders(reply);
+    return reply.redirect(nextPath, 303);
   };
 };
 const createLogoutPageHandler = (authConfig) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     if (authConfig.mode === "password") {
       await destroySession(req);
-      setLoginPageHeaders(res);
-      res.redirect(303, "/login");
-      return;
+      setLoginPageHeaders(reply);
+      return reply.redirect("/login", 303);
     }
-    setLoginPageHeaders(res);
-    res.redirect(303, "/");
+    setLoginPageHeaders(reply);
+    return reply.redirect("/", 303);
   };
 };
 export {

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

@@ -1,6 +1,7 @@
 import { buildAuthSessionResponse } from "@baejino/auth";
 import { compareSharedSecret as compareCommonSharedSecret } from "@baejino/auth/crypto";
 import crypto from "crypto";
+import { issueCsrfToken } from "../../modules/auth-guard.js";
 import { sanitizeRedirectPath } from "../../modules/auth-redirect.js";
 import { createAppError } from "../../modules/error-handler.js";
 const AUTH_SESSION_GENERATION_HEADER = "X-Ocean-Brain-Session-Generation";
@@ -18,44 +19,23 @@ const comparePassword = async (password, storedHash) => {
 };
 const compareSharedSecret = compareCommonSharedSecret;
 const buildSessionResponse = (authConfig, req) => buildAuthSessionResponse(authConfig, Boolean(req.session?.authenticated));
-const setSessionStatusHeaders = (res) => {
-  res.set(AUTH_SESSION_GENERATION_HEADER, getSessionGeneration());
-  res.set("Cache-Control", "no-store");
-};
-const refreshCsrfToken = (req) => {
-  const requestWithCsrf = req;
-  requestWithCsrf.csrfToken?.();
+const setSessionStatusHeaders = (reply) => {
+  reply.header(AUTH_SESSION_GENERATION_HEADER, getSessionGeneration());
+  reply.header("Cache-Control", "no-store");
 };
+const refreshCsrfToken = (authConfig, reply) => issueCsrfToken(authConfig, reply);
 const assertPasswordLoginAvailable = (authConfig) => {
   if (authConfig.mode !== "password") {
     throw createAppError(409, "AUTH_OPEN_MODE", "Login is unavailable while auth mode is open.");
   }
   return authConfig.password;
 };
-const regenerateSession = async (req) => {
-  await new Promise((resolve, reject) => {
-    req.session.regenerate((error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
-};
+const regenerateSession = async (req) => req.session.regenerate();
 const destroySession = async (req) => {
   if (!req.session) {
     return;
   }
-  await new Promise((resolve, reject) => {
-    req.session.destroy((error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
+  await req.session.destroy();
 };
 export {
   AUTH_SESSION_GENERATION_HEADER,

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

@@ -9,7 +9,7 @@ const cacheType = gql`
 const cacheQuery = gql`
     type Query {
         allCaches: [Cache!]!
-        cache(key: String!): Cache!
+        cache(key: String!): Cache
     }
 `;
 const cacheMutation = gql`

package/server/dist/features/image/http/upload.js

@@ -25,7 +25,7 @@ const createUploadValidationError = (error) => {
   return createAppError(400, "INVALID_IMAGE_UPLOAD", "Uploaded image content is invalid.");
 };
 const createUploadImageHandler = (persistImage = persistUploadedImage) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const { image } = req.body ?? {};
     if (typeof image !== "string") {
       throw createAppError(400, "INVALID_IMAGE_UPLOAD", "No image uploaded");
@@ -50,7 +50,7 @@ const createUploadImageHandler = (persistImage = persistUploadedImage) => {
       buffer: validatedImage.buffer,
       extension: validatedImage.extension
     });
-    res.status(200).json(createUploadResponse(uploadedImage)).end();
+    return reply.status(200).send(createUploadResponse(uploadedImage));
   };
 };
 export {

package/server/dist/features/mcp-admin/http/handlers.js

@@ -9,36 +9,36 @@ const createMcpAdminStatusResponse = async (service) => {
   };
 };
 const createMcpAdminStatusHandler = (service = createMcpAdminService()) => {
-  return async (_req, res) => {
+  return async (_req, reply) => {
     const status = await createMcpAdminStatusResponse(service);
-    res.status(200).json(status).end();
+    return reply.status(200).send(status);
   };
 };
 const createMcpAdminSetEnabledHandler = (service = createMcpAdminService()) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const enabled = req.body?.enabled;
     if (typeof enabled !== "boolean") {
       throw createAppError(400, "INVALID_MCP_ENABLED", "enabled must be a boolean.");
     }
     await service.setEnabled(enabled);
     const status = await createMcpAdminStatusResponse(service);
-    res.status(200).json(status).end();
+    return reply.status(200).send(status);
   };
 };
 const createMcpAdminRotateTokenHandler = (service = createMcpAdminService()) => {
-  return async (_req, res) => {
+  return async (_req, reply) => {
     const result = await service.rotateToken();
-    res.status(200).json({
+    return reply.status(200).send({
       token: result.token,
       message: "Save this token now. It is shown only once."
-    }).end();
+    });
   };
 };
 const createMcpAdminRevokeTokenHandler = (service = createMcpAdminService()) => {
-  return async (_req, res) => {
+  return async (_req, reply) => {
     await service.revokeActiveToken();
     const status = await createMcpAdminStatusResponse(service);
-    res.status(200).json(status).end();
+    return reply.status(200).send(status);
   };
 };
 export {

package/server/dist/features/note/http/mcp.js

@@ -227,7 +227,7 @@ const resolveSeparator = (value) => {
   throw createAppError(400, "INVALID_SEPARATOR", 'Separator must be "\\n" or "\\n\\n".');
 };
 const createMcpCreateNoteHandler = (createNote = createNoteFromMarkdown, emitEvent = emitServerEvent) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const { title, markdown, layout } = req.body ?? {};
     const resolvedLayout = resolveNoteLayout(layout);
     if (typeof title !== "string") {
@@ -251,10 +251,10 @@ const createMcpCreateNoteHandler = (createNote = createNoteFromMarkdown, emitEve
         noteId: note.id,
         updatedAt: note.updatedAt
       });
-      res.status(200).json({
+      return reply.status(200).send({
         created: true,
         note
-      }).end();
+      });
     } catch (error) {
       if (error instanceof InvalidNoteAuthoringInputError) {
         throw createAppError(400, "INVALID_NOTE_INPUT", error.message);
@@ -270,19 +270,19 @@ const createMcpNoteWriteBaselineHandler = (findNoteBaseline = async (id) => mode
     updatedAt: true
   }
 })) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const noteId = resolvePositiveNoteId(req.body?.id);
     const note = await findNoteBaseline(noteId);
     if (!note) {
       throw createAppError(404, "NOTE_NOT_FOUND", "The requested note was not found.");
     }
-    res.status(200).json({
+    return reply.status(200).send({
       note: serializeNoteWriteBaseline(note)
-    }).end();
+    });
   };
 };
 const createMcpPatchNoteMarkdownHandler = (patchMarkdown = patchNoteMarkdown, emitEvent = emitServerEvent) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const { id, expectedUpdatedAt, baseMarkdownSha256, intent, selector, operation, policy } = req.body ?? {};
     const noteId = resolvePositiveNoteId(id);
     const resolvedExpectedUpdatedAt = resolveOptionalString(
@@ -315,11 +315,11 @@ const createMcpPatchNoteMarkdownHandler = (patchMarkdown = patchNoteMarkdown, em
         updatedAt: result.note.updatedAt
       });
     }
-    res.status(200).json(result).end();
+    return reply.status(200).send(result);
   };
 };
 const createMcpAppendNoteMarkdownHandler = (appendMarkdown = appendNoteMarkdown, emitEvent = emitServerEvent) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const { id, expectedUpdatedAt, baseMarkdownSha256, intent, insertion, placement, separator, policy } = req.body ?? {};
     const noteId = resolvePositiveNoteId(id);
     const resolvedExpectedUpdatedAt = resolveOptionalString(
@@ -356,11 +356,11 @@ const createMcpAppendNoteMarkdownHandler = (appendMarkdown = appendNoteMarkdown,
         updatedAt: result.note.updatedAt
       });
     }
-    res.status(200).json(result).end();
+    return reply.status(200).send(result);
   };
 };
 const createMcpReplaceNoteMarkdownHandler = (replaceMarkdown = replaceNoteMarkdown, emitEvent = emitServerEvent) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const { id, expectedUpdatedAt, baseMarkdownSha256, intent, replacement, policy } = req.body ?? {};
     const noteId = resolvePositiveNoteId(id);
     const resolvedExpectedUpdatedAt = resolveOptionalString(
@@ -395,11 +395,11 @@ const createMcpReplaceNoteMarkdownHandler = (replaceMarkdown = replaceNoteMarkdo
         updatedAt: result.note.updatedAt
       });
     }
-    res.status(200).json(result).end();
+    return reply.status(200).send(result);
   };
 };
 const createMcpUpdateNoteMetadataHandler = (updateMetadata = updateNoteMetadata, emitEvent = emitServerEvent) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const { id, expectedUpdatedAt, title, layout, properties } = req.body ?? {};
     const noteId = resolvePositiveNoteId(id);
     const resolvedLayout = resolveNoteLayout(layout);
@@ -431,11 +431,11 @@ const createMcpUpdateNoteMetadataHandler = (updateMetadata = updateNoteMetadata,
         updatedAt: result.note.updatedAt
       });
     }
-    res.status(200).json(result).end();
+    return reply.status(200).send(result);
   };
 };
 const createMcpDeleteNoteHandler = (deleteNote = deleteNoteById, emitEvent = emitServerEvent) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const id = Number(req.body?.id);
     if (!Number.isInteger(id) || id <= 0) {
       throw createAppError(400, "INVALID_NOTE_ID", "A valid note id is required.");
@@ -449,10 +449,10 @@ const createMcpDeleteNoteHandler = (deleteNote = deleteNoteById, emitEvent = emi
       source: "mcp",
       noteId: deletedNote.id
     });
-    res.status(200).json({
+    return reply.status(200).send({
       deleted: true,
       note: deletedNote
-    }).end();
+    });
   };
 };
 export {

package/server/dist/features/search/http/handlers.js

@@ -70,33 +70,33 @@ const parseBaseUrl = (value) => {
   return baseUrl;
 };
 const createSearchAdminStatusHandler = (manager = getDefaultSemanticSearchManager()) => {
-  return async (_req, res) => {
-    res.status(200).json(await manager.getStatus()).end();
+  return async (_req, reply) => {
+    return reply.status(200).send(await manager.getStatus());
   };
 };
 const createSearchAdminSaveConfigHandler = (manager = getDefaultSemanticSearchManager()) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const status = await manager.saveConfig(parseConfig(req.body), parseApiKeyInput(req.body));
-    res.status(200).json(status).end();
+    return reply.status(200).send(status);
   };
 };
 const createSearchAdminTestConnectionHandler = (manager = getDefaultSemanticSearchManager()) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const config = parseConfig({ ...req.body, enabled: true });
     const result = await manager.testConnection(config, parseApiKeyInput(req.body));
-    res.status(200).json(result).end();
+    return reply.status(200).send(result);
   };
 };
 const createSearchAdminListModelsHandler = (listModels = (baseUrl, apiKeyInput) => getDefaultSemanticSearchManager().listModels(baseUrl, apiKeyInput)) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const models = await listModels(parseBaseUrl(req.body), parseApiKeyInput(req.body));
-    res.status(200).json({ models }).end();
+    return reply.status(200).send({ models });
   };
 };
 const createSearchAdminReindexHandler = (manager = getDefaultSemanticSearchManager()) => {
-  return async (_req, res) => {
+  return async (_req, reply) => {
     const result = await manager.startReindex();
-    res.status(result.started ? 202 : 200).json(result).end();
+    return reply.status(result.started ? 202 : 200).send(result);
   };
 };
 export {

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

@@ -355,6 +355,21 @@ class SemanticSearchManager {
       this.noteSyncReconciliationTimer = null;
     }
   }
+  async close() {
+    this.stopBackgroundSync();
+    const activeOperations = [];
+    if (this.activeReindex) {
+      activeOperations.push(this.activeReindex);
+    }
+    if (this.activeNoteSync) {
+      activeOperations.push(this.activeNoteSync);
+    }
+    if (this.activeReconciliation) {
+      activeOperations.push(this.activeReconciliation);
+    }
+    await Promise.allSettled(activeOperations);
+    await this.dependencies.vectorIndex.close?.();
+  }
   async trySearch(query, limit) {
     const status = await this.getStatus();
     if (!status.available) {
@@ -389,6 +404,7 @@ class SemanticSearchManager {
   }
 }
 let defaultSemanticSearchManager = null;
+let defaultSemanticSearchUnsubscribers = [];
 const getDefaultSemanticSearchManager = () => {
   if (!defaultSemanticSearchManager) {
     defaultSemanticSearchManager = new SemanticSearchManager({
@@ -415,17 +431,29 @@ const getDefaultSemanticSearchManager = () => {
       }),
       apiKeyStore: new FileEmbeddingApiKeyStore(paths.embeddingApiKey)
     });
-    subscribeServerEvents((event) => {
-      void defaultSemanticSearchManager?.scheduleNoteSync(Number(event.noteId)).catch(() => void 0);
-    });
-    subscribeSemanticSearchNoteChanges((noteId) => {
-      void defaultSemanticSearchManager?.scheduleNoteSync(noteId).catch(() => void 0);
-    });
+    defaultSemanticSearchUnsubscribers = [
+      subscribeServerEvents((event) => {
+        void defaultSemanticSearchManager?.scheduleNoteSync(Number(event.noteId)).catch(() => void 0);
+      }),
+      subscribeSemanticSearchNoteChanges((noteId) => {
+        void defaultSemanticSearchManager?.scheduleNoteSync(noteId).catch(() => void 0);
+      })
+    ];
     defaultSemanticSearchManager.startBackgroundSync();
   }
   return defaultSemanticSearchManager;
 };
+const closeDefaultSemanticSearchManager = async () => {
+  const manager = defaultSemanticSearchManager;
+  defaultSemanticSearchManager = null;
+  for (const unsubscribe of defaultSemanticSearchUnsubscribers) {
+    unsubscribe();
+  }
+  defaultSemanticSearchUnsubscribers = [];
+  await manager?.close();
+};
 export {
   SemanticSearchManager,
+  closeDefaultSemanticSearchManager,
   getDefaultSemanticSearchManager
 };

package/server/dist/features/tag/http/mcp.js

@@ -1,14 +1,14 @@
 import { ensureTagByName, InvalidTagNameError } from "../../../features/tag/services/organization.js";
 import { createAppError } from "../../../modules/error-handler.js";
 const createMcpCreateTagHandler = (ensureTag = ensureTagByName) => {
-  return async (req, res) => {
+  return async (req, reply) => {
     const name = req.body?.name;
     if (typeof name !== "string") {
       throw createAppError(400, "INVALID_TAG_NAME", "A tag name is required.");
     }
     try {
       const result = await ensureTag(name);
-      res.status(200).json(result).end();
+      return reply.status(200).send(result);
     } catch (error) {
       if (error instanceof InvalidTagNameError) {
         throw createAppError(400, "INVALID_TAG_NAME", error.message);