1152 lines
46 KiB
JavaScript
1152 lines
46 KiB
JavaScript
// Dashboard SCH3DUL3S tab — reminders + scheduled-prompts.
|
||
//
|
||
// Reminders (a separate sqlite table, not part of /api/state) and the
|
||
// operator's scheduled prompts: the lists, the inline create row, the
|
||
// per-row edit form, and the fire-now / cancel actions. Live updates
|
||
// arrive via the `reminders_changed` / `schedules_changed` dashboard
|
||
// events (wired into the entry's mutation dispatch table); the
|
||
// tab-activation re-fetch is the cold-load / reconnect recovery path.
|
||
//
|
||
// Owns its own module state (the schedules list + edit-in-progress
|
||
// tracking); reads the shared agent roster from state.js for the
|
||
// target-chip pickers. Render + format helpers come from util.js.
|
||
|
||
import { $, el, appendLinkified } from './common.js';
|
||
import { themedConfirm, themedToast } from './modal.js';
|
||
import { paintAtomic, epochSec, fmtAgo, fmtDuration } from './util.js';
|
||
import { containersState } from './state.js';
|
||
|
||
export async function refreshReminders() {
|
||
const liveRoot = $('reminders-section');
|
||
if (!liveRoot) return;
|
||
try {
|
||
const resp = await fetch('/api/reminders');
|
||
if (!resp.ok) {
|
||
paintAtomic(liveRoot, (root) => {
|
||
root.append(el('p', { class: 'empty' }, 'reminders unavailable: http ' + resp.status));
|
||
});
|
||
return;
|
||
}
|
||
const rows = await resp.json();
|
||
renderReminders(rows);
|
||
} catch (err) {
|
||
paintAtomic(liveRoot, (root) => {
|
||
root.append(el('p', { class: 'empty' }, 'reminders fetch failed: ' + err));
|
||
});
|
||
}
|
||
}
|
||
function renderReminders(rows) {
|
||
const liveRoot = $('reminders-section');
|
||
if (!liveRoot) return;
|
||
paintAtomic(liveRoot, (root) => {
|
||
if (!rows.length) {
|
||
root.append(el('p', { class: 'empty' }, 'no queued reminders'));
|
||
return;
|
||
}
|
||
const ul = el('ul', { class: 'reminders' });
|
||
for (const r of rows) {
|
||
const failed = (r.attempt_count || 0) > 0;
|
||
const li = el('li', { class: 'reminder-row' + (failed ? ' reminder-failed' : '') });
|
||
const dueIn = epochSec(r.due_at) - Math.floor(Date.now() / 1000);
|
||
const dueLabel = dueIn <= 0
|
||
? `overdue ${fmtAgo(r.due_at)}`
|
||
: `in ${fmtDuration(dueIn)}`;
|
||
const head = el('div', { class: 'reminder-head' },
|
||
el('span', { class: 'agent' }, r.agent), ' ',
|
||
el('span', {
|
||
class: 'meta reminder-due',
|
||
title: new Date(r.due_at).toISOString(),
|
||
'data-due-at': String(epochSec(r.due_at)),
|
||
}, dueLabel),
|
||
' ',
|
||
el('span', { class: 'meta' }, `· id ${r.id}`),
|
||
);
|
||
if (r.file_path) {
|
||
head.append(' ', el('span', { class: 'meta' }, '· payload → '));
|
||
appendLinkified(head, r.file_path);
|
||
}
|
||
if (failed) {
|
||
head.append(' ', el('span',
|
||
{
|
||
class: 'badge badge-warn',
|
||
title: 'consecutive failed delivery attempts (capped at 5; over the cap the scheduler stops retrying until you click R3TRY or cancel)',
|
||
},
|
||
`⚠ ${r.attempt_count} failed`));
|
||
}
|
||
const body = el('div', { class: 'reminder-body' });
|
||
appendLinkified(body, r.message);
|
||
li.append(head, body);
|
||
if (r.last_error) {
|
||
li.append(el('div', { class: 'reminder-error' },
|
||
el('span', { class: 'msg-sep' }, 'error: '),
|
||
r.last_error,
|
||
));
|
||
}
|
||
const actions = el('div', { class: 'reminder-actions' });
|
||
if (failed) {
|
||
// Retry resets the failure counters so the scheduler picks
|
||
// the row up again on its next 5s tick. No data-no-refresh
|
||
// — the resulting refreshState re-fires refreshReminders.
|
||
const retryForm = el('form', {
|
||
method: 'POST', action: '/api/retry-reminder/' + r.id,
|
||
class: 'inline', 'data-async': '',
|
||
});
|
||
retryForm.append(el('button',
|
||
{ type: 'submit', class: 'btn btn-restart' }, '↻ R3TRY'));
|
||
actions.append(retryForm);
|
||
}
|
||
const cancelForm = el('form', {
|
||
method: 'POST', action: '/api/cancel-reminder/' + r.id,
|
||
class: 'inline', 'data-async': '',
|
||
'data-confirm': `cancel reminder ${r.id} for ${r.agent}? this drops the queued delivery; no undo.`,
|
||
});
|
||
cancelForm.append(el('button', { type: 'submit', class: 'btn btn-deny' }, '✗ C4NC3L'));
|
||
actions.append(cancelForm);
|
||
li.append(actions);
|
||
ul.append(li);
|
||
}
|
||
root.append(ul);
|
||
});
|
||
}
|
||
// ─── scheduled prompts ─────────────────────────────────────────────────
|
||
// Backend exposes `/api/schedules` (snapshot), `/api/schedules`
|
||
// (POST, operator-direct submit), `/api/schedules/{id}/cancel`
|
||
// (whole or per-target), `/api/schedules/{id}` (PATCH edit),
|
||
// `/api/schedules/{id}/fire-now` (POST). Mutations now emit a
|
||
// `schedules_changed` SSE event so the list updates live;
|
||
// `applySchedulesChanged` handles it. Tab-activation re-fetch kept as
|
||
// a safety net for approval-path inserts and disconnect windows.
|
||
// Local cache lets `refreshTabCounts` show the active count without
|
||
// re-fetching every second.
|
||
let schedulesState = [];
|
||
// Schedule ids whose inline edit form is currently open. The set
|
||
// survives across refreshSchedules() calls so a state
|
||
// poll doesn't yank the form out from under the operator. Per-id
|
||
// mid-edit carry sits in `scheduleEditCarry` so unsaved typing
|
||
// also rides the refresh.
|
||
const editingSchedules = new Set();
|
||
const scheduleEditCarry = new Map();
|
||
export async function refreshSchedules() {
|
||
const listRoot = $('schedules-section');
|
||
if (!listRoot) return;
|
||
try {
|
||
const resp = await fetch('/api/schedules');
|
||
if (!resp.ok) {
|
||
paintAtomic(listRoot, (root) => {
|
||
root.append(el('p', { class: 'empty' }, 'schedules unavailable: http ' + resp.status));
|
||
});
|
||
return;
|
||
}
|
||
schedulesState = await resp.json();
|
||
} catch (err) {
|
||
paintAtomic(listRoot, (root) => {
|
||
root.append(el('p', { class: 'empty' }, 'schedules fetch failed: ' + err));
|
||
});
|
||
return;
|
||
}
|
||
renderSchedulesList();
|
||
}
|
||
// Active = at least one target still alive (no `cancelled_at_unix`)
|
||
// AND the whole schedule isn't cancelled. Drives the tab pill count.
|
||
export function activeScheduleCount() {
|
||
let n = 0;
|
||
for (const s of schedulesState) {
|
||
if (s.cancelled_at_unix) continue;
|
||
if ((s.targets || []).some((t) => !t.cancelled_at_unix)) n++;
|
||
}
|
||
return n;
|
||
}
|
||
// Label + caption wrapper shared by every field on the schedule
|
||
// forms — `<label class="schedule-field"><span
|
||
// class="schedule-field-label">…</span>…children…</label>`. Variadic
|
||
// children land inside the label after the caption span, which is
|
||
// what every caller wants (the input + any preset/parts/preview
|
||
// sub-rows live next to the caption).
|
||
function scheduleField(labelText, ...children) {
|
||
return el('label', { class: 'schedule-field' },
|
||
el('span', { class: 'schedule-field-label' }, labelText),
|
||
...children);
|
||
}
|
||
|
||
// Interval composer — shared between the new-schedule form and
|
||
// the edit-schedule form. Builds the preset chip row +
|
||
// d/h/m/s sub-fields + live preview, and returns helpers to read
|
||
// and write the value.
|
||
//
|
||
// The composer carries no opinion on what "0 / blank" means at the
|
||
// semantic layer: it just reports the integer total. Callers decide
|
||
// whether to treat 0 as `null` (one-shot) for their own submit path.
|
||
function buildIntervalComposer({
|
||
label = 'interval (blank / all-zero = one-shot)',
|
||
namePrefix = 'interval_',
|
||
initialSeconds = 0,
|
||
} = {}) {
|
||
const wrapper = scheduleField(label);
|
||
const presets = [
|
||
['1m', 60], ['5m', 300], ['15m', 900], ['30m', 1800],
|
||
['1h', 3600], ['6h', 21600], ['12h', 43200],
|
||
['1d', 86400], ['7d', 604800],
|
||
];
|
||
const presetsRow = el('div', { class: 'schedule-interval-presets' });
|
||
for (const [presetLabel, secs] of presets) {
|
||
presetsRow.append(el('button', {
|
||
type: 'button',
|
||
class: 'btn btn-interval-preset',
|
||
'data-secs': String(secs),
|
||
}, presetLabel));
|
||
}
|
||
presetsRow.append(el('button', {
|
||
type: 'button',
|
||
class: 'btn btn-interval-preset btn-interval-oneshot',
|
||
'data-secs': '0',
|
||
}, 'one-shot'));
|
||
wrapper.append(presetsRow);
|
||
|
||
const partsRow = el('div', { class: 'schedule-interval-parts' });
|
||
const mkPart = (suffix, unit) => {
|
||
const inp = el('input', {
|
||
type: 'number', name: namePrefix + suffix, min: '0', step: '1', placeholder: '0',
|
||
class: 'schedule-interval-num',
|
||
});
|
||
partsRow.append(inp, el('span', { class: 'schedule-interval-unit' }, unit));
|
||
return inp;
|
||
};
|
||
const dInp = mkPart('d', 'd');
|
||
const hInp = mkPart('h', 'h');
|
||
const mInp = mkPart('m', 'm');
|
||
const sInp = mkPart('s', 's');
|
||
wrapper.append(partsRow);
|
||
|
||
const preview = el('div', { class: 'schedule-interval-preview', 'aria-live': 'polite' });
|
||
wrapper.append(preview);
|
||
|
||
function getSeconds() {
|
||
const n = (v) => {
|
||
const x = parseInt(v, 10);
|
||
return Number.isFinite(x) && x > 0 ? x : 0;
|
||
};
|
||
return n(dInp.value) * 86400 + n(hInp.value) * 3600
|
||
+ n(mInp.value) * 60 + n(sInp.value);
|
||
}
|
||
function fillFromSeconds(total) {
|
||
const t = Math.max(0, Math.floor(total));
|
||
const d = Math.floor(t / 86400);
|
||
const h = Math.floor((t % 86400) / 3600);
|
||
const m = Math.floor((t % 3600) / 60);
|
||
const s = t % 60;
|
||
dInp.value = d > 0 ? String(d) : '';
|
||
hInp.value = h > 0 ? String(h) : '';
|
||
mInp.value = m > 0 ? String(m) : '';
|
||
sInp.value = s > 0 ? String(s) : '';
|
||
}
|
||
function setParts({ d, h, m, s }) {
|
||
if (d !== undefined) dInp.value = d;
|
||
if (h !== undefined) hInp.value = h;
|
||
if (m !== undefined) mInp.value = m;
|
||
if (s !== undefined) sInp.value = s;
|
||
}
|
||
function updatePreview() {
|
||
const total = getSeconds();
|
||
preview.textContent = total > 0
|
||
? '↻ every ' + fmtDuration(total)
|
||
: 'one-shot (fires once at first-fire time)';
|
||
preview.classList.toggle('schedule-interval-preview-oneshot', total === 0);
|
||
}
|
||
for (const inp of [dInp, hInp, mInp, sInp]) {
|
||
inp.addEventListener('input', updatePreview);
|
||
}
|
||
for (const b of presetsRow.querySelectorAll('button[data-secs]')) {
|
||
b.addEventListener('click', () => {
|
||
fillFromSeconds(parseInt(b.getAttribute('data-secs'), 10) || 0);
|
||
updatePreview();
|
||
});
|
||
}
|
||
if (initialSeconds > 0) fillFromSeconds(initialSeconds);
|
||
updatePreview();
|
||
|
||
return { wrapper, getSeconds, fillFromSeconds, setParts, updatePreview };
|
||
}
|
||
|
||
// Parse the d/h/m/s sub-fields of a `buildIntervalComposer` instance
|
||
// out of submitted FormData. Returns total seconds, or NaN if any
|
||
// field carries a non-integer / negative value — the caller alerts
|
||
// and bails. Total `0` means "one-shot" at the call site (wire is
|
||
// `interval_seconds: null`). `namePrefix` matches the prefix passed
|
||
// to `buildIntervalComposer` (e.g. `interval_` or `edit_interval_`).
|
||
function intervalSecondsFromFormData(fd, namePrefix) {
|
||
const part = (suffix, mult) => {
|
||
const raw = String(fd.get(namePrefix + suffix) || '').trim();
|
||
if (!raw) return 0;
|
||
const n = parseInt(raw, 10);
|
||
if (!Number.isFinite(n) || n < 0) return NaN;
|
||
return n * mult;
|
||
};
|
||
return part('d', 86400) + part('h', 3600) + part('m', 60) + part('s', 1);
|
||
}
|
||
|
||
// Targets multi-select chip box — shared between the new-schedule
|
||
// form and the edit-schedule form. Same DOM shape, same candidate
|
||
// list (containers + operator + root); only the chip element id
|
||
// prefix and checkbox field name vary. Used to be inlined twice in
|
||
// near-identical 18-line blocks; consolidated here so a future
|
||
// change (new chip kind, candidate-list source swap, etc.) lives in
|
||
// one place. Returns the wrapping `<label class="schedule-field">`
|
||
// ready to append to the form.
|
||
function buildTargetChips({ idPrefix, fieldName, checked, extraNames = [] }) {
|
||
const candidates = ['operator'];
|
||
const containerNames = Array.from(containersState.values())
|
||
.map((c) => c.name)
|
||
.filter((n) => n !== 'operator')
|
||
.sort();
|
||
for (const n of containerNames) candidates.push(n);
|
||
// `extraNames` lets the edit form keep showing an already-active
|
||
// target that's vanished from the live container list (operator's
|
||
// typo, container destroyed mid-schedule, etc.) so it's still
|
||
// explicitly uncheckable. New-schedule callers pass `[]`.
|
||
for (const n of extraNames) if (!candidates.includes(n)) candidates.push(n);
|
||
|
||
const box = el('div', { class: 'schedule-targets' });
|
||
for (const name of candidates) {
|
||
const id_ = idPrefix + name;
|
||
const cb = el('input', {
|
||
type: 'checkbox', name: fieldName, value: name, id: id_,
|
||
});
|
||
if (checked.has(name)) cb.checked = true;
|
||
box.append(el('label', { class: 'schedule-target-chip', for: id_ },
|
||
cb, el('span', {}, name)));
|
||
}
|
||
return scheduleField('targets', box);
|
||
}
|
||
|
||
// Inline-create carry-state — survives paintAtomic re-renders.
|
||
// The schedules table refreshes on tab activate + after every mutation,
|
||
// and each refresh rebuilds the DOM via `paintAtomic`. The bottom
|
||
// create row's inputs would lose mid-typing values without this
|
||
// carry. `readNewScheduleCarryFromDOM` is called BEFORE every
|
||
// re-render so the carry sees the latest user input; the row
|
||
// builders then pre-fill from `newScheduleCarry`.
|
||
const newScheduleCarry = {
|
||
targets: new Set(),
|
||
body: '',
|
||
description: '',
|
||
first_fire: '',
|
||
interval_d: '',
|
||
interval_h: '',
|
||
interval_m: '',
|
||
interval_s: '',
|
||
};
|
||
function readNewScheduleCarryFromDOM(tr) {
|
||
if (!tr) return;
|
||
const get = (sel) => tr.querySelector(sel);
|
||
const checked = Array.from(tr.querySelectorAll('input[name="new_targets"]:checked'))
|
||
.map((i) => i.value);
|
||
newScheduleCarry.targets = new Set(checked);
|
||
const setIfDefined = (key, sel) => {
|
||
const el_ = get(sel);
|
||
if (el_) newScheduleCarry[key] = el_.value || '';
|
||
};
|
||
setIfDefined('body', 'textarea[name="new_body"]');
|
||
setIfDefined('description', 'input[name="new_description"]');
|
||
setIfDefined('first_fire', 'input[name="new_first_fire"]');
|
||
setIfDefined('interval_d', 'input[name="new_interval_d"]');
|
||
setIfDefined('interval_h', 'input[name="new_interval_h"]');
|
||
setIfDefined('interval_m', 'input[name="new_interval_m"]');
|
||
setIfDefined('interval_s', 'input[name="new_interval_s"]');
|
||
}
|
||
function resetNewScheduleCarry() {
|
||
newScheduleCarry.targets = new Set();
|
||
newScheduleCarry.body = '';
|
||
newScheduleCarry.description = '';
|
||
newScheduleCarry.first_fire = '';
|
||
newScheduleCarry.interval_d = '';
|
||
newScheduleCarry.interval_h = '';
|
||
newScheduleCarry.interval_m = '';
|
||
newScheduleCarry.interval_s = '';
|
||
}
|
||
function isoForDatetimeLocal(date) {
|
||
// `<input type="datetime-local">` expects `YYYY-MM-DDTHH:MM`
|
||
// in the user's local timezone (with no trailing Z). Build it
|
||
// by hand rather than slicing toISOString which is always UTC.
|
||
const pad = (n) => String(n).padStart(2, '0');
|
||
return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`
|
||
+ `T${pad(date.getHours())}:${pad(date.getMinutes())}`;
|
||
}
|
||
// Schedules render as a single table — one row per schedule,
|
||
// attribute columns + one ✓/✕ column per agent (tilted 45° header
|
||
// so a row of agents takes ~28px each instead of full word width),
|
||
// actions column on the right. Edit form expands into a colspan'd
|
||
// row underneath when its row's `✎` is toggled on.
|
||
function renderSchedulesList() {
|
||
const liveRoot = $('schedules-section');
|
||
if (!liveRoot) return;
|
||
// Capture any mid-typed inline-create state BEFORE paintAtomic
|
||
// blows the row away so a refresh doesn't yank the operator's
|
||
// half-filled form. The carry is replayed by
|
||
// `renderInlineCreateRow` below.
|
||
readNewScheduleCarryFromDOM(liveRoot.querySelector('.schedules-table-create-row'));
|
||
paintAtomic(liveRoot, (root) => {
|
||
const agents = schedulesTableAgentSet();
|
||
const table = el('table', { class: 'schedules-table' });
|
||
table.append(renderSchedulesTableHead(agents));
|
||
const tbody = el('tbody', {});
|
||
const sorted = schedulesState.slice().sort((a, b) => {
|
||
// Cancelled → bucket 2, paused → bucket 1, active → bucket 0.
|
||
const aOrd = a.cancelled_at_unix ? 2 : a.paused_at_unix ? 1 : 0;
|
||
const bOrd = b.cancelled_at_unix ? 2 : b.paused_at_unix ? 1 : 0;
|
||
if (aOrd !== bOrd) return aOrd - bOrd;
|
||
return epochSec(a.next_fire_at_unix) - epochSec(b.next_fire_at_unix);
|
||
});
|
||
for (const s of sorted) {
|
||
tbody.append(renderScheduleRow(s, agents));
|
||
if (editingSchedules.has(s.id) && !s.cancelled_at_unix) {
|
||
tbody.append(renderScheduleEditRow(s, agents));
|
||
}
|
||
}
|
||
// Always-visible inline create row at the bottom of the table
|
||
// — fill cells + click ＋ to POST. See
|
||
// docs/web-ui.md::SCH3DUL3S tab for the layout rationale.
|
||
tbody.append(renderInlineCreateRow(agents));
|
||
table.append(tbody);
|
||
const wrap = el('div', { class: 'schedules-table-wrap' });
|
||
wrap.append(table);
|
||
root.append(wrap);
|
||
});
|
||
}
|
||
// Inline create row. Each column carries an input matching its
|
||
// display semantics (datetime-local for next-fire, mini d/h/m/s
|
||
// number inputs for every, textarea for body, checkbox per agent
|
||
// column for targets). Submitting POSTs `/api/schedules` and clears
|
||
// the carry on success; the next `refreshSchedules` redraws the
|
||
// table with the new schedule above.
|
||
function renderInlineCreateRow(agents) {
|
||
const tr = el('tr', { class: 'schedules-table-create-row' });
|
||
|
||
tr.append(el('td', { class: 'meta schedules-table-id' }, 'new'));
|
||
tr.append(el('td', { class: 'meta' }, '—'));
|
||
|
||
const nextInput = el('input', {
|
||
type: 'datetime-local',
|
||
name: 'new_first_fire',
|
||
class: 'schedules-table-inline-input schedules-table-inline-datetime',
|
||
required: 'required',
|
||
title: 'first fire time (defaults to 5 minutes from now)',
|
||
});
|
||
// Default: 5 minutes from now so a stale-clock or quick-submit
|
||
// accident doesn't fire immediately on `now()`.
|
||
nextInput.value = newScheduleCarry.first_fire
|
||
|| isoForDatetimeLocal(new Date(Date.now() + 5 * 60 * 1000));
|
||
tr.append(el('td', { class: 'schedules-table-create-cell' }, nextInput));
|
||
|
||
const intervalRow = el('div', {
|
||
class: 'schedules-table-inline-interval',
|
||
title: 'recurring every D days H hours M minutes S seconds (all blank / zero = one-shot)',
|
||
});
|
||
const mkUnit = (suffix, unit) => {
|
||
const inp = el('input', {
|
||
type: 'number',
|
||
name: 'new_interval_' + suffix,
|
||
min: '0',
|
||
step: '1',
|
||
placeholder: '0',
|
||
class: 'schedules-table-inline-num',
|
||
'aria-label': 'interval ' + suffix,
|
||
});
|
||
inp.value = newScheduleCarry['interval_' + suffix] || '';
|
||
intervalRow.append(inp, el('span', { class: 'schedules-table-inline-unit' }, unit));
|
||
};
|
||
mkUnit('d', 'd');
|
||
mkUnit('h', 'h');
|
||
mkUnit('m', 'm');
|
||
mkUnit('s', 's');
|
||
tr.append(el('td', { class: 'schedules-table-create-cell' }, intervalRow));
|
||
|
||
tr.append(el('td', { class: 'meta' }, 'operator'));
|
||
|
||
const bodyTa = el('textarea', {
|
||
name: 'new_body',
|
||
rows: '1',
|
||
required: 'required',
|
||
placeholder: 'prompt body (required, multi-line ok)',
|
||
class: 'schedules-table-inline-textarea',
|
||
});
|
||
bodyTa.value = newScheduleCarry.body;
|
||
const descInput = el('input', {
|
||
type: 'text',
|
||
name: 'new_description',
|
||
placeholder: 'description (optional)',
|
||
class: 'schedules-table-inline-input schedules-table-inline-desc',
|
||
});
|
||
descInput.value = newScheduleCarry.description;
|
||
tr.append(el('td', { class: 'schedules-table-create-cell schedules-table-create-body' },
|
||
bodyTa, descInput));
|
||
|
||
// Per-agent target checkboxes — one cell per agent column. Wrap
|
||
// each checkbox in a label so the whole cell area is clickable.
|
||
for (const a of agents) {
|
||
const td = el('td', { class: 'schedules-table-check schedules-table-create-cell' });
|
||
const id_ = 'new-target-' + a;
|
||
const cb = el('input', {
|
||
type: 'checkbox',
|
||
name: 'new_targets',
|
||
value: a,
|
||
id: id_,
|
||
class: 'schedules-table-inline-check',
|
||
});
|
||
if (newScheduleCarry.targets.has(a)) cb.checked = true;
|
||
const lbl = el('label', {
|
||
for: id_,
|
||
class: 'schedules-table-inline-check-lbl',
|
||
title: 'tick to target ' + a,
|
||
}, cb);
|
||
td.append(lbl);
|
||
tr.append(td);
|
||
}
|
||
|
||
// Actions cell — submit button + reset.
|
||
const actionsCell = el('td', { class: 'schedules-table-actions' });
|
||
const submitBtn = el('button', {
|
||
type: 'button',
|
||
class: 'btn btn-spawn btn-inline-small schedules-table-create-submit',
|
||
title: 'queue this new schedule',
|
||
}, '＋');
|
||
submitBtn.addEventListener('click', () => submitNewScheduleInline(tr, submitBtn));
|
||
const resetBtn = el('button', {
|
||
type: 'button',
|
||
class: 'btn btn-inline-small schedules-table-create-reset',
|
||
title: 'clear all fields',
|
||
}, '⌫');
|
||
resetBtn.addEventListener('click', () => {
|
||
resetNewScheduleCarry();
|
||
renderSchedulesList();
|
||
});
|
||
actionsCell.append(submitBtn, resetBtn);
|
||
tr.append(actionsCell);
|
||
|
||
return tr;
|
||
}
|
||
async function submitNewScheduleInline(tr, submitBtn) {
|
||
const targets = Array.from(tr.querySelectorAll('input[name="new_targets"]:checked'))
|
||
.map((i) => i.value);
|
||
const body = String(tr.querySelector('textarea[name="new_body"]')?.value || '').trim();
|
||
const description = String(tr.querySelector('input[name="new_description"]')?.value || '').trim();
|
||
const firstFireStr = String(tr.querySelector('input[name="new_first_fire"]')?.value || '');
|
||
|
||
if (!targets.length) {
|
||
themedToast('schedule must have at least one target — tick at least one agent column', { type: 'error' });
|
||
return;
|
||
}
|
||
if (!body) { themedToast('prompt body must be non-empty', { type: 'error' }); return; }
|
||
if (!firstFireStr) { themedToast('first fire timestamp is required', { type: 'error' }); return; }
|
||
const firstFireDate = new Date(firstFireStr);
|
||
if (Number.isNaN(firstFireDate.getTime())) {
|
||
themedToast('first fire is not a valid datetime', { type: 'error' }); return;
|
||
}
|
||
const first_fire_at_unix = Math.floor(firstFireDate.getTime() / 1000);
|
||
|
||
// Parse the d/h/m/s parts inline — we don't use FormData since
|
||
// the inline row isn't wrapped in a <form>. Mirrors
|
||
// `intervalSecondsFromFormData` semantics: blank/0 = one-shot,
|
||
// anything non-integer or negative → NaN → alert.
|
||
const part = (suffix, mult) => {
|
||
const raw = String(tr.querySelector(`input[name="new_interval_${suffix}"]`)?.value || '').trim();
|
||
if (!raw) return 0;
|
||
const n = parseInt(raw, 10);
|
||
if (!Number.isFinite(n) || n < 0) return NaN;
|
||
return n * mult;
|
||
};
|
||
const intervalTotal = part('d', 86400) + part('h', 3600) + part('m', 60) + part('s', 1);
|
||
if (Number.isNaN(intervalTotal)) {
|
||
themedToast('interval fields must be non-negative integers (or blank for one-shot)', { type: 'error' });
|
||
return;
|
||
}
|
||
const interval_seconds = intervalTotal > 0 ? intervalTotal : null;
|
||
|
||
const payload = { targets, body, first_fire_at_unix };
|
||
if (interval_seconds != null) payload.interval_seconds = interval_seconds;
|
||
if (description) payload.description = description;
|
||
|
||
const originalLabel = submitBtn.innerHTML;
|
||
submitBtn.disabled = true;
|
||
submitBtn.innerHTML = '<span class="spinner">◐</span>';
|
||
try {
|
||
const resp = await fetch('/api/schedules', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(payload),
|
||
});
|
||
if (!resp.ok) {
|
||
const text = await resp.text().catch(() => '');
|
||
themedToast('schedule submit failed: http ' + resp.status + (text ? '\n\n' + text : ''), { type: 'error' });
|
||
return;
|
||
}
|
||
// Reset carry so the next render shows an empty row.
|
||
resetNewScheduleCarry();
|
||
await refreshSchedules();
|
||
} catch (err) {
|
||
themedToast('schedule submit failed: ' + err, { type: 'error' });
|
||
} finally {
|
||
submitBtn.disabled = false;
|
||
submitBtn.innerHTML = originalLabel;
|
||
}
|
||
}
|
||
// The set of agent columns in the schedules table: operator + root
|
||
// (manager) first, then live containers (sorted), then any extra names
|
||
// that appear as a schedule target but aren't in the live container list
|
||
// (operator typo, container destroyed mid-schedule, etc.) — same
|
||
// membership rule as `buildTargetChips` so the table and the new-/
|
||
// edit-form chip boxes agree on what's addressable.
|
||
function schedulesTableAgentSet() {
|
||
const seen = new Set();
|
||
const out = [];
|
||
const push = (n) => { if (!seen.has(n)) { seen.add(n); out.push(n); } };
|
||
push('operator');
|
||
const containerNames = Array.from(containersState.values())
|
||
.map((c) => c.name)
|
||
.filter((n) => n !== 'operator')
|
||
.sort();
|
||
for (const n of containerNames) push(n);
|
||
for (const s of schedulesState) {
|
||
for (const t of s.targets || []) push(t.target);
|
||
}
|
||
return out;
|
||
}
|
||
function renderSchedulesTableHead(agents) {
|
||
const thead = el('thead', {});
|
||
const headerRow = el('tr', {});
|
||
headerRow.append(
|
||
el('th', { class: 'schedules-table-id' }, '#'),
|
||
el('th', {}, 'src'),
|
||
el('th', { class: 'schedules-table-next-col' }, 'next'),
|
||
el('th', { class: 'schedules-table-every-col' }, 'every'),
|
||
el('th', {}, 'owner'),
|
||
el('th', { class: 'schedules-table-body-th' }, 'body'),
|
||
);
|
||
// 'operator' is always a valid target; every other column maps to a
|
||
// container, so flag any column whose agent is no longer in the live
|
||
// roster — its past schedules linger in the table but the agent is gone.
|
||
const liveNames = new Set(Array.from(containersState.values()).map((c) => c.name));
|
||
for (const a of agents) {
|
||
const gone = a !== 'operator' && !liveNames.has(a);
|
||
headerRow.append(el('th', {
|
||
class: 'schedules-table-agent-th' + (gone ? ' schedules-table-agent-th--gone' : ''),
|
||
title: gone ? a + ' — no longer exists (gone)' : a,
|
||
}, el('div', {}, el('span', {}, a))));
|
||
}
|
||
headerRow.append(el('th', { class: 'schedules-table-actions-th' }, ''));
|
||
thead.append(headerRow);
|
||
return thead;
|
||
}
|
||
function renderScheduleRow(s, agents) {
|
||
const cancelled = !!s.cancelled_at_unix;
|
||
const paused = !cancelled && !!s.paused_at_unix;
|
||
const tr = el('tr', {
|
||
class: 'schedules-table-row'
|
||
+ (cancelled ? ' schedules-table-row-cancelled' : '')
|
||
+ (paused ? ' schedules-table-row-paused' : ''),
|
||
});
|
||
|
||
tr.append(el('td', { class: 'meta schedules-table-id' }, '#' + s.id));
|
||
|
||
const srcKind = s.source && s.source.kind === 'approval' ? 'approval' : 'manual';
|
||
tr.append(el('td', {},
|
||
el('span', { class: 'rqe-source rqe-source-' + srcKind },
|
||
srcKind === 'approval' ? 'approval' : 'operator')));
|
||
|
||
// "next" cell — relative due-in for active schedules, "cancelled"
|
||
// for cancelled ones, "paused" for paused ones. Both carry the
|
||
// absolute ISO in the title.
|
||
const nextCell = el('td', { class: 'meta schedules-table-next-col' });
|
||
if (cancelled) {
|
||
nextCell.title = 'cancelled ' + new Date(s.cancelled_at_unix).toISOString();
|
||
nextCell.textContent = 'cancelled';
|
||
} else if (paused) {
|
||
nextCell.title = 'paused since '
|
||
+ new Date(s.paused_at_unix).toISOString()
|
||
+ '\nwould fire at '
|
||
+ new Date(s.next_fire_at_unix).toISOString();
|
||
nextCell.append(
|
||
el('span', { class: 'sched-paused-label' }, '⏸ paused'),
|
||
);
|
||
} else {
|
||
const dueIn = epochSec(s.next_fire_at_unix) - Math.floor(Date.now() / 1000);
|
||
nextCell.title = new Date(s.next_fire_at_unix).toISOString();
|
||
nextCell.textContent = dueIn <= 0
|
||
? 'overdue ' + fmtAgo(s.next_fire_at_unix)
|
||
: fmtDuration(dueIn);
|
||
nextCell.classList.add('sched-due');
|
||
nextCell.dataset.dueAt = String(epochSec(s.next_fire_at_unix));
|
||
}
|
||
tr.append(nextCell);
|
||
|
||
tr.append(el('td', { class: 'meta schedules-table-every-col' },
|
||
s.interval_seconds ? '↻ ' + fmtDuration(s.interval_seconds) : 'one-shot'));
|
||
|
||
tr.append(el('td', { class: 'meta' }, s.owner));
|
||
|
||
// Body cell — truncates with ellipsis; full body + description on hover.
|
||
const bodyCell = el('td', { class: 'schedules-table-body-cell' });
|
||
const bodyText = s.body || '';
|
||
bodyCell.title = (s.description ? s.description + '\n\n' : '') + bodyText;
|
||
bodyCell.textContent = bodyText;
|
||
tr.append(bodyCell);
|
||
|
||
// Per-agent target cells. Three states:
|
||
// - active target → ✓ button that cancels just that target on
|
||
// click (same affordance as the per-row ✕ on the old layout's
|
||
// targets table)
|
||
// - cancelled target → muted ✕ glyph (no button — backend
|
||
// re-add flows through the edit form's targets multi-select)
|
||
// - not a target → empty cell
|
||
const targetByName = new Map();
|
||
for (const t of s.targets || []) targetByName.set(t.target, t);
|
||
for (const a of agents) {
|
||
const t = targetByName.get(a);
|
||
const td = el('td', { class: 'schedules-table-check' });
|
||
if (!t) {
|
||
// empty — no button, no glyph
|
||
} else if (t.cancelled_at_unix) {
|
||
td.title = 'cancelled — '
|
||
+ (t.last_fired_at_unix
|
||
? 'last fired ' + fmtAgo(t.last_fired_at_unix) + ' ago'
|
||
: 'never fired')
|
||
+ (t.last_result ? ' · ' + t.last_result : '');
|
||
td.append(el('span', { class: 'schedules-table-check-cancelled' }, '✕'));
|
||
} else {
|
||
const lastFireDesc = t.last_fired_at_unix
|
||
? 'last fired ' + fmtAgo(t.last_fired_at_unix) + ' ago'
|
||
: 'never fired';
|
||
const lastResultDesc = t.last_result ? ' · ' + t.last_result : '';
|
||
const checkBtn = el('button', {
|
||
type: 'button',
|
||
class: 'schedules-table-check-btn',
|
||
}, '✓');
|
||
checkBtn.title = lastFireDesc + lastResultDesc
|
||
+ (cancelled ? '' : '\nclick to cancel this target');
|
||
if (cancelled) {
|
||
checkBtn.disabled = true;
|
||
} else {
|
||
checkBtn.addEventListener('click', () => cancelScheduleTargets(s.id, [a]));
|
||
}
|
||
td.append(checkBtn);
|
||
}
|
||
tr.append(td);
|
||
}
|
||
|
||
// Actions cell — fire / pause-toggle / edit / cancel-all.
|
||
// Glyph-only to fit a compact column; colour classes carry the
|
||
// visual cue: mauve = fire, teal = pause/resume, yellow = edit,
|
||
// red = cancel.
|
||
const actionsCell = el('td', { class: 'schedules-table-actions' });
|
||
if (!cancelled) {
|
||
const activeTargets = (s.targets || []).filter((t) => !t.cancelled_at_unix);
|
||
const isOneShot = !s.interval_seconds;
|
||
const fireBtn = el('button', {
|
||
type: 'button',
|
||
class: 'btn btn-fire-now btn-inline-small',
|
||
}, '↯');
|
||
fireBtn.title = isOneShot
|
||
? 'fire once — one-shot, consumed after the manual fire'
|
||
: 'fire once now — recurring; choose whether to reset the next-fire timer';
|
||
if (!activeTargets.length || paused) {
|
||
fireBtn.disabled = true;
|
||
fireBtn.title = paused
|
||
? 'resume the schedule first to use fire-now'
|
||
: 'every target is cancelled — nothing to fire';
|
||
}
|
||
fireBtn.addEventListener('click', () =>
|
||
fireScheduleNow(s.id, isOneShot, activeTargets.map((t) => t.target), fireBtn));
|
||
actionsCell.append(fireBtn);
|
||
|
||
// Pause / resume toggle — only meaningful for recurring schedules.
|
||
// One-shots can still be paused (to delay a one-time fire), so we
|
||
// show the button for both cases.
|
||
const pauseBtn = el('button', {
|
||
type: 'button',
|
||
class: 'btn btn-pause-schedule btn-inline-small' + (paused ? ' btn-resume-schedule' : ''),
|
||
}, paused ? '▶' : '⏸');
|
||
pauseBtn.title = paused ? 'resume schedule' : 'pause schedule';
|
||
pauseBtn.addEventListener('click', () =>
|
||
paused ? resumeSchedule(s.id) : pauseSchedule(s.id));
|
||
actionsCell.append(pauseBtn);
|
||
|
||
const editingThis = editingSchedules.has(s.id);
|
||
const editBtn = el('button', {
|
||
type: 'button',
|
||
class: 'btn btn-edit-schedule btn-inline-small',
|
||
}, editingThis ? '✎×' : '✎');
|
||
editBtn.title = editingThis
|
||
? 'close edit'
|
||
: 'edit body / description / interval / next-fire / targets';
|
||
editBtn.addEventListener('click', () => {
|
||
if (editingThis) {
|
||
editingSchedules.delete(s.id);
|
||
scheduleEditCarry.delete(s.id);
|
||
} else {
|
||
editingSchedules.add(s.id);
|
||
}
|
||
renderSchedulesList();
|
||
});
|
||
actionsCell.append(editBtn);
|
||
|
||
const cancelBtn = el('button', {
|
||
type: 'button',
|
||
class: 'btn btn-deny btn-inline-small',
|
||
}, '✕');
|
||
cancelBtn.title = 'cancel the whole schedule';
|
||
cancelBtn.addEventListener('click', () => cancelScheduleAll(s.id));
|
||
actionsCell.append(cancelBtn);
|
||
}
|
||
tr.append(actionsCell);
|
||
|
||
return tr;
|
||
}
|
||
function renderScheduleEditRow(s, agents) {
|
||
// colspan = 6 attribute cols + N agent cols + 1 actions col
|
||
const colCount = 7 + agents.length;
|
||
const tr = el('tr', { class: 'schedules-table-edit-row' });
|
||
const td = el('td', { colspan: String(colCount) });
|
||
td.append(renderScheduleEditForm(s));
|
||
tr.append(td);
|
||
return tr;
|
||
}
|
||
|
||
// Inline edit form. Renders inside the schedule row when the
|
||
// row's `✎ edit` button is toggled on. Pre-filled with current
|
||
// values; submit PATCHes /api/schedules/{id}. Targets stay
|
||
// immutable (per damocles's backend; the workaround for retargeting
|
||
// is cancel + new schedule). Mid-edit field values survive a
|
||
// state-poll refresh via `scheduleEditCarry`.
|
||
function renderScheduleEditForm(s) {
|
||
const wrapper = el('div', { class: 'schedule-edit-form-wrapper' });
|
||
const form_ = el('form', { class: 'schedule-edit-form' });
|
||
form_.addEventListener('submit', (e) => {
|
||
e.preventDefault();
|
||
submitEditSchedule(s, form_);
|
||
});
|
||
|
||
const carry = scheduleEditCarry.get(s.id) || {};
|
||
|
||
const bodyInput = el('textarea', { name: 'body', rows: '4', required: 'required' });
|
||
bodyInput.value = carry.body !== undefined ? carry.body : s.body;
|
||
form_.append(scheduleField('body', bodyInput));
|
||
|
||
const descInput = el('input', { type: 'text', name: 'description' });
|
||
descInput.value = carry.description !== undefined
|
||
? carry.description
|
||
: (s.description || '');
|
||
form_.append(scheduleField('description (blank to clear)', descInput));
|
||
|
||
const firstFireInput = el('input', {
|
||
type: 'datetime-local', name: 'next_fire', required: 'required',
|
||
});
|
||
firstFireInput.value = carry.next_fire !== undefined
|
||
? carry.next_fire
|
||
: isoForDatetimeLocal(new Date(s.next_fire_at_unix));
|
||
form_.append(scheduleField('next fire', firstFireInput));
|
||
|
||
const intervalCx = buildIntervalComposer({
|
||
label: 'interval (blank / all-zero = flip to one-shot)',
|
||
namePrefix: 'edit_interval_',
|
||
initialSeconds: 0,
|
||
});
|
||
form_.append(intervalCx.wrapper);
|
||
if (carry.interval_d !== undefined || carry.interval_h !== undefined
|
||
|| carry.interval_m !== undefined || carry.interval_s !== undefined) {
|
||
intervalCx.setParts({
|
||
d: carry.interval_d || '',
|
||
h: carry.interval_h || '',
|
||
m: carry.interval_m || '',
|
||
s: carry.interval_s || '',
|
||
});
|
||
} else if (s.interval_seconds) {
|
||
intervalCx.fillFromSeconds(s.interval_seconds);
|
||
}
|
||
intervalCx.updatePreview();
|
||
|
||
// Persist carry on every input + checkbox change so a refresh
|
||
// repaint preserves it.
|
||
const saveCarry = () => {
|
||
const fd = new FormData(form_);
|
||
scheduleEditCarry.set(s.id, {
|
||
body: String(fd.get('body') || ''),
|
||
description: String(fd.get('description') || ''),
|
||
next_fire: String(fd.get('next_fire') || ''),
|
||
interval_d: String(fd.get('edit_interval_d') || ''),
|
||
interval_h: String(fd.get('edit_interval_h') || ''),
|
||
interval_m: String(fd.get('edit_interval_m') || ''),
|
||
interval_s: String(fd.get('edit_interval_s') || ''),
|
||
targets: fd.getAll('edit_targets').map(String),
|
||
});
|
||
};
|
||
form_.addEventListener('input', saveCarry);
|
||
form_.addEventListener('change', saveCarry);
|
||
|
||
// Targets multi-select. Shares the chip-box pattern with the
|
||
// new-schedule form via `buildTargetChips`;
|
||
// cancelled tombstones aren't listed (re-adding them flows
|
||
// through `targets_add`, which the backend replace-on-conflict
|
||
// drops the tombstone for). Submit diffs against the original
|
||
// active set to populate `targets_add` / `targets_remove` on the
|
||
// PATCH body.
|
||
const originalActiveTargets = new Set(
|
||
(s.targets || []).filter((t) => !t.cancelled_at_unix).map((t) => t.target),
|
||
);
|
||
form_.append(buildTargetChips({
|
||
idPrefix: 'se-' + s.id + '-',
|
||
fieldName: 'edit_targets',
|
||
checked: carry.targets ? new Set(carry.targets) : originalActiveTargets,
|
||
extraNames: [...originalActiveTargets],
|
||
}));
|
||
form_.append(el('p', { class: 'meta schedule-edit-targets-note' },
|
||
're-adding a previously cancelled target drops its history and starts fresh; '
|
||
+ 'unchecking an active target cancels it.'));
|
||
|
||
const actions = el('div', { class: 'schedule-actions' });
|
||
const submit = el('button', { type: 'submit', class: 'btn btn-spawn' }, '✓ save changes');
|
||
const cancelEdit = el('button', { type: 'button', class: 'btn' }, 'cancel');
|
||
cancelEdit.addEventListener('click', () => {
|
||
editingSchedules.delete(s.id);
|
||
scheduleEditCarry.delete(s.id);
|
||
renderSchedulesList();
|
||
});
|
||
actions.append(submit, cancelEdit);
|
||
form_.append(actions);
|
||
|
||
wrapper.append(form_);
|
||
return wrapper;
|
||
}
|
||
|
||
async function submitEditSchedule(originalSchedule, form_) {
|
||
const s = originalSchedule;
|
||
const fd = new FormData(form_);
|
||
const newBody = String(fd.get('body') || '').trim();
|
||
const newDescription = String(fd.get('description') || '').trim();
|
||
const newNextFireStr = String(fd.get('next_fire') || '');
|
||
|
||
if (!newBody) { themedToast('body must be non-empty', { type: 'error' }); return; }
|
||
if (!newNextFireStr) { themedToast('next-fire timestamp is required', { type: 'error' }); return; }
|
||
const newNextFireDate = new Date(newNextFireStr);
|
||
if (Number.isNaN(newNextFireDate.getTime())) {
|
||
themedToast('next-fire is not a valid datetime', { type: 'error' }); return;
|
||
}
|
||
const newNextFireUnix = Math.floor(newNextFireDate.getTime() / 1000);
|
||
|
||
// Compute interval total from the d/h/m/s fields (composer uses
|
||
// `edit_interval_*` names in this form).
|
||
const intervalTotal = intervalSecondsFromFormData(fd, 'edit_interval_');
|
||
if (Number.isNaN(intervalTotal)) {
|
||
themedToast('interval fields must be non-negative integers', { type: 'error' });
|
||
return;
|
||
}
|
||
const newIntervalSeconds = intervalTotal > 0 ? intervalTotal : null;
|
||
|
||
// Compute target diff against the schedule's currently-active set
|
||
// (cancelled tombstones don't count). The backend treats
|
||
// `targets_add` as replace-on-conflict (re-adding a tombstoned
|
||
// target drops its history), so we can just blanket "send the
|
||
// checked list as add, send the unchecked-but-was-active list as
|
||
// remove."
|
||
const newTargets = new Set(fd.getAll('edit_targets').map(String));
|
||
const originalActive = new Set(
|
||
(s.targets || [])
|
||
.filter((t) => !t.cancelled_at_unix)
|
||
.map((t) => t.target),
|
||
);
|
||
if (!newTargets.size) {
|
||
themedToast('schedule must have at least one target — uncheck submit, or use ✕ cancel all instead', { type: 'error' });
|
||
return;
|
||
}
|
||
const targetsAdd = [...newTargets].filter((t) => !originalActive.has(t));
|
||
const targetsRemove = [...originalActive].filter((t) => !newTargets.has(t));
|
||
|
||
// Build the PATCH body. Only include keys for fields that
|
||
// actually changed; explicit `null` clears description / flips
|
||
// recurring→one-shot. `targets_add` / `targets_remove` only
|
||
// populated when non-empty so the wire body stays minimal.
|
||
const patch = {};
|
||
if (newBody !== s.body) patch.body = newBody;
|
||
if (newDescription !== (s.description || '')) {
|
||
patch.description = newDescription || null;
|
||
}
|
||
if (newNextFireUnix !== epochSec(s.next_fire_at_unix)) {
|
||
patch.next_fire_at_unix = newNextFireUnix;
|
||
}
|
||
if (newIntervalSeconds !== (s.interval_seconds || null)) {
|
||
patch.interval_seconds = newIntervalSeconds;
|
||
}
|
||
if (targetsAdd.length) patch.targets_add = targetsAdd;
|
||
if (targetsRemove.length) patch.targets_remove = targetsRemove;
|
||
if (!Object.keys(patch).length) {
|
||
// No-op submit. Treat as "close edit form".
|
||
editingSchedules.delete(s.id);
|
||
scheduleEditCarry.delete(s.id);
|
||
renderSchedulesList();
|
||
return;
|
||
}
|
||
|
||
const submitBtn = form_.querySelector('button[type="submit"]');
|
||
const originalLabel = submitBtn ? submitBtn.textContent : '';
|
||
if (submitBtn) { submitBtn.disabled = true; submitBtn.textContent = 'saving…'; }
|
||
try {
|
||
const resp = await fetch('/api/schedules/' + encodeURIComponent(s.id), {
|
||
method: 'PATCH',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(patch),
|
||
});
|
||
if (!resp.ok) {
|
||
const text = await resp.text().catch(() => '');
|
||
themedToast('edit failed: http ' + resp.status + (text ? '\n\n' + text : ''), { type: 'error' });
|
||
return;
|
||
}
|
||
editingSchedules.delete(s.id);
|
||
scheduleEditCarry.delete(s.id);
|
||
await refreshSchedules();
|
||
} catch (err) {
|
||
themedToast('edit failed: ' + err, { type: 'error' });
|
||
} finally {
|
||
if (submitBtn) { submitBtn.disabled = false; submitBtn.textContent = originalLabel; }
|
||
}
|
||
}
|
||
async function fireScheduleNow(id, isOneShot, targets, btn) {
|
||
const targetList = targets.length ? targets.join(', ') : '(no active targets)';
|
||
// Recurring schedules get a "reset timer" checkbox (default on): firing
|
||
// now also re-arms the next regular fire to now + interval. One-shot is
|
||
// consumed regardless, so the flag is moot there (no checkbox).
|
||
const checkboxes = isOneShot ? [] : [{
|
||
name: 'reset_timer',
|
||
label: 'reset timer — re-arm next fire to now + interval',
|
||
checked: true,
|
||
}];
|
||
const prompt = isOneShot
|
||
? `fire schedule #${id} now to ${targetList}?\n\n`
|
||
+ 'this is a ONE-SHOT — firing now consumes the schedule. '
|
||
+ 'the scheduled fire time will no longer trigger.'
|
||
: `fire schedule #${id} now to ${targetList}?\n\n`
|
||
+ 'this is RECURRING — sends an extra pulse out-of-band. '
|
||
+ 'leave "reset timer" on to re-arm the next regular fire to '
|
||
+ 'now + interval; uncheck it to keep the existing cadence.';
|
||
const confirmRes = await themedConfirm({ message: prompt, danger: true, checkboxes });
|
||
if (!confirmRes) return;
|
||
const resetTimer = !!confirmRes.reset_timer;
|
||
// Capture child nodes so we can restore on error, then replace
|
||
// with DOM-built content (textContent + element children rather
|
||
// than innerHTML — the format string only carries server-side
|
||
// ints/bool today but textContent is the safer pattern if a
|
||
// stringy field ever lands).
|
||
const originalChildren = btn ? Array.from(btn.childNodes) : [];
|
||
const restoreBtn = () => {
|
||
if (!btn) return;
|
||
btn.disabled = false;
|
||
while (btn.firstChild) btn.removeChild(btn.firstChild);
|
||
for (const n of originalChildren) btn.appendChild(n);
|
||
};
|
||
if (btn) {
|
||
btn.disabled = true;
|
||
while (btn.firstChild) btn.removeChild(btn.firstChild);
|
||
btn.append(el('span', { class: 'spinner' }, '◐'), ' firing…');
|
||
}
|
||
try {
|
||
const resp = await fetch('/api/schedules/' + encodeURIComponent(id) + '/fire-now', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ reset_timer: resetTimer }),
|
||
});
|
||
if (!resp.ok) {
|
||
const text = await resp.text().catch(() => '');
|
||
themedToast('fire-now failed: http ' + resp.status + (text ? '\n\n' + text : ''), { type: 'error' });
|
||
restoreBtn();
|
||
return;
|
||
}
|
||
// Backend returns FireNowReport { ok, failed, missing, one_shot_consumed,
|
||
// timer_reset }. Flash the per-target outcome on the button itself so the
|
||
// operator sees the result immediately, then refresh to pick up the
|
||
// authoritative per-target `last_result` annotations.
|
||
let report = null;
|
||
try { report = await resp.json(); } catch { /* shape drift / empty body — ignore */ }
|
||
if (btn && report) {
|
||
const bits = [];
|
||
if (report.ok) bits.push(report.ok + ' ok');
|
||
if (report.failed) bits.push(report.failed + ' failed');
|
||
if (report.missing) bits.push(report.missing + ' missing');
|
||
const suffix = report.one_shot_consumed ? ' — consumed'
|
||
: (report.timer_reset ? ' — timer reset' : '');
|
||
while (btn.firstChild) btn.removeChild(btn.firstChild);
|
||
btn.textContent = '↯ fired: ' + (bits.join(', ') || 'no targets') + suffix;
|
||
btn.classList.add('btn-fire-now-flashed');
|
||
}
|
||
// Hold the flash briefly so the operator can read it before the
|
||
// refresh wipes the row in place.
|
||
setTimeout(refreshSchedules, 1500);
|
||
} catch (err) {
|
||
themedToast('fire-now failed: ' + err, { type: 'error' });
|
||
restoreBtn();
|
||
}
|
||
}
|
||
async function cancelScheduleAll(id) {
|
||
if (!(await themedConfirm({ message: `cancel schedule #${id}? this stops all future fires for every target.`, danger: true }))) return;
|
||
await postScheduleCancel(id, null);
|
||
}
|
||
async function cancelScheduleTargets(id, targets) {
|
||
if (!(await themedConfirm({ message: `cancel schedule #${id} for ${targets.join(', ')}? other targets keep firing.`, danger: true }))) return;
|
||
await postScheduleCancel(id, targets);
|
||
}
|
||
async function postScheduleCancel(id, targets) {
|
||
try {
|
||
const opts = {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
// Always send a valid JSON body — cancel-all is `{}` (an empty body
|
||
// with a json content-type would 400 a strict extractor). Per-target
|
||
// cancel carries the list.
|
||
body: JSON.stringify(targets ? { targets } : {}),
|
||
};
|
||
const resp = await fetch('/api/schedules/' + encodeURIComponent(id) + '/cancel', opts);
|
||
if (!resp.ok) {
|
||
const text = await resp.text().catch(() => '');
|
||
themedToast('cancel failed: http ' + resp.status + (text ? '\n\n' + text : ''), { type: 'error' });
|
||
return;
|
||
}
|
||
await refreshSchedules();
|
||
} catch (err) {
|
||
themedToast('cancel failed: ' + err, { type: 'error' });
|
||
}
|
||
}
|
||
|
||
async function pauseSchedule(id) {
|
||
try {
|
||
const resp = await fetch('/api/schedules/' + encodeURIComponent(id) + '/pause', {
|
||
method: 'POST',
|
||
});
|
||
if (!resp.ok) {
|
||
const text = await resp.text().catch(() => '');
|
||
themedToast('pause failed: http ' + resp.status + (text ? '\n\n' + text : ''), { type: 'error' });
|
||
return;
|
||
}
|
||
await refreshSchedules();
|
||
} catch (err) {
|
||
themedToast('pause failed: ' + err, { type: 'error' });
|
||
}
|
||
}
|
||
async function resumeSchedule(id) {
|
||
try {
|
||
const resp = await fetch('/api/schedules/' + encodeURIComponent(id) + '/resume', {
|
||
method: 'POST',
|
||
});
|
||
if (!resp.ok) {
|
||
const text = await resp.text().catch(() => '');
|
||
themedToast('resume failed: http ' + resp.status + (text ? '\n\n' + text : ''), { type: 'error' });
|
||
return;
|
||
}
|
||
await refreshSchedules();
|
||
} catch (err) {
|
||
themedToast('resume failed: ' + err, { type: 'error' });
|
||
}
|
||
}
|
||
|
||
export function applySchedulesChanged(ev) {
|
||
schedulesState = (ev.schedules || []).slice();
|
||
renderSchedulesList();
|
||
}
|
||
export function applyRemindersChanged(ev) {
|
||
renderReminders(ev.reminders || []);
|
||
}
|