@mastra/deployer 0.0.1-alpha.0

package/src/server/handlers/tools.ts

@@ -0,0 +1,156 @@
+import { Context } from 'hono';
+import { stringify } from 'superjson';
+import zodToJsonSchema from 'zod-to-json-schema';
+
+import { HTTPException } from 'hono/http-exception';
+
+import { handleError } from './error';
+import { validateBody } from './utils';
+
+// Tool handlers
+export async function getToolsHandler(c: Context) {
+  try {
+    const tools = c.get('tools');
+
+    if (!tools) {
+      return c.json({});
+    }
+
+    const serializedTools = Object.entries(tools).reduce(
+      (acc, [id, _tool]) => {
+        const tool = _tool as any;
+        acc[id] = {
+          ...tool,
+          inputSchema: tool.inputSchema ? stringify(zodToJsonSchema(tool.inputSchema)) : undefined,
+          outputSchema: tool.outputSchema ? stringify(zodToJsonSchema(tool.outputSchema)) : undefined,
+        };
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
+
+    return c.json(serializedTools);
+  } catch (error) {
+    return handleError(error, 'Error getting tools');
+  }
+}
+
+export async function getToolByIdHandler(c: Context) {
+  try {
+    const tools = c.get('tools');
+    const toolId = c.req.param('toolId');
+    const tool = Object.values(tools || {}).find((tool: any) => tool.id === toolId) as any;
+
+    if (!tool) {
+      throw new HTTPException(404, { message: 'Tool not found' });
+    }
+
+    const serializedTool = {
+      ...tool,
+      inputSchema: tool.inputSchema ? stringify(zodToJsonSchema(tool.inputSchema)) : undefined,
+      outputSchema: tool.outputSchema ? stringify(zodToJsonSchema(tool.outputSchema)) : undefined,
+    };
+
+    return c.json(serializedTool);
+  } catch (error) {
+    return handleError(error, 'Error getting tool');
+  }
+}
+
+export async function getToolResultHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+    const threadId = c.req.param('threadId');
+    const { toolName, toolArgs } = await c.req.json();
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    validateBody({ toolName, toolArgs });
+
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: 'Thread not found' });
+    }
+
+    const result = await memory.getToolResult({ threadId, toolName, toolArgs });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error getting tool result');
+  }
+}
+
+export async function validateToolCallArgsHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+    const { hashedArgs } = await c.req.json();
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    validateBody({ hashedArgs });
+
+    const result = await memory.validateToolCallArgs({ hashedArgs });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error validating tool call args');
+  }
+}
+
+export function executeToolHandler(tools: Record<string, any>) {
+  return async (c: Context) => {
+    try {
+      const toolId = decodeURIComponent(c.req.param('toolId'));
+      const tool = Object.values(tools || {}).find((tool: any) => tool.id === toolId) as any;
+
+      if (!tool) {
+        return c.json({ error: 'Tool not found' }, 404);
+      }
+
+      const { input } = await c.req.json();
+      const mastra = c.get('mastra');
+      const result = await tool.execute({
+        context: {
+          ...input,
+        },
+        mastra,
+        runId: mastra.runId,
+      });
+
+      return c.json(result);
+    } catch (error) {
+      return handleError(error, 'Error executing tool');
+    }
+  };
+}
+
+export async function executeAgentToolHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const toolId = c.req.param('toolId');
+    const agent = mastra.getAgent(agentId);
+    const tool = Object.values(agent?.tools || {}).find((tool: any) => tool.id === toolId) as any;
+
+    if (!tool) {
+      throw new HTTPException(404, { message: 'Tool not found' });
+    }
+
+    const body = await c.req.json();
+    const result = await tool.execute({
+      context: {
+        ...body,
+      },
+      mastra,
+      runId: agentId,
+    });
+
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error executing tool');
+  }
+}

package/src/server/handlers/utils.ts

