@mastra/deployer 0.0.0-commonjs-20250227130920

package/src/deploy/log.ts

@@ -0,0 +1,61 @@
+import { spawn } from 'child_process';
+import { Transform } from 'stream';
+import type { Logger } from '@mastra/core/logger';
+
+export const createPinoStream = (logger: Logger) => {
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      // Convert Buffer/string to string and trim whitespace
+      const line = chunk.toString().trim();
+
+      if (line) {
+        console.log(line);
+        // Log each line through Pino
+        logger.info(line);
+      }
+
+      // Pass through the original data
+      callback(null, chunk);
+    },
+  });
+};
+
+export function createChildProcessLogger({ logger, root }: { logger: Logger; root: string }) {
+  const pinoStream = createPinoStream(logger);
+  return async ({ cmd, args, env }: { cmd: string; args: string[]; env: Record<string, string> }) => {
+    try {
+      const subprocess = spawn(cmd, args, {
+        cwd: root,
+        shell: true,
+        env,
+      });
+
+      // Pipe stdout and stderr through the Pino stream
+      subprocess.stdout?.pipe(pinoStream);
+      subprocess.stderr?.pipe(pinoStream);
+
+      // Wait for the process to complete
+      return new Promise((resolve, reject) => {
+        subprocess.on('close', code => {
+          pinoStream.end();
+          if (code === 0) {
+            resolve({ success: true });
+          } else {
+            reject(new Error(`Process exited with code ${code}`));
+          }
+        });
+
+        subprocess.on('error', error => {
+          pinoStream.end();
+          logger.error('Process failed', { error });
+          reject(error);
+        });
+      });
+    } catch (error) {
+      console.log(error);
+      logger.error('Process failed', { error });
+      pinoStream.end();
+      return { success: false, error };
+    }
+  };
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './deploy';
+export { Deps, FileService } from './build';
+export { getDeployer } from './build/deployer';

package/src/server/handlers/agents.ts

@@ -0,0 +1,209 @@
+import type { Mastra } from '@mastra/core';
+import type { Context } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import { stringify } from 'superjson';
+import zodToJsonSchema from 'zod-to-json-schema';
+
+import { handleError } from './error';
+import { validateBody } from './utils';
+
+// Agent handlers
+export async function getAgentsHandler(c: Context) {
+  try {
+    const mastra: 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] = {
+        name: agent.name,
+        instructions: agent.instructions,
+        tools: serializedAgentTools,
+        provider: agent.llm?.getProvider(),
+        modelId: agent.llm?.getModelId(),
+      };
+      return acc;
+    }, {});
+
+    return c.json(serializedAgents);
+  } catch (error) {
+    return handleError(error, 'Error getting agents');
+  }
+}
+
+export async function getAgentByIdHandler(c: Context) {
+  try {
+    const mastra: 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({
+      name: agent.name,
+      instructions: agent.instructions,
+      tools: serializedAgentTools,
+      provider: agent.llm?.getProvider(),
+      modelId: agent.llm?.getModelId(),
+    });
+  } catch (error) {
+    return handleError(error, 'Error getting agent');
+  }
+}
+
+export async function getEvalsByAgentIdHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const agent = mastra.getAgent(agentId);
+    const evals = (await mastra.storage?.getEvalsByAgentName?.(agent.name, 'test')) || [];
+    return c.json({
+      id: agentId,
+      name: agent.name,
+      instructions: agent.instructions,
+      evals,
+    });
+  } catch (error) {
+    return handleError(error, 'Error getting test evals');
+  }
+}
+
+export async function getLiveEvalsByAgentIdHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const agent = mastra.getAgent(agentId);
+    const evals = (await mastra.storage?.getEvalsByAgentName?.(agent.name, 'live')) || [];
+
+    return c.json({
+      id: agentId,
+      name: agent.name,
+      instructions: agent.instructions,
+      evals,
+    });
+  } catch (error) {
+    return handleError(error, 'Error getting live evals');
+  }
+}
+
+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, resourceId, output, runId } = await c.req.json();
+    validateBody({ messages });
+
+    if (!Array.isArray(messages)) {
+      throw new HTTPException(400, { message: 'Messages should be an array' });
+    }
+
+    // Use resourceId if provided, fall back to resourceid (deprecated)
+    const finalResourceId = resourceId ?? resourceid;
+
+    const result = await agent.generate(messages, { threadId, resourceId: finalResourceId, output, runId });
+
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error generating from agent');
+  }
+}
+
+export async function streamGenerateHandler(c: Context): Promise<Response | undefined> {
+  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, resourceId, output, runId } = await c.req.json();
+
+    validateBody({ messages });
+
+    if (!Array.isArray(messages)) {
+      throw new HTTPException(400, { message: 'Messages should be an array' });
+    }
+
+    // Use resourceId if provided, fall back to resourceid (deprecated)
+    const finalResourceId = resourceId ?? resourceid;
+
+    const streamResult = await agent.stream(messages, { threadId, resourceId: finalResourceId, output, runId });
+
+    const streamResponse = output
+      ? streamResult.toTextStreamResponse()
+      : streamResult.toDataStreamResponse({
+          sendUsage: true,
+          sendReasoning: true,
+          getErrorMessage: (error: any) => {
+            return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
+          },
+        });
+
+    return streamResponse;
+  } catch (error) {
+    return handleError(error, 'Error streaming from agent');
+  }
+}
+
+export async function setAgentInstructionsHandler(c: Context) {
+  try {
+    // Check if this is a playground request
+    const isPlayground = c.get('playground') === true;
+    if (!isPlayground) {
+      return c.json({ error: 'This API is only available in the playground environment' }, 403);
+    }
+
+    const agentId = c.req.param('agentId');
+    const { instructions } = await c.req.json();
+
+    if (!agentId || !instructions) {
+      return c.json({ error: 'Missing required fields' }, 400);
+    }
+
+    const mastra: Mastra = c.get('mastra');
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      return c.json({ error: 'Agent not found' }, 404);
+    }
+
+    agent.__updateInstructions(instructions);
+
+    return c.json(
+      {
+        instructions,
+      },
+      200,
+    );
+  } catch (error) {
+    return handleError(error, 'Error setting agent instructions');
+  }
+}

