@mastra/deployer 1.37.0-alpha.1 → 1.37.0-alpha.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @mastra/deployer
 
+## 1.37.0-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [[`df1947a`](https://github.com/mastra-ai/mastra/commit/df1947affa40f742067542251fac7ca759492ef4), [`ee59b74`](https://github.com/mastra-ai/mastra/commit/ee59b743ce73ad11784b4d9c6fbba8568edee1c8), [`a97b1a0`](https://github.com/mastra-ai/mastra/commit/a97b1a0abaed83946c3519d1e0f680d0815b8a67)]:
+  - @mastra/core@1.37.0-alpha.2
+  - @mastra/server@1.37.0-alpha.2
+
 ## 1.37.0-alpha.1
 
 ### Patch Changes

package/dist/_types/@hono_node-server/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { createAdaptorServer, serve } from './server.js';
+export { getRequestListener } from './listener.js';
+export { RequestError } from './request.js';
+export { Http2Bindings, HttpBindings, ServerType } from './types.js';
+import 'node:net';
+import 'node:http';
+import 'node:http2';
+import 'node:https';

package/dist/_types/@hono_node-server/dist/listener.d.ts

@@ -0,0 +1,13 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import { FetchCallback, CustomErrorHandler } from './types.js';
+import 'node:https';
+
+declare const getRequestListener: (fetchCallback: FetchCallback, options?: {
+    hostname?: string;
+    errorHandler?: CustomErrorHandler;
+    overrideGlobalObjects?: boolean;
+    autoCleanupIncoming?: boolean;
+}) => (incoming: IncomingMessage | Http2ServerRequest, outgoing: ServerResponse | Http2ServerResponse) => Promise<void>;
+
+export { getRequestListener };

package/dist/_types/@hono_node-server/dist/request.d.ts

@@ -0,0 +1,25 @@
+import { IncomingMessage } from 'node:http';
+import { Http2ServerRequest } from 'node:http2';
+
+declare class RequestError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+declare const toRequestError: (e: unknown) => RequestError;
+declare const GlobalRequest: {
+    new (input: RequestInfo | URL, init?: RequestInit): globalThis.Request;
+    prototype: globalThis.Request;
+};
+declare class Request extends GlobalRequest {
+    constructor(input: string | Request, options?: RequestInit);
+}
+type IncomingMessageWithWrapBodyStream = IncomingMessage & {
+    [wrapBodyStream]: boolean;
+};
+declare const wrapBodyStream: unique symbol;
+declare const abortControllerKey: unique symbol;
+declare const getAbortController: unique symbol;
+declare const newRequest: (incoming: IncomingMessage | Http2ServerRequest, defaultHostname?: string) => any;
+
+export { GlobalRequest, type IncomingMessageWithWrapBodyStream, Request, RequestError, abortControllerKey, getAbortController, newRequest, toRequestError, wrapBodyStream };

package/dist/_types/@hono_node-server/dist/server.d.ts

@@ -0,0 +1,10 @@
+import { AddressInfo } from 'node:net';
+import { Options, ServerType } from './types.js';
+import 'node:http';
+import 'node:http2';
+import 'node:https';
+
+declare const createAdaptorServer: (options: Options) => ServerType;
+declare const serve: (options: Options, listeningListener?: (info: AddressInfo) => void) => ServerType;
+
+export { createAdaptorServer, serve };

package/dist/_types/@hono_node-server/dist/types.d.ts

