clay-server 4.1.0-beta.5 → 4.1.0-beta.7

package/lib/public/modules/scheduled-message-state.js

@@ -0,0 +1,46 @@
+import { store } from './store.js';
+
+function correlation(message) {
+  if (!message || !message.jobId || !message.revision) return null;
+  return { jobId: message.jobId, revision: message.revision };
+}
+
+function sameCorrelation(left, right) {
+  return !!left && !!right && left.jobId === right.jobId && left.revision === right.revision;
+}
+
+export function applyScheduledMessageQueued(message, actions) {
+  store.set({ scheduledMessageCorrelation: correlation(message) });
+  actions.add(message.text, message.resetsAt, message);
+  actions.setDisabled(true);
+}
+
+export function applyScheduledMessageTerminal(message, actions) {
+  var current = store.get('scheduledMessageCorrelation');
+  if (current && !sameCorrelation(current, correlation(message))) return false;
+  store.set({ scheduledMessageCorrelation: null });
+  actions.remove();
+  actions.setDisabled(false);
+  return true;
+}
+
+export function applyScheduledMessageState(message, actions) {
+  actions.remove();
+  actions.setDisabled(false);
+  var pending = message && message.scheduledMessage;
+  store.set({ scheduledMessageCorrelation: correlation(pending) });
+  if (!pending && message && message.interrupted && actions.interrupted) actions.interrupted(message.interrupted);
+  if (!pending) return false;
+  actions.add(pending.text, pending.resetsAt, pending);
+  actions.setDisabled(true);
+  return true;
+}
+
+export function scheduledMessageControl(type, correlation) {
+  var message = { type: type };
+  if (correlation && correlation.jobId && correlation.revision) {
+    message.jobId = correlation.jobId;
+    message.revision = correlation.revision;
+  }
+  return message;
+}

package/lib/public/modules/scheduled-task-edit-state.js

@@ -0,0 +1,7 @@
+export function reconcileScheduledTaskEdit(editState, serverRecord) {
+  if (!editState || !serverRecord || editState.id !== serverRecord.id) return editState || null;
+  if (Number(editState.revision) === Number(serverRecord.revision)) return editState;
+  return Object.assign({}, editState, {
+    conflict: "This task changed while you were editing. Your text is preserved; reopen or reconcile it before saving.",
+  });
+}

package/lib/public/modules/scheduled-task-engine.js

@@ -0,0 +1,48 @@
+import { effortLevelsFor, effortDisplayName } from './app-panels.js';
+
+function modelValue(model) { return typeof model === "string" ? model : model && (model.value || model.id) || ""; }
+function modelLabel(model) { return typeof model === "string" ? model : model && (model.displayName || model.name || model.value || model.id) || ""; }
+
+function fillRuntimeRole(root, state, role, runtime) {
+  var vendorSelect = root.querySelector('[data-runtime="' + role + '-vendor"]');
+  var modelSelect = root.querySelector('[data-runtime="' + role + '-model"]');
+  var effortSelect = root.querySelector('[data-runtime="' + role + '-effort"]');
+  if (!vendorSelect || !modelSelect || !effortSelect) return null;
+  var installed = state && (state.runtimeInstalledVendors || state.installedVendors) || [];
+  runtime = runtime || {};
+  var fallbackIndex = role === "worker" && installed.length > 1 ? 1 : 0;
+  var vendor = runtime.vendor || installed[fallbackIndex] || "";
+  vendorSelect.innerHTML = '<option value="">Choose vendor</option>';
+  for (var i = 0; i < installed.length; i++) {
+    var vendorOption = document.createElement("option"); vendorOption.value = installed[i]; vendorOption.textContent = installed[i].charAt(0).toUpperCase() + installed[i].slice(1); vendorSelect.appendChild(vendorOption);
+  }
+  if (vendor && installed.indexOf(vendor) === -1) { var unavailableVendor = document.createElement("option"); unavailableVendor.value = vendor; unavailableVendor.textContent = "Unavailable: " + vendor; unavailableVendor.disabled = true; vendorSelect.appendChild(unavailableVendor); }
+  vendorSelect.value = vendor;
+  var models = state && state.modelsByVendor && state.modelsByVendor[vendor] || [];
+  var ready = !!(state && state.catalogReadyByVendor && state.catalogReadyByVendor[vendor]);
+  modelSelect.innerHTML = '<option value="">Choose model</option>';
+  var selectedModel = runtime.vendor === vendor ? runtime.model || "" : ""; var foundModel = !selectedModel;
+  for (var mi = 0; mi < models.length; mi++) { var option = document.createElement("option"); option.value = modelValue(models[mi]); option.textContent = modelLabel(models[mi]); modelSelect.appendChild(option); if (option.value === selectedModel) foundModel = true; }
+  if (!foundModel) { var unavailableModel = document.createElement("option"); unavailableModel.value = selectedModel; unavailableModel.textContent = "Unavailable: " + selectedModel; unavailableModel.disabled = true; modelSelect.appendChild(unavailableModel); }
+  modelSelect.value = selectedModel;
+  var levels = effortLevelsFor(vendor, models, modelSelect.value);
+  effortSelect.innerHTML = '<option value="">Choose effort</option>';
+  for (var ei = 0; ei < levels.length; ei++) { var effortOption = document.createElement("option"); effortOption.value = levels[ei]; effortOption.textContent = effortDisplayName(levels[ei]); effortSelect.appendChild(effortOption); }
+  var selectedEffort = runtime.vendor === vendor ? runtime.effort || "" : "";
+  if (selectedEffort && levels.indexOf(selectedEffort) === -1) { var unavailableEffort = document.createElement("option"); unavailableEffort.value = selectedEffort; unavailableEffort.textContent = "Unavailable: " + selectedEffort; unavailableEffort.disabled = true; effortSelect.appendChild(unavailableEffort); }
+  effortSelect.value = selectedEffort;
+  modelSelect.disabled = !ready; effortSelect.disabled = !ready;
+  return { vendor: vendor, model: modelSelect.value, effort: effortSelect.value };
+}
+
+export function renderExecutionRuntime(root, state, execution) {
+  execution = execution || {};
+  return { driver: fillRuntimeRole(root, state, "driver", execution.driver), worker: fillRuntimeRole(root, state, "worker", execution.worker) };
+}
+
+export function readExecutionRuntime(root) {
+  function role(name) {
+    return { vendor: root.querySelector('[data-runtime="' + name + '-vendor"]').value, model: root.querySelector('[data-runtime="' + name + '-model"]').value || null, effort: root.querySelector('[data-runtime="' + name + '-effort"]').value || null };
+  }
+  return { driver: role("driver"), worker: role("worker") };
+}

