@mastra/deployer 0.0.1-alpha.0

package/src/deploy/base.ts

@@ -0,0 +1,171 @@
+import { Mastra } from '@mastra/core';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import path, { join } from 'path';
+import { fileURLToPath } from 'url';
+
+import { bundle } from '../build/bundle.js';
+import { Deps } from '../build/deps.js';
+import { upsertMastraDir } from '../build/utils.js';
+
+export class Deployer {
+  deps: Deps = new Deps();
+  dotMastraPath: string;
+  name: string = '';
+  type: 'Deploy' | 'Dev';
+
+  log = (message: string) => {
+    console.log(`[Mastra ${this.type}] - ${message}`);
+  };
+
+  constructor({ dir, type }: { dir: string; type: 'Deploy' | 'Dev' }) {
+    this.dotMastraPath = join(dir, '.mastra');
+    this.type = type;
+  }
+
+  getMastraPath() {
+    return this.dotMastraPath;
+  }
+
+  async getMastra() {
+    return (await import(join(this.dotMastraPath, 'mastra.mjs'))) as { mastra: Mastra };
+  }
+
+  async writePackageJson() {
+    this.log('Writing package.json');
+    let projectPkg: any = {
+      dependencies: {},
+    };
+
+    try {
+      projectPkg = JSON.parse(readFileSync(join(this.dotMastraPath, '..', 'package.json'), 'utf-8'));
+    } catch (_e) {
+      // no-op
+    }
+
+    const mastraDeps = Object.entries(projectPkg.dependencies)
+      .filter(([name]) => name.startsWith('@mastra') && !name.startsWith('@mastra/deployer'))
+      .reduce((acc: any, [name, version]) => {
+        if (version === 'workspace:*') {
+          acc[name] = 'latest';
+        } else {
+          acc[name] = version;
+        }
+
+        return acc;
+      }, {});
+
+    const pkgPath = join(this.dotMastraPath, 'package.json');
+
+    if (this.type === 'Dev' && existsSync(pkgPath)) {
+      return;
+    }
+
+    writeFileSync(
+      pkgPath,
+      JSON.stringify(
+        {
+          name: 'server',
+          version: '1.0.0',
+          description: '',
+          type: 'module',
+          main: 'index.mjs',
+          scripts: {
+            start: 'node ./index.mjs',
+          },
+          author: '',
+          license: 'ISC',
+          dependencies: {
+            ...mastraDeps,
+            hono: '4.6.17',
+            execa: 'latest',
+            '@hono/node-server': '^1.13.7',
+            superjson: '^2.2.2',
+            'zod-to-json-schema': '^3.24.1',
+          },
+        },
+        null,
+        2,
+      ),
+    );
+  }
+
+  async install() {
+    this.log('Ensuring your dependencies up to date...');
+    await this.deps.install();
+  }
+
+  protected getEnvFiles(): string[] {
+    const envFiles = ['.env', '.env.development', '.env.local']
+      .map(file => join(process.cwd(), file))
+      .filter(file => existsSync(file));
+    return envFiles;
+  }
+
+  getEnvVars() {
+    // Get all env vars
+    const envFiles = this.getEnvFiles();
+    const envVars: Record<string, string> = {};
+
+    for (const file of envFiles) {
+      const vars = this.parseEnvFile(file);
+      for (const envVar of vars) {
+        const [key, value] = envVar.split('=');
+        if (key && value) {
+          envVars[key] = value;
+        }
+      }
+    }
+
+    return envVars;
+  }
+
+  protected parseEnvFile(filePath: string): string[] {
+    const content = readFileSync(filePath, 'utf-8');
+    return content
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line && !line.startsWith('#'))
+      .filter(line => line.includes('=')); // Only include valid KEY=value pairs
+  }
+
+  async build({ dir, useBanner = true }: { dir: string; useBanner?: boolean }) {
+    if (!existsSync(this.dotMastraPath)) {
+      mkdirSync(this.dotMastraPath);
+    }
+
+    await bundle(dir, { useBanner, outfile: join(this.dotMastraPath, 'mastra.mjs') });
+  }
+
+  async buildServer({ playground = false }: { playground?: boolean } = { playground: false }) {
+    upsertMastraDir();
+
+    const templatePath = join(this.dotMastraPath, 'hono.mjs');
+
+    writeFileSync(
+      templatePath,
+      `
+      import { createHonoServer } from './server.mjs';
+      import { mastra } from './mastra.mjs';
+
+      export const app = await createHonoServer(mastra, { playground: ${playground} });
+    `,
+    );
+  }
+
+  async writeServerFile() {
+    const fileServerPath = await import.meta.resolve('@mastra/deployer/server');
+    const serverPath = fileURLToPath(fileServerPath);
+    copyFileSync(serverPath, join(this.dotMastraPath, 'server.mjs'));
+  }
+
+  async prepare({ dir, playground, useBanner = true }: { useBanner?: boolean; dir?: string; playground?: boolean }) {
+    this.log('Preparing .mastra directory');
+    upsertMastraDir();
+    const dirPath = dir || path.join(process.cwd(), 'src/mastra');
+    this.writePackageJson();
+    this.writeServerFile();
+    await this.install();
+    await this.build({ dir: dirPath, useBanner });
+    await this.buildServer({ playground });
+  }
+}

