@mastra/deployer 1.61.0-alpha.2 → 1.61.0-alpha.4

package/dist/server/index.cjs

@@ -3768,6 +3768,20 @@ function handleClientsRefresh(c) {
 		"Access-Control-Allow-Origin": "*"
 	} });
 }
+/**
+* End every open refresh SSE stream. Studio keeps one of these connections
+* open for its whole lifetime, so without this the graceful-shutdown drain
+* would wait on them until the drain deadline (stalling `mastra dev` hot
+* reloads while Studio is open).
+*/
+function closeRefreshStreams() {
+	clients.forEach((controller) => {
+		try {
+			controller.close();
+		} catch {}
+	});
+	clients.clear();
+}
 function handleTriggerClientsRefresh(c) {
 	clients.forEach((controller) => {
 		try {
@@ -4633,6 +4647,8 @@ async function createNodeServer(mastra, options = { tools: {} }) {
 	const injectWebSocket = app.injectWebSocket;
 	const serverOptions = mastra.getServer();
 	const apiPrefix = serverOptions?.apiPrefix ?? "/api";
+	const drainTimeoutMs = serverOptions?.drainTimeout ?? 5e3;
+	if (serverOptions?.handleShutdownSignals !== false && (!Number.isFinite(drainTimeoutMs) || drainTimeoutMs < 0 || drainTimeoutMs > 2147483647)) throw new RangeError("server.drainTimeout must be a finite number between 0 and 2147483647 milliseconds");
 	const key = serverOptions?.https?.key ?? (process.env.MASTRA_HTTPS_KEY ? Buffer.from(process.env.MASTRA_HTTPS_KEY, "base64") : void 0);
 	const cert = serverOptions?.https?.cert ?? (process.env.MASTRA_HTTPS_CERT ? Buffer.from(process.env.MASTRA_HTTPS_CERT, "base64") : void 0);
 	const isHttpsEnabled = Boolean(key && cert);
@@ -4674,33 +4690,62 @@ async function createNodeServer(mastra, options = { tools: {} }) {
 	else await workerLifecycle.startEventEngine();
 	import("@mastra/core/telemetry").then(({ syncUsageTelemetry }) => syncUsageTelemetry(mastra)).catch(() => {});
 	import("@mastra/core/telemetry").then(({ syncFeatureUsageTelemetry }) => syncFeatureUsageTelemetry(mastra)).catch(() => {});
-	const SHUTDOWN_TIMEOUT_MS = 5e3;
-	let shuttingDown = false;
-	const shutdown = async (signal) => {
-		if (shuttingDown) return;
-		shuttingDown = true;
-		const logger = mastra.getLogger();
-		logger.info("Shutting down Mastra server", { signal });
-		server.close();
-		const lifecycle = mastra;
-		if (typeof lifecycle.shutdown === "function") {
+	if (serverOptions?.handleShutdownSignals !== false) {
+		const CORE_SHUTDOWN_TIMEOUT_MS = 5e3;
+		const timedOut = Symbol("shutdown-timeout");
+		const race = async (work, ms) => {
 			let timeout;
-			const timedOut = Symbol("shutdown-timeout");
 			const timeoutPromise = new Promise((resolve) => {
-				timeout = setTimeout(() => resolve(timedOut), SHUTDOWN_TIMEOUT_MS);
+				timeout = setTimeout(() => resolve(timedOut), ms);
 			});
 			try {
-				if (await Promise.race([lifecycle.shutdown(), timeoutPromise]) === timedOut) logger.warn("Mastra shutdown timed out; forcing exit", { timeoutMs: SHUTDOWN_TIMEOUT_MS });
-			} catch (error) {
-				logger.error("Error during Mastra shutdown", { error });
+				return await Promise.race([work, timeoutPromise]);
 			} finally {
 				clearTimeout(timeout);
 			}
-		}
-		process.exit(0);
-	};
-	process.once("SIGINT", () => void shutdown("SIGINT"));
-	process.once("SIGTERM", () => void shutdown("SIGTERM"));
+		};
+		let shuttingDown = false;
+		const shutdown = async (signal) => {
+			if (shuttingDown) {
+				process.exit(1);
+				return;
+			}
+			shuttingDown = true;
+			const logger = mastra.getLogger();
+			logger.info("Shutting down Mastra server", { signal });
+			try {
+				const drained = new Promise((resolve) => {
+					server.close(() => resolve());
+				});
+				closeRefreshStreams();
+				const closeIdleConnections = () => server.closeIdleConnections?.();
+				closeIdleConnections();
+				const idleSweep = setInterval(closeIdleConnections, 100);
+				idleSweep.unref?.();
+				try {
+					if (await race(drained, drainTimeoutMs) === timedOut) {
+						logger.warn("Mastra server drain timed out; closing remaining HTTP connections", { timeoutMs: drainTimeoutMs });
+						server.closeAllConnections?.();
+					}
+				} finally {
+					clearInterval(idleSweep);
+				}
+			} catch (error) {
+				logger.error("Error while draining Mastra server", { error });
+			}
+			try {
+				const lifecycle = mastra;
+				if (typeof lifecycle.shutdown === "function") {
+					if (await race(lifecycle.shutdown(), CORE_SHUTDOWN_TIMEOUT_MS) === timedOut) logger.warn("Mastra shutdown timed out; forcing exit", { timeoutMs: CORE_SHUTDOWN_TIMEOUT_MS });
+				}
+			} catch (error) {
+				logger.error("Error during Mastra shutdown", { error });
+			}
+			process.exit(0);
+		};
+		process.on("SIGINT", () => void shutdown("SIGINT"));
+		process.on("SIGTERM", () => void shutdown("SIGTERM"));
+	}
 	return server;
 }
 //#endregion