Do the parsing on startup instead of at run time

Author: myftija

apps/supervisor/src/env.ts

@@ -167,7 +167,51 @@ const Env = z
     // Schedule toleration settings - scheduled runs tolerate taints on the dedicated pool
     // Comma-separated list of tolerations in the format: key=value:effect
     // For Exists operator (no value): key:effect
-    KUBERNETES_SCHEDULED_RUN_TOLERATIONS: z.string().optional(),
+    KUBERNETES_SCHEDULED_RUN_TOLERATIONS: z
+      .string()
+      .transform((val, ctx) => {
+        const tolerations = val
+          .split(",")
+          .map((entry) => entry.trim())
+          .filter((entry) => entry.length > 0)
+          .map((entry) => {
+            const colonIdx = entry.lastIndexOf(":");
+            if (colonIdx === -1) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Invalid toleration format (missing effect): "${entry}"`,
+              });
+              return z.NEVER;
+            }
+
+            const effect = entry.slice(colonIdx + 1);
+            const validEffects = ["NoSchedule", "NoExecute", "PreferNoSchedule"];
+            if (!validEffects.includes(effect)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Invalid toleration effect "${effect}" in "${entry}". Must be one of: ${validEffects.join(", ")}`,
+              });
+              return z.NEVER;
+            }
+
+            const keyValue = entry.slice(0, colonIdx);
+            const eqIdx = keyValue.indexOf("=");
+
+            if (eqIdx === -1) {
+              return { key: keyValue, operator: "Exists" as const, effect };
+            }
+
+            return {
+              key: keyValue.slice(0, eqIdx),
+              operator: "Equal" as const,
+              value: keyValue.slice(eqIdx + 1),
+              effect,
+            };
+          });
+
+        return tolerations;
+      })
+      .optional(),
 
     // Placement tags settings
     PLACEMENT_TAGS_ENABLED: BoolEnv.default(false),

apps/supervisor/src/workloadManager/kubernetes.ts

@@ -530,37 +530,11 @@ export class KubernetesWorkloadManager implements WorkloadManager {
   }
 
   #getScheduleTolerations(isScheduledRun: boolean): k8s.V1Toleration[] | undefined {
-    if (!isScheduledRun || !env.KUBERNETES_SCHEDULED_RUN_TOLERATIONS) {
+    if (!isScheduledRun || !env.KUBERNETES_SCHEDULED_RUN_TOLERATIONS?.length) {
       return undefined;
     }
 
-    return env.KUBERNETES_SCHEDULED_RUN_TOLERATIONS.split(",")
-      .map((entry) => entry.trim())
-      .filter((entry) => entry.length > 0)
-      .map((entry) => {
-        // Format: key=value:effect or key:effect (Exists operator)
-        const colonIdx = entry.lastIndexOf(":");
-        if (colonIdx === -1) {
-          throw new Error(`Invalid toleration format (missing effect): "${entry}"`);
-        }
-
-        const effect = entry.slice(colonIdx + 1) as k8s.V1Toleration["effect"];
-        const keyValue = entry.slice(0, colonIdx);
-        const eqIdx = keyValue.indexOf("=");
-
-        if (eqIdx === -1) {
-          // key:effect -> Exists operator
-          return { key: keyValue, operator: "Exists" as const, effect };
-        }
-
-        // key=value:effect -> Equal operator
-        return {
-          key: keyValue.slice(0, eqIdx),
-          operator: "Equal" as const,
-          value: keyValue.slice(eqIdx + 1),
-          effect,
-        };
-      });
+    return env.KUBERNETES_SCHEDULED_RUN_TOLERATIONS;
   }
 
   #getProjectPodAffinity(projectId: string): k8s.V1PodAffinity | undefined {