spawnfile 0.1.14 → 0.1.17

package/dist/manifest/scheduleSchemas.js

@@ -1,10 +1,91 @@
 import { z } from "zod";
-const schedulePromptSchema = z.string().min(1);
-const scheduleTimezoneSchema = z.string().min(1);
+import { parseEveryScheduleMs } from "../runtime/scheduleUtils.js";
+const MAX_RUNTIME_STRING_BYTES = 16_384;
+const MAX_RUNTIME_STRING_CODEPOINTS = 4_096;
+const schedulePromptSchema = z.string().min(1).superRefine((value, context) => {
+    if (!value.trim()) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "prompt must not be empty" });
+    }
+    else if (Buffer.byteLength(value, "utf8") > MAX_RUNTIME_STRING_BYTES || [...value].length > MAX_RUNTIME_STRING_CODEPOINTS) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "prompt exceeds Daimon's schedule string bound" });
+    }
+});
+const CRON_FIELD_BOUNDS = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 7]];
+const scheduleTimezoneSchema = z.string().min(1).superRefine((value, context) => {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: value });
+    }
+    catch {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "timezone must be a valid IANA timezone" });
+    }
+});
+const cronSchema = z.string().trim().min(1).superRefine((value, context) => {
+    const fields = value.split(/\s+/u);
+    if ([...value].length > MAX_RUNTIME_STRING_CODEPOINTS) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "cron exceeds Daimon's runtime string bound" });
+    }
+    if (fields.length !== 5 || !fields.every((field, index) => validCronField(field, CRON_FIELD_BOUNDS[index])) || !cronCalendarPossible(fields)) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "cron must contain five supported numeric fields within their bounds" });
+    }
+}).transform((value) => value.replace(/\s+/gu, " "));
+const validCronField = (field, [minimum, maximum]) => field.split(",").every((part) => {
+    const pieces = part.split("/");
+    const step = Number(pieces[1] ?? 1);
+    if (pieces.length > 2 || !pieces[0] || (pieces[1] !== undefined && !/^\d+$/u.test(pieces[1])) || !Number.isSafeInteger(step) || step < 1)
+        return false;
+    const range = pieces[0];
+    if (range === "*")
+        return true;
+    const bounds = range.split("-");
+    if (bounds.length > 2 || !bounds.every((bound) => /^\d+$/u.test(bound)))
+        return false;
+    const first = Number(bounds[0]);
+    const last = Number(bounds[1] ?? bounds[0]);
+    return first >= minimum && last <= maximum && first <= last;
+});
+const cronCalendarPossible = (raw) => {
+    if (raw.length !== 5)
+        return false;
+    const fields = raw.map((field, index) => cronValues(field, CRON_FIELD_BOUNDS[index]));
+    for (let year = 2000; year < 2400; year += 1)
+        for (const month of fields[3]) {
+            const days = new Date(Date.UTC(year, month, 0)).getUTCDate();
+            for (const day of fields[2])
+                if (day <= days && fields[4].includes(new Date(Date.UTC(year, month - 1, day)).getUTCDay()))
+                    return true;
+        }
+    return false;
+};
+const cronValues = (field, [minimum, maximum]) => {
+    const result = new Set();
+    for (const part of field.split(",")) {
+        const [range, rawStep] = part.split("/");
+        const step = Number(rawStep ?? 1);
+        const bounds = range === "*" ? [minimum, maximum] : range.split("-").map(Number);
+        for (let value = bounds[0]; value <= (bounds[1] ?? bounds[0]); value += step)
+            result.add(value === 7 && maximum === 7 ? 0 : value);
+    }
+    return [...result];
+};
+const everySchema = z.string().trim().min(1).superRefine((value, context) => {
+    if (parseEveryScheduleMs(value) === null)
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "every must be a positive duration" });
+});
+/**
+ * Upper bound on `schedule.jitter_seconds`, mirroring Daimon's
+ * `ORGANIZATION_RUNTIME_MAX_SCHEDULE_JITTER_SECONDS` so every jitter value this
+ * schema accepts also lowers cleanly into the Daimon runtime config: one hour,
+ * generous next to the finest cron granularity (a minute) while staying small
+ * relative to the daily/sub-daily cadences jitter exists to blur, so a
+ * jittered wake still lands recognizably near its scheduled instant.
+ */
+const MAX_SCHEDULE_JITTER_SECONDS = 3_600;
+const jitterSecondsSchema = z.number().int().min(0).max(MAX_SCHEDULE_JITTER_SECONDS);
 export const agentScheduleSchema = z.discriminatedUnion("kind", [
     z
         .object({
-        cron: z.string().min(1),
+        cron: cronSchema,
+        jitter_seconds: jitterSecondsSchema.optional(),
         kind: z.literal("cron"),
         prompt: schedulePromptSchema.optional(),
         timezone: scheduleTimezoneSchema.optional()
@@ -12,12 +93,17 @@ export const agentScheduleSchema = z.discriminatedUnion("kind", [
         .strict(),
     z
         .object({
-        every: z.string().min(1),
+        every: everySchema,
+        jitter_seconds: jitterSecondsSchema.optional(),
         kind: z.literal("every"),
         prompt: schedulePromptSchema.optional(),
         timezone: scheduleTimezoneSchema.optional()
     })
-        .strict(),
+        .strict()
+        .superRefine((value, context) => {
+        if (value.timezone !== undefined)
+            context.addIssue({ code: z.ZodIssueCode.custom, message: "every schedules cannot declare a timezone" });
+    }),
     z
         .object({
         kind: z.literal("disabled")