feat(web): add independent saved schedule editor modules

This commit is contained in:
2026-10-21 00:42:27 +01:00
parent 7e790126c5
commit 366931eeec
5 changed files with 502 additions and 0 deletions
+89
View File
@@ -0,0 +1,89 @@
// Saved schedules are independent RunInfo snapshots, never pipeline definitions.
export const SCHEDULE_DAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
const clone = (value) => JSON.parse(JSON.stringify(value));
const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
export function scheduleDraft({ pipeline, schedule = null, run = null, workspace = '', timezone } = {}) {
const source = schedule ?? run ?? {};
const input = clone(source.input ?? {});
const { prompt = '', ...other } = input;
const rule = source.rule ?? {};
return {
name: schedule?.name ?? '', prompt, version: String(source.version ?? pipeline?.Version ?? pipeline?.version ?? pipeline?.Pipeline?.version ?? ''),
workspace: source.workspace ?? workspace, enabled: schedule?.enabled ?? true,
mode: rule.times?.length ? 'clock' : 'interval', every: rule.every ?? '24h',
times: (rule.times ?? []).join(', '), days: [...(rule.days ?? [])],
timezone: rule.timezone ?? (schedule ? '' : (timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone)),
model: source.model ?? '', stageModels: JSON.stringify(source.stage_models ?? {}, null, 2),
otherInput: JSON.stringify(other, null, 2), title: source.title ?? '',
notifyMode: source.notify_mode ?? 'auto', outputFormat: source.output_format ?? '',
};
}
export function parseScheduleObject(text, label) {
let value;
try { value = JSON.parse(text); } catch { throw new Error(`${label} must be valid JSON.`); }
if (!object(value)) throw new Error(`${label} must be a JSON object (not an array or null).`);
return value;
}
export function validScheduleModel(value) {
return typeof value === 'string' && /^[^\s/]+\/[^\s]+$/.test(value);
}
export function serializeSchedule(draft, { pipelineId, schedule = null } = {}) {
if (!String(draft.name).trim()) throw new Error('Enter a schedule name.');
if (typeof draft.prompt !== 'string' || !draft.prompt.trim()) throw new Error('Enter a prompt.');
const version = Number(draft.version);
if (!/^\d+$/.test(String(draft.version)) || !Number.isSafeInteger(version) || version < 1) throw new Error('Choose a positive pinned version, not latest (0).');
if (!draft.workspace?.startsWith('/') || /[\0\r\n]/.test(draft.workspace)) throw new Error('Enter an absolute workspace path on the server.');
const input = parseScheduleObject(draft.otherInput, 'Other input');
const stageModels = parseScheduleObject(draft.stageModels, 'Stage models');
if (draft.model && !validScheduleModel(draft.model)) throw new Error('Model must be provider/model.');
for (const [key, model] of Object.entries(stageModels)) {
if (!key || !validScheduleModel(model)) throw new Error('Each stage model must be provider/model.');
}
if (!['auto', 'on', 'off'].includes(draft.notifyMode)) throw new Error('Choose a notification mode.');
if (!Array.isArray(draft.days) || draft.days.some(day => !SCHEDULE_DAYS.includes(day)) || new Set(draft.days).size !== draft.days.length) throw new Error('Choose valid, distinct weekdays.');
const rule = { ...(schedule?.rule ?? {}) };
delete rule.every; delete rule.times; delete rule.days; delete rule.timezone;
if (draft.mode === 'interval') {
const every = draft.every.trim();
// Accept Go-style compound durations and decimal components, without parseInt truncation.
const parts = [...every.matchAll(/((?:\d+(?:\.\d*)?|\.\d+))(ms|us|µs|ns|h|m|s)/g)];
const units = { h: 3600000, m: 60000, s: 1000, ms: 1, us: .001, 'µs': .001, ns: .000001 };
const duration = parts.reduce((sum, part) => sum + Number(part[1]) * units[part[2]], 0);
if (parts.map(part => part[0]).join('') !== every || !Number.isFinite(duration) || duration < 60000) throw new Error('Interval must be at least 1m (for example 24h or 1h30m).');
rule.every = every;
} else if (draft.mode === 'clock') {
const times = draft.times.split(',').map(time => time.trim());
if (!times.length || times.some(time => !/^([01]\d|2[0-3]):[0-5]\d$/.test(time)) || new Set(times).size !== times.length) throw new Error('Enter distinct 24-hour times, such as 09:00, 17:30.');
rule.times = times;
} else throw new Error('Choose an interval or clock times.');
if (draft.days.length) rule.days = [...draft.days];
if (draft.timezone.trim()) {
try { new Intl.DateTimeFormat('en', { timeZone: draft.timezone.trim() }); }
catch { throw new Error('Enter a valid IANA timezone.'); }
rule.timezone = draft.timezone.trim();
}
const record = { ...(schedule ? clone(schedule) : {}), id: schedule?.id ?? 0,
name: draft.name.trim(), pipeline_id: schedule?.pipeline_id ?? pipelineId,
version, enabled: Boolean(draft.enabled), input: { ...input, prompt: draft.prompt },
workspace: draft.workspace, rule, notify_mode: draft.notifyMode };
for (const [key, value] of Object.entries({ model: draft.model, stage_models: stageModels, title: draft.title, output_format: draft.outputFormat })) {
if (typeof value === 'object' ? Object.keys(value).length : value !== '') record[key] = value;
else delete record[key];
}
return record;
}
export function scheduleRuleLabel(rule = {}) {
return [rule.every ? `Every ${rule.every}` : (rule.times ?? []).join(', '),
(rule.days ?? []).join(', '), rule.timezone || 'Server timezone'].filter(Boolean).join(' · ');
}
export function scheduleDueLabel(value) {
if (!value) return 'Not scheduled';
const date = new Date(value);
return Number.isNaN(date.getTime()) ? 'Next time unavailable' : date.toLocaleString();
}
+165
View File
@@ -0,0 +1,165 @@
import { h } from '../dom.js';
import { SCHEDULE_DAYS, scheduleDraft, serializeSchedule, scheduleRuleLabel, scheduleDueLabel } from '../schedules.js';
export function createSchedulesView(rt) {
const cache = new Map();
const pipelineId = pipeline => pipeline.Pipeline?.id ?? pipeline.id;
const message = error => {
const text = error?.message || String(error);
return /unknown (message|request|command)|unsupported.*schedule/i.test(text)
? `This server does not support saved schedules. Upgrade the server to use schedules. (${text})` : text;
};
const unsupported = () => new Error('This server does not support saved schedules. Upgrade the server to use schedules.');
const refresh = () => rt.renderContent();
function clearScheduleCache() { cache.clear(); }
function loadPipelineSchedules(id, { force = false } = {}) {
const prior = cache.get(id);
if (prior?.pending || (!force && prior)) return prior.pending ?? Promise.resolve(prior.items);
const entry = { items: prior?.items ?? [], loading: true, error: null };
cache.set(id, entry);
entry.pending = Promise.resolve().then(() => {
if (!rt.repo.listSchedules) throw unsupported();
return rt.repo.listSchedules(id);
}).then(items => {
if (!Array.isArray(items)) throw new Error('Server returned an invalid schedules response.');
entry.items = items;
return items;
}).catch(error => { entry.error = message(error); return null; }).finally(() => {
entry.loading = false; entry.pending = null;
if (cache.get(id) === entry) refresh();
});
return entry.pending;
}
async function changed(id) {
await loadPipelineSchedules(id, { force: true });
await rt.scheduleChanged?.(id);
refresh();
}
function button(text, onclick, props = {}) {
return h('button', { type: 'button', text, onclick, ...props });
}
function renderPipelineSchedules(pipeline) {
const id = pipelineId(pipeline);
if (!cache.has(id)) void loadPipelineSchedules(id);
const entry = cache.get(id);
const section = h('section', { class: 'schedule-section', 'aria-label': 'Schedules' },
h('div', { class: 'schedule-heading' }, h('h3', { text: `Schedules${entry && !entry.loading && !entry.error ? ` (${entry.items.length})` : ''}` }),
button('Add schedule', event => openScheduleEditor({ pipeline, trigger: event.currentTarget }), { class: 'schedule-add' })),
h('p', { class: 'schedule-muted', text: 'Independent prompts and timers for this pipeline. Schedules do not change its definition.' }));
if (entry.loading) section.append(h('p', { role: 'status', text: 'Loading schedules…' }));
if (entry.error) section.append(h('div', { class: 'schedule-error', role: 'alert' }, entry.error,
button('Retry', () => { void loadPipelineSchedules(id, { force: true }); refresh(); })));
if (!entry.loading && !entry.error && !entry.items.length) section.append(h('p', { class: 'schedule-muted', text: 'No schedules yet. Add one for each topic or recurring task.' }));
for (const schedule of entry.items) {
const errorNode = h('p', { class: 'schedule-error', role: 'alert', hidden: true });
const card = h('article', { class: 'schedule-card', 'data-schedule-id': schedule.id },
h('div', { class: 'schedule-heading' }, h('strong', { text: schedule.name }), h('span', { class: 'schedule-badge', text: schedule.enabled ? 'Enabled' : 'Paused' })),
h('div', { class: 'schedule-muted', text: `Pinned v${schedule.version} · ${scheduleRuleLabel(schedule.rule)}` }),
h('p', { class: 'schedule-prompt', text: schedule.input?.prompt ?? '' }),
h('div', { class: 'schedule-muted', text: `Next: ${schedule.enabled ? scheduleDueLabel(schedule.next_due) : 'Paused'}` }), errorNode);
const actions = h('div', { class: 'schedule-actions' });
const edit = button('Edit', event => openScheduleEditor({ pipeline, schedule, trigger: event.currentTarget }));
const toggle = button(schedule.enabled ? 'Pause' : 'Enable', async () => {
toggle.disabled = true;
try {
if (!rt.repo.saveSchedule) throw unsupported();
await rt.repo.saveSchedule({ ...schedule, enabled: !schedule.enabled });
await changed(id);
} catch (error) { errorNode.hidden = false; errorNode.textContent = message(error); }
finally { toggle.disabled = false; }
});
actions.append(edit, toggle, button('Delete', event => openDelete(schedule, event.currentTarget)));
card.append(actions); section.append(card);
}
return section;
}
function openDelete(schedule, trigger) {
let pending = false;
const close = () => { if (!pending) rt.modal.close('schedule-delete'); };
const errorNode = h('p', { class: 'schedule-error', role: 'alert' });
const confirm = button('Delete schedule', async () => {
if (pending) return;
pending = true; confirm.disabled = true;
try {
if (!rt.repo.deleteSchedule) throw unsupported();
await rt.repo.deleteSchedule(schedule.id, schedule.revision);
} catch (error) {
errorNode.textContent = message(error); pending = false; confirm.disabled = false; return;
}
// Keep mutation success separate from a subsequent list-refresh failure.
pending = false;
await changed(schedule.pipeline_id).catch(error => { errorNode.textContent = message(error); });
rt.modal.close('schedule-delete');
});
const panel = h('div', { class: 'schedule-overlay', role: 'dialog', 'aria-modal': 'true', 'aria-label': 'Delete schedule' },
h('div', { class: 'schedule-panel schedule-confirm' }, h('h2', { text: `Delete ${schedule.name}?` }),
h('p', { text: 'Future runs only. Run history and active runs will not be deleted.' }), errorNode,
h('div', { class: 'schedule-actions' }, button('Keep schedule', close), confirm)));
rt.modal.open('schedule-delete', panel, { trigger, onClose: close, renderManaged: false, history: false,
fallbackSelectors: ['.schedule-add'] });
}
function openScheduleEditor({ pipeline, schedule = null, run = null, trigger = null }) {
const draft = scheduleDraft({ pipeline, schedule, run, workspace: rt.state.workspace });
let pending = false;
const close = () => { if (!pending) rt.modal.close('schedule-editor'); };
const fields = {};
const field = (key, label, { textarea = false, ...props } = {}) => {
const input = h(textarea ? 'textarea' : 'input', { class: 'schedule-input', name: key, type: textarea ? null : 'text', ...props });
input.value = draft[key]; fields[key] = input;
return h('label', { class: 'schedule-field' }, h('span', { text: label }), input);
};
const mode = h('select', { name: 'mode', 'aria-label': 'Timer mode' }, h('option', { value: 'interval', text: 'Interval' }), h('option', { value: 'clock', text: 'Clock times' }));
mode.value = draft.mode;
const interval = field('every', 'Interval (at least 1m)');
const clock = field('times', 'Clock times (24h, comma separated)');
const updateMode = () => { interval.hidden = mode.value !== 'interval'; clock.hidden = mode.value !== 'clock'; };
mode.addEventListener('change', updateMode); updateMode();
const days = h('fieldset', { class: 'schedule-days' }, h('legend', { text: 'Weekdays (none means every day)' }));
const dayInputs = SCHEDULE_DAYS.map(day => {
const input = h('input', { type: 'checkbox', value: day, checked: draft.days.includes(day) });
days.append(h('label', {}, input, day)); return input;
});
const enabled = h('input', { type: 'checkbox', name: 'enabled', checked: draft.enabled });
const notify = h('select', { name: 'notifyMode' }, ...['auto', 'on', 'off'].map(value => h('option', { value, text: value })));
notify.value = draft.notifyMode;
const errorNode = h('p', { class: 'schedule-error', role: 'alert', hidden: true });
const save = h('button', { type: 'submit', text: 'Save schedule' });
const form = h('form', { class: 'schedule-panel', novalidate: true },
h('h2', { text: schedule ? 'Edit schedule' : 'Add schedule' }),
h('p', { class: 'schedule-muted', text: 'Future runs only; does not publish or change the workflow. Saving does not start a run.' }),
field('name', 'Name', { required: true }), field('prompt', 'Prompt', { textarea: true, required: true, rows: 5 }),
h('div', { class: 'schedule-grid' }, field('version', 'Pinned version', { inputmode: 'numeric' }), field('workspace', 'Server workspace', { required: true })),
h('label', { class: 'schedule-field' }, 'Timer', mode), interval, clock, days,
field('timezone', 'Timezone (blank uses server timezone)'), h('label', { class: 'schedule-check' }, enabled, 'Enabled'),
h('details', { class: 'schedule-advanced' }, h('summary', { text: 'Advanced run options' }),
field('model', 'Model (provider/model)'), field('stageModels', 'Stage models (JSON object)', { textarea: true, rows: 3 }),
field('otherInput', 'Other input (JSON object; prompt above wins)', { textarea: true, rows: 4 }),
field('title', 'Run title (optional)'), h('label', { class: 'schedule-field' }, 'Notifications', notify), field('outputFormat', 'Output format (optional)')),
errorNode, h('div', { class: 'schedule-actions schedule-footer' }, button('Cancel', close), save));
form.addEventListener('submit', async event => {
event.preventDefault(); if (pending) return;
errorNode.hidden = true;
let record;
try {
for (const [key, input] of Object.entries(fields)) draft[key] = input.value;
Object.assign(draft, { mode: mode.value, days: dayInputs.filter(input => input.checked).map(input => input.value), enabled: enabled.checked, notifyMode: notify.value });
record = serializeSchedule(draft, { pipelineId: pipelineId(pipeline), schedule });
if (!rt.repo.saveSchedule) throw unsupported();
} catch (error) { errorNode.textContent = message(error); errorNode.hidden = false; return; }
const controls = [...form.querySelectorAll('input, textarea, select, button')];
pending = true; controls.forEach(control => { control.disabled = true; }); save.textContent = 'Saving…';
try { await rt.repo.saveSchedule(record); }
catch (error) {
errorNode.textContent = `${message(error)} Your draft is preserved. If this schedule changed elsewhere, reopen it before retrying.`;
errorNode.hidden = false; pending = false; controls.forEach(control => { control.disabled = false; }); save.textContent = 'Save schedule'; return;
}
await changed(record.pipeline_id).catch(() => {});
pending = false; close();
});
const overlay = h('div', { class: 'schedule-overlay', role: 'dialog', 'aria-modal': 'true', 'aria-label': schedule ? 'Edit schedule' : 'Add schedule' }, form);
rt.modal.open('schedule-editor', overlay, { trigger, onClose: close, renderManaged: false, history: false,
fallbackSelectors: ['.schedule-add'] });
return overlay;
}
return { renderPipelineSchedules, openScheduleEditor, loadPipelineSchedules, clearScheduleCache };
}