@@ -0,0 +1,44 @@
+import { IncomingMessage, ServerResponse, ServerOptions as ServerOptions$1, createServer, Server } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse, ServerOptions as ServerOptions$3, createServer as createServer$2, SecureServerOptions, createSecureServer, Http2Server, Http2SecureServer } from 'node:http2';
+import { ServerOptions as ServerOptions$2, createServer as createServer$1 } from 'node:https';
+
+type HttpBindings = {
+    incoming: IncomingMessage;
+    outgoing: ServerResponse;
+};
+type Http2Bindings = {
+    incoming: Http2ServerRequest;
+    outgoing: Http2ServerResponse;
+};
+type FetchCallback = (request: Request, env: HttpBindings | Http2Bindings) => Promise<unknown> | unknown;
+type NextHandlerOption = {
+    fetch: FetchCallback;
+};
+type ServerType = Server | Http2Server | Http2SecureServer;
+type createHttpOptions = {
+    serverOptions?: ServerOptions$1;
+    createServer?: typeof createServer;
+};
+type createHttpsOptions = {
+    serverOptions?: ServerOptions$2;
+    createServer?: typeof createServer$1;
+};
+type createHttp2Options = {
+    serverOptions?: ServerOptions$3;
+    createServer?: typeof createServer$2;
+};
+type createSecureHttp2Options = {
+    serverOptions?: SecureServerOptions;
+    createServer?: typeof createSecureServer;
+};
+type ServerOptions = createHttpOptions | createHttpsOptions | createHttp2Options | createSecureHttp2Options;
+type Options = {
+    fetch: FetchCallback;
+    overrideGlobalObjects?: boolean;
+    autoCleanupIncoming?: boolean;
+    port?: number;
+    hostname?: string;
+} & ServerOptions;
+type CustomErrorHandler = (err: unknown) => void | Response | Promise<void | Response>;
+
+export type { CustomErrorHandler, FetchCallback, Http2Bindings, HttpBindings, NextHandlerOption, Options, ServerOptions, ServerType };

package/dist/_types/@mastra_hono/dist/auth-middleware.d.ts

@@ -0,0 +1,8 @@
+import type { Mastra } from '@mastra/core/mastra';
+import type { MiddlewareHandler } from 'hono';
+export interface HonoAuthMiddlewareOptions {
+    mastra: Mastra;
+    requiresAuth?: boolean;
+}
+export declare function createAuthMiddleware({ mastra, requiresAuth }: HonoAuthMiddlewareOptions): MiddlewareHandler;
+//# sourceMappingURL=auth-middleware.d.ts.map

package/dist/_types/@mastra_hono/dist/browser-stream/index.d.ts

@@ -0,0 +1,35 @@
+import type { BrowserStreamConfig, BrowserStreamResult } from '@mastra/server/browser-stream';
+import type { Env, Hono, Schema } from 'hono';
+/**
+ * Set up WebSocket-based browser stream endpoint for real-time screencast viewing.
+ *
+ * Creates a WebSocket route at `/browser/:agentId/stream` that:
+ * - Accepts viewer connections
+ * - Starts screencast when first viewer connects
+ * - Broadcasts frames to all connected viewers
+ * - Stops screencast when last viewer disconnects
+ *
+ * **Note**: Requires `ws` package to be installed. If not available, returns null
+ * and logs a warning. Browser streaming will be disabled but everything else works.
+ *
+ * @param app - The Hono application instance
+ * @param config - Configuration for browser stream
+ * @returns Object containing injectWebSocket function and registry instance, or null if ws is not available
+ *
+ * @example
+ * ```typescript
+ * import { Hono } from 'hono';
+ * import { serve } from '@hono/node-server';
+ * import { setupBrowserStream } from '@mastra/hono';
+ *
+ * const app = new Hono();
+ * const browserStream = await setupBrowserStream(app, {
+ *   getToolset: (agentId) => browserToolsets.get(agentId),
+ * });
+ *
+ * const server = serve({ fetch: app.fetch, port: 4111 });
+ * browserStream?.injectWebSocket(server);
+ * ```
+ */
+export declare function setupBrowserStream<E extends Env, S extends Schema, B extends string>(app: Hono<E, S, B>, config: BrowserStreamConfig): Promise<BrowserStreamResult | null>;
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/@mastra_hono/dist/index.d.ts

