@hachej/boring-automation 0.1.71 → 0.1.80

package/dist/shared/index.d.ts

@@ -6,14 +6,22 @@ declare const BORING_AUTOMATION_ROUTE_PREFIX = "/api/v1/boring-automation";
 
 declare const BORING_AUTOMATION_ERROR_CODES: {
     readonly INVALID_BODY: "BORING_AUTOMATION_INVALID_BODY";
+    readonly INVALID_CRON: "BORING_AUTOMATION_INVALID_CRON";
+    readonly INVALID_TIMEZONE: "BORING_AUTOMATION_INVALID_TIMEZONE";
+    readonly INVALID_MODEL: "BORING_AUTOMATION_INVALID_MODEL";
     readonly AUTOMATION_NOT_FOUND: "BORING_AUTOMATION_NOT_FOUND";
     readonly RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND";
+    readonly RUN_ALREADY_ACTIVE: "BORING_AUTOMATION_RUN_ALREADY_ACTIVE";
+    readonly RUN_ALREADY_RECORDED: "BORING_AUTOMATION_RUN_ALREADY_RECORDED";
+    readonly RUN_EXECUTOR_UNAVAILABLE: "BORING_AUTOMATION_RUN_EXECUTOR_UNAVAILABLE";
+    readonly TRIGGER_FORBIDDEN: "BORING_AUTOMATION_TRIGGER_FORBIDDEN";
+    readonly RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED";
 };
 type BoringAutomationErrorCode = typeof BORING_AUTOMATION_ERROR_CODES[keyof typeof BORING_AUTOMATION_ERROR_CODES];
 
 declare const AutomationRunStatusSchema: z.ZodEnum<["queued", "running", "succeeded", "failed", "cancelled"]>;
 declare const AutomationRunTriggerSchema: z.ZodEnum<["manual", "scheduled"]>;
