@mettlelabs/mettle 0.0.0-0 → 0.0.0-beta.1-linux-x64

package/harness/chunk-56csr8sw.mjs

@@ -0,0 +1,322 @@
+import"./chunk-z6n9thea.mjs";
+import"./chunk-3wvjs93w.mjs";
+import"./chunk-c1631s2x.mjs";
+import"./chunk-50sbrf09.mjs";
+import {
+  resolveSuspendedToolRunId
+} from "./chunk-3m7jn5ac.mjs";
+import {
+  BACKGROUND_TASK_WORKFLOW_ID
+} from "./chunk-6kgqw9ny.mjs";
+import {
+  createStep$1,
+  createWorkflow
+} from "./chunk-ageqxj9v.mjs";
+import {
+  string,
+  boolean,
+  any,
+  unknown,
+  object,
+  _enum
+} from "./chunk-1sygmp11.mjs";
+
+// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/workflow-DLhRNxEW.js
+var inputSchema = object({ taskId: string() });
+var attemptOutcomeSchema = _enum([
+  "success",
+  "retry",
+  "failed",
+  "cancelled",
+  "timed_out"
+]);
+var attemptOutputSchema = object({
+  taskId: string(),
+  outcome: attemptOutcomeSchema,
+  result: unknown().optional(),
+  error: any().optional()
+});
+var bodyIOSchema = object({
+  taskId: string(),
+  done: boolean().optional(),
+  result: unknown().optional()
+});
+var bodyOutputSchema = object({
+  taskId: string(),
+  done: boolean(),
+  result: unknown().optional()
+});
+var WORKFLOW_STATUS_TO_PERSIST = [
+  "suspended",
+  "pending",
+  "paused",
+  "waiting"
+];
+function buildBackgroundTaskWorkflow(manager) {
+  const runAttemptStep = createStep$1({
+    id: "run-attempt",
+    inputSchema: bodyIOSchema,
+    outputSchema: attemptOutputSchema,
+    execute: async ({ inputData, abortSignal: workflowAbortSignal, suspend, resumeData, suspendData }) => {
+      const { taskId } = inputData;
+      const storage = await manager.getStorage();
+      const task = await storage.getTask(taskId);
+      if (!task || task.status === "cancelled") {
+        manager.deregisterTaskContext(taskId);
+        return {
+          taskId,
+          outcome: "cancelled"
+        };
+      }
+      const executor = manager.taskContexts.get(taskId)?.executor ?? (task.agentId ? manager.getStaticExecutor(`${task.agentId}:${task.toolName}`) : undefined) ?? manager.getStaticExecutor(task.toolName);
+      if (!executor) {
+        const errorInfo = { message: `No executor registered for tool "${task.toolName}". Register the tool on Mastra (so workers can resolve it cross-process) or run the task in the same process as the producer.` };
+        await storage.updateTask(taskId, {
+          status: "failed",
+          error: errorInfo,
+          completedAt: /* @__PURE__ */ new Date
+        });
+        const failedTask = await storage.getTask(taskId);
+        if (failedTask) {
+          await manager.runLocalCompletionHooks(failedTask, "failed", { error: errorInfo });
+          await manager.publishLifecycleEvent("task.failed", failedTask);
+        }
+        manager.deregisterTaskContext(taskId);
+        throw new Error(errorInfo.message);
+      }
+      const progressThrottleMs = manager.config.progressThrottleMs;
+      const shouldThrottleProgress = typeof progressThrottleMs === "number" && Number.isFinite(progressThrottleMs) && progressThrottleMs > 0;
+      let lastProgressEmitMs;
+      const onProgress = async (chunk) => {
+        if (shouldThrottleProgress) {
+          const now = Date.now();
+          if (lastProgressEmitMs !== undefined && now - lastProgressEmitMs < progressThrottleMs)
+            return;
+          lastProgressEmitMs = now;
+        }
+        await manager.publishLifecycleEvent("task.output", {
+          ...task,
+          chunk
+        });
+      };
+      const abortController = new AbortController;
+      if (!manager.registerActiveAbortController(taskId, abortController)) {
+        manager.deregisterTaskContext(taskId);
+        return {
+          taskId,
+          outcome: "cancelled"
+        };
+      }
+      const onWorkflowAbort = () => abortController.abort(/* @__PURE__ */ new Error("Task cancelled"));
+      if (workflowAbortSignal.aborted)
+        abortController.abort(/* @__PURE__ */ new Error("Task cancelled"));
+      else
+        workflowAbortSignal.addEventListener("abort", onWorkflowAbort, { once: true });
+      const timeoutHandle = setTimeout(() => {
+        abortController.abort(/* @__PURE__ */ new Error(`Task timed out after ${task.timeoutMs}ms`));
+      }, task.timeoutMs);
+      let pendingSuspend;
+      const wrappedSuspend = async (data, suspendOptions) => {
+        await storage.updateTask(taskId, {
+          status: "suspended",
+          suspendPayload: data,
+          suspendedAt: /* @__PURE__ */ new Date
+        });
+        const suspendedTask = await storage.getTask(taskId);
+        if (suspendedTask) {
+          await manager.runLocalSuspendHooks(suspendedTask);
+          await manager.publishLifecycleEvent("task.suspended", suspendedTask);
+        }
+        pendingSuspend = {
+          data,
+          suspendOptions
+        };
+      };
+      try {
+        const args = { ...task.args };
+        delete args.suspendedToolRunId;
+        const suspendedToolRunId = resolveSuspendedToolRunId(suspendData?.suspendedToolRunId);
+        if (resumeData !== undefined && suspendedToolRunId)
+          args.suspendedToolRunId = suspendedToolRunId;
+        const result = await executor.execute(args, {
+          abortSignal: abortController.signal,
+          onProgress,
+          suspend: wrappedSuspend,
+          resumeData,
+          suspendedToolRunId: resumeData !== undefined ? suspendedToolRunId : undefined
+        });
+        if (pendingSuspend) {
+          const opts = pendingSuspend.suspendOptions;
+          const agentRunId = opts?.isAgentSuspend && typeof opts.runId === "string" ? opts.runId : undefined;
+          return suspend(!agentRunId ? pendingSuspend.data : pendingSuspend.data && typeof pendingSuspend.data === "object" ? {
+            ...pendingSuspend.data,
+            suspendedToolRunId: agentRunId
+          } : { suspendedToolRunId: agentRunId }, opts);
+        }
+        return {
+          taskId,
+          outcome: "success",
+          result
+        };
+      } catch (error) {
+        const currentTask = await storage.getTask(taskId);
+        if (!currentTask || currentTask.status === "cancelled") {
+          manager.deregisterTaskContext(taskId);
+          return {
+            taskId,
+            outcome: "cancelled"
+          };
+        }
+        if (manager.isShuttingDown()) {
+          manager.deregisterTaskContext(taskId);
+          return {
+            taskId,
+            outcome: "cancelled"
+          };
+        }
+        if (abortController.signal.aborted || error?.name === "AbortError" || error?.message === "Task cancelled" || error?.message?.startsWith("Task timed out after "))
+          return {
+            taskId,
+            outcome: "timed_out"
+          };
+        if (error?.name === "FGADeniedError")
+          return {
+            taskId,
+            outcome: "failed",
+            error: {
+              name: error.name,
+              message: error?.message ?? "Authorization denied",
+              stack: error?.stack
+            }
+          };
+        return {
+          taskId,
+          outcome: "retry",
+          error: {
+            message: error?.message ?? "Unknown error",
+            stack: error?.stack
+          }
+        };
+      } finally {
+        clearTimeout(timeoutHandle);
+        workflowAbortSignal.removeEventListener("abort", onWorkflowAbort);
+        manager.activeAbortControllers.delete(taskId);
+      }
+    }
+  });
+  const classifyOutcomeStep = createStep$1({
+    id: "classify-outcome",
+    inputSchema: attemptOutputSchema,
+    outputSchema: bodyOutputSchema,
+    execute: async ({ inputData }) => {
+      const { taskId, outcome, result, error } = inputData;
+      const storage = await manager.getStorage();
+      const task = await storage.getTask(taskId);
+      if (!task)
+        return {
+          taskId,
+          done: true
+        };
+      if (outcome === "cancelled") {
+        manager.deregisterTaskContext(taskId);
+        return {
+          taskId,
+          done: true
+        };
+      }
+      if (outcome === "timed_out") {
+        const status = task.status;
+        if (status !== "timed_out" && status !== "cancelled") {
+          await storage.updateTask(taskId, {
+            status: "timed_out",
+            error: { message: `Task timed out after ${task.timeoutMs}ms` },
+            completedAt: /* @__PURE__ */ new Date
+          });
+          const timedOutTask = await storage.getTask(taskId);
+          if (timedOutTask)
+            await manager.publishLifecycleEvent("task.failed", timedOutTask);
+        }
+        return {
+          taskId,
+          done: true
+        };
+      }
+      if (outcome === "success") {
+        if (task.status === "cancelled") {
+          manager.deregisterTaskContext(taskId);
+          return {
+            taskId,
+            done: true
+          };
+        }
+        await storage.updateTask(taskId, {
+          status: "completed",
+          result,
+          completedAt: /* @__PURE__ */ new Date
+        });
+        const completedTask = await storage.getTask(taskId);
+        if (completedTask) {
+          await manager.runLocalCompletionHooks(completedTask, "completed", { result });
+          await manager.publishLifecycleEvent("task.completed", completedTask);
+        }
+        return {
+          taskId,
+          done: true,
+          result
+        };
+      }
+      if (outcome === "retry" && task.retryCount < task.maxRetries) {
+        await storage.updateTask(taskId, {
+          retryCount: task.retryCount + 1,
+          error: undefined,
+          startedAt: /* @__PURE__ */ new Date
+        });
+        return {
+          taskId,
+          done: false
+        };
+      }
+      const errorInfo = error ?? { message: "Unknown error" };
+      await storage.updateTask(taskId, {
+        status: "failed",
+        error: errorInfo,
+        completedAt: /* @__PURE__ */ new Date
+      });
+      const failedTask = await storage.getTask(taskId);
+      if (failedTask) {
+        await manager.runLocalCompletionHooks(failedTask, "failed", { error: errorInfo });
+        await manager.publishLifecycleEvent("task.failed", failedTask);
+      }
+      const thrown = new Error(errorInfo.message);
+      if (errorInfo.name)
+        thrown.name = errorInfo.name;
+      if (errorInfo.stack)
+        thrown.stack = errorInfo.stack;
+      throw thrown;
+    }
+  });
+  const attemptBodyWorkflow = createWorkflow({
+    id: `${BACKGROUND_TASK_WORKFLOW_ID}__attempt`,
+    inputSchema: bodyIOSchema,
+    outputSchema: bodyOutputSchema,
+    steps: [runAttemptStep, classifyOutcomeStep],
+    options: {
+      validateInputs: false,
+      shouldPersistSnapshot: ({ workflowStatus }) => WORKFLOW_STATUS_TO_PERSIST.includes(workflowStatus),
+      tracingPolicy: { internal: 1 }
+    }
+  }).then(runAttemptStep).then(classifyOutcomeStep).commit();
+  return createWorkflow({
+    id: BACKGROUND_TASK_WORKFLOW_ID,
+    inputSchema,
+    outputSchema: bodyOutputSchema,
+    steps: [attemptBodyWorkflow],
+    options: {
+      shouldPersistSnapshot: ({ workflowStatus }) => WORKFLOW_STATUS_TO_PERSIST.includes(workflowStatus),
+      tracingPolicy: { internal: 1 }
+    }
+  }).dountil(attemptBodyWorkflow, async ({ inputData }) => inputData?.done === true).commit();
+}
+export {
+  buildBackgroundTaskWorkflow
+};

