@mastra/deployer 0.24.7-alpha.0 → 0.24.7-alpha.2

package/dist/server/index.cjs

@@ -1078,8 +1078,9 @@ var defaultAuthConfig = {
 };
 
 // src/server/handlers/auth/helpers.ts
-var isDevPlaygroundRequest = (req) => {
-  return req.header("x-mastra-dev-playground") === "true" && process.env.MASTRA_DEV === "true";
+var isDevPlaygroundRequest = (req, authConfig) => {
+  const protectedAccess = [...defaultAuthConfig.protected || [], ...authConfig.protected || []];
+  return process.env.MASTRA_DEV === "true" && (!isAnyMatch(req.path, req.method, protectedAccess) || req.header("x-mastra-dev-playground") === "true");
 };
 var isCustomRoutePublic = (path, method, customRouteAuthConfig) => {
   if (!customRouteAuthConfig) {
@@ -1184,7 +1185,7 @@ var authenticationMiddleware = async (c2, next) => {
   if (!authConfig) {
     return next();
   }
-  if (isDevPlaygroundRequest(c2.req)) {
+  if (isDevPlaygroundRequest(c2.req, authConfig)) {
     return next();
   }
   if (!isProtectedPath(c2.req.path, c2.req.method, authConfig, customRouteAuthConfig)) {
@@ -1227,7 +1228,7 @@ var authorizationMiddleware = async (c2, next) => {
   }
   const path = c2.req.path;
   const method = c2.req.method;
-  if (isDevPlaygroundRequest(c2.req)) {
+  if (isDevPlaygroundRequest(c2.req, authConfig)) {
     return next();
   }
   if (!isProtectedPath(c2.req.path, c2.req.method, authConfig, customRouteAuthConfig)) {
@@ -1343,6 +1344,17 @@ async function healthHandler(c2) {
   return c2.json({ success: true }, 200);
 }
 
+// src/server/handlers/restart-active-runs.ts
+async function restartAllActiveWorkflowRunsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    void mastra.restartAllActiveWorkflowRuns();
+    return c2.json({ message: "Restarting all active workflow runs..." });
+  } catch (error) {
+    return handleError(error, "Error restarting active workflow runs");
+  }
+}
+
 // src/server/handlers/root.ts
 async function rootHandler(c2) {
   const baseUrl = new URL(c2.req.url).origin;
@@ -2581,9 +2593,11 @@ var vNextBodyOptions = {
   ...sharedBodyOptions
 };
 async function getAgentsHandler(c2) {
+  const partial = c2.req.query("partial") === "true";
   const serializedAgents = await agents.getAgentsHandler({
     mastra: c2.get("mastra"),
-    runtimeContext: c2.get("runtimeContext")
+    runtimeContext: c2.get("runtimeContext"),
+    partial
   });
   return c2.json(serializedAgents);
 }
@@ -9914,8 +9928,10 @@ function vectorRouter(bodyLimitOptions) {
 async function getWorkflowsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
+    const partial = c2.req.query("partial") === "true";
     const workflows$1 = await workflows.getWorkflowsHandler({
-      mastra
+      mastra,
+      partial
     });
     return c2.json(workflows$1);
   } catch (error) {
@@ -10358,6 +10374,163 @@ async function sendWorkflowRunEventHandler(c2) {
     return handleError(error, "Error sending workflow run event");
   }
 }
+async function restartAsyncWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { tracingOptions } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to restart workflow" });
+    }
+    const result = await workflows.restartAsyncWorkflowHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      tracingOptions
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error restarting workflow run");
+  }
+}
+async function restartWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { tracingOptions } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to restart workflow" });
+    }
+    await workflows.restartWorkflowHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      tracingOptions
+    });
+    return c2.json({ message: "Workflow run restarted" });
+  } catch (error) {
+    return handleError(error, "Error restarting workflow");
+  }
+}
+async function restartAllActiveWorkflowRunsAsyncHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const result = await workflows.restartAllActiveWorkflowRunsAsyncHandler({
+      mastra,
+      workflowId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error restarting all active workflow runs");
+  }
+}
+async function restartAllActiveWorkflowRunsHandler2(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    await workflows.restartAllActiveWorkflowRunsHandler({
+      mastra,
+      workflowId
+    });
+    return c2.json({ message: "All active workflow runs restarted" });
+  } catch (error) {
+    return handleError(error, "Error restarting all active workflow runs");
+  }
+}
+async function timeTravelAsyncWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { tracingOptions, ...body } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to time travel workflow" });
+    }
+    const result = await workflows.timeTravelAsyncWorkflowHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      tracingOptions,
+      body
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error time traveling workflow run");
+  }
+}
+async function timeTravelWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { tracingOptions, ...body } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to time travel workflow" });
+    }
+    await workflows.timeTravelWorkflowHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      tracingOptions,
+      body
+    });
+    return c2.json({ message: "Workflow run time traveled" });
+  } catch (error) {
+    return handleError(error, "Error time traveling workflow");
+  }
+}
+async function timeTravelStreamWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const logger2 = mastra.getLogger();
+    const workflowId = c2.req.param("workflowId");
+    const { tracingOptions, ...body } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(
+      c2,
+      async (stream6) => {
+        try {
+          const result = await workflows.timeTravelStreamWorkflowHandler({
+            mastra,
+            workflowId,
+            runId,
+            body,
+            runtimeContext,
+            tracingOptions
+          });
+          const reader = result.getReader();
+          stream6.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream6.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in workflow time travel stream: " + (err?.message ?? "Unknown error"));
+        }
+      },
+      async (err) => {
+        logger2.error("Error in workflow time travel stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error streaming time traveled workflow");
+  }
+}
 async function getLegacyWorkflowsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -11100,6 +11273,315 @@ function workflowsRouter(bodyLimitOptions) {
     }),
     resumeAsyncWorkflowHandler
   );