package/src/deploy/index.ts

@@ -0,0 +1 @@
+export * from './base.js';

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './deploy/index.js';
+export * from './build/index.js';
+export * from './server/index.js';

package/src/server/handlers/agents.ts

@@ -0,0 +1,121 @@
+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';
+
+// Agent handlers
+export async function getAgentsHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const agents = mastra.getAgents();
+
+    const serializedAgents = Object.entries(agents).reduce<any>((acc, [_id, _agent]) => {
+      const agent = _agent as any;
+      const serializedAgentTools = Object.entries(agent?.tools || {}).reduce<any>((acc, [key, tool]) => {
+        const _tool = tool as any;
+        acc[key] = {
+          ..._tool,
+          inputSchema: _tool.inputSchema ? stringify(zodToJsonSchema(_tool.inputSchema)) : undefined,
+          outputSchema: _tool.outputSchema ? stringify(zodToJsonSchema(_tool.outputSchema)) : undefined,
+        };
+        return acc;
+      }, {});
+      acc[_id] = {
+        ...agent,
+        tools: serializedAgentTools,
+      };
+      return acc;
+    }, {});
+
+    return c.json(serializedAgents);
+  } catch (error) {
+    return handleError(error, 'Error getting agents');
+  }
+}
+
+export async function getAgentByIdHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const agent = mastra.getAgent(agentId);
+
+    if (!agent) {
+      throw new HTTPException(404, { message: 'Agent not found' });
+    }
+
+    const serializedAgentTools = Object.entries(agent?.tools || {}).reduce<any>((acc, [key, tool]) => {
+      const _tool = tool as any;
+      acc[key] = {
+        ..._tool,
+        inputSchema: _tool.inputSchema ? stringify(zodToJsonSchema(_tool.inputSchema)) : undefined,
+        outputSchema: _tool.outputSchema ? stringify(zodToJsonSchema(_tool.outputSchema)) : undefined,
+      };
+      return acc;
+    }, {});
+
+    return c.json({
+      ...agent,
+      tools: serializedAgentTools,
+    });
+  } catch (error) {
+    return handleError(error, 'Error getting agent');
+  }
+}
+
+export async function generateHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const agent = mastra.getAgent(agentId);
+
+    if (!agent) {
+      throw new HTTPException(404, { message: 'Agent not found' });
+    }
+
+    const { messages, threadId, resourceid, output } = await c.req.json();
+    validateBody({ messages });
+
+    if (!Array.isArray(messages)) {
+      throw new HTTPException(400, { message: 'Messages should be an array' });
+    }
+
+    const result = await agent.generate(messages, { threadId, resourceid, output });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error generating from agent');
+  }
+}
+
+export async function streamGenerateHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const agent = mastra.getAgent(agentId);
+
+    if (!agent) {
+      throw new HTTPException(404, { message: 'Agent not found' });
+    }
+
+    const { messages, threadId, resourceid, output } = await c.req.json();
+    validateBody({ messages });
+
+    if (!Array.isArray(messages)) {
+      throw new HTTPException(400, { message: 'Messages should be an array' });
+    }
+
+    const streamResult = await agent.stream(messages, { threadId, resourceid, output });
+    return new Response(streamResult.toDataStream(), {
+      headers: {
+        'Content-Type': 'text/x-unknown',
+        'content-encoding': 'identity',
+        'transfer-encoding': 'chunked',
+      },
+    });
+  } catch (error) {
+    return handleError(error, 'Error streaming from agent');
+  }
+}

package/src/server/handlers/client.ts

@@ -0,0 +1,36 @@
+import { Context } from 'hono';
+
+const clients = new Set<ReadableStreamDefaultController>();
+
+export function handleClientsRefresh(c: Context) {
+  const stream = new ReadableStream({
+    start(controller) {
+      clients.add(controller);
+      controller.enqueue('data: connected\n\n');
+
+      c.req.raw.signal.addEventListener('abort', () => {
+        clients.delete(controller);
+      });
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+      'Access-Control-Allow-Origin': '*',
+    },
+  });
+}
+
+export function handleTriggerClientsRefresh(c: Context) {
+  clients.forEach(controller => {
+    try {
+      controller.enqueue('data: refresh\n\n');
+    } catch {
+      clients.delete(controller);
+    }
+  });
+  return c.json({ success: true, clients: clients.size });
+}

package/src/server/handlers/error.ts