package/harness/chunk-5cvb1jnb.mjs

@@ -0,0 +1,41 @@
+import {
+  isLoopback,
+  HarnessError
+} from "./chunk-2gt4cy7x.mjs";
+import {
+  assertDatabaseRuntime
+} from "./chunk-7bg2gnv2.mjs";
+
+// apps/harness/src/config.ts
+function databaseConfig(environment = process.env) {
+  assertDatabaseRuntime();
+  const profile = environment.HARNESS_DATABASE_PROFILE;
+  if (profile !== "local" && profile !== "remote") {
+    throw new HarnessError("database_config", "Set HARNESS_DATABASE_PROFILE=local (loopback) or remote (explicit opt-in, TLS required).");
+  }
+  const connectionString = environment.HARNESS_DATABASE_URL;
+  if (!connectionString)
+    throw new HarnessError("database_config", "An explicit HARNESS_DATABASE_URL is required; DATABASE_URL is never used as a fallback.");
+  let endpoint;
+  try {
+    endpoint = new URL(connectionString);
+  } catch {
+    throw new HarnessError("database_config", "The database URL is invalid.");
+  }
+  if (!["postgres:", "postgresql:"].includes(endpoint.protocol) || endpoint.search || endpoint.hash || endpoint.pathname.length < 2) {
+    throw new HarnessError("database_config", "Use an explicit PostgreSQL database URL without query or fragment overrides.");
+  }
+  const loopback = isLoopback(endpoint.hostname);
+  if (profile === "local") {
+    if (!loopback) {
+      throw new HarnessError("database_config", "The local profile requires a loopback address, 127.0.0.1 or [::1]. Use HARNESS_DATABASE_PROFILE=remote for a non-loopback database.");
+    }
+    return { connectionString, ssl: false };
+  }
+  if (loopback) {
+    throw new HarnessError("database_config", "The remote profile is for non-loopback databases. Use HARNESS_DATABASE_PROFILE=local for loopback.");
+  }
+  return { connectionString, ssl: true };
+}
+
+export { databaseConfig };