+  router.post(
+    "/:workflowId/time-travel",
+    w({
+      description: "Time travel a workflow run",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                inputData: { type: "object" },
+                resumeData: { type: "object" },
+                initialState: { type: "object" },
+                context: { type: "object", description: "Context for the workflow execution" },
+                nestedStepsContext: { type: "object", description: "Nested steps context for the workflow execution" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the workflow execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    timeTravelWorkflowHandler
+  );
+  router.post(
+    "/:workflowId/time-travel-stream",
+    w({
+      description: "Time travel a workflow run using streamVNext",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                inputData: { type: "object" },
+                resumeData: { type: "object" },
+                initialState: { type: "object" },
+                context: { type: "object", description: "Context for the workflow execution" },
+                nestedStepsContext: { type: "object", description: "Nested steps context for the workflow execution" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the workflow execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    timeTravelStreamWorkflowHandler
+  );
+  router.post(
+    "/:workflowId/time-travel-async",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Time travel a workflow run asynchronously",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                inputData: { type: "object" },
+                resumeData: { type: "object" },
+                initialState: { type: "object" },
+                context: { type: "object", description: "Context for the workflow execution" },
+                nestedStepsContext: { type: "object", description: "Nested steps context for the workflow execution" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the workflow execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    timeTravelAsyncWorkflowHandler
+  );
+  router.post(
+    "/:workflowId/restart",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Restart a workflow run",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the workflow execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }),
+    restartWorkflowHandler
+  );
+  router.post(
+    "/:workflowId/restart-async",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Restart a workflow run asynchronously",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the workflow execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }),
+    restartAsyncWorkflowHandler
+  );
+  router.post(
+    "/:workflowId/restart-all-active-workflow-runs",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Restart all active workflow runs",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ]
+    }),
+    restartAllActiveWorkflowRunsHandler2
+  );
+  router.post(
+    "/:workflowId/restart-all-active-workflow-runs-async",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Restart all active workflow runs asynchronously",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ]
+    }),
+    restartAllActiveWorkflowRunsAsyncHandler
+  );
   router.post(
     "/:workflowId/stream-legacy",
     w({
@@ -12083,6 +12565,15 @@ async function createHonoServer(mastra, options = {
       middleware({ url: "/openapi.json" })
     );
   }
+  if (options?.isDev) {
+    app.post(
+      "/__restart-active-workflow-runs",
+      w({
+        hide: true
+      }),
+      restartAllActiveWorkflowRunsHandler
+    );
+  }
   if (options?.playground) {
     app.get(
       "/refresh-events",