diff --git a/web/schedules.css b/web/schedules.css new file mode 100644 index 00000000..5f6b031b --- /dev/null +++ b/web/schedules.css @@ -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; } +} diff --git a/web/src/schedules.js b/web/src/schedules.js new file mode 100644 index 00000000..073eb319 --- /dev/null +++ b/web/src/schedules.js @@ -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(); +} diff --git a/web/src/views/schedules.js b/web/src/views/schedules.js new file mode 100644 index 00000000..f79fab46 --- /dev/null +++ b/web/src/views/schedules.js @@ -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 }; +} diff --git a/web/test/schedules-browser.mjs b/web/test/schedules-browser.mjs new file mode 100644 index 00000000..00d8664f --- /dev/null +++ b/web/test/schedules-browser.mjs @@ -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 = ` + + +

Research

+`; +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)); +} diff --git a/web/test/schedules.test.mjs b/web/test/schedules.test.mjs new file mode 100644 index 00000000..b06c1c91 --- /dev/null +++ b/web/test/schedules.test.mjs @@ -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); +});