@@ -0,0 +1,29 @@
+import { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+import { ContentfulStatusCode } from 'hono/utils/http-status';
+
+import { ApiError } from '../types';
+
+// Helper to handle errors consistently
+export function handleError(error: unknown, defaultMessage: string) {
+  console.error(defaultMessage, error);
+  const apiError = error as ApiError;
+  throw new HTTPException((apiError.status || 500) as ContentfulStatusCode, {
+    message: apiError.message || defaultMessage,
+  });
+}
+
+// Error handlers
+export function notFoundHandler() {
+  throw new HTTPException(404, { message: 'Not Found' });
+}
+
+export function errorHandler(err: Error, c: Context) {
+  if (err instanceof HTTPException) {
+    return c.json({ error: err.message }, err.status);
+  }
+
+  console.error(err);
+  return c.json({ error: 'Internal Server Error' }, 500);
+}

package/src/server/handlers/logs.ts

@@ -0,0 +1,24 @@
+import { Context } from 'hono';
+
+import { handleError } from './error';
+
+export async function getLogsHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const logs = await mastra.getLogs();
+    return c.json(logs);
+  } catch (error) {
+    return handleError(error, 'Error getting logs');
+  }
+}
+
+export async function getLogsByRunIdHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const runId = c.req.param('runId');
+    const logs = await mastra.getLogsByRunId(runId);
+    return c.json(logs);
+  } catch (error) {
+    return handleError(error, 'Error getting logs by run ID');
+  }
+}

package/src/server/handlers/memory.ts

@@ -0,0 +1,208 @@
+import { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+
+import { handleError } from './error';
+import { validateBody } from './utils';
+
+// Memory handlers
+export async function getMemoryStatusHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+
+    if (!memory) {
+      return c.json({ result: false });
+    }
+
+    return c.json({ result: true });
+  } catch (error) {
+    return handleError(error, 'Error getting memory status');
+  }
+}
+
+export async function getThreadsHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+    const { resourceid } = c.req.query();
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    const threads = await memory.getThreadsByResourceId({ resourceid });
+    return c.json(threads);
+  } catch (error) {
+    return handleError(error, 'Error getting threads');
+  }
+}
+
+export async function getThreadByIdHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+    const threadId = c.req.param('threadId');
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: 'Thread not found' });
+    }
+
+    return c.json(thread);
+  } catch (error) {
+    return handleError(error, 'Error getting thread');
+  }
+}
+
+export async function saveMessagesHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+    const { messages } = await c.req.json();
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    validateBody({ messages });
+
+    if (!Array.isArray(messages)) {
+      throw new HTTPException(400, { message: 'Messages should be an array' });
+    }
+
+    const processedMessages = messages.map(message => ({
+      ...message,
+      id: memory.generateId(),
+      createdAt: message.createdAt ? new Date(message.createdAt) : new Date(),
+    }));
+
+    const result = await memory.saveMessages({ messages: processedMessages });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error saving messages');
+  }
+}
+
+export async function getContextWindowHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+    const threadId = c.req.param('threadId');
+    const { startDate, endDate, format } = c.req.query();
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: 'Thread not found' });
+    }
+
+    const result = await memory.getContextWindow({ threadId, startDate, endDate, format });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error getting context window from memory');
+  }
+}
+
+export async function createThreadHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+    const { title, metadata, resourceid, threadId } = await c.req.json();
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    validateBody({ resourceid });
+
+    const result = await memory.createThread({ resourceid, title, metadata, threadId });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error saving thread to memory');
+  }
+}
+
+export async function updateThreadHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+    const threadId = c.req.param('threadId');
+    const { title, metadata, resourceid } = await c.req.json();
+    const updatedAt = new Date();
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: 'Thread not found' });
+    }
+
+    const updatedThread = {
+      ...thread,
+      title: title || thread.title,
+      metadata: metadata || thread.metadata,
+      resourceid: resourceid || thread.resourceid,
+      createdAt: thread.createdat,
+      updatedAt,
+    };
+
+    const result = await memory.saveThread({ thread: updatedThread });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error updating thread');
+  }
+}
+
+export async function deleteThreadHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+    const threadId = c.req.param('threadId');
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: 'Thread not found' });
+    }
+
+    await memory.deleteThread(threadId);
+    return c.json({ result: 'Thread deleted' });
+  } catch (error) {
+    return handleError(error, 'Error deleting thread');
+  }
+}
+
+export async function getMessagesHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const memory = mastra.memory;
+    const threadId = c.req.param('threadId');
+
+    if (!memory) {
+      return c.json({ error: 'Memory is not initialized' }, 400);
+    }
+
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      return c.json({ error: 'Thread not found' }, 404);
+    }
+
+    const result = await memory.getMessages({ threadId });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error getting messages');
+  }
+}

package/src/server/handlers/root.ts

@@ -0,0 +1,6 @@
+import { Context } from 'hono';
+
+// Root handler
+export async function rootHandler(c: Context) {
+  return c.text('Hello to the Mastra API!');
+}

package/src/server/handlers/syncs.ts

@@ -0,0 +1,19 @@
+import { Context } from 'hono';
+
+import { handleError } from './error';
+import { validateBody } from './utils';
+
+export async function executeSyncHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const syncId = c.req.param('syncId');
+    const { runId, params: syncParams } = await c.req.json();
+
+    validateBody({ params: syncParams });
+
+    const result = await mastra.sync(syncId, syncParams, runId);
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error executing sync');
+  }
+}