package/src/server/handlers/client.ts

@@ -0,0 +1,36 @@
+import type { Context } from 'hono';
+
+const clients = new Set<ReadableStreamDefaultController>();
+
+export function handleClientsRefresh(c: Context): Response {
+  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 type { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
+
+import type { ApiError } from '../types';
+
+// Helper to handle errors consistently
+export function handleError(error: unknown, defaultMessage: string): Promise<Response> {
+  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): Response {
+  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,53 @@
+import type { Mastra } from '@mastra/core';
+import type { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+
+import { handleError } from './error';
+
+export async function getLogsHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const transportId = c.req.query('transportId');
+
+    if (!transportId) {
+      throw new HTTPException(400, { message: 'transportId is required' });
+    }
+
+    const logs = await mastra.getLogs(transportId);
+    return c.json(logs);
+  } catch (error) {
+    return handleError(error, 'Error getting logs');
+  }
+}
+
+export async function getLogsByRunIdHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const runId = c.req.param('runId');
+    const transportId = c.req.query('transportId');
+
+    if (!transportId) {
+      throw new HTTPException(400, { message: 'transportId is required' });
+    }
+
+    const logs = await mastra.getLogsByRunId({ runId, transportId });
+    return c.json(logs);
+  } catch (error) {
+    return handleError(error, 'Error getting logs by run ID');
+  }
+}
+
+export async function getLogTransports(c: Context) {
+  console.log('here');
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const logger = mastra.getLogger();
+    const transports = logger.transports;
+    return c.json({
+      transports: Object.keys(transports),
+    });
+  } catch (e) {
+    return handleError(e, 'Error getting log Transports ');
+  }
+}

package/src/server/handlers/memory.ts

@@ -0,0 +1,196 @@
+import type { MastraMemory } from '@mastra/core/memory';
+import type { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+
+import { handleError } from './error';
+import { validateBody } from './utils';
+
+function getMemoryFromContext(c: Context): MastraMemory | null | undefined {
+  const mastra = c.get('mastra');
+  const agentId = c.req.query('agentId');
+  const agent = agentId ? mastra.getAgent(agentId) : null;
+
+  if (agentId && !agent) {
+    throw new HTTPException(404, { message: 'Agent not found' });
+  }
+
+  const memory = agent?.getMemory?.() || mastra.memory;
+
+  return memory;
+}
+
+// Memory handlers
+export async function getMemoryStatusHandler(c: Context) {
+  try {
+    const memory = getMemoryFromContext(c);
+
+    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 { resourceid } = c.req.query();
+    const memory = getMemoryFromContext(c);
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    if (!resourceid) {
+      throw new HTTPException(400, { message: 'Resource ID is required' });
+    }
+
+    const threads = await memory.getThreadsByResourceId({ resourceId: resourceid });
+    return c.json(threads);
+  } catch (error) {
+    return handleError(error, 'Error getting threads');
+  }
+}
+
+export async function getThreadByIdHandler(c: Context) {
+  try {
+    const memory = getMemoryFromContext(c);
+    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 memory = getMemoryFromContext(c);
+    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, memoryConfig: {} });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error saving messages');
+  }
+}
+
+export async function createThreadHandler(c: Context) {
+  try {
+    const memory = getMemoryFromContext(c);
+    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: 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 memory = getMemoryFromContext(c);
+    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 memory = getMemoryFromContext(c);
+    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 memory = getMemoryFromContext(c);
+    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.query({ threadId });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error getting messages');
+  }
+}