@@ -0,0 +1,15 @@
+import { HTTPException } from 'hono/http-exception';
+
+// Validation helper
+export function validateBody(body: Record<string, unknown>) {
+  const errorResponse = Object.entries(body).reduce<Record<string, string>>((acc, [key, value]) => {
+    if (!value) {
+      acc[key] = `${key} is required`;
+    }
+    return acc;
+  }, {});
+
+  if (Object.keys(errorResponse).length > 0) {
+    throw new HTTPException(400, { message: JSON.stringify(errorResponse) });
+  }
+}

package/src/server/handlers/workflows.ts

@@ -0,0 +1,60 @@
+import { Context } from 'hono';
+import { stringify } from 'superjson';
+import zodToJsonSchema from 'zod-to-json-schema';
+
+import { handleError } from './error';
+
+export async function getWorkflowsHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const workflows = mastra.getWorkflows({ serialized: true });
+    return c.json(workflows);
+  } catch (error) {
+    return handleError(error, 'Error getting workflows');
+  }
+}
+
+export async function getWorkflowByIdHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const workflowId = c.req.param('workflowId');
+    const workflow = mastra.getWorkflow(workflowId);
+
+    const triggerSchema = workflow.triggerSchema;
+    const stepGraph = workflow.stepGraph;
+    const stepSubscriberGraph = workflow.stepSubscriberGraph;
+    const serializedSteps = Object.entries(workflow.steps).reduce<any>((acc, [key, step]) => {
+      const _step = step as any;
+      acc[key] = {
+        ..._step,
+        inputSchema: _step.inputSchema ? stringify(zodToJsonSchema(_step.inputSchema)) : undefined,
+        outputSchema: _step.outputSchema ? stringify(zodToJsonSchema(_step.outputSchema)) : undefined,
+      };
+      return acc;
+    }, {});
+
+    return c.json({
+      name: workflow.name,
+      triggerSchema: triggerSchema ? stringify(zodToJsonSchema(triggerSchema)) : undefined,
+      steps: serializedSteps,
+      stepGraph,
+      stepSubscriberGraph,
+    });
+  } catch (error) {
+    return handleError(error, 'Error getting workflow');
+  }
+}
+
+export async function executeWorkflowHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const workflowId = c.req.param('workflowId');
+    const workflow = mastra.getWorkflow(workflowId);
+    const body = await c.req.json();
+
+    const result = await workflow.execute(body);
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error executing workflow');
+  }
+}

package/src/server/index.ts

