330 lines
13 KiB
TypeScript
330 lines
13 KiB
TypeScript
 
|
/**
|
|||
|
|
* Client-side mirror of the scheduled-task rules in
|
|||
|
|
* `src-tauri/src/commands/inspect_commands.rs`, plus a plain-English reading of
|
|||
|
|
* a cron expression.
|
|||
|
|
*
|
|||
|
|
* The backend remains the authority — it re-validates everything and is the
|
|||
|
|
* only thing standing between a prompt and the container. This module exists so
|
|||
|
|
* the form can say what is wrong *before* a round trip, and so the cron field
|
|||
|
|
* can show the user what they actually typed.
|
|||
|
|
*
|
|||
|
|
* The cron rules match Debian/vixie cron, which is what the container runs:
|
|||
|
|
* five fields, names in month and day-of-week only, day-of-week 0–7, and a
|
|||
|
|
* `/step` only after `*` or a range (vixie rejects `1/2`).
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
export const MAX_TASK_NAME_LEN = 100;
|
|||
|
|
export const MAX_TASK_PROMPT_LEN = 8000;
|
|||
|
|
export const MAX_WORKING_DIR_LEN = 512;
|
|||
|
|
export const DEFAULT_WORKING_DIR = "/workspace";
|
|||
|
|
|
|||
|
|
const MAX_CRON_LEN = 256;
|
|||
|
|
const MAX_CRON_STEP = 1000;
|
|||
|
|
|
|||
|
|
const MONTH_NAMES = [
|
|||
|
|
"jan", "feb", "mar", "apr", "may", "jun",
|
|||
|
|
"jul", "aug", "sep", "oct", "nov", "dec",
|
|||
|
|
];
|
|||
|
|
const DOW_NAMES = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
|
|||
|
|
|
|||
|
|
const MONTH_LABELS = [
|
|||
|
|
"January", "February", "March", "April", "May", "June",
|
|||
|
|
"July", "August", "September", "October", "November", "December",
|
|||
|
|
];
|
|||
|
|
const DOW_LABELS = [
|
|||
|
|
"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
|
|||
|
|
];
|
|||
|
|
|
|||
|
|
interface CronFieldSpec {
|
|||
|
|
label: string;
|
|||
|
|
min: number;
|
|||
|
|
max: number;
|
|||
|
|
names: string[];
|
|||
|
|
/** Numeric value of `names[0]` — 1 for January, 0 for Sunday. */
|
|||
|
|
nameBase: number;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const CRON_FIELDS: CronFieldSpec[] = [
|
|||
|
|
{ label: "minute", min: 0, max: 59, names: [], nameBase: 0 },
|
|||
|
|
{ label: "hour", min: 0, max: 23, names: [], nameBase: 0 },
|
|||
|
|
{ label: "day of month", min: 1, max: 31, names: [], nameBase: 0 },
|
|||
|
|
{ label: "month", min: 1, max: 12, names: MONTH_NAMES, nameBase: 1 },
|
|||
|
|
{ label: "day of week", min: 0, max: 7, names: DOW_NAMES, nameBase: 0 },
|
|||
|
|
];
|
|||
|
|
|
|||
|
|
/** A handful of schedules that cover most of what people actually want. */
|
|||
|
|
export const CRON_PRESETS: { label: string; expression: string }[] = [
|
|||
|
|
{ label: "Every 30 minutes", expression: "*/30 * * * *" },
|
|||
|
|
{ label: "Hourly", expression: "0 * * * *" },
|
|||
|
|
{ label: "Daily at 09:00", expression: "0 9 * * *" },
|
|||
|
|
{ label: "Weekdays at 09:00", expression: "0 9 * * 1-5" },
|
|||
|
|
{ label: "Mondays at 08:00", expression: "0 8 * * 1" },
|
|||
|
|
];
|
|||
|
|
|
|||
|
|
// ── Field validation ─────────────────────────────────────────────────────────
|
|||
|
|
|
|||
|
|
/** `null` means valid; otherwise the message to show under the field. */
|
|||
|
|
export type FieldError = string | null;
|
|||
|
|
|
|||
|
|
/** C0 and C1 control characters. */
|
|||
|
|
// eslint-disable-next-line no-control-regex
|
|||
|
|
const CONTROL_CHARS = /[\u0000-\u001F\u007F-\u009F]/;
|
|||
|
|
/** The same, minus tab / LF / CR — a multi-line prompt is normal. */
|
|||
|
|
// eslint-disable-next-line no-control-regex
|
|||
|
|
const CONTROL_CHARS_EXCEPT_WHITESPACE =
|
|||
|
|
/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/;
|
|||
|
|
|
|||
|
|
const hasControlChars = (value: string, allowNewlines: boolean) =>
|
|||
|
|
(allowNewlines ? CONTROL_CHARS_EXCEPT_WHITESPACE : CONTROL_CHARS).test(value);
|
|||
|
|
|
|||
|
|
export function validateTaskName(name: string): FieldError {
|
|||
|
|
const trimmed = name.trim();
|
|||
|
|
if (!trimmed) return "Task name is required.";
|
|||
|
|
if ([...trimmed].length > MAX_TASK_NAME_LEN)
|
|||
|
|
return `Task name is too long (max ${MAX_TASK_NAME_LEN} characters).`;
|
|||
|
|
if (hasControlChars(trimmed, false)) return "Task name must be a single line.";
|
|||
|
|
if (trimmed.startsWith("-")) return "Task name cannot start with “-”.";
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
export function validateTaskPrompt(prompt: string): FieldError {
|
|||
|
|
const trimmed = prompt.trim();
|
|||
|
|
if (!trimmed) return "Task prompt is required.";
|
|||
|
|
if ([...trimmed].length > MAX_TASK_PROMPT_LEN)
|
|||
|
|
return `Task prompt is too long (max ${MAX_TASK_PROMPT_LEN} characters).`;
|
|||
|
|
if (hasControlChars(trimmed, true)) return "Task prompt contains an unsupported character.";
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
export function validateWorkingDir(dir: string): FieldError {
|
|||
|
|
const trimmed = dir.trim();
|
|||
|
|
if (!trimmed) return null; // Blank falls back to /workspace, as the CLI does.
|
|||
|
|
if ([...trimmed].length > MAX_WORKING_DIR_LEN)
|
|||
|
|
return `Working directory is too long (max ${MAX_WORKING_DIR_LEN} characters).`;
|
|||
|
|
if (hasControlChars(trimmed, false)) return "Working directory must be a single line.";
|
|||
|
|
if (!trimmed.startsWith("/"))
|
|||
|
|
return "Working directory must be an absolute path inside the container, e.g. /workspace.";
|
|||
|
|
if (trimmed.split("/").includes("..")) return "Working directory cannot contain “..”.";
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ── Cron ─────────────────────────────────────────────────────────────────────
|
|||
|
|
|
|||
|
|
function cronValue(spec: CronFieldSpec, token: string): number | null {
|
|||
|
|
if (token.length > 0 && /^[0-9]+$/.test(token)) {
|
|||
|
|
const value = Number(token);
|
|||
|
|
return value >= spec.min && value <= spec.max ? value : null;
|
|||
|
|
}
|
|||
|
|
const index = spec.names.indexOf(token.toLowerCase());
|
|||
|
|
return index >= 0 ? index + spec.nameBase : null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function validateCronElement(spec: CronFieldSpec, element: string): FieldError {
|
|||
|
|
if (!element) return `Empty value in the ${spec.label} field.`;
|
|||
|
|
|
|||
|
|
const slash = element.indexOf("/");
|
|||
|
|
const base = slash === -1 ? element : element.slice(0, slash);
|
|||
|
|
|
|||
|
|
if (slash !== -1) {
|
|||
|
|
const raw = element.slice(slash + 1);
|
|||
|
|
if (!/^[0-9]{1,4}$/.test(raw))
|
|||
|
|
return `“${element}” in the ${spec.label} field: a step must be a number, like */5.`;
|
|||
|
|
const step = Number(raw);
|
|||
|
|
if (step < 1 || step > MAX_CRON_STEP)
|
|||
|
|
return `“${element}” in the ${spec.label} field: a step must be between 1 and ${MAX_CRON_STEP}.`;
|
|||
|
|
if (base !== "*" && !base.includes("-"))
|
|||
|
|
return `“${element}” in the ${spec.label} field: a step can only follow * or a range, like */5 or 1-5/2.`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (base === "*") return null;
|
|||
|
|
|
|||
|
|
const dash = base.indexOf("-");
|
|||
|
|
const tokens = dash === -1 ? [base] : [base.slice(0, dash), base.slice(dash + 1)];
|
|||
|
|
for (const token of tokens) {
|
|||
|
|
if (cronValue(spec, token) === null) {
|
|||
|
|
return /^[0-9]+$/.test(token)
|
|||
|
|
? `“${token}” is out of range for the ${spec.label} field (${spec.min}–${spec.max}).`
|
|||
|
|
: `“${token}” is not valid in the ${spec.label} field.`;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
export function validateCronExpression(expression: string): FieldError {
|
|||
|
|
if (expression.length > MAX_CRON_LEN)
|
|||
|
|
return `Cron expression is too long (max ${MAX_CRON_LEN} characters).`;
|
|||
|
|
const fields = expression.trim().split(/\s+/).filter(Boolean);
|
|||
|
|
if (fields.length !== 5)
|
|||
|
|
return `A cron schedule needs exactly 5 fields (minute hour day-of-month month day-of-week); got ${fields.length}.`;
|
|||
|
|
|
|||
|
|
for (let i = 0; i < 5; i++) {
|
|||
|
|
for (const element of fields[i].split(",")) {
|
|||
|
|
const error = validateCronElement(CRON_FIELDS[i], element);
|
|||
|
|
if (error) return error;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/** Matches the scheduler's own `--at` regex, then checks it is a real instant. */
|
|||
|
|
export function validateAtTimestamp(at: string): FieldError {
|
|||
|
|
const trimmed = at.trim();
|
|||
|
|
if (!trimmed) return "A date and time is required.";
|
|||
|
|
const match = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2})$/.exec(trimmed);
|
|||
|
|
if (!match) return "Use the format YYYY-MM-DD HH:MM, e.g. 2026-12-25 09:05.";
|
|||
|
|
const [, y, mo, d, h, mi] = match.map(Number);
|
|||
|
|
const date = new Date(y, mo - 1, d, h, mi);
|
|||
|
|
const real =
|
|||
|
|
date.getFullYear() === y &&
|
|||
|
|
date.getMonth() === mo - 1 &&
|
|||
|
|
date.getDate() === d &&
|
|||
|
|
date.getHours() === h &&
|
|||
|
|
date.getMinutes() === mi;
|
|||
|
|
return real ? null : "That is not a real date and time.";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/** `true` when a valid one-shot time has already passed (a warning, not an error). */
|
|||
|
|
export function atTimestampIsPast(at: string, now: Date = new Date()): boolean {
|
|||
|
|
if (validateAtTimestamp(at)) return false;
|
|||
|
|
const [datePart, timePart] = at.trim().split(" ");
|
|||
|
|
const [y, mo, d] = datePart.split("-").map(Number);
|
|||
|
|
const [h, mi] = timePart.split(":").map(Number);
|
|||
|
|
return new Date(y, mo - 1, d, h, mi).getTime() < now.getTime();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ── Plain-English reading of a cron expression ───────────────────────────────
|
|||
|
|
|
|||
|
|
const pad = (n: number) => String(n).padStart(2, "0");
|
|||
|
|
|
|||
|
|
function joinList(items: string[]): string {
|
|||
|
|
if (items.length <= 1) return items[0] ?? "";
|
|||
|
|
if (items.length === 2) return `${items[0]} and ${items[1]}`;
|
|||
|
|
return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/** The step of a bare `*/n` field, or `null` for anything else. */
|
|||
|
|
function simpleStep(field: string): number | null {
|
|||
|
|
const match = /^\*\/([0-9]+)$/.exec(field);
|
|||
|
|
return match ? Number(match[1]) : null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Every value a (already valid) field selects, or `null` for "all of them".
|
|||
|
|
* Bounded by the field's own range, so this cannot run away.
|
|||
|
|
*/
|
|||
|
|
function expandField(spec: CronFieldSpec, field: string): number[] | null {
|
|||
|
|
if (field === "*") return null;
|
|||
|
|
const values = new Set<number>();
|
|||
|
|
for (const element of field.split(",")) {
|
|||
|
|
const slash = element.indexOf("/");
|
|||
|
|
const base = slash === -1 ? element : element.slice(0, slash);
|
|||
|
|
const step = slash === -1 ? 1 : Number(element.slice(slash + 1));
|
|||
|
|
|
|||
|
|
let from: number;
|
|||
|
|
let to: number;
|
|||
|
|
if (base === "*") {
|
|||
|
|
from = spec.min;
|
|||
|
|
to = spec.max;
|
|||
|
|
} else {
|
|||
|
|
const dash = base.indexOf("-");
|
|||
|
|
if (dash === -1) {
|
|||
|
|
from = to = cronValue(spec, base) as number;
|
|||
|
|
} else {
|
|||
|
|
from = cronValue(spec, base.slice(0, dash)) as number;
|
|||
|
|
to = cronValue(spec, base.slice(dash + 1)) as number;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
for (let v = from; v <= to; v += step) values.add(v);
|
|||
|
|
}
|
|||
|
|
const sorted = [...values].sort((a, b) => a - b);
|
|||
|
|
// A field that names every value reads better as "every".
|
|||
|
|
return sorted.length >= spec.max - spec.min + 1 ? null : sorted;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const isContiguous = (values: number[]) =>
|
|||
|
|
values.every((v, i) => i === 0 || v === values[i - 1] + 1);
|
|||
|
|
|
|||
|
|
function timePhrase(
|
|||
|
|
minutes: number[] | null,
|
|||
|
|
hours: number[] | null,
|
|||
|
|
minuteField: string,
|
|||
|
|
hourField: string,
|
|||
|
|
): string {
|
|||
|
|
if (minutes === null && hours === null) return "Every minute";
|
|||
|
|
|
|||
|
|
if (hours === null) {
|
|||
|
|
const step = simpleStep(minuteField);
|
|||
|
|
if (step !== null) return step === 1 ? "Every minute" : `Every ${step} minutes`;
|
|||
|
|
return `At ${joinList((minutes as number[]).map((m) => `:${pad(m)}`))} past every hour`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (minutes === null) {
|
|||
|
|
return `Every minute of ${joinList(hours.map((h) => `${pad(h)}:00`))}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const hourStep = simpleStep(hourField);
|
|||
|
|
if (hourStep !== null && minutes.length === 1) {
|
|||
|
|
return `At :${pad(minutes[0])} past every ${hourStep === 1 ? "hour" : `${hourStep} hours`}`;
|
|||
|
|
}
|
|||
|
|
if (minutes.length === 1 && hours.length >= 3 && isContiguous(hours)) {
|
|||
|
|
return `At :${pad(minutes[0])} past every hour from ${pad(hours[0])}:00 to ${pad(
|
|||
|
|
hours[hours.length - 1],
|
|||
|
|
)}:00`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const times: string[] = [];
|
|||
|
|
for (const h of hours) for (const m of minutes) times.push(`${pad(h)}:${pad(m)}`);
|
|||
|
|
if (times.length <= 6) return `At ${joinList(times)}`;
|
|||
|
|
return `At minute ${joinList(minutes.map(String))} of hour ${joinList(hours.map(String))}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function weekdayPhrase(dows: number[]): string {
|
|||
|
|
const labels = dows.map((d) => DOW_LABELS[d]);
|
|||
|
|
if (dows.length >= 3 && isContiguous(dows))
|
|||
|
|
return `${labels[0]} to ${labels[labels.length - 1]}`;
|
|||
|
|
return joinList(labels);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function dayPhrase(doms: number[] | null, dows: number[] | null): string {
|
|||
|
|
if (doms === null && dows === null) return "every day";
|
|||
|
|
if (dows !== null && doms === null) return `on ${weekdayPhrase(dows)}`;
|
|||
|
|
if (doms !== null && dows === null)
|
|||
|
|
return `on day ${joinList(doms.map(String))} of the month`;
|
|||
|
|
// Cron ORs the two day fields when both are restricted.
|
|||
|
|
return `on day ${joinList((doms as number[]).map(String))} of the month or on ${weekdayPhrase(
|
|||
|
|
dows as number[],
|
|||
|
|
)}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Read a cron expression back to the user in English, or `null` if it is not
|
|||
|
|
* valid. Deliberately a *reading*, not a scheduler: it never claims to know the
|
|||
|
|
* next run time.
|
|||
|
|
*/
|
|||
|
|
export function describeCron(expression: string): string | null {
|
|||
|
|
if (validateCronExpression(expression)) return null;
|
|||
|
|
const [minuteField, hourField, domField, monthField, dowField] = expression
|
|||
|
|
.trim()
|
|||
|
|
.split(/\s+/);
|
|||
|
|
|
|||
|
|
const minutes = expandField(CRON_FIELDS[0], minuteField);
|
|||
|
|
const hours = expandField(CRON_FIELDS[1], hourField);
|
|||
|
|
const doms = expandField(CRON_FIELDS[2], domField);
|
|||
|
|
const months = expandField(CRON_FIELDS[3], monthField);
|
|||
|
|
|
|||
|
|
let dows = expandField(CRON_FIELDS[4], dowField);
|
|||
|
|
if (dows) {
|
|||
|
|
// 0 and 7 are both Sunday.
|
|||
|
|
dows = [...new Set(dows.map((d) => (d === 7 ? 0 : d)))].sort((a, b) => a - b);
|
|||
|
|
if (dows.length === 7) dows = null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const monthPart =
|
|||
|
|
months === null ? "" : ` in ${joinList(months.map((m) => MONTH_LABELS[m - 1]))}`;
|
|||
|
|
|
|||
|
|
return `${timePhrase(minutes, hours, minuteField, hourField)}, ${dayPhrase(
|
|||
|
|
doms,
|
|||
|
|
dows,
|
|||
|
|
)}${monthPart}.`;
|
|||
|
|
}
|