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
+31
View File
@@ -0,0 +1,31 @@
.schedule-section { margin-top: 24px; min-width: 0; }
.schedule-heading, .schedule-actions { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
.schedule-heading { justify-content: space-between; }
.schedule-heading h3 { margin: 0; }
.schedule-muted { color: var(--color-muted); font-size: .9em; overflow-wrap: anywhere; }
.schedule-card { border: 1px solid var(--color-border); border-radius: var(--radius-control); padding: 16px; margin-top: 12px; background: var(--color-surface); min-width: 0; overflow-wrap: anywhere; }
.schedule-badge { color: var(--color-accent); font-size: .85em; }
.schedule-prompt { white-space: pre-wrap; overflow-wrap: anywhere; max-height: 8em; overflow: auto; }
.schedule-card .schedule-actions { margin-top: 12px; }
.schedule-overlay { position: fixed; inset: 0; z-index: 80; padding: 24px; background: #0009; display: flex; align-items: center; justify-content: center; }
.schedule-panel { background: var(--color-surface); border: 1px solid var(--color-border); border-radius: 16px; padding: 24px; width: 100%; max-width: 720px; max-height: 100%; overflow: auto; overscroll-behavior: contain; min-width: 0; box-shadow: 0 20px 80px #0008; }
.schedule-panel h2 { margin-top: 0; }
.schedule-field { display: flex; flex-direction: column; gap: 6px; margin: 14px 0; min-width: 0; }
.schedule-field[hidden] { display: none; }
.schedule-input { width: 100%; min-width: 0; padding: 9px 10px; }
.schedule-field textarea { resize: vertical; line-height: 1.5; }
.schedule-grid { display: grid; grid-template-columns: 1fr 2fr; gap: 16px; }
.schedule-days { border: 1px solid var(--color-border); border-radius: var(--radius-control); display: flex; flex-wrap: wrap; gap: 10px; padding: 12px; margin: 14px 0; }
.schedule-days label, .schedule-check { display: inline-flex; align-items: center; gap: 6px; min-height: 32px; }
.schedule-days legend { color: var(--color-muted); font-size: .9em; }
.schedule-advanced { margin-top: 16px; }
.schedule-advanced summary { cursor: pointer; padding: 8px 0; }
.schedule-error { color: var(--color-danger, #ff9f9f); overflow-wrap: anywhere; }
.schedule-footer { justify-content: flex-end; border-top: 1px solid var(--color-border); padding-top: 16px; margin-top: 18px; }
.schedule-confirm { max-width: 480px; }
@media (max-width: 599px) {
.schedule-overlay { padding: 10px; }
.schedule-panel { padding: 16px; border-radius: 12px; }
.schedule-grid { grid-template-columns: 1fr; gap: 0; }
.schedule-input { font-size: 16px; }
}
+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 };
}
+125
View File
@@ -0,0 +1,125 @@
// Local static fixture only: real view + modal controller, no RuntimeSocket/server/providers.
// node web/test/schedules-browser.mjs /approved/temp/capture-directory
import assert from 'node:assert/strict';
import { createServer } from 'node:http';
import { readFile, mkdir, writeFile } from 'node:fs/promises';
import { fileURLToPath } from 'node:url';
import { resolve, extname } from 'node:path';
import { createHash } from 'node:crypto';
import { launchChrome, eventually } from './browser.mjs';
const root = fileURLToPath(new URL('../', import.meta.url));
const out = process.argv[2];
if (!out) throw new Error('Pass an approved capture directory.');
await mkdir(out, { recursive: true });
const fixture = `<!doctype html><meta name="viewport" content="width=device-width,initial-scale=1">
<link rel="stylesheet" href="/design/tokens/tokens.css"><link rel="stylesheet" href="/base.css"><link rel="stylesheet" href="/schedules.css">
<style>body{overflow:auto}.app-root{max-width:960px;margin:auto;padding:24px}#pane-main{min-width:0}</style>
<div class="app-root"><h1>Research</h1><main id="pane-main" tabindex="-1"></main></div><div id="modalLayer"></div>
<script type="module">
import { createSchedulesView } from '/src/views/schedules.js';
import { createModalController } from '/src/modal.js';
window.records=[]; window.calls={list:0,save:0,delete:0}; window.refuse=false; window.unsupported=false;
const pipeline={id:42,version:7,name:'Research'};
const rt={state:{workspace:'/srv/research'},modal:createModalController(),repo:{
async listSchedules(){calls.list++; if(window.holdRead)await new Promise(resolve=>window.releaseRead=resolve); if(window.unsupported)throw Error('Unknown message: list_schedules (old server)'); return structuredClone(records);},
async saveSchedule(record){calls.save++; if(window.refuse)throw Error('409 revision conflict');
if(record.id){const i=records.findIndex(x=>x.id===record.id);records[i]=structuredClone({...record,revision:record.revision+1});}
else records.push(structuredClone({...record,id:records.length+1,revision:1}));return record;},
async deleteSchedule(id,revision){calls.delete++; records=records.filter(x=>x.id!==id);}
},renderContent(){document.querySelector('#pane-main').replaceChildren(view.renderPipelineSchedules(pipeline));rt.modal.reconcile();}};
const view=createSchedulesView(rt); window.view=view;window.rt=rt;
window.seed=async()=>{records=[{id:1,revision:1,name:'AI news',pipeline_id:42,version:7,enabled:true,input:{prompt:'Research AI news',count:2},workspace:'/srv/research',rule:{every:'24h',timezone:'UTC'},next_due:'2026-10-22T09:00:00Z'},
{id:2,revision:1,name:'Battery news',pipeline_id:42,version:3,enabled:true,input:{prompt:'Research battery advances'},workspace:'/srv/batteries',rule:{times:['09:00'],days:['mon','fri'],timezone:'UTC'},next_due:'2026-10-23T09:00:00Z'}];await view.loadPipelineSchedules(42,{force:true});};
rt.renderContent();window.ready=true;
</script>`;
const server = createServer(async (req, res) => {
try {
if (req.url === '/') { res.setHeader('Content-Type', 'text/html'); res.end(fixture); return; }
const path = resolve(root, `.${new URL(req.url, 'http://fixture').pathname}`);
if (!path.startsWith(root)) { res.writeHead(403); res.end(); return; }
res.setHeader('Content-Type', ({ '.js': 'text/javascript', '.css': 'text/css' })[extname(path)] ?? 'text/plain');
res.end(await readFile(path));
} catch { res.writeHead(404); res.end(); }
});
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
let browser;
const manifest = [];
try {
browser = await launchChrome({ width: 1100, height: 900 });
const page = await browser.openPage(`http://127.0.0.1:${server.address().port}/`);
await page.waitForText('No schedules yet');
const capture = async name => {
const path = resolve(out, `${name}.png`); await page.screenshot(path);
manifest.push({ path, sha256: createHash('sha256').update(await readFile(path)).digest('hex') });
};
const noOverflow = async () => assert.equal(await page.evaluate('document.documentElement.scrollWidth <= innerWidth'), true);
await capture('schedule-empty-1100');
await page.evaluate('seed()'); await page.waitForText('Battery news');
assert.equal(await page.evaluate('document.querySelectorAll(".schedule-card").length'), 2);
await capture('schedule-two-1100');
await page.clickText('[data-schedule-id="2"] button', 'Edit');
await capture('schedule-clock-editor-1100'); await noOverflow();
assert.equal(await page.evaluate('document.querySelector("[name=mode]").value'), 'clock');
await page.clickText('.schedule-panel button', 'Cancel');
await page.clickText('[data-schedule-id="1"] button', 'Edit');
await page.fill('[name="prompt"]', 'AI draft remains here');
assert.equal(await page.evaluate('document.activeElement.name'), 'prompt');
await page.evaluate('rt.renderContent()');
assert.equal(await page.evaluate('document.querySelector("[name=prompt]").value'), 'AI draft remains here');
assert.equal(await page.evaluate('document.activeElement.name'), 'prompt');
await page.evaluate('window.refuse=true'); await page.clickText('.schedule-panel button', 'Save schedule');
await page.waitForText('409 revision conflict');
assert.equal(await page.evaluate('document.querySelector("[name=prompt]").value'), 'AI draft remains here');
await capture('schedule-conflict-1100');
await page.evaluate('window.refuse=false'); await page.clickText('.schedule-panel button', 'Save schedule');
await eventually(() => page.evaluate('!rt.modal.isOpen("schedule-editor")'));
assert.equal(await page.evaluate('records[1].input.prompt'), 'Research battery advances');
assert.equal(await page.evaluate('records[0].input.count'), 2);
await page.clickText('[data-schedule-id="1"] button', 'Pause');
await eventually(() => page.evaluate('!records[0].enabled'));
await capture('schedule-paused-1100');
await page.clickText('[data-schedule-id="1"] button', 'Delete');
assert.equal(await page.evaluate('calls.delete'), 0);
await capture('schedule-delete-confirm-1100');
await page.clickText('.schedule-confirm button', 'Keep schedule');
assert.equal(await page.evaluate('document.activeElement.textContent'), 'Delete');
await page.clickText('[data-schedule-id="1"] button', 'Delete');
await page.clickText('.schedule-confirm button', 'Delete schedule');
await eventually(() => page.evaluate('records.length===1 && !rt.modal.isOpen("schedule-delete")'));
assert.equal(await page.evaluate('records[0].id'), 2);
await page.evaluate('seed()');
await page.resize(390, 844);
await capture('schedule-two-390'); await noOverflow();
await page.click('.schedule-add');
await page.fill('[name="name"]', 'Third independent topic'); await page.fill('[name="prompt"]', 'Mobile draft');
await page.click('.schedule-advanced summary');
await page.fill('[name="otherInput"]', 'null');
await page.clickText('.schedule-panel button', 'Save schedule');
await page.waitForText('Other input must be a JSON object');
assert.equal(await page.evaluate('document.querySelector("[name=prompt]").value'), 'Mobile draft');
await capture('schedule-invalid-json-390');
await page.fill('[name="otherInput"]', '{"count":3}');
await page.clickText('.schedule-panel button', 'Save schedule');
await eventually(() => page.evaluate('records.length===3 && !rt.modal.isOpen("schedule-editor")'));
await page.clickText('[data-schedule-id="3"] button', 'Edit');
await capture('schedule-editor-390'); await noOverflow();
await page.click('.schedule-advanced summary');
await page.fill('[name="model"]', 'provider/model');
assert.equal(await page.evaluate('document.activeElement.name'), 'model');
await capture('schedule-advanced-390'); await noOverflow();
await page.clickText('.schedule-panel button', 'Cancel');
assert.equal(await page.evaluate('document.activeElement.textContent'), 'Edit');
await page.evaluate('holdRead=true;view.clearScheduleCache();rt.renderContent()');
await page.waitForText('Loading schedules'); await capture('schedule-loading-390');
await page.evaluate('holdRead=false;releaseRead()'); await page.waitForText('Third independent topic');
await page.evaluate('unsupported=true;view.clearScheduleCache();rt.renderContent()');
await page.waitForText('old server'); await capture('schedule-old-server-390');
await page.evaluate('unsupported=false'); await page.clickText('.schedule-section button', 'Retry');
await page.waitForText('Third independent topic');
await page.close();
await writeFile(resolve(out, 'manifest.json'), JSON.stringify(manifest, null, 2));
console.log(JSON.stringify({ checks: 'passed', captures: manifest }, null, 2));
} finally {
await browser?.close(); await new Promise(resolve => server.close(resolve));
}
+92
View File
@@ -0,0 +1,92 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { scheduleDraft, serializeSchedule, scheduleDueLabel, scheduleRuleLabel } from '../src/schedules.js';
import { createSchedulesView } from '../src/views/schedules.js';
const pipeline = { id: 42, version: 7 };
const make = () => ({ ...scheduleDraft({ pipeline, workspace: '/srv/research', timezone: 'UTC' }), name: 'AI news', prompt: 'Research AI news' });
const serialize = draft => serializeSchedule(draft, { pipelineId: 42 });
test('new schedules independently snapshot prompts and positive pinned versions', () => {
const a = serialize(make());
const b = serialize({ ...make(), prompt: 'Research batteries', every: '48h' });
assert.equal(a.id, 0); assert.equal(a.version, 7); assert.equal(a.pipeline_id, 42);
assert.notEqual(a.input.prompt, b.input.prompt); assert.equal(a.rule.every, '24h');
assert.equal(b.rule.every, '48h');
for (const version of ['0', '-1', '1.2', '7junk', 'Infinity']) assert.throws(() => serialize({ ...make(), version }), /pinned version/);
});
test('existing record roundtrip preserves CAS, unknown fields and typed extra inputs', () => {
const original = { ...serialize(make()), id: 9, revision: 13, server_extra: { keep: true },
input: { prompt: 'Topic', count: 4, flag: false, nested: { list: [null, 2] } },
rule: { times: ['09:00', '17:30'], days: ['mon', 'fri'], timezone: '', future: 'keep' },
model: 'provider/model', stage_models: { research: 'provider/other' }, title: 'Saved title', output_format: 'json', notify_mode: 'off' };
const draft = scheduleDraft({ pipeline, schedule: original });
const result = serializeSchedule(draft, { pipelineId: 42, schedule: original });
assert.equal(result.id, 9); assert.equal(result.revision, 13);
assert.deepEqual(result.input, original.input); assert.deepEqual(result.server_extra, original.server_extra);
assert.equal(result.rule.future, 'keep'); assert.equal(draft.timezone, '');
assert.deepEqual(result.stage_models, original.stage_models); assert.equal(result.title, 'Saved title');
draft.prompt = 'Changed';
assert.equal(original.input.prompt, 'Topic');
});
test('run seeding copies only RunSpec and never origin metadata or a locked title', () => {
const run = { version: 3, workspace: '/server/run', input: { prompt: 'Past run', count: 2 },
model: 'p/m', stage_models: { a: 'p/x' }, notify_mode: 'on', title: 'User title', output_format: 'markdown',
id: 87, origin: { kind: 'schedule' }, request_key: 'no-copy' };
const draft = scheduleDraft({ pipeline, run, workspace: '/different', timezone: 'UTC' });
const saved = serialize({ ...draft, name: 'From run', prompt: 'Editable title and prompt', otherInput: '{"count":2,"prompt":"ignored","array":[1,false]}' });
assert.equal(saved.version, 3); assert.equal(saved.workspace, '/server/run');
assert.equal(saved.input.prompt, 'Editable title and prompt'); assert.deepEqual(saved.input.array, [1, false]);
assert.equal(saved.title, 'User title'); assert.equal(saved.model, 'p/m');
assert.equal(saved.origin, undefined); assert.equal(saved.request_key, undefined); assert.equal(saved.id, 0);
});
test('rule modes mutually exclude interval and clock, validate days, timezone and times', () => {
const old = { ...serialize(make()), id: 3, rule: { every: '24h', days: ['mon'] } };
const draft = { ...scheduleDraft({ pipeline, schedule: old }), mode: 'clock', times: '09:00, 23:59' };
const clock = serializeSchedule(draft, { schedule: old });
assert.equal(clock.rule.every, undefined); assert.deepEqual(clock.rule.times, ['09:00', '23:59']);
const interval = serializeSchedule({ ...draft, mode: 'interval', every: '1.5m' }, { schedule: clock });
assert.equal(interval.rule.times, undefined); assert.equal(interval.rule.every, '1.5m');
assert.equal(serialize({ ...make(), every: '.5h' }).rule.every, '.5h');
for (const times of ['', '24:00', '9:00', '09:60', '09:00,09:00']) assert.throws(() => serialize({ ...make(), mode: 'clock', times }), /24-hour/);
for (const every of ['59s', 'NaN', '-1h', '1.1x', 'Infinityh']) assert.throws(() => serialize({ ...make(), every }), /at least 1m/);
for (const days of [['Monday'], ['mon', 'mon']]) assert.throws(() => serialize({ ...make(), days }), /weekdays/);
assert.throws(() => serialize({ ...make(), timezone: 'Nowhere/Invalid' }), /IANA/);
});
test('invalid JSON, model and workspace reject without mutating the draft', () => {
for (const otherInput of ['null', '[]', '{bad']) assert.throws(() => serialize({ ...make(), otherInput }), /JSON/);
for (const stageModels of ['null', '[]', '{"a":2}', '{"a":"no-provider"}']) assert.throws(() => serialize({ ...make(), stageModels }), /JSON|provider\/model/);
for (const model of ['plain', '/model', 'p/', 'p/m x']) assert.throws(() => serialize({ ...make(), model }), /provider\/model/);
for (const workspace of ['', 'relative', '~/repo', '/srv\npath']) assert.throws(() => serialize({ ...make(), workspace }), /absolute workspace/);
const draft = { ...make(), otherInput: 'null' }; const copy = structuredClone(draft);
assert.throws(() => serialize(draft)); assert.deepEqual(draft, copy);
});
test('display is honest for invalid or absent next_due', () => {
assert.equal(scheduleDueLabel('invalid'), 'Next time unavailable');
assert.equal(scheduleDueLabel(null), 'Not scheduled');
assert.match(scheduleRuleLabel({ every: '24h' }), /Server timezone/);
});
test('view cache shares pending reads, refreshes explicitly and recovers after refusal', async () => {
let calls = 0; let resolveRead; let fail = false; let renders = 0;
const view = createSchedulesView({ repo: { listSchedules() {
calls++; if (fail) throw new Error('unknown command list_schedules');
return new Promise(resolve => { resolveRead = resolve; });
} }, renderContent() { renders++; } });
const a = view.loadPipelineSchedules(42);
const b = view.loadPipelineSchedules(42, { force: true });
assert.equal(a, b); await Promise.resolve(); assert.equal(calls, 1);
resolveRead([{ id: 1 }]); assert.deepEqual(await a, [{ id: 1 }]);
await view.loadPipelineSchedules(42); assert.equal(calls, 1);
fail = true; assert.equal(await view.loadPipelineSchedules(42, { force: true }), null);
fail = false; const retry = view.loadPipelineSchedules(42, { force: true });
await Promise.resolve(); resolveRead([]); assert.deepEqual(await retry, []);
view.clearScheduleCache(); const newRead = view.loadPipelineSchedules(42);
await Promise.resolve(); resolveRead([]); await newRead;
assert.equal(calls, 4); assert.equal(renders, 4);
});