package/lib/public/modules/scheduled-task-form.js

@@ -0,0 +1,122 @@
+import { isStrictCron, humanRecurrence } from './scheduled-task-recurrence.js';
+import { humanScheduleRule, scheduleRuleState, serializeScheduleRule } from './scheduled-task-schedule-rule.js';
+import { readExecutionRuntime, renderExecutionRuntime } from './scheduled-task-engine.js';
+
+var DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+
+function pad(value) { return String(value).padStart(2, "0"); }
+
+function defaultOnce() {
+  var date = new Date();
+  date.setMinutes(0, 0, 0); date.setHours(date.getHours() + 1);
+  return { date: date.getFullYear() + "-" + pad(date.getMonth() + 1) + "-" + pad(date.getDate()), time: pad(date.getHours()) + ":00" };
+}
+
+export function editorFields(data, mode) {
+  var saveLabel = mode === "edit" ? "Save changes" : "Create task";
+  var days = DAY_NAMES.map(function (day, index) { return '<label><input data-field="weekday" type="checkbox" value="' + index + '" aria-label="' + day + '"><span title="' + day + '">' + day.slice(0, 1) + '</span></label>'; }).join("");
+  return '<label>Name<input data-field="name" maxlength="120" autocomplete="off"></label>' +
+    '<label>Instructions<textarea data-field="instructions" maxlength="20000"></textarea></label>' +
+    '<fieldset class="scheduled-task-schedule-card"><legend>Schedule</legend>' +
+      '<div class="scheduled-task-date-time"><label>Date<input data-field="date" type="date"></label><label>Time<input data-field="time" type="time"></label></div>' +
+      '<details class="scheduled-task-accordion" data-accordion="repeat"><summary><span><strong>Repeat</strong><small data-summary="repeat">Does not repeat</small></span></summary><div class="scheduled-task-accordion-body">' +
+        '<label class="scheduled-task-checkbox"><input data-field="repeatEnabled" type="checkbox"><span>Repeat this task</span></label>' +
+        '<div class="scheduled-task-every"><span>Every</span><input data-field="repeatEvery" aria-label="Repeat every" type="number" min="1" max="99"><select data-field="repeatUnit" aria-label="Repeat unit"><option value="day">day</option><option value="week">week</option><option value="month">month</option><option value="year">year</option></select></div>' +
+        '<div data-repeat="week"><span class="scheduled-task-control-label">On</span><div class="scheduled-task-weekdays">' + days + '</div></div>' +
+        '<div class="scheduled-task-ending"><span>Ends</span><select data-field="repeatEndType" aria-label="Repeat ends"><option value="never">Never</option><option value="until">Until date</option><option value="after">After occurrences</option></select><input data-field="repeatEndDate" aria-label="Repeat until date" type="date"><span data-end-label="repeat-count"><input data-field="repeatEndCount" aria-label="Repeat occurrence count" type="number" min="1" max="999"> occurrences</span></div>' +
+      '</div></details>' +
+      '<details class="scheduled-task-accordion" data-accordion="interval"><summary><span><strong>Interval</strong><small data-summary="interval">Run once at selected time</small></span></summary><div class="scheduled-task-accordion-body">' +
+        '<label class="scheduled-task-checkbox"><input data-field="intervalEnabled" type="checkbox"><span>Run repeatedly within each active day</span></label>' +
+        '<div class="scheduled-task-every"><span>Every</span><input data-field="intervalEvery" aria-label="Interval every" type="number" min="1" max="999"><select data-field="intervalUnit" aria-label="Interval unit"><option value="minute">minutes</option><option value="hour">hours</option></select></div>' +
+        '<div class="scheduled-task-ending"><span>Ends</span><select data-field="intervalEndType" aria-label="Interval ends"><option value="allday">All day</option><option value="after">Stop after runs</option><option value="until">Stop at time</option></select><span data-end-label="interval-count"><input data-field="intervalEndCount" aria-label="Interval run count" type="number" min="1" max="999"> runs</span><input data-field="intervalEndTime" aria-label="Interval stop time" type="time"></div>' +
+      '</div></details>' +
+      '<details class="scheduled-task-advanced" data-accordion="custom"><summary>Advanced custom schedule</summary><div class="scheduled-task-advanced-body"><label class="scheduled-task-checkbox"><input data-field="advanced" type="checkbox"><span>Use a five-field cron expression</span></label><label data-advanced-cron>Custom cron<input data-field="customCron" class="scheduled-task-cron" autocomplete="off" spellcheck="false"><small>Existing custom expressions remain unchanged unless edited here.</small></label></div></details>' +
+      '<div class="scheduled-task-schedule-summary"><strong data-schedule-summary></strong><span>Times use the server local timezone: <span data-timezone></span>.</span></div>' +
+    '</fieldset>' +
+    '<fieldset class="scheduled-task-runtime"><legend>Execution pair</legend><div class="scheduled-task-runtime-row"><strong>Driver</strong><select data-runtime="driver-vendor" aria-label="Driver vendor"></select><select data-runtime="driver-model" aria-label="Driver model"></select><select data-runtime="driver-effort" aria-label="Driver effort"></select></div><div class="scheduled-task-runtime-row"><strong>Split Worker</strong><select data-runtime="worker-vendor" aria-label="Split Worker vendor"></select><select data-runtime="worker-model" aria-label="Split Worker model"></select><select data-runtime="worker-effort" aria-label="Split Worker effort"></select></div><label class="scheduled-task-checkbox"><input data-field="skipIfRunning" type="checkbox"><span>Skip a scheduled start while this task already has an active run</span><small>When off, overlapping starts are combined into one queued run.</small></label></fieldset>' +
+    '<p class="scheduled-task-form-error" role="alert"></p><div class="scheduled-task-form-actions"><button type="button" data-action="' + (mode === "edit" ? "edit-cancel" : "draft-cancel") + '">Cancel</button><button type="button" class="primary" data-action="' + (mode === "edit" ? "edit-save" : "draft-save") + '">' + saveLabel + '</button></div>';
+}
+
+function readSchedule(root) {
+  return {
+    originalCron: root.dataset.originalCron || "", scheduleDirty: root.dataset.scheduleDirty === "true",
+    advanced: root.querySelector('[data-field="advanced"]').checked, customCron: root.querySelector('[data-field="customCron"]').value.trim(), date: root.querySelector('[data-field="date"]').value, time: root.querySelector('[data-field="time"]').value,
+    repeatEnabled: root.querySelector('[data-field="repeatEnabled"]').checked, repeatEvery: Number(root.querySelector('[data-field="repeatEvery"]').value), repeatUnit: root.querySelector('[data-field="repeatUnit"]').value,
+    weekdays: Array.from(root.querySelectorAll('[data-field="weekday"]:checked')).map(function (input) { return Number(input.value); }), repeatEndType: root.querySelector('[data-field="repeatEndType"]').value, repeatEndDate: root.querySelector('[data-field="repeatEndDate"]').value, repeatEndCount: Number(root.querySelector('[data-field="repeatEndCount"]').value),
+    intervalEnabled: root.querySelector('[data-field="intervalEnabled"]').checked, intervalEvery: Number(root.querySelector('[data-field="intervalEvery"]').value), intervalUnit: root.querySelector('[data-field="intervalUnit"]').value, intervalEndType: root.querySelector('[data-field="intervalEndType"]').value, intervalEndCount: Number(root.querySelector('[data-field="intervalEndCount"]').value), intervalEndTime: root.querySelector('[data-field="intervalEndTime"]').value,
+  };
+}
+
+function setValue(root, field, value) { root.querySelector('[data-field="' + field + '"]').value = value; }
+
+function normalizeEditorRoot(root) {
+  if (!root || !root.matches) return root;
+  if (root.matches(".scheduled-task-draft-form, .scheduled-task-edit-form")) return root;
+  return root.querySelector(".scheduled-task-draft-form, .scheduled-task-edit-form") || root;
+}
+
+function updateVisibility(root) {
+  var state = readSchedule(root); var serialized = serializeScheduleRule(state);
+  root.querySelector('[data-repeat="week"]').classList.toggle("hidden", !state.repeatEnabled || state.repeatUnit !== "week");
+  root.querySelector('[data-field="repeatEndDate"]').classList.toggle("hidden", !state.repeatEnabled || state.repeatEndType !== "until");
+  root.querySelector('[data-end-label="repeat-count"]').classList.toggle("hidden", !state.repeatEnabled || state.repeatEndType !== "after");
+  root.querySelector('[data-end-label="interval-count"]').classList.toggle("hidden", !state.intervalEnabled || state.intervalEndType !== "after");
+  root.querySelector('[data-field="intervalEndTime"]').classList.toggle("hidden", !state.intervalEnabled || state.intervalEndType !== "until");
+  root.querySelector('[data-advanced-cron]').classList.toggle("hidden", !state.advanced);
+  root.querySelector('[data-summary="repeat"]').textContent = state.advanced ? "Advanced custom expression" : (state.repeatEnabled ? humanScheduleRule(serialized.scheduleRule).split(" · every ")[0] : "Does not repeat");
+  root.querySelector('[data-summary="interval"]').textContent = state.intervalEnabled ? "Every " + state.intervalEvery + " " + state.intervalUnit + (state.intervalEvery === 1 ? "" : "s") : "Run once at selected time";
+  root.querySelector('[data-schedule-summary]').textContent = state.advanced ? (isStrictCron(state.customCron) ? humanRecurrence(state.customCron) : "Complete the advanced custom expression") : humanScheduleRule(serialized.scheduleRule);
+}
+
+export function fillEditor(root, data, timeZone, runtimeState) {
+  root = normalizeEditorRoot(root);
+  var defaults = defaultOnce(); var state = data._scheduleState || scheduleRuleState(data, defaults);
+  root.dataset.originalCron = state.originalCron || ""; root.dataset.scheduleDirty = state.scheduleDirty ? "true" : "false";
+  setValue(root, "name", data.name || ""); setValue(root, "instructions", data.instructions || data.task || data.prompt || "");
+  var fields = ["customCron", "date", "time", "repeatEvery", "repeatUnit", "repeatEndType", "repeatEndDate", "repeatEndCount", "intervalEvery", "intervalUnit", "intervalEndType", "intervalEndCount", "intervalEndTime"];
+  for (var i = 0; i < fields.length; i++) setValue(root, fields[i], state[fields[i]]);
+  root.querySelector('[data-field="advanced"]').checked = state.advanced; root.querySelector('[data-field="repeatEnabled"]').checked = state.repeatEnabled; root.querySelector('[data-field="intervalEnabled"]').checked = state.intervalEnabled;
+  var weekdayInputs = root.querySelectorAll('[data-field="weekday"]'); for (var wi = 0; wi < weekdayInputs.length; wi++) weekdayInputs[wi].checked = state.weekdays.indexOf(Number(weekdayInputs[wi].value)) !== -1;
+  renderExecutionRuntime(root, runtimeState || {}, data.execution); root.querySelector('[data-field="skipIfRunning"]').checked = data.skipIfRunning !== false;
+  var instructions = root.querySelector('[data-field="instructions"]'); if (data.linkedTaskId) { instructions.readOnly = true; instructions.setAttribute("aria-description", "Instructions are managed by the linked task."); }
+  root.querySelector('[data-timezone]').textContent = timeZone || "server local";
+  var accordions = root.querySelectorAll("details[data-accordion]");
+  for (var ai = 0; ai < accordions.length; ai++) accordions[ai].open = Array.isArray(data._openAccordions) ? data._openAccordions.indexOf(accordions[ai].dataset.accordion) !== -1 : (state.advanced && accordions[ai].dataset.accordion === "custom");
+  updateVisibility(root);
+}
+
+export function readEditor(root) {
+  var scheduleState = readSchedule(root);
+  var schedule = scheduleState.originalCron && !scheduleState.scheduleDirty ? { cron: scheduleState.originalCron, date: scheduleState.date, time: scheduleState.time, scheduleRule: null } : serializeScheduleRule(scheduleState);
+  var openAccordions = Array.from(root.querySelectorAll("details[data-accordion][open]")).map(function (details) { return details.dataset.accordion; });
+  return Object.assign({ name: root.querySelector('[data-field="name"]').value.trim(), instructions: root.querySelector('[data-field="instructions"]').value.trim(), execution: readExecutionRuntime(root), skipIfRunning: root.querySelector('[data-field="skipIfRunning"]').checked, _openAccordions: openAccordions, _scheduleState: scheduleState }, schedule);
+}
+
+export function serverEditorData(data) { var copy = Object.assign({}, data); delete copy._scheduleState; delete copy._advancedOpen; delete copy._openAccordions; return copy; }
+
+export function validateEditor(root, data) {
+  var error = ""; var rule = data.scheduleRule;
+  if (!data.name) error = "Enter a task name."; else if (!data.instructions) error = "Enter task instructions.";
+  else if (!rule && !isStrictCron(data.cron)) error = "Enter a valid five-field custom cron expression.";
+  else if (rule && (!/^\d{4}-\d{2}-\d{2}$/.test(data.date) || !/^([01]\d|2[0-3]):[0-5]\d$/.test(data.time))) error = "Choose a valid date and time.";
+  else if (rule && rule.recurrence && (!Number.isInteger(rule.recurrence.every) || rule.recurrence.every < 1 || rule.recurrence.every > 99)) error = "Repeat cadence must be between 1 and 99.";
+  else if (rule && rule.recurrence && rule.recurrence.unit === "week" && !rule.recurrence.weekdays.length) error = "Choose at least one weekday.";
+  else if (rule && rule.recurrenceEnd && rule.recurrenceEnd.type === "after" && (!Number.isInteger(rule.recurrenceEnd.count) || rule.recurrenceEnd.count < 1 || rule.recurrenceEnd.count > 999)) error = "Occurrence count must be between 1 and 999.";
+  else if (rule && rule.interval && (!Number.isInteger(rule.interval.every) || rule.interval.every < 1 || rule.interval.every > 999)) error = "Interval must be between 1 and 999.";
+  else if (rule && rule.interval && rule.interval.unit === "hour" && rule.interval.every > 23) error = "Hour intervals must be between 1 and 23.";
+  else if (rule && rule.interval && rule.interval.end && rule.interval.end.type === "after" && (!Number.isInteger(rule.interval.end.count) || rule.interval.end.count < 1 || rule.interval.end.count > 999)) error = "Run count must be between 1 and 999.";
+  else if (rule && rule.interval && rule.interval.end && rule.interval.end.type === "until" && rule.interval.end.time <= data.time) error = "Stop time must be after the selected time.";
+  else if (!data.execution || !data.execution.driver.vendor || !data.execution.driver.model || !data.execution.worker.vendor || !data.execution.worker.model) error = "Choose a model for both the Driver and Split Worker.";
+  else if ((root.querySelector('[data-runtime="driver-effort"]').options.length > 1 && !data.execution.driver.effort) || (root.querySelector('[data-runtime="worker-effort"]').options.length > 1 && !data.execution.worker.effort)) error = "Choose a reasoning effort for each runtime that supports it.";
+  root.querySelector(".scheduled-task-form-error").textContent = error; return !error;
+}
+
+export function handleEditorScheduleChange(target) {
+  var root = target && target.closest && (target.closest(".scheduled-task-draft-form") || target.closest(".scheduled-task-edit-form"));
+  if (!root || !target.dataset || !target.dataset.field) return false;
+  if (["date", "time", "repeatEnabled", "repeatEvery", "repeatUnit", "weekday", "repeatEndType", "repeatEndDate", "repeatEndCount", "intervalEnabled", "intervalEvery", "intervalUnit", "intervalEndType", "intervalEndCount", "intervalEndTime", "advanced", "customCron"].indexOf(target.dataset.field) !== -1) root.dataset.scheduleDirty = "true";
+  if (target.dataset.field === "date" && root.querySelector('[data-field="repeatEndDate"]').value === "") root.querySelector('[data-field="repeatEndDate"]').value = target.value;
+  updateVisibility(root); return true;
+}
+
+export { scheduleRuleState, serializeScheduleRule };