@@ -0,0 +1,185 @@
+import { serve } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { type Mastra } from '@mastra/core';
+import { Hono } from 'hono';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+
+import { readFile } from 'fs/promises';
+import { cors } from 'hono/cors';
+
+import { generateHandler, getAgentByIdHandler, getAgentsHandler, streamGenerateHandler } from './handlers/agents.js';
+import { handleClientsRefresh } from './handlers/client.js';
+import { handleTriggerClientsRefresh } from './handlers/client.js';
+import { getLogsByRunIdHandler, getLogsHandler } from './handlers/logs';
+import {
+  createThreadHandler,
+  deleteThreadHandler,
+  getContextWindowHandler,
+  getMemoryStatusHandler,
+  getMessagesHandler,
+  getThreadByIdHandler,
+  getThreadsHandler,
+  saveMessagesHandler,
+  updateThreadHandler,
+} from './handlers/memory';
+import { rootHandler } from './handlers/root.js';
+import { executeSyncHandler } from './handlers/syncs.js';
+import {
+  executeAgentToolHandler,
+  executeToolHandler,
+  getToolByIdHandler,
+  getToolResultHandler,
+  getToolsHandler,
+  validateToolCallArgsHandler,
+} from './handlers/tools';
+import { executeWorkflowHandler, getWorkflowByIdHandler, getWorkflowsHandler } from './handlers/workflows';
+import { html } from './welcome.js';
+
+type Bindings = {};
+
+type Variables = {
+  mastra: Mastra;
+  clients: Set<{ controller: ReadableStreamDefaultController }>;
+  tools: Record<string, any>;
+};
+
+export async function createHonoServer(mastra: Mastra, options: { playground?: boolean } = {}) {
+  // Create typed Hono app
+  const app = new Hono<{ Bindings: Bindings; Variables: Variables }>();
+
+  // Initialize tools
+  const mastraToolsPaths = process.env.MASTRA_TOOLS_PATH;
+  const toolImports = mastraToolsPaths
+    ? await Promise.all(
+        mastraToolsPaths.split(',').map(async toolPath => {
+          return import(pathToFileURL(toolPath).href);
+        }),
+      )
+    : [];
+
+  const tools = toolImports.reduce((acc, toolModule) => {
+    Object.entries(toolModule).forEach(([key, tool]) => {
+      acc[key] = tool;
+    });
+    return acc;
+  }, {});
+
+  // Middleware
+  app.use('*', cors());
+
+  // Add Mastra to context
+  app.use('*', async (c, next) => {
+    c.set('mastra', mastra);
+    c.set('tools', tools);
+    await next();
+  });
+
+  // API routes
+  app.get('/api', rootHandler);
+
+  // Agent routes
+  app.get('/api/agents', getAgentsHandler);
+  app.get('/api/agents/:agentId', getAgentByIdHandler);
+  app.post('/api/agents/:agentId/generate', generateHandler);
+  app.post('/api/agents/:agentId/stream', streamGenerateHandler);
+  app.post('/api/agents/:agentId/tools/:toolId/execute', executeAgentToolHandler);
+
+  // Memory routes
+  app.get('/api/memory/status', getMemoryStatusHandler);
+  app.get('/api/memory/threads', getThreadsHandler);
+  app.get('/api/memory/threads/:threadId', getThreadByIdHandler);
+  app.get('/api/memory/threads/:threadId/messages', getMessagesHandler);
+  app.get('/api/memory/threads/:threadId/context-window', getContextWindowHandler);
+  app.post('/api/memory/threads', createThreadHandler);
+  app.patch('/api/memory/threads/:threadId', updateThreadHandler);
+  app.delete('/api/memory/threads/:threadId', deleteThreadHandler);
+  app.post('/api/memory/save-messages', saveMessagesHandler);
+  app.post('/api/memory/threads/:threadId/tool-result', getToolResultHandler);
+  app.post('/api/memory/validate-tool-call-args', validateToolCallArgsHandler);
+
+  // Workflow routes
+  app.get('/api/workflows', getWorkflowsHandler);
+  app.get('/api/workflows/:workflowId', getWorkflowByIdHandler);
+  app.post('/api/workflows/:workflowId/execute', executeWorkflowHandler);
+
+  // Sync routes
+  app.post('/api/syncs/:syncId/execute', executeSyncHandler);
+
+  // Log routes
+  app.get('/api/logs', getLogsHandler);
+  app.get('/api/logs/:runId', getLogsByRunIdHandler);
+
+  // Tool routes
+  app.get('/api/tools', getToolsHandler);
+  app.get('/api/tools/:toolId', getToolByIdHandler);
+  app.post('/api/tools/:toolId/execute', executeToolHandler(tools));
+
+  // SSE endpoint for refresh notifications
+  app.get('/refresh-events', handleClientsRefresh);
+
+  // Trigger refresh for all clients
+  app.post('/__refresh', handleTriggerClientsRefresh);
+
+  if (options?.playground) {
+    // Playground routes - these should come after API routes
+    // Serve assets with specific MIME types
+    app.use('/assets/*', async (c, next) => {
+      const path = c.req.path;
+      if (path.endsWith('.js')) {
+        c.header('Content-Type', 'application/javascript');
+      } else if (path.endsWith('.css')) {
+        c.header('Content-Type', 'text/css');
+      }
+      await next();
+    });
+
+    // Serve assets from playground directory
+    app.use(
+      '/assets/*',
+      serveStatic({
+        root: './playground/assets',
+      }),
+    );
+
+    // Serve static files from playground directory
+    app.use(
+      '*',
+      serveStatic({
+        root: './playground',
+      }),
+    );
+  }
+
+  // Catch-all route to serve index.html for any non-API routes
+  app.get('*', async (c, next) => {
+    // Skip if it's an API route
+    if (c.req.path.startsWith('/api/')) {
+      return await next();
+    }
+    if (options?.playground) {
+      // For all other routes, serve index.html
+      const indexHtml = await readFile(join(process.cwd(), './playground/index.html'), 'utf-8');
+      return c.newResponse(indexHtml, 200, { 'Content-Type': 'text/html' });
+    }
+
+    return c.newResponse(html, 200, { 'Content-Type': 'text/html' });
+  });
+
+  return app;
+}
+
+export async function createNodeServer(mastra: Mastra, options: { playground?: boolean } = {}) {
+  const app = await createHonoServer(mastra, options);
+  return serve(
+    {
+      fetch: app.fetch,
+      port: Number(process.env.PORT) || 4111,
+    },
+    () => {
+      console.log(`🦄 Server running on port ${process.env.PORT || 4111}/api`);
+      console.log(`📚 Open API documentation available at http://localhost:${process.env.PORT || 4111}/openapi.json`);
+      console.log(`👨‍💻 Playground available at http://localhost:${process.env.PORT || 4111}/`);
+    },
+  );
+}

