adispatchd 0.0.0-stage → 0.1.0

package/dist/ui/public/js/client/pages/config.js

@@ -0,0 +1,126 @@
+/**
+ * Configuration / System (Spec §16, §19): YAML read-only, validation, manual
+ * reload, runtime overrides note, notification delivery failures.
+ */
+import { ApiError, api, qs } from '../api.js';
+import { h, replaceChildren, rerender } from '../dom.js';
+import { createRefresher } from '../../shared/throttle.js';
+import { buildHash } from '../../shared/route.js';
+import { stateTone } from '../../shared/format.js';
+import { act, badge, button, confirmDialog, errorBox, jsonBlock, kv, loading, section, table, text, time, toast } from '../ui.js';
+function issuesList(issues) {
+    return h('ul', { class: 'issues' }, issues.map((i) => h('li', null, badge(i.severity, i.severity === 'error' ? 'error' : 'warn'), ' ', h('code', null, `${i.file}${i.line ? `:${i.line}` : ''}${i.path ? ` ${i.path}` : ''}`), ' ', i.message)));
+}
+export const configPage = (ctx) => {
+    ctx.setTitle('Configuration');
+    const tab = ctx.route.query.tab === 'notifications' ? 'notifications' : 'config';
+    const tabs = h('nav', { class: 'tabs' }, h('a', { href: buildHash(['config']), class: tab === 'config' ? 'active' : null }, 'Configuration'), h('a', { href: buildHash(['config'], { tab: 'notifications' }), class: tab === 'notifications' ? 'active' : null }, 'Notifications'));
+    const body = h('div', null, loading());
+    const el = h('div', { class: 'page' }, h('h1', null, 'Configuration / System'), tabs, body);
+    // ------------------------------------------------------------ config tab
+    const result = h('div');
+    const validateBtn = button('Validate', () => {
+        void (async () => {
+            const res = await act(validateBtn, () => api.post('/api/v1/config/validate'));
+            if (!res)
+                return;
+            replaceChildren(result, h('div', { class: `alert ${res.ok ? 'alert-ok' : 'alert-error'}` }, res.ok ? `Configuration on disk is valid${res.hash ? ` (hash ${res.hash.slice(0, 12)})` : ''}. Nothing was activated.` : `Configuration on disk is invalid (${res.errors.length} error(s)).`, res.errors.length ? issuesList(res.errors) : null, res.warnings.length ? issuesList(res.warnings) : null));
+        })();
+    });
+    const reloadBtn = button('Reload', () => {
+        void (async () => {
+            const r = await confirmDialog({
+                title: 'Reload configuration?',
+                message: h('div', null, h('p', null, 'All YAML files are read and validated. Only if everything is valid, the new configuration is activated atomically; otherwise the active configuration is kept.'), h('p', null, 'Runtime overrides of affected settings are reset to the YAML values. Running runs keep their configuration snapshot.')),
+                confirmLabel: 'Reload',
+            });
+            if (!r.ok)
+                return;
+            reloadBtn.disabled = true;
+            try {
+                const res = await api.post('/api/v1/config/reload');
+                toast(res.changed ? `Configuration v${res.version} activated` : 'Configuration unchanged', 'ok');
+                replaceChildren(result, h('div', { class: 'alert alert-ok' }, res.changed ? `Reloaded: version ${res.version}, hash ${res.hash.slice(0, 12)}.` : 'No changes.', res.warnings.length ? issuesList(res.warnings) : null, h('details', null, h('summary', null, 'Diff / reset overrides'), jsonBlock({ diff: res.diff, resetOverrides: res.resetOverrides }))));
+                void loadConfig();
+            }
+            catch (err) {
+                const issues = err instanceof ApiError ? (err.details?.errors ?? []) : [];
+                replaceChildren(result, h('div', { class: 'alert alert-error' }, err instanceof ApiError && err.code === 'config_invalid' ? 'Reload rejected – the active configuration was kept.' : errorBox(err), issues.length ? issuesList(issues) : null));
+            }
+            finally {
+                reloadBtn.disabled = false;
+            }
+        })();
+    }, { kind: 'primary' });
+    const systemBox = h('div');
+    const filesBox = h('div', null, loading());
+    const loadConfig = async () => {
+        try {
+            const [status, files, cfg] = await Promise.all([
+                api.get('/api/v1/status'),
+                api.get('/api/v1/config/files'),
+                api.get('/api/v1/config'),
+            ]);
+            const overrideCount = Object.keys(cfg.overrides.global ?? {}).length + Object.values(cfg.overrides.workflows ?? {}).reduce((n, o) => n + Object.keys(o ?? {}).length, 0);
+            rerender(systemBox, h('div', { class: 'grid' }, section('Active configuration', kv([
+                ['Directory', h('code', null, status.config.configDir)],
+                ['Version', String(status.config.version)],
+                ['Hash', h('code', null, status.config.hash)],
+                ['Loaded', time(status.config.loadedAt)],
+                ['Runtime overrides', overrideCount > 0 ? h('span', null, badge(String(overrideCount), 'info'), ' active – not persistent, lost on restart, reset by reload') : 'none'],
+            ]), h('div', { class: 'actions' }, validateBtn, reloadBtn), result, overrideCount > 0 ? h('details', null, h('summary', null, 'Overrides'), jsonBlock(cfg.overrides)) : null), section('System', kv([
+                ['Version', status.version],
+                ['Started', time(status.startedAt)],
+                ['Bind', h('span', null, `${status.server.host}:${status.server.port ?? '?'} `, status.server.loopback ? badge('loopback', 'ok') : badge('not loopback – protect with proxy/VPN', 'warn'))],
+                ['Readiness', h('span', null, Object.entries(status.readiness.checks).map(([k, v]) => badge(k, (k === 'shuttingDown' ? !v : v) ? 'ok' : 'warn')))],
+                ['SSE clients', String(status.sse.clients)],
+                ['Notifications', Object.entries(status.counts.notifications).map(([k, v]) => `${k} ${v}`).join(', ') || '—'],
+                ['Retention', status.retention ? h('span', null, 'last run ', time(status.retention.lastRunAt), ` · deleted ${JSON.stringify(status.retention.deletedRuns)} · errors ${status.retention.errors}`) : text(null)],
+            ]))));
+            rerender(filesBox, h('h2', null, 'YAML files (read-only, secrets redacted)'), files.files.length === 0 ? h('p', { class: 'empty' }, 'No files.') : null, files.files.map((f) => h('details', { class: 'file' }, h('summary', null, h('code', null, f.file), f.error ? badge('unavailable', 'warn', f.error) : null), f.content !== null ? h('pre', { class: 'yaml' }, f.content) : h('p', { class: 'error-text' }, f.error ?? 'not available'))));
+        }
+        catch (err) {
+            replaceChildren(systemBox, errorBox(err));
+        }
+    };
+    // ----------------------------------------------------- notifications tab
+    let notifState = ctx.route.query.state === 'all' ? '' : 'failed';
+    const loadNotifications = async () => {
+        try {
+            const res = await api.get(`/api/v1/notifications${qs({ state: notifState, limit: 200 })}`);
+            const stateSel = h('select', { class: 'input', 'aria-label': 'Delivery state', on: { change: () => { notifState = stateSel.value; void loadNotifications(); } } }, h('option', { value: 'failed', selected: notifState === 'failed' }, `Failed deliveries (${res.counts.failed ?? 0})`), h('option', { value: '', selected: notifState === '' }, 'All'));
+            rerender(body, section('Orchestrator notifications', h('p', { class: 'hint' }, 'Central notifications (retry block created, lifecycle action failed, recovery failed) and their delivery attempts per channel.'), h('div', { class: 'filters' }, stateSel), table(['#', 'Event', 'Created', 'State', 'Deliveries', ''], res.notifications.map((n) => {
+                const retry = n.deliveryState === 'failed'
+                    ? button('Retry', () => void act(retry, () => api.post(`/api/v1/notifications/${n.id}/retry`), 'Delivery re-queued').then(() => loadNotifications()), { kind: 'primary' })
+                    : null;
+                return [
+                    String(n.id),
+                    h('span', null, h('code', null, n.eventType), h('details', null, h('summary', null, 'payload'), jsonBlock(n.payload, 20_000))),
+                    time(n.createdAt),
+                    badge(n.deliveryState, stateTone(n.deliveryState)),
+                    n.deliveries.length
+                        ? h('ul', { class: 'plain' }, n.deliveries.map((d) => h('li', null, h('code', null, d.channelId), ' ', badge(d.state, stateTone(d.state)), ` ${d.attempts} attempt(s)`, d.lastStatus !== null ? ` · HTTP ${d.lastStatus}` : '', d.lastError ? h('div', { class: 'error-text' }, d.lastError) : null, d.nextAttemptAt ? h('div', { class: 'muted' }, 'next attempt ', time(d.nextAttemptAt)) : null)))
+                        : text(n.lastError ?? 'no channels'),
+                    retry,
+                ];
+            }), { empty: notifState === 'failed' ? 'No failed deliveries.' : 'No notifications.' })));
+        }
+        catch (err) {
+            replaceChildren(body, errorBox(err));
+        }
+    };
+    const load = tab === 'config' ? loadConfig : loadNotifications;
+    if (tab === 'config')
+        replaceChildren(body, systemBox, h('section', { class: 'card' }, filesBox));
+    const refresher = createRefresher(load, 2000);
+    void load();
+    return {
+        el,
+        onLive: (msg) => {
+            if (msg.type === 'config.reloaded' || (tab === 'notifications' && msg.type === 'notification'))
+                refresher.trigger();
+        },
+        onResync: () => void refresher.now(),
+        dispose: () => refresher.dispose(),
+    };
+};