package/lib/public/modules/scheduled-task-recurrence.js

@@ -0,0 +1,46 @@
+export function isStrictCron(value) {
+  if (typeof value !== "string") return false;
+  var ranges = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6]];
+  var fields = value.trim().split(/\s+/);
+  if (fields.length !== 5) return false;
+  function validNumber(text, range) { return /^\d+$/.test(text) && Number(text) >= range[0] && Number(text) <= range[1]; }
+  function validPart(part, range) {
+    var step = part.split("/");
+    if (step.length > 2 || (step.length === 2 && (!/^\d+$/.test(step[1]) || Number(step[1]) < 1))) return false;
+    var base = step[0];
+    if (base === "*") return true;
+    var span = base.split("-");
+    if (span.length === 2) return validNumber(span[0], range) && validNumber(span[1], range) && Number(span[0]) <= Number(span[1]);
+    return span.length === 1 && validNumber(base, range);
+  }
+  for (var i = 0; i < fields.length; i++) {
+    var parts = fields[i].split(",");
+    for (var j = 0; j < parts.length; j++) if (!validPart(parts[j], ranges[i])) return false;
+  }
+  return true;
+}
+
+export function humanRecurrence(cron) {
+  if (!isStrictCron(cron)) return "Invalid schedule";
+  var fields = cron.trim().split(/\s+/);
+  var minute = fields[0];
+  var hour = fields[1];
+  var dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  var weekdayText = "";
+  if (fields[4] === "1-5") weekdayText = "Mon–Fri";
+  else if (fields[4] === "0,6" || fields[4] === "6,0") weekdayText = "weekends";
+  else if (/^[0-6](,[0-6])*$/.test(fields[4])) {
+    weekdayText = fields[4].split(",").map(function (day) { return dayNames[Number(day)]; }).join(", ");
+  } else if (/^[0-6]$/.test(fields[4])) weekdayText = dayNames[Number(fields[4])];
+  var weekday = weekdayText ? " · " + weekdayText : (fields[4] === "*" ? "" : " · " + fields[4]);
+  if (minute.indexOf("*/") === 0 && hour === "*" && fields[2] === "*" && fields[3] === "*") return "Every " + minute.slice(2) + " minutes" + weekday;
+  if (minute === "0" && hour.indexOf("*/") === 0 && fields[2] === "*" && fields[3] === "*") return "Every " + hour.slice(2) + " hours" + weekday;
+  if (/^\d+$/.test(minute) && /^\d+$/.test(hour) && fields[2] === "*" && fields[3] === "*" && fields[4] === "*") {
+    var h = Number(hour); var suffix = h >= 12 ? "pm" : "am"; var displayHour = h % 12 || 12;
+    return "Daily at " + displayHour + ":" + String(Number(minute)).padStart(2, "0") + suffix;
+  }
+  if (/^\d+$/.test(minute) && /^\d+$/.test(hour) && fields[2] === "*" && fields[3] === "*" && fields[4] === "1-5") return "Weekdays at " + String(Number(hour)).padStart(2, "0") + ":" + String(Number(minute)).padStart(2, "0");
+  if (/^\d+$/.test(minute) && /^\d+$/.test(hour) && fields[2] === "*" && fields[3] === "*" && fields[4] !== "*") return "Weekly on " + (weekdayText || fields[4]) + " at " + String(Number(hour)).padStart(2, "0") + ":" + String(Number(minute)).padStart(2, "0");
+  if (/^\d+$/.test(minute) && /^\d+$/.test(hour) && /^\d+$/.test(fields[2]) && fields[3] === "*" && fields[4] === "*") return "Monthly on day " + fields[2] + " at " + String(Number(hour)).padStart(2, "0") + ":" + String(Number(minute)).padStart(2, "0");
+  return "Cron · " + cron;
+}