package/src/server/types.ts

@@ -0,0 +1,4 @@
+export interface ApiError extends Error {
+  message: string;
+  status?: number;
+}

package/src/server/welcome.ts

@@ -0,0 +1,105 @@
+export const html = `
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Welcome to Mastra</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/inter-ui/3.19.3/inter.min.css" />
+    <style>
+      body {
+        margin: 0;
+        padding: 0;
+        background-color: #0d0d0d;
+        color: #ffffff;
+        font-family:
+          'Inter',
+          -apple-system,
+          BlinkMacSystemFont,
+          system-ui,
+          sans-serif;
+        min-height: 100vh;
+        display: flex;
+        flex-direction: column;
+      }
+
+      main {
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        padding: 2rem;
+        text-align: center;
+      }
+
+      h1 {
+        font-size: 4rem;
+        font-weight: 600;
+        margin: 0 0 1rem 0;
+        background: linear-gradient(to right, #fff, #ccc);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        line-height: 1.2;
+      }
+
+      .subtitle {
+        color: #9ca3af;
+        font-size: 1.25rem;
+        max-width: 600px;
+        margin: 0 auto 3rem auto;
+        line-height: 1.6;
+      }
+
+      .docs-link {
+        background-color: #1a1a1a;
+        padding: 1rem 2rem;
+        border-radius: 0.5rem;
+        display: flex;
+        align-items: center;
+        gap: 1rem;
+        font-family: monospace;
+        font-size: 1rem;
+        color: #ffffff;
+        text-decoration: none;
+        transition: background-color 0.2s;
+      }
+
+      .docs-link:hover {
+        background-color: #252525;
+      }
+
+      .arrow-icon {
+        transition: transform 0.2s;
+      }
+
+      .docs-link:hover .arrow-icon {
+        transform: translateX(4px);
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>Welcome to Mastra</h1>
+      <p class="subtitle">
+        From the team that brought you Gatsby: prototype and productionize AI features with a modern JS/TS stack.
+      </p>
+
+      <a href="https://mastra.ai/docs" class="docs-link">
+        Browse the docs
+        <svg
+          class="arrow-icon"
+          width="20"
+          height="20"
+          viewBox="0 0 24 24"
+          fill="none"
+          stroke="currentColor"
+          stroke-width="2"
+        >
+          <path d="M5 12h14M12 5l7 7-7 7" />
+        </svg>
+      </a>
+    </main>
+  </body>
+</html>
+`;

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    include: ['src/**/*.test.ts'],
+  },
+});