package/dist/ui/public/js/client/pages/dashboard.js

@@ -0,0 +1,175 @@
+/** Dashboard (Spec §16): scheduler state, limit/usage, pause/resume, drain, cancel all, active runs. */
+import { api, qs, seg } from '../api.js';
+import { h, replaceChildren, rerender } from '../dom.js';
+import { createRefresher } from '../../shared/throttle.js';
+import { formatDuration, formatRelative } from '../../shared/format.js';
+import { isStateChange } from '../page.js';
+import { act, badge, button, confirmDialog, errorBox, isEditing, kv, loading, routeLink, runLink, runOutcomeBadges, section, table, text, time, externalLink } from '../ui.js';
+export function schedulerStateBadge(s) {
+    const tone = s.state === 'running' ? 'ok' : s.state === 'paused' ? 'warn' : s.state === 'recovering' ? 'info' : 'error';
+    return badge(s.state, tone, 'Scheduler state');
+}
+function meter(active, max) {
+    const pct = max > 0 ? Math.min(100, Math.round((active / max) * 100)) : 0;
+    return h('span', { class: 'meter-wrap' }, h('meter', { min: 0, max: Math.max(1, max), value: active, high: Math.max(1, max) - 0.5, title: `${active}/${max} (${pct}%)` }), ` ${active} / ${max}`);
+}
+export function cancelRunButton(run, after) {
+    if (!run.active || run.status === 'cancelling' || run.status === 'finalizing' || run.status === 'recovery_pending')
+        return null;
+    const btn = button('Cancel', () => {
+        void (async () => {
+            const r = await confirmDialog({
+                title: 'Cancel run?',
+                message: h('p', null, 'The run ', h('code', null, run.id), ' will be cancelled (SIGTERM, then SIGKILL after the grace period). Its on_cancel hook runs afterwards.'),
+                confirmLabel: 'Cancel run',
+                danger: true,
+                input: { label: 'Reason (optional)', placeholder: 'cancelled via UI' },
+            });
+            if (!r.ok)
+                return;
+            await act(btn, () => api.post(`/api/v1/runs/${seg(run.id)}/cancel`, r.value ? { reason: r.value } : {}), 'Cancel requested');
+            after();
+        })();
+    }, { kind: 'danger' });
+    return btn;
+}
+export const dashboardPage = (ctx) => {
+    ctx.setTitle('Dashboard');
+    const el = h('div', { class: 'page' }, h('h1', null, 'Dashboard'));
+    const body = h('div', { class: 'grid' }, loading());
+    el.appendChild(body);
+    const load = async () => {
+        if (isEditing(body)) {
+            setTimeout(() => refresher.trigger(), 2000);
+            return;
+        }
+        try {
+            const [status, active, recent] = await Promise.all([
+                api.get('/api/v1/status'),
+                api.get(`/api/v1/runs${qs({ active: 'true', limit: 100 })}`),
+                api.get(`/api/v1/runs${qs({ active: 'false', limit: 10 })}`),
+            ]);
+            render(status, active.runs, active.total, recent.runs);
+        }
+        catch (err) {
+            replaceChildren(body, errorBox(err));
+        }
+    };
+    const refresher = createRefresher(load, 1000);
+    const render = (s, active, activeTotal, recent) => {
+        const sch = s.scheduler;
+        const controls = h('div', { class: 'actions' });
+        if (sch.paused) {
+            const b = button('Resume', () => void act(b, () => api.post('/api/v1/scheduler/resume'), 'Scheduler resumed').then(() => refresher.now()), { kind: 'primary' });
+            controls.appendChild(b);
+        }
+        else {
+            const b = button('Pause', () => void act(b, () => api.post('/api/v1/scheduler/pause'), 'Automatic starts paused').then(() => refresher.now()), {
+                disabled: sch.stopping || sch.draining,
+                title: 'Pause automatic starts (manual starts still possible)',
+            });
+            controls.appendChild(b);
+        }
+        const drain = button('Drain', () => {
+            void (async () => {
+                const r = await confirmDialog({
+                    title: 'Drain and stop the orchestrator?',
+                    message: h('div', null, h('p', null, 'No new runs are started. Active runs (', String(s.usage.activeRuns), ') finish normally, then the orchestrator process exits.'), h('p', null, 'The UI is unavailable afterwards until the service is started again.')),
+                    confirmLabel: 'Start drain',
+                    danger: true,
+                });
+                if (r.ok)
+                    await act(drain, () => api.post('/api/v1/shutdown/drain'), 'Drain started');
+                await refresher.now();
+            })();
+        }, { kind: 'danger', disabled: sch.draining || sch.stopping });
+        const cancelAll = button('Cancel All', () => {
+            void (async () => {
+                const r = await confirmDialog({
+                    title: 'Cancel all runs and stop?',
+                    message: h('div', null, h('p', null, 'All ', String(s.usage.activeRuns), ' active run(s) are cancelled (on_cancel hooks run), then the orchestrator process exits.'), h('p', null, 'This cannot be undone.')),
+                    confirmLabel: 'Cancel all and stop',
+                    danger: true,
+                    input: { label: 'Reason (optional)', placeholder: 'cancel all via UI' },
+                });
+                if (r.ok)
+                    await act(cancelAll, () => api.post('/api/v1/shutdown/cancel-all', r.value ? { reason: r.value } : {}), 'Cancel all started');
+                await refresher.now();
+            })();
+        }, { kind: 'danger', disabled: sch.stopping });
+        controls.append(drain, cancelAll);
+        const notices = [];
+        if (sch.draining)
+            notices.push(h('div', { class: 'alert alert-warn' }, 'Drain in progress: no new runs; the process exits when active runs have finished.'));
+        if (sch.stopping)
+            notices.push(h('div', { class: 'alert alert-error' }, 'Shutdown in progress.'));
+        if (!s.readiness.ready)
+            notices.push(h('div', { class: 'alert alert-info' }, 'Not ready (recovery or startup in progress).'));
+        if (!s.server.loopback) {
+            notices.push(h('div', { class: 'alert alert-warn' }, `The API is bound to ${s.server.host} without authentication – only expose it behind an authenticating proxy/VPN.`));
+        }
+        // Global limit override
+        const limitInput = h('input', { type: 'number', min: 1, step: 1, class: 'input input-narrow', value: s.limits.override ?? '', placeholder: String(s.limits.configuredMaxConcurrent), 'aria-label': 'Global max concurrent override' });
+        const setLimit = button('Set', () => {
+            const v = limitInput.value.trim();
+            const n = Number(v);
+            if (v === '' || !Number.isInteger(n) || n < 1) {
+                limitInput.setCustomValidity('Integer ≥ 1');
+                limitInput.reportValidity();
+                return;
+            }
+            limitInput.setCustomValidity('');
+            void act(setLimit, () => api.patch('/api/v1/scheduler/runtime', { maxConcurrent: n }), 'Limit override set').then(() => refresher.now());
+        });
+        const resetLimit = button('Reset to YAML', () => void act(resetLimit, () => api.patch('/api/v1/scheduler/runtime', { maxConcurrent: null }), 'Limit reset to YAML value').then(() => refresher.now()), { disabled: s.limits.override === null });
+        const byWf = Object.entries(s.usage.byWorkflow).map(([id, u]) => [routeLink(['workflows', id], id), meter(u.active, u.max)]);
+        const counts = s.counts;
+        const failedNotifications = counts.notifications.failed ?? 0;
+        rerender(body, notices.length ? h('div', { class: 'span-all' }, notices) : null, section('Scheduler', kv([
+            ['State', schedulerStateBadge(sch)],
+            ['Ready', s.readiness.ready ? badge('ready', 'ok') : badge('not ready', 'warn')],
+            ['Polling interval', formatDuration(sch.pollingIntervalMs)],
+            [
+                'Last planning step',
+                sch.lastPlanningStep
+                    ? h('span', null, time(sch.lastPlanningStep.finishedAt), sch.lastPlanningStep.skipped ? ` (skipped: ${sch.lastPlanningStep.skipped})` : ` – ${sch.lastPlanningStep.startedRunIds.length} run(s) started`)
+                    : text(null),
+            ],
+            ['Version', `${s.version}, up since ${formatRelative(s.startedAt, Date.now()).replace(' ago', '')}`],
+        ]), controls), section('Capacity', kv([
+            ['Global', meter(s.usage.activeRuns, s.limits.maxConcurrent)],
+            ['Limit', h('span', null, String(s.limits.maxConcurrent), s.limits.override !== null ? badge('override', 'info', `YAML value: ${s.limits.configuredMaxConcurrent}`) : ' (YAML)')],
+            ['Override', h('span', { class: 'inline-form' }, limitInput, setLimit, resetLimit)],
+            ['Recovery pending', s.usage.recoveryPending > 0 ? badge(String(s.usage.recoveryPending), 'warn') : '0'],
+        ]), h('p', { class: 'hint' }, 'Runtime overrides are not persistent: they are lost on restart and reset by a configuration reload.'), byWf.length ? table(['Workflow', 'Active / max'], byWf) : null), section('Attention', kv([
+            ['Retry blocks', counts.activeBlocks > 0 ? routeLink(['blocked'], badge(String(counts.activeBlocks), 'warn')) : '0'],
+            ['Failed actions', counts.failedActions > 0 ? routeLink(['actions'], badge(String(counts.failedActions), 'error')) : '0'],
+            ['Failed notifications', failedNotifications > 0 ? routeLink(['config'], badge(String(failedNotifications), 'error'), { tab: 'notifications' }) : '0'],
+        ])), h('section', { class: 'card span-all' }, h('h2', null, `Active runs (${activeTotal})`), table(['Run', 'Workflow', 'Item', 'State', 'Started', 'Last status message', ''], active.map((r) => [
+            runLink(r.id),
+            r.workflowName ?? r.workflowId,
+            r.sourceUrl ? externalLink(r.sourceUrl, r.sourceItemKey ?? r.sourceUrl) : text(r.sourceItemKey ?? r.triggerType),
+            runOutcomeBadges(r),
+            r.startedAt ? h('span', { title: r.startedAt }, formatRelative(r.startedAt, Date.now())) : text(null),
+            text(r.statusMessage),
+            cancelRunButton(r, () => refresher.trigger()),
+        ]), { empty: 'No active runs.' }), activeTotal > active.length ? h('p', null, routeLink(['runs'], `Show all ${activeTotal} active runs`, { scope: 'active' })) : null), h('section', { class: 'card span-all' }, h('h2', null, 'Recently finished'), table(['Run', 'Workflow', 'Outcome', 'Finished', 'Duration', 'Message'], recent.map((r) => [
+            runLink(r.id),
+            r.workflowName ?? r.workflowId,
+            runOutcomeBadges(r),
+            time(r.finishedAt),
+            formatDuration(r.durationMs),
+            text(r.resultMessage ?? r.finalReason),
+        ]), { empty: 'No finished runs yet.' }), h('p', null, routeLink(['runs'], 'All runs →', { scope: 'history' }))));
+    };
+    void load();
+    return {
+        el,
+        onLive: (msg) => {
+            if (isStateChange(msg))
+                refresher.trigger();
+        },
+        onResync: () => void refresher.now(),
+        dispose: () => refresher.dispose(),
+    };
+};