package/lib/public/modules/scheduled-task-schedule-rule.js

@@ -0,0 +1,115 @@
+var DAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+
+function pad(value) { return String(value).padStart(2, "0"); }
+
+function detectedInterval(field, max) {
+  if (/^\*\/\d+$/.test(field)) {
+    var wildcardStep = Number(field.slice(2));
+    return wildcardStep > 0 && max % wildcardStep === 0 ? { every: wildcardStep, offset: 0 } : null;
+  }
+  if (!/^\d+(,\d+)+$/.test(field)) return null;
+  var values = field.split(",").map(Number);
+  if (values[0] < 0 || values[values.length - 1] >= max) return null;
+  var step = values[1] - values[0];
+  if (step < 1) return null;
+  for (var i = 1; i < values.length; i++) if (values[i] - values[i - 1] !== step) return null;
+  return values[values.length - 1] + step === max + values[0] ? { every: step, offset: values[0] } : null;
+}
+
+function parsedWeekdays(field) {
+  if (/^[0-6](,[0-6])*$/.test(field)) return field.split(",").map(Number);
+  var range = field.match(/^([0-6])-([0-6])$/);
+  if (!range || Number(range[1]) > Number(range[2])) return null;
+  var days = [];
+  for (var day = Number(range[1]); day <= Number(range[2]); day++) days.push(day);
+  return days;
+}
+
+function cronState(record, defaults) {
+  var fields = record.cron.trim().split(/\s+/);
+  if (fields.length !== 5) return null;
+  var minuteInterval = fields[1] === "*" && fields[2] === "*" && fields[3] === "*" ? detectedInterval(fields[0], 60) : null;
+  var hourInterval = /^\d+$/.test(fields[0]) && fields[2] === "*" && fields[3] === "*" ? detectedInterval(fields[1], 24) : null;
+  if (hourInterval && hourInterval.every > 23) hourInterval = null;
+  var minute = /^\d+$/.test(fields[0]) ? Number(fields[0]) : (minuteInterval ? minuteInterval.offset : 0);
+  var hour = /^\d+$/.test(fields[1]) ? Number(fields[1]) : (hourInterval ? hourInterval.offset : 0);
+  var weekdays = fields[4] === "*" ? null : parsedWeekdays(fields[4]);
+  if (fields[4] !== "*" && !weekdays) return null;
+  var recurrence = null;
+  if (fields[2] === "*" && fields[3] === "*" && fields[4] === "*") recurrence = { every: 1, unit: "day" };
+  else if (fields[2] === "*" && fields[3] === "*" && weekdays) recurrence = { every: 1, unit: "week", weekdays: weekdays };
+  else if (/^\d+$/.test(fields[2]) && fields[3] === "*" && fields[4] === "*") recurrence = { every: 1, unit: "month" };
+  else if (/^\d+$/.test(fields[2]) && /^\d+$/.test(fields[3]) && fields[4] === "*") recurrence = { every: 1, unit: "year" };
+  if ((minuteInterval || hourInterval) && record.recurrenceEnd && record.recurrenceEnd.type === "until" && record.recurrenceEnd.date === record.date) recurrence = null;
+  if ((!recurrence && !minuteInterval && !hourInterval) || (!minuteInterval && !hourInterval && (!/^\d+$/.test(fields[0]) || !/^\d+$/.test(fields[1])))) return null;
+  var date = record.date || defaults.date;
+  if (recurrence && recurrence.unit === "month") date = date.slice(0, 8) + pad(fields[2]);
+  if (recurrence && recurrence.unit === "year") date = date.slice(0, 5) + pad(fields[3]) + "-" + pad(fields[2]);
+  return { version: 1, timezone: "server-local", anchorDate: date, time: pad(hour) + ":" + pad(minute), recurrence: recurrence, recurrenceEnd: recurrence ? record.recurrenceEnd || null : null, interval: minuteInterval || hourInterval ? { every: (minuteInterval || hourInterval).every, unit: minuteInterval ? "minute" : "hour", end: record.intervalEnd || null } : null };
+}
+
+export function humanScheduleRule(rule) {
+  if (!rule || !rule.anchorDate || !rule.time) return "Incomplete schedule";
+  var repeat = rule.recurrence;
+  var text = "Does not repeat";
+  if (repeat) {
+    var unit = repeat.unit + (repeat.every === 1 ? "" : "s");
+    text = "Every " + (repeat.every === 1 ? "" : repeat.every + " ") + unit;
+    if (repeat.unit === "week" && repeat.weekdays && repeat.weekdays.length) text += " · " + repeat.weekdays.map(function (day) { return DAY_NAMES[day]; }).join(", ");
+  }
+  if (rule.interval) text += " · every " + rule.interval.every + " " + rule.interval.unit + (rule.interval.every === 1 ? "" : "s");
+  text += " · " + rule.anchorDate + " at " + rule.time;
+  if (rule.recurrenceEnd && rule.recurrenceEnd.type === "until") text += " · until " + rule.recurrenceEnd.date;
+  if (rule.recurrenceEnd && rule.recurrenceEnd.type === "after") text += " · after " + rule.recurrenceEnd.count + " scheduled starts";
+  if (rule.interval && rule.interval.end && rule.interval.end.type === "until") text += " · stop at " + rule.interval.end.time;
+  if (rule.interval && rule.interval.end && rule.interval.end.type === "after") text += " · stop after " + rule.interval.end.count + " runs per day";
+  return text;
+}
+
+export function scheduleRuleState(record, defaults) {
+  var parsedCron = record && record.cron ? cronState(record, defaults) : null;
+  var rule = record && record.scheduleRule || parsedCron;
+  if (!rule) return {
+    advanced: !!(record && record.cron), customCron: record && record.cron || "", date: record && record.date || defaults.date, time: record && record.time || defaults.time,
+    repeatEnabled: false, repeatEvery: 1, repeatUnit: "week", weekdays: [new Date((record && record.date || defaults.date) + "T00:00:00").getDay()], repeatEndType: "never", repeatEndDate: defaults.date, repeatEndCount: 10,
+    intervalEnabled: false, intervalEvery: 10, intervalUnit: "minute", intervalEndType: "allday", intervalEndCount: 5, intervalEndTime: "18:00",
+  };
+  return {
+    advanced: false, customCron: record && record.cron || "", originalCron: parsedCron && record.cron || "", date: rule.anchorDate, time: rule.time,
+    repeatEnabled: !!rule.recurrence, repeatEvery: rule.recurrence && rule.recurrence.every || 1, repeatUnit: rule.recurrence && rule.recurrence.unit || "week", weekdays: rule.recurrence && rule.recurrence.weekdays || [new Date(rule.anchorDate + "T00:00:00").getDay()],
+    repeatEndType: rule.recurrenceEnd && rule.recurrenceEnd.type || "never", repeatEndDate: rule.recurrenceEnd && rule.recurrenceEnd.date || rule.anchorDate, repeatEndCount: rule.recurrenceEnd && rule.recurrenceEnd.count || 10,
+    intervalEnabled: !!rule.interval, intervalEvery: rule.interval && rule.interval.every || 10, intervalUnit: rule.interval && rule.interval.unit || "minute", intervalEndType: rule.interval && rule.interval.end && rule.interval.end.type || "allday", intervalEndCount: rule.interval && rule.interval.end && rule.interval.end.count || 5, intervalEndTime: rule.interval && rule.interval.end && rule.interval.end.time || "18:00",
+  };
+}
+
+export function serializeScheduleRule(state) {
+  if (state.advanced) return { cron: state.customCron || "", date: null, time: null, scheduleRule: null };
+  var recurrence = state.repeatEnabled ? { every: Number(state.repeatEvery), unit: state.repeatUnit } : null;
+  if (recurrence && recurrence.unit === "week") recurrence.weekdays = state.weekdays.slice().sort(function (a, b) { return a - b; });
+  var recurrenceEnd = null;
+  if (state.repeatEnabled && state.repeatEndType === "until") recurrenceEnd = { type: "until", date: state.repeatEndDate };
+  if (state.repeatEnabled && state.repeatEndType === "after") recurrenceEnd = { type: "after", count: Number(state.repeatEndCount) };
+  var interval = null;
+  if (state.intervalEnabled) {
+    interval = { every: Number(state.intervalEvery), unit: state.intervalUnit, end: null };
+    if (state.intervalEndType === "until") interval.end = { type: "until", time: state.intervalEndTime };
+    if (state.intervalEndType === "after") interval.end = { type: "after", count: Number(state.intervalEndCount) };
+  }
+  return { cron: null, date: state.date, time: state.time, scheduleRule: { version: 1, timezone: "server-local", anchorDate: state.date, time: state.time, recurrence: recurrence, recurrenceEnd: recurrenceEnd, interval: interval } };
+}
+
+export function legacyScheduleRule(state) {
+  var recurrence = null;
+  if (state.repeatType === "daily") recurrence = { every: 1, unit: "day" };
+  else if (state.repeatType === "weekly") recurrence = { every: 1, unit: "week", weekdays: [state.anchorWeekday] };
+  else if (state.repeatType === "biweekly") recurrence = { every: 2, unit: "week", weekdays: [state.anchorWeekday] };
+  else if (state.repeatType === "monthly") recurrence = { every: 1, unit: "month" };
+  else if (state.repeatType === "yearly") recurrence = { every: 1, unit: "year" };
+  else if (state.repeatType === "weekdays") recurrence = { every: 1, unit: "week", weekdays: [1, 2, 3, 4, 5] };
+  else if (state.repeatType === "custom" && ["day", "week", "month", "year"].indexOf(state.repeatUnit) !== -1) {
+    recurrence = { every: state.repeatEvery, unit: state.repeatUnit };
+    if (state.repeatUnit === "week") recurrence.weekdays = state.weekdays.length ? state.weekdays : [state.anchorWeekday];
+  }
+  if (!recurrence && !state.interval) return null;
+  return { version: 1, timezone: "server-local", anchorDate: state.anchorDate, time: state.time, recurrence: recurrence, recurrenceEnd: state.recurrenceEnd, interval: state.interval };
+}