@kb-labs/workflow-contracts 1.1.0

package/dist/index.js

@@ -0,0 +1,849 @@
+import { z } from 'zod';
+import { RUN_STATES, JOB_STATES, STEP_STATES, JOB_PRIORITIES } from '@kb-labs/workflow-constants';
+import { defineFlags } from '@kb-labs/sdk';
+
+// src/schemas.ts
+var RUN_STATE_VALUES = RUN_STATES;
+var JOB_STATE_VALUES = JOB_STATES;
+var STEP_STATE_VALUES = STEP_STATES;
+var RunStateSchema = z.enum(RUN_STATE_VALUES);
+var JobStateSchema = z.enum(JOB_STATE_VALUES);
+var StepStateSchema = z.enum(STEP_STATE_VALUES);
+var IdempotencyKeySchema = z.string().min(1).max(256);
+var ConcurrencyGroupSchema = z.string().min(1).max(256);
+var TenantIdSchema = z.string().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/).describe("Tenant identifier").optional();
+var RetryModeSchema = z.enum(["exp", "lin"]);
+var RetryPolicySchema = z.object({
+  max: z.number().int().nonnegative(),
+  backoff: RetryModeSchema.default("exp"),
+  initialIntervalMs: z.number().int().positive().default(1e3),
+  maxIntervalMs: z.number().int().positive().optional()
+});
+var TimeoutSchema = z.number().int().positive().max(1e3 * 60 * 60 * 24);
+var ExecutionTargetSchema = z.object({
+  environmentId: z.string().min(1).optional(),
+  workspaceId: z.string().min(1).optional(),
+  namespace: z.string().min(1).optional(),
+  workdir: z.string().min(1).optional()
+});
+var IsolationProfileSchema = z.enum(["strict", "balanced", "relaxed"]);
+var PhaseSchema = z.object({
+  label: z.string().min(1),
+  description: z.string().optional()
+});
+var StepProgressSchema = z.object({
+  source: z.string().min(1),
+  format: z.string().min(1)
+});
+var StepArtifactSchema = z.object({
+  type: z.enum(["markdown", "issues", "table", "diff", "log", "json", "link"]),
+  source: z.string().min(1),
+  label: z.string().min(1),
+  digest: z.string().optional(),
+  showInSummary: z.boolean().optional()
+});
+var ApprovalReviewItemSchema = z.object({
+  artifact: z.string().min(1),
+  editable: z.boolean().optional(),
+  decisions: z.boolean().optional()
+});
+var StepSpecSchema = z.object({
+  name: z.string().min(1),
+  uses: z.union([
+    z.literal("builtin:shell"),
+    z.literal("builtin:approval"),
+    z.literal("builtin:gate"),
+    z.string().regex(/^(plugin:|workflow:)?[a-zA-Z0-9@/_:+#.-]+$/)
+  ]).optional(),
+  id: z.string().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/).optional(),
+  if: z.string().optional(),
+  with: z.record(z.string(), z.unknown()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  secrets: z.array(z.string().min(1)).optional(),
+  timeoutMs: TimeoutSchema.optional(),
+  continueOnError: z.boolean().optional(),
+  // Presentation layer
+  summary: z.string().optional(),
+  phase: z.string().optional(),
+  progress: StepProgressSchema.optional(),
+  artifacts: z.record(z.string().min(1), StepArtifactSchema).optional()
+});
+var JobConcurrencySchema = z.object({
+  group: ConcurrencyGroupSchema,
+  cancelInProgress: z.boolean().optional()
+});
+var ArtifactMergeStrategySchema = z.enum(["append", "overwrite", "json-merge"]);
+var ArtifactMergeSourceSchema = z.object({
+  runId: z.string().min(1),
+  jobId: z.string().min(1).optional()
+});
+var ArtifactMergeConfigSchema = z.object({
+  strategy: ArtifactMergeStrategySchema,
+  from: z.array(ArtifactMergeSourceSchema).min(1)
+});
+var JobArtifactsSchema = z.object({
+  produce: z.array(z.string().min(1)).optional(),
+  consume: z.array(z.string().min(1)).optional(),
+  merge: ArtifactMergeConfigSchema.optional()
+}).optional();
+var JobHooksSchema = z.object({
+  pre: z.array(StepSpecSchema).optional(),
+  post: z.array(StepSpecSchema).optional(),
+  onFailure: z.array(StepSpecSchema).optional(),
+  onSuccess: z.array(StepSpecSchema).optional()
+}).optional();
+var JobSpecSchema = z.object({
+  runsOn: z.enum(["local", "sandbox"]),
+  target: ExecutionTargetSchema.optional(),
+  isolation: IsolationProfileSchema.optional(),
+  concurrency: JobConcurrencySchema.optional(),
+  steps: z.array(StepSpecSchema).min(1),
+  artifacts: JobArtifactsSchema,
+  hooks: JobHooksSchema,
+  if: z.string().optional(),
+  timeoutMs: TimeoutSchema.optional(),
+  retries: RetryPolicySchema.optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  secrets: z.array(z.string().min(1)).optional(),
+  needs: z.array(z.string().min(1)).optional(),
+  priority: z.enum(["high", "normal", "low"]).optional()
+});
+var WorkflowTriggerSchema = z.object({
+  manual: z.boolean().optional(),
+  push: z.boolean().optional(),
+  webhook: z.union([
+    z.boolean(),
+    z.object({
+      secret: z.string().min(1).optional(),
+      path: z.string().min(1).optional(),
+      headers: z.record(z.string(), z.string()).optional()
+    })
+  ]).optional(),
+  schedule: z.object({
+    cron: z.string().min(1),
+    timezone: z.string().min(1).optional()
+  }).optional()
+}).refine(
+  (value) => value.manual || value.push || !!value.webhook || !!value.schedule,
+  {
+    message: "At least one trigger must be defined",
+    path: ["manual"]
+  }
+);
+var WorkflowInputFieldSchema = z.object({
+  type: z.enum(["string", "number", "boolean"]),
+  description: z.string().optional(),
+  required: z.boolean().optional(),
+  default: z.unknown().optional()
+});
+var WorkflowSpecSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().min(1),
+  description: z.string().optional(),
+  target: ExecutionTargetSchema.optional(),
+  isolation: IsolationProfileSchema.optional(),
+  on: WorkflowTriggerSchema,
+  inputs: z.record(z.string(), WorkflowInputFieldSchema).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  secrets: z.array(z.string().min(1)).optional(),
+  jobs: z.record(z.string().min(1), JobSpecSchema),
+  // Presentation layer
+  phases: z.record(z.string().min(1), PhaseSchema).optional()
+}).refine(
+  (value) => Object.keys(value.jobs).length > 0 && Object.keys(value.jobs).every((key) => key.trim().length > 0),
+  {
+    message: "At least one job must be defined with a non-empty id",
+    path: ["jobs"]
+  }
+);
+var StepRunErrorSchema = z.object({
+  message: z.string(),
+  code: z.string().optional(),
+  stack: z.string().optional(),
+  timestamp: z.string().optional(),
+  details: z.record(z.string(), z.unknown()).optional()
+});
+var StepRunSchema = z.object({
+  id: z.string().min(1),
+  runId: z.string().min(1),
+  jobId: z.string().min(1),
+  name: z.string().min(1),
+  index: z.number().int().nonnegative(),
+  status: StepStateSchema,
+  queuedAt: z.string().datetime(),
+  startedAt: z.string().datetime().optional(),
+  finishedAt: z.string().datetime().optional(),
+  durationMs: z.number().int().nonnegative().optional(),
+  attempt: z.number().int().nonnegative().default(0),
+  timeoutMs: TimeoutSchema.optional(),
+  continueOnError: z.boolean().optional(),
+  error: StepRunErrorSchema.optional(),
+  outputs: z.record(z.string(), z.unknown()).optional(),
+  skipReason: z.string().optional(),
+  spec: StepSpecSchema
+});
+var JobRunSchema = z.object({
+  id: z.string().min(1),
+  runId: z.string().min(1),
+  tenantId: TenantIdSchema,
+  // ← Inherited from run for isolation
+  jobName: z.string().min(1),
+  status: JobStateSchema,
+  runsOn: z.enum(["local", "sandbox"]),
+  queuedAt: z.string().datetime(),
+  startedAt: z.string().datetime().optional(),
+  finishedAt: z.string().datetime().optional(),
+  durationMs: z.number().int().nonnegative().optional(),
+  attempt: z.number().int().nonnegative().default(0),
+  concurrency: JobConcurrencySchema.optional(),
+  retries: RetryPolicySchema.optional(),
+  timeoutMs: TimeoutSchema.optional(),
+  target: ExecutionTargetSchema.optional(),
+  isolation: IsolationProfileSchema.optional(),
+  artifacts: JobArtifactsSchema,
+  error: StepRunErrorSchema.optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  secrets: z.array(z.string().min(1)).optional(),
+  needs: z.array(z.string().min(1)).optional(),
+  pendingDependencies: z.array(z.string().min(1)).optional(),
+  blocked: z.boolean().optional(),
+  priority: z.enum(["high", "normal", "low"]).optional(),
+  steps: z.array(StepRunSchema)
+});
+var RunTriggerSchema = z.object({
+  type: z.enum(["manual", "webhook", "push", "schedule", "workflow"]),
+  actor: z.string().optional(),
+  payload: z.record(z.string(), z.unknown()).optional(),
+  parentRunId: z.string().optional(),
+  parentJobId: z.string().optional(),
+  parentStepId: z.string().optional(),
+  invokedByWorkflowId: z.string().optional()
+});
+var RunMetadataSchema = z.object({
+  idempotencyKey: IdempotencyKeySchema.optional(),
+  concurrencyGroup: ConcurrencyGroupSchema.optional(),
+  target: ExecutionTargetSchema.optional(),
+  isolation: IsolationProfileSchema.optional(),
+  workflowId: z.string().optional(),
+  workflowDepth: z.number().int().nonnegative().optional(),
+  parentRunId: z.string().optional(),
+  parentJobId: z.string().optional(),
+  parentStepId: z.string().optional()
+});
+var ResultErrorSchema = z.object({
+  message: z.string().min(1),
+  code: z.string().optional(),
+  details: z.record(z.string(), z.unknown()).optional()
+});
+var ResultMetricsSchema = z.object({
+  timeMs: z.number().int().nonnegative().optional(),
+  cpuMs: z.number().int().nonnegative().optional(),
+  memMb: z.number().nonnegative().optional(),
+  jobsTotal: z.number().int().nonnegative().optional(),
+  jobsSucceeded: z.number().int().nonnegative().optional(),
+  jobsFailed: z.number().int().nonnegative().optional(),
+  jobsCancelled: z.number().int().nonnegative().optional(),
+  stepsTotal: z.number().int().nonnegative().optional(),
+  stepsFailed: z.number().int().nonnegative().optional(),
+  stepsCancelled: z.number().int().nonnegative().optional()
+});
+var ExecutionResultSchema = z.object({
+  status: RunStateSchema,
+  summary: z.string().optional(),
+  startedAt: z.string().datetime().optional(),
+  completedAt: z.string().datetime().optional(),
+  metrics: ResultMetricsSchema.optional(),
+  details: z.record(z.string(), z.unknown()).optional(),
+  outputs: z.record(z.string(), z.unknown()).optional(),
+  error: ResultErrorSchema.optional()
+});
+var RunSchema = z.object({
+  id: z.string().min(1),
+  tenantId: TenantIdSchema,
+  // ← Multi-tenancy support
+  name: z.string().min(1),
+  version: z.string().min(1),
+  status: RunStateSchema,
+  createdAt: z.string().datetime(),
+  queuedAt: z.string().datetime(),
+  startedAt: z.string().datetime().optional(),
+  finishedAt: z.string().datetime().optional(),
+  durationMs: z.number().int().nonnegative().optional(),
+  trigger: RunTriggerSchema,
+  env: z.record(z.string(), z.string()).optional(),
+  secrets: z.array(z.string().min(1)).optional(),
+  jobs: z.array(JobRunSchema),
+  artifacts: z.array(z.string()).optional(),
+  metadata: RunMetadataSchema.optional(),
+  result: ExecutionResultSchema.optional()
+});
+
+// src/expressions.ts
+function parseWorkflowUses(uses) {
+  if (!uses.startsWith("workflow:")) {
+    return null;
+  }
+  const workflowId = uses.slice("workflow:".length);
+  if (!workflowId) {
+    return null;
+  }
+  return {
+    type: "workflow",
+    workflowId,
+    mode: "wait",
+    // default
+    inheritEnv: true
+    // default
+  };
+}
+function extractExpressions(str) {
+  const pattern = /\$\{\{\s*([^}]+)\s*\}\}/g;
+  const matches = [];
+  let match;
+  while ((match = pattern.exec(str)) !== null) {
+    matches.push(match[1].trim());
+  }
+  return matches;
+}
+function evaluateExpression(expr, context) {
+  const trimmed = expr.trim();
+  if (trimmed.includes("&&")) {
+    const parts = trimmed.split("&&").map((p) => p.trim());
+    return parts.every((part) => evaluateExpression(part, context));
+  }
+  if (trimmed.includes("||")) {
+    const parts = trimmed.split("||").map((p) => p.trim());
+    return parts.some((part) => evaluateExpression(part, context));
+  }
+  if (trimmed.startsWith("!")) {
+    return !evaluateExpression(trimmed.slice(1).trim(), context);
+  }
+  if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+    return evaluateExpression(trimmed.slice(1, -1).trim(), context);
+  }
+  if (trimmed === "true") {
+    return true;
+  }
+  if (trimmed === "false") {
+    return false;
+  }
+  if (trimmed.includes("==")) {
+    const parts = trimmed.split("==").map((s) => s.trim());
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      const left = resolveValue(parts[0], context);
+      const right = resolveValue(parts[1], context);
+      if (typeof left === "number" && typeof right === "number") {
+        return left === right;
+      }
+      return coerceToString(left) === coerceToString(right);
+    }
+  }
+  if (trimmed.includes("!=")) {
+    const parts = trimmed.split("!=").map((s) => s.trim());
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      const left = resolveValue(parts[0], context);
+      const right = resolveValue(parts[1], context);
+      if (typeof left === "number" && typeof right === "number") {
+        return left !== right;
+      }
+      return coerceToString(left) !== coerceToString(right);
+    }
+  }
+  if (trimmed.includes("contains(")) {
+    const match = trimmed.match(/contains\(([^,]+),\s*([^)]+)\)/);
+    if (match && match[1] && match[2]) {
+      const value2 = resolveValue(match[1].trim(), context);
+      const search = match[2].trim().replace(/^["']|["']$/g, "");
+      return String(value2).includes(search);
+    }
+  }
+  if (trimmed.includes("startsWith(")) {
+    const match = trimmed.match(/startsWith\(([^,]+),\s*([^)]+)\)/);
+    if (match && match[1] && match[2]) {
+      const value2 = resolveValue(match[1].trim(), context);
+      const prefix = match[2].trim().replace(/^["']|["']$/g, "");
+      return String(value2).startsWith(prefix);
+    }
+  }
+  if (trimmed.includes("endsWith(")) {
+    const match = trimmed.match(/endsWith\(([^,]+),\s*([^)]+)\)/);
+    if (match && match[1] && match[2]) {
+      const value2 = resolveValue(match[1].trim(), context);
+      const suffix = match[2].trim().replace(/^["']|["']$/g, "");
+      return String(value2).endsWith(suffix);
+    }
+  }
+  const value = resolveValue(trimmed, context);
+  return Boolean(value);
+}
+function resolveValue(path, context) {
+  const cleanPath = path.replace(/^["']|["']$/g, "");
+  if (cleanPath.startsWith("env.")) {
+    const key = cleanPath.slice("env.".length);
+    return context.env[key] ?? "";
+  }
+  if (cleanPath.startsWith("trigger.")) {
+    const key = cleanPath.slice("trigger.".length);
+    if (key === "type") {
+      return context.trigger.type;
+    }
+    if (key === "actor") {
+      return context.trigger.actor ?? "";
+    }
+    if (key.startsWith("payload.")) {
+      const payloadKey = key.slice("payload.".length);
+      return context.trigger.payload?.[payloadKey] ?? "";
+    }
+    return "";
+  }
+  if (cleanPath.startsWith("steps.")) {
+    const rest = cleanPath.slice("steps.".length);
+    const match = rest.match(/^([^.]+)\.outputs\.(.+)$/);
+    if (match) {
+      const stepId = match[1];
+      const outputKey = match[2];
+      const outputs = context.steps[stepId]?.outputs;
+      if (outputs === void 0) return "";
+      const parts = outputKey.split(".");
+      let value = outputs;
+      for (const part of parts) {
+        if (value === void 0 || value === null || typeof value !== "object") return "";
+        value = value[part];
+      }
+      return value !== void 0 ? value : "";
+    }
+    return "";
+  }
+  if (cleanPath.startsWith("matrix.") && context.matrix) {
+    const key = cleanPath.slice("matrix.".length);
+    return context.matrix[key] ?? "";
+  }
+  const num = Number(cleanPath);
+  if (!isNaN(num) && isFinite(num)) {
+    return num;
+  }
+  if (cleanPath === "true") {
+    return true;
+  }
+  if (cleanPath === "false") {
+    return false;
+  }
+  return cleanPath;
+}
+function coerceToString(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  return String(value);
+}
+function interpolateString(str, context) {
+  const expressions = extractExpressions(str);
+  let result = str;
+  for (const expr of expressions) {
+    const value = resolveValueWithFallback(expr, context);
+    const replacement = coerceToString(value);
+    const pattern = new RegExp(
+      `\\$\\{\\{\\s*${escapeRegex(expr)}\\s*\\}\\}`,
+      "g"
+    );
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function resolveValueWithFallback(expr, context) {
+  const parts = splitOnOperator(expr, "||");
+  if (parts.length === 1) {
+    return resolveValue(parts[0].trim(), context);
+  }
+  for (let i = 0; i < parts.length; i++) {
+    const value = resolveValue(parts[i].trim(), context);
+    if (isTruthy(value)) {
+      return value;
+    }
+    if (i === parts.length - 1) {
+      return value;
+    }
+  }
+  return "";
+}
+function splitOnOperator(expr, op) {
+  const parts = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let i = 0;
+  while (i < expr.length) {
+    const ch = expr[i];
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += ch;
+      i++;
+    } else if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += ch;
+      i++;
+    } else if (!inSingle && !inDouble && expr.slice(i, i + op.length) === op) {
+      parts.push(current);
+      current = "";
+      i += op.length;
+    } else {
+      current += ch;
+      i++;
+    }
+  }
+  parts.push(current);
+  return parts;
+}
+function isTruthy(value) {
+  if (value === "" || value === null || value === void 0 || value === false || value === 0) {
+    return false;
+  }
+  return true;
+}
+function resolveExpression(str, context) {
+  const trimmed = str.trim();
+  const singleExprMatch = trimmed.match(/^\$\{\{\s*([^}]+)\s*\}\}$/);
+  if (singleExprMatch && singleExprMatch[1]) {
+    return resolveValueWithFallback(singleExprMatch[1].trim(), context);
+  }
+  if (trimmed.includes("${{")) {
+    return interpolateString(trimmed, context);
+  }
+  return str;
+}
+function interpolateObject(obj, context) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key] = interpolateValue(value, context);
+  }
+  return result;
+}
+function interpolateValue(value, context) {
+  if (typeof value === "string") {
+    return resolveExpression(value, context);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolateValue(item, context));
+  }
+  if (value !== null && typeof value === "object") {
+    return interpolateObject(value, context);
+  }
+  return value;
+}
+var statusFlags = defineFlags({
+  json: {
+    type: "boolean",
+    description: "Output result as JSON",
+    default: false
+  },
+  "job-id": {
+    type: "string",
+    description: "Job ID to get status for"
+  }
+});
+var logsFlags = defineFlags({
+  json: {
+    type: "boolean",
+    description: "Output result as JSON",
+    default: false
+  },
+  "job-id": {
+    type: "string",
+    description: "Job ID to get logs for (required)"
+  },
+  follow: {
+    type: "boolean",
+    description: "Follow log output (stream new logs)",
+    default: false
+  }
+});
+var metricsFlags = defineFlags({
+  json: {
+    type: "boolean",
+    description: "Output result as JSON",
+    default: false
+  }
+});
+var healthFlags = defineFlags({
+  json: {
+    type: "boolean",
+    description: "Output result as JSON",
+    default: false
+  }
+});
+var listFlags = defineFlags({
+  json: {
+    type: "boolean",
+    description: "Output result as JSON",
+    default: false
+  },
+  status: {
+    type: "string",
+    description: "Filter by status (running, completed, failed)"
+  },
+  type: {
+    type: "string",
+    description: 'Filter by type: "runs" (active executions), "cron" (scheduled jobs)'
+  }
+});
+var runFlags = defineFlags({
+  json: {
+    type: "boolean",
+    description: "Output result as JSON",
+    default: false
+  },
+  handler: {
+    type: "string",
+    description: 'Plugin handler to run (e.g., "mind:rag-query")'
+  },
+  input: {
+    type: "string",
+    description: "JSON string of input parameters"
+  },
+  priority: {
+    type: "number",
+    description: "Job priority (1-10, default: 5)"
+  },
+  wait: {
+    type: "boolean",
+    description: "Wait for job completion",
+    default: false
+  }
+});
+var JOB_PRIORITY_VALUES = JOB_PRIORITIES;
+var CronScheduleSchema = z.string().regex(
+  /^(\*|([0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])|\*\/([0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])) (\*|([0-9]|1[0-9]|2[0-3])|\*\/([0-9]|1[0-9]|2[0-3])) (\*|([1-9]|1[0-9]|2[0-9]|3[0-1])|\*\/([1-9]|1[0-9]|2[0-9]|3[0-1])) (\*|([1-9]|1[0-2])|\*\/([1-9]|1[0-2])) (\*|[0-6]|\*\/[0-6])$/,
+  "Invalid cron expression"
+).describe("Cron schedule expression");
+var PluginCronJobSchema = z.object({
+  id: z.string().min(1).max(64).describe("Unique cron job identifier"),
+  schedule: CronScheduleSchema,
+  handler: z.string().min(1).describe('Plugin handler (e.g., "mind:rag-index")'),
+  input: z.record(z.string(), z.unknown()).optional().describe("Input parameters for handler"),
+  priority: z.enum(JOB_PRIORITY_VALUES).default("normal"),
+  enabled: z.boolean().default(true).describe("Whether cron job is enabled"),
+  timezone: z.string().optional().describe("Timezone for schedule (default: UTC)"),
+  metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata")
+});
+var UserCronJobSchema = z.object({
+  name: z.string().min(1).describe("Human-readable job name"),
+  schedule: CronScheduleSchema,
+  autoStart: z.boolean().default(true).describe("Auto-start on daemon boot"),
+  priority: z.enum(JOB_PRIORITY_VALUES).default("normal"),
+  enabled: z.boolean().default(true).describe("Whether cron job is enabled"),
+  timezone: z.string().optional().describe("Timezone for schedule (default: UTC)"),
+  env: z.record(z.string(), z.string()).optional().describe("Environment variables"),
+  jobs: z.record(z.string(), z.any()).describe("Workflow jobs specification"),
+  metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata")
+});
+var CronExecutionSchema = z.object({
+  cronJobId: z.string(),
+  runId: z.string().describe("Workflow run ID"),
+  scheduledAt: z.string().datetime().describe("When execution was scheduled"),
+  startedAt: z.string().datetime().optional().describe("When execution started"),
+  finishedAt: z.string().datetime().optional().describe("When execution finished"),
+  status: z.enum(["pending", "running", "success", "failed"]),
+  error: z.object({
+    message: z.string(),
+    stack: z.string().optional()
+  }).optional()
+});
+var JobStatusSchema = z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var JobStatusInfoSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  status: JobStatusSchema,
+  tenantId: z.string().optional(),
+  priority: z.number().optional(),
+  createdAt: z.union([z.string(), z.date()]).optional(),
+  startedAt: z.union([z.string(), z.date()]).optional(),
+  finishedAt: z.union([z.string(), z.date()]).optional(),
+  attempt: z.number().optional(),
+  maxRetries: z.number().optional(),
+  result: z.unknown().optional(),
+  error: z.string().optional(),
+  progress: z.number().min(0).max(100).optional(),
+  progressMessage: z.string().optional()
+});
+var JobListResponseSchema = z.object({
+  jobs: z.array(JobStatusInfoSchema)
+});
+var JobCancelResponseSchema = z.object({
+  cancelled: z.boolean()
+});
+var CronInfoSchema = z.object({
+  id: z.string(),
+  schedule: z.string(),
+  jobType: z.string(),
+  timezone: z.string().optional(),
+  enabled: z.boolean(),
+  lastRun: z.union([z.string(), z.date()]).optional(),
+  nextRun: z.union([z.string(), z.date()]).optional(),
+  pluginId: z.string().optional()
+});
+var CronListResponseSchema = z.object({
+  crons: z.array(CronInfoSchema)
+});
+var WorkflowInfoSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  source: z.enum(["manifest", "standalone"]),
+  pluginId: z.string().optional(),
+  status: z.enum(["active", "inactive"]).optional(),
+  tags: z.array(z.string()).optional()
+});
+var WorkflowListResponseSchema = z.object({
+  workflows: z.array(WorkflowInfoSchema)
+});
+var WorkflowRunRequestSchema = z.object({
+  input: z.unknown().optional(),
+  target: z.object({
+    environmentId: z.string().min(1).optional(),
+    workspaceId: z.string().min(1).optional(),
+    namespace: z.string().min(1).optional(),
+    workdir: z.string().min(1).optional()
+  }).optional(),
+  isolation: z.enum(["strict", "balanced", "relaxed"]).optional(),
+  trigger: z.object({
+    type: z.enum(["manual", "api", "cron"]),
+    user: z.string().optional()
+  }).optional()
+});
+var DashboardStatsResponseSchema = z.object({
+  workflows: z.object({
+    total: z.number(),
+    active: z.number(),
+    inactive: z.number()
+  }),
+  jobs: z.object({
+    running: z.number(),
+    pending: z.number(),
+    completed: z.number(),
+    failed: z.number()
+  }),
+  crons: z.object({
+    total: z.number(),
+    enabled: z.number(),
+    disabled: z.number()
+  }),
+  activeExecutions: z.array(z.object({
+    id: z.string(),
+    type: z.string(),
+    workflowName: z.string().optional(),
+    status: z.literal("running"),
+    progress: z.number().min(0).max(100).optional(),
+    progressMessage: z.string().optional(),
+    startedAt: z.string(),
+    durationMs: z.number().optional()
+  })),
+  recentActivity: z.array(z.object({
+    id: z.string(),
+    type: z.string(),
+    workflowName: z.string().optional(),
+    status: z.enum(["completed", "failed", "cancelled"]),
+    finishedAt: z.string(),
+    durationMs: z.number().optional(),
+    error: z.string().optional()
+  }))
+});
+var JobLogsResponseSchema = z.object({
+  jobId: z.string(),
+  logs: z.array(z.object({
+    timestamp: z.string(),
+    level: z.enum(["info", "warn", "error", "debug"]),
+    message: z.string(),
+    context: z.record(z.unknown()).optional()
+  })),
+  total: z.number(),
+  hasMore: z.boolean()
+});
+var JobStepInfoSchema = z.object({
+  name: z.string(),
+  handler: z.string().optional(),
+  status: z.enum(["pending", "running", "completed", "failed", "skipped"]),
+  progress: z.number().min(0).max(100).optional(),
+  startedAt: z.string().optional(),
+  finishedAt: z.string().optional(),
+  durationMs: z.number().optional(),
+  error: z.string().optional(),
+  output: z.unknown().optional()
+});
+var JobStepsResponseSchema = z.object({
+  jobId: z.string(),
+  workflowName: z.string().optional(),
+  status: z.enum(["pending", "running", "completed", "failed", "cancelled"]),
+  steps: z.array(JobStepInfoSchema),
+  currentStep: z.number().optional()
+});
+var WorkflowRunInfoSchema = z.object({
+  id: z.string(),
+  workflowId: z.string(),
+  status: z.enum(["pending", "running", "completed", "failed", "cancelled"]),
+  trigger: z.object({
+    type: z.enum(["manual", "api", "cron"]),
+    user: z.string().optional()
+  }),
+  startedAt: z.string(),
+  finishedAt: z.string().optional(),
+  durationMs: z.number().optional(),
+  error: z.string().optional()
+});
+var WorkflowRunHistoryResponseSchema = z.object({
+  workflowId: z.string(),
+  runs: z.array(WorkflowRunInfoSchema),
+  total: z.number()
+});
+
+// src/routes.ts
+var WORKFLOW_BASE_PATH = "/plugins/workflow";
+var WORKFLOW_ROUTES = {
+  /** GET /stats - Dashboard statistics */
+  STATS: "/stats",
+  /** GET /workflows - List all workflow definitions */
+  WORKFLOWS: "/workflows",
+  /** GET /workflows/:id - Get workflow definition details */
+  WORKFLOW_DETAIL: "/workflows/:id",
+  /** POST /workflows/:id/run - Run a workflow */
+  WORKFLOW_RUN: "/workflows/:id/run",
+  /** GET /workflows/:id/runs - Get workflow run history */
+  WORKFLOW_RUNS: "/workflows/:id/runs",
+  /** POST /workflows/runs/:runId/cancel - Cancel a workflow run */
+  WORKFLOW_RUN_CANCEL: "/workflows/runs/:runId/cancel",
+  /** GET /runs - List all workflow runs */
+  RUNS: "/runs",
+  /** GET /runs/:runId - Get a specific workflow run */
+  RUN_DETAIL: "/runs/:runId",
+  /** GET /jobs - List all jobs */
+  JOBS: "/jobs",
+  /** GET /jobs/:jobId - Get job details */
+  JOB_DETAIL: "/jobs/:jobId",
+  /** GET /jobs/:jobId/logs - Get job logs */
+  JOB_LOGS: "/jobs/:jobId/logs",
+  /** GET /jobs/:jobId/steps - Get job execution steps */
+  JOB_STEPS: "/jobs/:jobId/steps",
+  /** POST /jobs/:jobId/cancel - Cancel a job */
+  JOB_CANCEL: "/jobs/:jobId/cancel",
+  /** GET /cron - List cron jobs */
+  CRON: "/cron",
+  /** GET /runs/:runId/pending-approvals - List pending approvals */
+  PENDING_APPROVALS: "/runs/:runId/pending-approvals",
+  /** POST /runs/:runId/approve - Resolve an approval */
+  RESOLVE_APPROVAL: "/runs/:runId/approve"
+};
+
+export { ApprovalReviewItemSchema, ArtifactMergeConfigSchema, ArtifactMergeSourceSchema, ArtifactMergeStrategySchema, ConcurrencyGroupSchema, CronExecutionSchema, CronInfoSchema, CronListResponseSchema, CronScheduleSchema, DashboardStatsResponseSchema, ExecutionResultSchema, ExecutionTargetSchema, IdempotencyKeySchema, IsolationProfileSchema, JobArtifactsSchema, JobCancelResponseSchema, JobConcurrencySchema, JobHooksSchema, JobListResponseSchema, JobLogsResponseSchema, JobRunSchema, JobSpecSchema, JobStateSchema, JobStatusInfoSchema, JobStatusSchema, JobStepInfoSchema, JobStepsResponseSchema, PhaseSchema, PluginCronJobSchema, ResultErrorSchema, ResultMetricsSchema, RetryModeSchema, RetryPolicySchema, RunMetadataSchema, RunSchema, RunStateSchema, RunTriggerSchema, StepArtifactSchema, StepProgressSchema, StepRunErrorSchema, StepRunSchema, StepSpecSchema, StepStateSchema, TenantIdSchema, TimeoutSchema, UserCronJobSchema, WORKFLOW_BASE_PATH, WORKFLOW_ROUTES, WorkflowInfoSchema, WorkflowInputFieldSchema, WorkflowListResponseSchema, WorkflowRunHistoryResponseSchema, WorkflowRunInfoSchema, WorkflowRunRequestSchema, WorkflowSpecSchema, WorkflowTriggerSchema, evaluateExpression, extractExpressions, healthFlags, interpolateObject, interpolateString, listFlags, logsFlags, metricsFlags, parseWorkflowUses, resolveExpression, resolveValue, runFlags, statusFlags };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map