@@ -0,0 +1,59 @@
+import type { ToolsInput } from '@mastra/core/agent';
+import type { Mastra } from '@mastra/core/mastra';
+import type { RequestContext } from '@mastra/core/request-context';
+import type { InMemoryTaskStore } from '@mastra/server/a2a/store';
+import type { ParsedRequestParams, ServerRoute } from '@mastra/server/server-adapter';
+import { MastraServer as MastraServerBase } from '@mastra/server/server-adapter';
+import type { Context, HonoRequest, MiddlewareHandler } from 'hono';
+export { createAuthMiddleware } from './auth-middleware.js';
+export type { HonoAuthMiddlewareOptions } from './auth-middleware.js';
+export { setupBrowserStream } from './browser-stream/index.js';
+export type HonoVariables = {
+    mastra: Mastra;
+    requestContext: RequestContext;
+    registeredTools: ToolsInput;
+    abortSignal: AbortSignal;
+    taskStore: InMemoryTaskStore;
+    customRouteAuthConfig?: Map<string, boolean>;
+    cachedBody?: unknown;
+};
+export type HonoBindings = {};
+/**
+ * Generic handler function type compatible across Hono versions.
+ * Uses a minimal signature that all Hono middleware handlers satisfy.
+ */
+type HonoRouteHandler = (...args: any[]) => any;
+/**
+ * Minimal interface representing what MastraServer needs from a Hono app.
+ * This allows any Hono app instance to be passed without strict generic matching,
+ * avoiding the version mismatch issues that occur with Hono's strict generic types.
+ */
+export interface HonoApp {
+    use(path: string, ...handlers: HonoRouteHandler[]): unknown;
+    get(path: string, ...handlers: HonoRouteHandler[]): unknown;
+    post(path: string, ...handlers: HonoRouteHandler[]): unknown;
+    put(path: string, ...handlers: HonoRouteHandler[]): unknown;
+    delete(path: string, ...handlers: HonoRouteHandler[]): unknown;
+    patch(path: string, ...handlers: HonoRouteHandler[]): unknown;
+    all(path: string, ...handlers: HonoRouteHandler[]): unknown;
+}
+export declare class MastraServer extends MastraServerBase<HonoApp, HonoRequest, Context> {
+    createContextMiddleware(): MiddlewareHandler;
+    stream(route: ServerRoute, res: Context, result: {
+        fullStream: ReadableStream;
+    }): Promise<any>;
+    getParams(route: ServerRoute, request: HonoRequest): Promise<ParsedRequestParams>;
+    /**
+     * Parse FormData into a plain object, converting File objects to Buffers.
+     */
+    private parseFormData;
+    sendResponse(route: ServerRoute, response: Context, result: unknown, prefix?: string): Promise<any>;
+    registerRoute(app: HonoApp, route: ServerRoute, { prefix: prefixParam }?: {
+        prefix?: string;
+    }): Promise<void>;
+    registerCustomApiRoutes(): Promise<void>;
+    registerContextMiddleware(): void;
+    registerAuthMiddleware(): void;
+    registerHttpLoggingMiddleware(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-deployer
 description: Documentation for @mastra/deployer. Use when working with @mastra/deployer APIs, configuration, or implementation.
 metadata:
   package: "@mastra/deployer"
-  version: "1.37.0-alpha.1"
+  version: "1.37.0-alpha.2"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.37.0-alpha.1",
+  "version": "1.37.0-alpha.2",
   "package": "@mastra/deployer",
   "exports": {
     "Deps": {

package/dist/server/index.cjs

@@ -7,7 +7,7 @@ var path = require('path');
 var url = require('url');
 var http = require('http');
 var http2 = require('http2');
-var stream$1 = require('stream');
+var stream = require('stream');
 var crypto = require('crypto');
 var mime = require('hono/utils/mime');
 var fs = require('fs');
@@ -17,6 +17,8 @@ var tools = require('@mastra/core/tools');
 var serverAdapter = require('@mastra/server/server-adapter');
 var util = require('util');
 var buffer = require('buffer');
+var bodyLimit = require('hono/body-limit');
+var streaming = require('hono/streaming');
 var auth = require('@mastra/server/auth');
 var browserStream = require('@mastra/server/browser-stream');
 var store = require('@mastra/server/a2a/store');
@@ -65,7 +67,7 @@ var toRequestError = (e) => {
   return new RequestError(e.message, { cause: e });
 };
 var GlobalRequest = global.Request;
-var Request2 = class extends GlobalRequest {
+var Request = class extends GlobalRequest {
   constructor(input, options) {
     if (typeof input === "object" && getRequestCache in input) {
       input = input[getRequestCache]();
@@ -97,7 +99,7 @@ var newRequestFromIncoming = (method, url, headers, incoming, abortController) =
   };
   if (method === "TRACE") {
     init.method = "GET";
-    const req = new Request2(url, init);
+    const req = new Request(url, init);
     Object.defineProperty(req, "method", {
       get() {
         return "TRACE";
@@ -118,7 +120,7 @@ var newRequestFromIncoming = (method, url, headers, incoming, abortController) =
       init.body = new ReadableStream({
         async pull(controller) {
           try {
-            reader ||= stream$1.Readable.toWeb(incoming).getReader();
+            reader ||= stream.Readable.toWeb(incoming).getReader();
             const { done, value } = await reader.read();
             if (done) {
               controller.close();
@@ -131,10 +133,10 @@ var newRequestFromIncoming = (method, url, headers, incoming, abortController) =
         }
       });
     } else {
-      init.body = stream$1.Readable.toWeb(incoming);
+      init.body = stream.Readable.toWeb(incoming);
     }
   }
-  return new Request2(url, init);
+  return new Request(url, init);
 };
 var getRequestCache = /* @__PURE__ */ Symbol("getRequestCache");
 var requestCache = /* @__PURE__ */ Symbol("requestCache");
@@ -206,7 +208,7 @@ Object.defineProperty(requestPrototype, /* @__PURE__ */ Symbol.for("nodejs.util.
     return `Request (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
   }
 });
-Object.setPrototypeOf(requestPrototype, Request2.prototype);
+Object.setPrototypeOf(requestPrototype, Request.prototype);
 var newRequest = (incoming, defaultHostname) => {
   const req = Object.create(requestPrototype);
   req[incomingKey] = incoming;
@@ -575,9 +577,9 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
 };
 var getRequestListener = (fetchCallback, options = {}) => {
   const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
-  if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
+  if (options.overrideGlobalObjects !== false && global.Request !== Request) {
     Object.defineProperty(global, "Request", {
-      value: Request2
+      value: Request
     });
     Object.defineProperty(global, "Response", {
       value: Response2
@@ -691,7 +693,7 @@ var pr54206Applied = () => {
 var useReadableToWeb = pr54206Applied();
 var createStreamBody = (stream2) => {
   if (useReadableToWeb) {
-    return stream$1.Readable.toWeb(stream2);
+    return stream.Readable.toWeb(stream2);
   }
   const body = new ReadableStream({
     start(controller) {
@@ -1127,7 +1129,7 @@ var kHeadersCount = /* @__PURE__ */ Symbol("kHeadersCount");
 var kTrailers = /* @__PURE__ */ Symbol("kTrailers");
 var kTrailersDistinct = /* @__PURE__ */ Symbol("kTrailersDistinct");
 var kTrailersCount = /* @__PURE__ */ Symbol("kTrailersCount");
-var FetchIncomingMessage = class extends stream$1.Readable {
+var FetchIncomingMessage = class extends stream.Readable {
   get socket() {
     return null;
   }
@@ -1583,7 +1585,7 @@ var WrittenDataBuffer = class {
     return this[kCorked];
   }
 };
-var FetchOutgoingMessage = class extends stream$1.Writable {
+var FetchOutgoingMessage = class extends stream.Writable {
   req;
   outputData;
   outputSize;
@@ -2784,197 +2786,6 @@ function toFetchResponse(res) {
   }
   return res.fetchResponse;
 }
-var HTTPException = class extends Error {
-  res;
-  status;
-  /**
-   * Creates an instance of `HTTPException`.
-   * @param status - HTTP status code for the exception. Defaults to 500.
-   * @param options - Additional options for the exception.
-   */
-  constructor(status = 500, options) {
-    super(options?.message, { cause: options?.cause });
-    this.res = options?.res;
-    this.status = status;
-  }
-  /**
-   * Returns the response object associated with the exception.
-   * If a response object is not provided, a new response is created with the error message and status code.
-   * @returns The response object.
-   */
-  getResponse() {
-    if (this.res) {
-      const newResponse = new Response(this.res.body, {
-        status: this.status,
-        headers: this.res.headers
-      });
-      return newResponse;
-    }
-    return new Response(this.message, {
-      status: this.status
-    });
-  }
-};
-var ERROR_MESSAGE = "Payload Too Large";
-var bodyLimit = (options) => {
-  const onError3 = options.onError || (() => {
-    const res = new Response(ERROR_MESSAGE, {
-      status: 413
-    });
-    throw new HTTPException(413, { res });
-  });
-  const maxSize = options.maxSize;
-  return async function bodyLimit2(c, next) {
-    if (!c.req.raw.body) {
-      return next();
-    }
-    const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
-    const hasContentLength = c.req.raw.headers.has("content-length");
-    if (hasContentLength && !hasTransferEncoding) {
-      const contentLength = parseInt(c.req.raw.headers.get("content-length") || "0", 10);
-      return contentLength > maxSize ? onError3(c) : next();
-    }
-    let size = 0;
-    const chunks = [];
-    const rawReader = c.req.raw.body.getReader();
-    for (; ; ) {
-      const { done, value } = await rawReader.read();
-      if (done) {
-        break;
-      }
-      size += value.length;
-      if (size > maxSize) {
-        return onError3(c);
-      }
-      chunks.push(value);
-    }
-    const requestInit = {
-      body: new ReadableStream({
-        start(controller) {
-          for (const chunk of chunks) {
-            controller.enqueue(chunk);
-          }
-          controller.close();
-        }
-      }),
-      duplex: "half"
-    };
-    c.req.raw = new Request(c.req.raw, requestInit);
-    return next();
-  };
-};
-var StreamingApi = class {
-  writer;
-  encoder;
-  writable;
-  abortSubscribers = [];
-  responseReadable;
-  /**
-   * Whether the stream has been aborted.
-   */
-  aborted = false;
-  /**
-   * Whether the stream has been closed normally.
-   */
-  closed = false;
-  constructor(writable, _readable) {
-    this.writable = writable;
-    this.writer = writable.getWriter();
-    this.encoder = new TextEncoder();
-    const reader = _readable.getReader();
-    this.abortSubscribers.push(async () => {
-      await reader.cancel();
-    });
-    this.responseReadable = new ReadableStream({
-      async pull(controller) {
-        const { done, value } = await reader.read();
-        done ? controller.close() : controller.enqueue(value);
-      },
-      cancel: () => {
-        this.abort();
-      }
-    });
-  }
-  async write(input) {
-    try {
-      if (typeof input === "string") {
-        input = this.encoder.encode(input);
-      }
-      await this.writer.write(input);
-    } catch {
-    }
-    return this;
-  }
-  async writeln(input) {
-    await this.write(input + "\n");
-    return this;
-  }
-  sleep(ms) {
-    return new Promise((res) => setTimeout(res, ms));
-  }
-  async close() {
-    try {
-      await this.writer.close();
-    } catch {
-    }
-    this.closed = true;
-  }
-  async pipe(body) {
-    this.writer.releaseLock();
-    await body.pipeTo(this.writable, { preventClose: true });
-    this.writer = this.writable.getWriter();
-  }
-  onAbort(listener) {
-    this.abortSubscribers.push(listener);
-  }
-  /**
-   * Abort the stream.
-   * You can call this method when stream is aborted by external event.
-   */
-  abort() {
-    if (!this.aborted) {
-      this.aborted = true;
-      this.abortSubscribers.forEach((subscriber) => subscriber());
-    }
-  }
-};
-var isOldBunVersion = () => {
-  const version2 = typeof Bun !== "undefined" ? Bun.version : void 0;
-  if (version2 === void 0) {
-    return false;
-  }
-  const result = version2.startsWith("1.1") || version2.startsWith("1.0") || version2.startsWith("0.");
-  isOldBunVersion = () => result;
-  return result;
-};
-var contextStash = /* @__PURE__ */ new WeakMap();
-var stream = (c, cb, onError3) => {
-  const { readable, writable } = new TransformStream();
-  const stream2 = new StreamingApi(writable, readable);
-  if (isOldBunVersion()) {
-    c.req.raw.signal.addEventListener("abort", () => {
-      if (!stream2.closed) {
-        stream2.abort();
-      }
-    });
-  }
-  contextStash.set(stream2.responseReadable, c);
-  (async () => {
-    try {
-      await cb(stream2);
-    } catch (e) {
-      if (e === void 0) ;
-      else if (e instanceof Error && onError3) {
-        await onError3(e, stream2);
-      } else {
-        console.error(e);
-      }
-    } finally {
-      stream2.close();
-    }
-  })();
-  return c.newResponse(stream2.responseReadable);
-};
 // @__NO_SIDE_EFFECTS__
 function $constructor(name, initializer3, params) {
   function init(inst, def) {
@@ -3345,7 +3156,7 @@ var MastraServer = class extends serverAdapter.MastraServer {
       res.header("Content-Type", "text/plain");
     }
     res.header("Transfer-Encoding", "chunked");
-    return stream(
+    return streaming.stream(
       res,
       async (stream2) => {
         const readableStream = result instanceof ReadableStream ? result : result.fullStream;
@@ -3517,7 +3328,7 @@ var MastraServer = class extends serverAdapter.MastraServer {
     const middlewares = [];
     if (shouldApplyBodyLimit && maxSize && this.bodyLimitOptions) {
       middlewares.push(
-        bodyLimit({
+        bodyLimit.bodyLimit({
           maxSize,
           onError: this.bodyLimitOptions.onError
         })