-declare const AutomationCreateSchema: z.ZodObject<{
+declare const AutomationCreateSchema: z.ZodEffects<z.ZodObject<{
     title: z.ZodString;
     enabled: z.ZodOptional<z.ZodBoolean>;
     cron: z.ZodString;
@@ -34,8 +42,22 @@ declare const AutomationCreateSchema: z.ZodObject<{
     model: string;
     enabled?: boolean | undefined;
     prompt?: string | undefined;
+}>, {
+    title: string;
+    cron: string;
+    timezone: string;
+    model: string;
+    enabled?: boolean | undefined;
+    prompt?: string | undefined;
+}, {
+    title: string;
+    cron: string;
+    timezone: string;
+    model: string;
+    enabled?: boolean | undefined;
+    prompt?: string | undefined;
 }>;
-declare const AutomationPatchSchema: z.ZodEffects<z.ZodObject<{
+declare const AutomationPatchSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     cron: z.ZodOptional<z.ZodString>;
@@ -43,27 +65,39 @@ declare const AutomationPatchSchema: z.ZodEffects<z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     title?: string | undefined;
-    enabled?: boolean | undefined;
     cron?: string | undefined;
     timezone?: string | undefined;
+    enabled?: boolean | undefined;
     model?: string | undefined;
 }, {
     title?: string | undefined;
-    enabled?: boolean | undefined;
     cron?: string | undefined;
     timezone?: string | undefined;
+    enabled?: boolean | undefined;
     model?: string | undefined;
 }>, {
     title?: string | undefined;
-    enabled?: boolean | undefined;
     cron?: string | undefined;
     timezone?: string | undefined;
+    enabled?: boolean | undefined;
     model?: string | undefined;
 }, {
     title?: string | undefined;
+    cron?: string | undefined;
+    timezone?: string | undefined;
+    enabled?: boolean | undefined;
+    model?: string | undefined;
+}>, {
+    title?: string | undefined;
+    cron?: string | undefined;
+    timezone?: string | undefined;
     enabled?: boolean | undefined;
+    model?: string | undefined;
+}, {
+    title?: string | undefined;
     cron?: string | undefined;
     timezone?: string | undefined;
+    enabled?: boolean | undefined;
     model?: string | undefined;
 }>;
 declare const PromptUpdateSchema: z.ZodObject<{
@@ -73,56 +107,31 @@ declare const PromptUpdateSchema: z.ZodObject<{
 }, {
     prompt: string;
 }>;
-declare const AutomationRunCreateSchema: z.ZodObject<{
+declare const AutomationRunBeginSchema: z.ZodObject<{
     automationId: z.ZodString;
-    sessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    status: z.ZodOptional<z.ZodEnum<["queued", "running", "succeeded", "failed", "cancelled"]>>;
     trigger: z.ZodEnum<["manual", "scheduled"]>;
     scheduledFor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    completedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    durationMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    totalTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     promptSnapshot: z.ZodString;
     modelSnapshot: z.ZodString;
-    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     automationId: string;
     trigger: "manual" | "scheduled";
     promptSnapshot: string;
     modelSnapshot: string;
-    error?: string | null | undefined;
-    status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
-    sessionId?: string | null | undefined;
     scheduledFor?: string | null | undefined;
-    startedAt?: string | null | undefined;
-    completedAt?: string | null | undefined;
-    durationMs?: number | null | undefined;
-    inputTokens?: number | null | undefined;
-    outputTokens?: number | null | undefined;
-    totalTokens?: number | null | undefined;
+    createdAt?: string | undefined;
 }, {
     automationId: string;
     trigger: "manual" | "scheduled";
     promptSnapshot: string;
     modelSnapshot: string;
-    error?: string | null | undefined;
-    status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
-    sessionId?: string | null | undefined;
     scheduledFor?: string | null | undefined;
-    startedAt?: string | null | undefined;
-    completedAt?: string | null | undefined;
-    durationMs?: number | null | undefined;
-    inputTokens?: number | null | undefined;
-    outputTokens?: number | null | undefined;
-    totalTokens?: number | null | undefined;
+    createdAt?: string | undefined;
 }>;
-declare const AutomationRunPatchSchema: z.ZodEffects<z.ZodObject<{
+declare const AutomationRunLifecyclePatchSchema: z.ZodEffects<z.ZodObject<{
     sessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     status: z.ZodOptional<z.ZodEnum<["queued", "running", "succeeded", "failed", "cancelled"]>>;
-    scheduledFor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     completedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     durationMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
@@ -134,7 +143,6 @@ declare const AutomationRunPatchSchema: z.ZodEffects<z.ZodObject<{
     error?: string | null | undefined;
     status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
     sessionId?: string | null | undefined;
-    scheduledFor?: string | null | undefined;
     startedAt?: string | null | undefined;
     completedAt?: string | null | undefined;
     durationMs?: number | null | undefined;
@@ -145,7 +153,6 @@ declare const AutomationRunPatchSchema: z.ZodEffects<z.ZodObject<{
     error?: string | null | undefined;
     status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
     sessionId?: string | null | undefined;
-    scheduledFor?: string | null | undefined;
     startedAt?: string | null | undefined;
     completedAt?: string | null | undefined;
     durationMs?: number | null | undefined;
@@ -156,7 +163,6 @@ declare const AutomationRunPatchSchema: z.ZodEffects<z.ZodObject<{
     error?: string | null | undefined;
     status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
     sessionId?: string | null | undefined;
-    scheduledFor?: string | null | undefined;
     startedAt?: string | null | undefined;
     completedAt?: string | null | undefined;
     durationMs?: number | null | undefined;
@@ -167,7 +173,6 @@ declare const AutomationRunPatchSchema: z.ZodEffects<z.ZodObject<{
     error?: string | null | undefined;
     status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
     sessionId?: string | null | undefined;
-    scheduledFor?: string | null | undefined;
     startedAt?: string | null | undefined;
     completedAt?: string | null | undefined;
     durationMs?: number | null | undefined;
@@ -184,8 +189,8 @@ declare const IdParamsSchema: z.ZodObject<{
 }>;
 type AutomationCreateInput = z.infer<typeof AutomationCreateSchema>;
 type AutomationPatchInput = z.infer<typeof AutomationPatchSchema>;
-type AutomationRunCreateInput = z.infer<typeof AutomationRunCreateSchema>;
-type AutomationRunPatchInput = z.infer<typeof AutomationRunPatchSchema>;
+type AutomationRunBeginInput = z.infer<typeof AutomationRunBeginSchema>;
+type AutomationRunLifecyclePatchInput = z.infer<typeof AutomationRunLifecyclePatchSchema>;
 
 type AutomationRunStatus = "queued" | "running" | "succeeded" | "failed" | "cancelled";
 type AutomationRunTrigger = "manual" | "scheduled";
@@ -234,26 +239,17 @@ interface AutomationRun {
     createdAt: string;
     updatedAt: string;
 }
-interface AutomationRunCreate {
+interface AutomationRunBegin {
     automationId: string;
-    sessionId?: string | null;
-    status?: AutomationRunStatus;
     trigger: AutomationRunTrigger;
     scheduledFor?: string | null;
-    startedAt?: string | null;
-    completedAt?: string | null;
-    durationMs?: number | null;
-    inputTokens?: number | null;
-    outputTokens?: number | null;
-    totalTokens?: number | null;
     promptSnapshot: string;
     modelSnapshot: string;
-    error?: string | null;
+    createdAt?: string;
 }
-interface AutomationRunPatch {
+interface AutomationRunLifecyclePatch {
     sessionId?: string | null;
     status?: AutomationRunStatus;
-    scheduledFor?: string | null;
     startedAt?: string | null;
     completedAt?: string | null;
     durationMs?: number | null;
@@ -263,4 +259,44 @@ interface AutomationRunPatch {
     error?: string | null;
 }
 
-export { type Automation, type AutomationCreate, type AutomationCreateInput, AutomationCreateSchema, type AutomationPatch, type AutomationPatchInput, AutomationPatchSchema, type AutomationRun, type AutomationRunCreate, type AutomationRunCreateInput, AutomationRunCreateSchema, type AutomationRunPatch, type AutomationRunPatchInput, AutomationRunPatchSchema, type AutomationRunStatus, AutomationRunStatusSchema, type AutomationRunTrigger, AutomationRunTriggerSchema, BORING_AUTOMATION_ERROR_CODES, BORING_AUTOMATION_PLUGIN_ID, BORING_AUTOMATION_PLUGIN_LABEL, BORING_AUTOMATION_ROUTE_PREFIX, type BoringAutomationErrorCode, IdParamsSchema, PromptUpdateSchema };
+declare const AUTOMATION_SCHEDULE_ERRORS: {
+    readonly INVALID_CRON: "Invalid cron schedule. Use exactly five fields, for example 0 9 * * *.";
+    readonly INVALID_TIMEZONE: "Invalid timezone. Use a valid IANA timezone, for example UTC or America/New_York.";
+};
+type AutomationScheduleSkipReason = "disabled" | "invalid-cron" | "invalid-timezone" | "not-current-minute" | "duplicate-scheduled-run" | "active-run";
+type AutomationScheduleDueReason = "current-minute-matched";
+interface AutomationScheduleValidationResult {
+    ok: boolean;
+    errors: Partial<Record<"cron" | "timezone", string>>;
+}
+interface AutomationScheduleDueDecision {
+    kind: "due";
+    automation: Automation;
+    automationId: string;
+    scheduledFor: string;
+    reason: AutomationScheduleDueReason;
+}
+interface AutomationScheduleSkipDecision {
+    kind: "skip";
+    automation: Automation;
+    automationId: string;
+    scheduledFor: string | null;
+    reason: AutomationScheduleSkipReason;
+    message: string;
+}
+type AutomationScheduleDecision = AutomationScheduleDueDecision | AutomationScheduleSkipDecision;
+interface EvaluateAutomationScheduleInput {
+    automations: readonly Automation[];
+    runs: readonly AutomationRun[];
+    now: Date;
+}
+interface EvaluateAutomationScheduleResult {
+    decisions: AutomationScheduleDecision[];
+    due: AutomationScheduleDueDecision[];
+}
+declare function validateAutomationSchedule(cron: string, timezone: string): AutomationScheduleValidationResult;
+declare function isValidFiveFieldCron(cron: string): boolean;
+declare function isValidIanaTimeZone(timezone: string): boolean;
+declare function evaluateAutomationSchedule(input: EvaluateAutomationScheduleInput): EvaluateAutomationScheduleResult;
+
+export { AUTOMATION_SCHEDULE_ERRORS, type Automation, type AutomationCreate, type AutomationCreateInput, AutomationCreateSchema, type AutomationPatch, type AutomationPatchInput, AutomationPatchSchema, type AutomationRun, type AutomationRunBegin, type AutomationRunBeginInput, AutomationRunBeginSchema, type AutomationRunLifecyclePatch, type AutomationRunLifecyclePatchInput, AutomationRunLifecyclePatchSchema, type AutomationRunStatus, AutomationRunStatusSchema, type AutomationRunTrigger, AutomationRunTriggerSchema, type AutomationScheduleDecision, type AutomationScheduleDueDecision, type AutomationScheduleDueReason, type AutomationScheduleSkipDecision, type AutomationScheduleSkipReason, type AutomationScheduleValidationResult, BORING_AUTOMATION_ERROR_CODES, BORING_AUTOMATION_PLUGIN_ID, BORING_AUTOMATION_PLUGIN_LABEL, BORING_AUTOMATION_ROUTE_PREFIX, type BoringAutomationErrorCode, type EvaluateAutomationScheduleInput, type EvaluateAutomationScheduleResult, IdParamsSchema, PromptUpdateSchema, evaluateAutomationSchedule, isValidFiveFieldCron, isValidIanaTimeZone, validateAutomationSchedule };

package/dist/shared/index.js

@@ -6,12 +6,110 @@ var BORING_AUTOMATION_ROUTE_PREFIX = "/api/v1/boring-automation";
 // src/shared/error-codes.ts
 var BORING_AUTOMATION_ERROR_CODES = {
   INVALID_BODY: "BORING_AUTOMATION_INVALID_BODY",
+  INVALID_CRON: "BORING_AUTOMATION_INVALID_CRON",
+  INVALID_TIMEZONE: "BORING_AUTOMATION_INVALID_TIMEZONE",
+  INVALID_MODEL: "BORING_AUTOMATION_INVALID_MODEL",
   AUTOMATION_NOT_FOUND: "BORING_AUTOMATION_NOT_FOUND",
-  RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND"
+  RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND",
+  RUN_ALREADY_ACTIVE: "BORING_AUTOMATION_RUN_ALREADY_ACTIVE",
+  RUN_ALREADY_RECORDED: "BORING_AUTOMATION_RUN_ALREADY_RECORDED",
+  RUN_EXECUTOR_UNAVAILABLE: "BORING_AUTOMATION_RUN_EXECUTOR_UNAVAILABLE",
+  TRIGGER_FORBIDDEN: "BORING_AUTOMATION_TRIGGER_FORBIDDEN",
+  RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED"
 };
 
 // src/shared/schema.ts
 import { z } from "zod";
+
+// src/shared/schedule.ts
+import { Cron } from "croner";
+var AUTOMATION_SCHEDULE_ERRORS = {
+  INVALID_CRON: "Invalid cron schedule. Use exactly five fields, for example 0 9 * * *.",
+  INVALID_TIMEZONE: "Invalid timezone. Use a valid IANA timezone, for example UTC or America/New_York."
+};
+function validateAutomationSchedule(cron, timezone) {
+  const errors = {};
+  if (!isValidFiveFieldCron(cron)) errors.cron = AUTOMATION_SCHEDULE_ERRORS.INVALID_CRON;
+  if (!isValidIanaTimeZone(timezone)) errors.timezone = AUTOMATION_SCHEDULE_ERRORS.INVALID_TIMEZONE;
+  return { ok: Object.keys(errors).length === 0, errors };
+}
+function isValidFiveFieldCron(cron) {
+  const normalized = normalizeSpace(cron);
+  if (!normalized || normalized.split(" ").length !== 5) return false;
+  try {
+    new Cron(normalized);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidIanaTimeZone(timezone) {
+  const normalized = timezone.trim();
+  if (!normalized) return false;
+  try {
+    const resolved = new Intl.DateTimeFormat("en-US", { timeZone: normalized }).resolvedOptions().timeZone;
+    return resolved === "UTC" || resolved.includes("/");
+  } catch {
+    return false;
+  }
+}
+function evaluateAutomationSchedule(input) {
+  const now = new Date(input.now);
+  const scheduledFor = floorToMinute(now).toISOString();
+  const runs = [...input.runs];
+  const decisions = input.automations.map((automation) => {
+    const validation = validateAutomationSchedule(automation.cron, automation.timezone);
+    if (validation.errors.cron) return skip(automation, null, "invalid-cron", validation.errors.cron);
+    if (validation.errors.timezone) return skip(automation, null, "invalid-timezone", validation.errors.timezone);
+    if (!automation.enabled) return skip(automation, null, "disabled", "Automation is disabled.");
+    const cron = new Cron(normalizeSpace(automation.cron), { timezone: automation.timezone.trim() });
+    if (!cron.match(new Date(scheduledFor))) {
+      return skip(automation, null, "not-current-minute", "Automation is not scheduled for the current minute.");
+    }
+    if (hasDuplicateScheduledRun(runs, automation.id, scheduledFor)) {
+      return skip(automation, scheduledFor, "duplicate-scheduled-run", "A run already exists for this scheduled minute.");
+    }
+    if (hasActiveRun(runs, automation.id)) {
+      return skip(automation, scheduledFor, "active-run", "Automation already has a queued or running run.");
+    }
+    return {
+      kind: "due",
+      automation,
+      automationId: automation.id,
+      scheduledFor,
+      reason: "current-minute-matched"
+    };
+  }).sort(compareScheduleDecisions);
+  return { decisions, due: decisions.filter((decision) => decision.kind === "due") };
+}
+function skip(automation, scheduledFor, reason, message) {
+  return { kind: "skip", automation, automationId: automation.id, scheduledFor, reason, message };
+}
+function hasDuplicateScheduledRun(runs, automationId, scheduledFor) {
+  return runs.some((run) => run.automationId === automationId && run.trigger === "scheduled" && run.scheduledFor === scheduledFor);
+}
+function hasActiveRun(runs, automationId) {
+  return runs.some((run) => run.automationId === automationId && (run.status === "queued" || run.status === "running"));
+}
+function floorToMinute(date) {
+  const next = new Date(date);
+  next.setUTCSeconds(0, 0);
+  return next;
+}
+function normalizeSpace(value) {
+  return value.trim().replace(/\s+/g, " ");
+}
+function compareScheduleDecisions(a, b) {
+  return compareNullableString(a.scheduledFor, b.scheduledFor) || a.automationId.localeCompare(b.automationId);
+}
+function compareNullableString(a, b) {
+  if (a === b) return 0;
+  if (a === null) return 1;
+  if (b === null) return -1;
+  return a.localeCompare(b);
+}
+
+// src/shared/schema.ts
 var nonEmptyString = z.string().trim().min(1);
 var isoString = z.string().datetime({ offset: true });
 var nonNegativeInteger = z.number().int().nonnegative();
@@ -24,37 +122,32 @@ var AutomationCreateSchema = z.object({
   timezone: nonEmptyString,
   model: nonEmptyString,
   prompt: z.string().optional()
-}).strict();
+}).strict().superRefine((value, ctx) => {
+  addScheduleIssues(ctx, value);
+});
 var AutomationPatchSchema = z.object({
   title: nonEmptyString.optional(),
   enabled: z.boolean().optional(),
   cron: nonEmptyString.optional(),
   timezone: nonEmptyString.optional(),
   model: nonEmptyString.optional()
-}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
+}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided").superRefine((value, ctx) => {
+  addScheduleIssues(ctx, value);
+});
 var PromptUpdateSchema = z.object({
   prompt: z.string()
 }).strict();
-var AutomationRunCreateSchema = z.object({
+var AutomationRunBeginSchema = z.object({
   automationId: nonEmptyString,
-  sessionId: nonEmptyString.nullable().optional(),
-  status: AutomationRunStatusSchema.optional(),
   trigger: AutomationRunTriggerSchema,
   scheduledFor: isoString.nullable().optional(),
-  startedAt: isoString.nullable().optional(),
-  completedAt: isoString.nullable().optional(),
-  durationMs: nonNegativeInteger.nullable().optional(),
-  inputTokens: nonNegativeInteger.nullable().optional(),
-  outputTokens: nonNegativeInteger.nullable().optional(),
-  totalTokens: nonNegativeInteger.nullable().optional(),
   promptSnapshot: z.string(),
   modelSnapshot: nonEmptyString,
-  error: z.string().nullable().optional()
+  createdAt: isoString.optional()
 }).strict();
-var AutomationRunPatchSchema = z.object({
+var AutomationRunLifecyclePatchSchema = z.object({
   sessionId: nonEmptyString.nullable().optional(),
   status: AutomationRunStatusSchema.optional(),
-  scheduledFor: isoString.nullable().optional(),
   startedAt: isoString.nullable().optional(),
   completedAt: isoString.nullable().optional(),
   durationMs: nonNegativeInteger.nullable().optional(),
@@ -64,11 +157,20 @@ var AutomationRunPatchSchema = z.object({
   error: z.string().nullable().optional()
 }).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
 var IdParamsSchema = z.object({ id: nonEmptyString });
+function addScheduleIssues(ctx, value) {
+  if (value.cron !== void 0 && !isValidFiveFieldCron(value.cron)) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["cron"], message: AUTOMATION_SCHEDULE_ERRORS.INVALID_CRON });
+  }
+  if (value.timezone !== void 0 && !isValidIanaTimeZone(value.timezone)) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["timezone"], message: AUTOMATION_SCHEDULE_ERRORS.INVALID_TIMEZONE });
+  }
+}
 export {
+  AUTOMATION_SCHEDULE_ERRORS,
   AutomationCreateSchema,
   AutomationPatchSchema,
-  AutomationRunCreateSchema,
-  AutomationRunPatchSchema,
+  AutomationRunBeginSchema,
+  AutomationRunLifecyclePatchSchema,
   AutomationRunStatusSchema,
   AutomationRunTriggerSchema,
   BORING_AUTOMATION_ERROR_CODES,
@@ -76,5 +178,9 @@ export {
   BORING_AUTOMATION_PLUGIN_LABEL,
   BORING_AUTOMATION_ROUTE_PREFIX,
   IdParamsSchema,
-  PromptUpdateSchema
+  PromptUpdateSchema,
+  evaluateAutomationSchedule,
+  isValidFiveFieldCron,
+  isValidIanaTimeZone,
+  validateAutomationSchedule
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-automation",
-  "version": "0.1.71",
+  "version": "0.1.80",
   "type": "module",
   "private": false,
   "license": "MIT",
@@ -39,26 +39,20 @@
     "./package.json": "./package.json"
   },
   "sideEffects": false,
-  "scripts": {
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run --no-file-parallelism",
-    "lint": "pnpm run typecheck",
-    "clean": "rm -rf dist .tsbuildinfo"
-  },
   "peerDependencies": {
-    "@hachej/boring-workspace": "workspace:*",
     "fastify": "^5.9.0",
     "react": "^18.0.0 || ^19.0.0",
-    "react-dom": "^18.0.0 || ^19.0.0"
+    "react-dom": "^18.0.0 || ^19.0.0",
+    "@hachej/boring-workspace": "0.1.80"
   },
   "dependencies": {
-    "@hachej/boring-ui-kit": "workspace:*",
+    "croner": "^10.0.1",
     "lucide-react": "^1.21.0",
-    "zod": "^3.23.0"
+    "postgres": "^3.4.7",
+    "zod": "^3.23.0",
+    "@hachej/boring-ui-kit": "0.1.80"
   },
   "devDependencies": {
-    "@hachej/boring-workspace": "workspace:*",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.0",
     "@types/node": "^22.20.0",
@@ -71,11 +65,19 @@
     "react-dom": "^19.2.7",
     "tsup": "^8.4.0",
     "typescript": "~6.0.3",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.9",
+    "@hachej/boring-workspace": "0.1.80"
   },
   "peerDependenciesMeta": {
     "fastify": {
       "optional": true
     }
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --no-file-parallelism",
+    "lint": "pnpm run typecheck",
+    "clean": "rm -rf dist .tsbuildinfo"
   }
-}
+}