@mastra/deployer 0.0.0-error-handler-fix-20251020202607 → 0.0.0-esbuild-bundle-worker-20260807182016

package/LICENSE.md

@@ -1,3 +1,18 @@
+Portions of this software are licensed as follows:
+
+- All content that resides under any directory named "ee/" within this
+  repository, including but not limited to:
+  - `packages/core/src/auth/ee/`
+  - `packages/server/src/server/auth/ee/`
+    is licensed under the license defined in `ee/LICENSE`.
+
+- All third-party components incorporated into the Mastra Software are
+  licensed under the original license provided by the owner of the
+  applicable component.
+
+- Content outside of the above-mentioned directories or restrictions is
+  available under the "Apache License 2.0" as defined below.
+
 # Apache License 2.0
 
 Copyright (c) 2025 Kepler Software, Inc.

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

@@ -0,0 +1,101 @@
+import { IncomingMessage, Server, ServerOptions, ServerResponse, createServer } from "node:http";
+import { Http2SecureServer, Http2Server, Http2ServerRequest, Http2ServerResponse, SecureServerOptions, ServerOptions as ServerOptions$1, createSecureServer, createServer as createServer$1 } from "node:http2";
+import { Duplex } from "node:stream";
+import { UpgradeWebSocket } from "hono/ws";
+import { AddressInfo } from "node:net";
+import { ServerOptions as ServerOptions$2, createServer as createServer$2 } from "node:https";
+
+//#region src/websocket-types.d.ts
+type WSReadyState = 0 | 1 | 2 | 3;
+type WebSocketData = string | ArrayBuffer | Uint8Array | readonly Uint8Array[];
+type WebSocketSendOptions = {
+  compress?: boolean;
+};
+interface WebSocketLike {
+  protocol: string;
+  readyState: WSReadyState;
+  close(code?: number, reason?: string): void;
+  send(data: string | ArrayBuffer | ArrayBufferView, options?: WebSocketSendOptions): void;
+  on(event: 'message', listener: (data: WebSocketData, isBinary: boolean) => void): this;
+  on(event: 'close', listener: (code: number, reason: Uint8Array) => void): this;
+  on(event: 'error', listener: (error: unknown) => void): this;
+  off(event: 'message', listener: (data: WebSocketData, isBinary: boolean) => void): this;
+}
+interface WebSocketServerLike {
+  options: {
+    noServer?: boolean;
+  };
+  on(event: 'connection', listener: (ws: WebSocketLike, request: IncomingMessage) => void): this;
+  on(event: 'headers', listener: (headers: string[]) => void): this;
+  off(event: 'headers', listener: (headers: string[]) => void): this;
+  emit(event: 'connection', ws: WebSocketLike, request: IncomingMessage): boolean;
+  handleUpgrade(request: IncomingMessage, socket: Duplex, head: Buffer, callback: (ws: WebSocketLike) => void): void;
+  close(): void;
+}
+//#endregion
+//#region src/types.d.ts
+type HttpBindings = {
+  incoming: IncomingMessage;
+  outgoing: ServerResponse;
+};
+type Http2Bindings = {
+  incoming: Http2ServerRequest;
+  outgoing: Http2ServerResponse;
+};
+type FetchCallback = (request: Request, env: HttpBindings | Http2Bindings) => Promise<unknown> | unknown;
+type ServerType = Server | Http2Server | Http2SecureServer;
+type createHttpOptions = {
+  serverOptions?: ServerOptions;
+  createServer?: typeof createServer;
+};
+type createHttpsOptions = {
+  serverOptions?: ServerOptions$2;
+  createServer?: typeof createServer$2;
+};
+type createHttp2Options = {
+  serverOptions?: ServerOptions$1;
+  createServer?: typeof createServer$1;
+};
+type createSecureHttp2Options = {
+  serverOptions?: SecureServerOptions;
+  createServer?: typeof createSecureServer;
+};
+type ServerOptions$3 = createHttpOptions | createHttpsOptions | createHttp2Options | createSecureHttp2Options;
+type Options = {
+  fetch: FetchCallback;
+  overrideGlobalObjects?: boolean;
+  autoCleanupIncoming?: boolean;
+  port?: number;
+  hostname?: string;
+  websocket?: {
+    server: WebSocketServerLike;
+  };
+} & ServerOptions$3;
+type CustomErrorHandler = (err: unknown) => void | Response | Promise<void | Response>;
+//#endregion
+//#region src/server.d.ts
+declare const createAdaptorServer: (options: Options) => ServerType;
+declare const serve: (options: Options, listeningListener?: (info: AddressInfo) => void) => ServerType;
+//#endregion
+//#region src/websocket.d.ts
+type UpgradeWebSocketOptions = {
+  onError: (err: unknown) => void;
+};
+declare const upgradeWebSocket: UpgradeWebSocket<WebSocketLike, UpgradeWebSocketOptions>;
+//#endregion
+//#region src/listener.d.ts
+declare const getRequestListener: (fetchCallback: FetchCallback, options?: {
+  hostname?: string;
+  errorHandler?: CustomErrorHandler;
+  overrideGlobalObjects?: boolean;
+  autoCleanupIncoming?: boolean;
+}) => (incoming: IncomingMessage | Http2ServerRequest, outgoing: ServerResponse | Http2ServerResponse) => Promise<void>;
+//#endregion
+//#region src/error.d.ts
+declare class RequestError extends Error {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+//#endregion
+export { type Http2Bindings, type HttpBindings, RequestError, type ServerType, type WebSocketData, type WebSocketLike, type WebSocketServerLike, createAdaptorServer, getRequestListener, serve, upgradeWebSocket };

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