adispatchd 0.0.0-stage → 0.1.0

package/dist/ui/public/js/shared/format.js

@@ -0,0 +1,213 @@
+/**
+ * Pure formatting helpers of the web UI (no DOM). Compiled for the browser
+ * (tsconfig.ui.json) and unit-tested under Node.
+ */
+/** Duration as `850 ms`, `12s`, `3m 05s`, `2h 04m`, `3d 02h`; `—` for null/invalid. */
+export function formatDuration(ms) {
+    if (ms === null || ms === undefined || !Number.isFinite(ms) || ms < 0)
+        return '—';
+    if (ms < 1000)
+        return `${Math.round(ms)} ms`;
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${String(s % 60).padStart(2, '0')}s`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ${String(m % 60).padStart(2, '0')}m`;
+    const d = Math.floor(h / 24);
+    return `${d}d ${String(h % 24).padStart(2, '0')}h`;
+}
+/** Byte size as `0 B`, `512 B`, `1.5 KiB`, `3.2 MiB`, `1.1 GiB`; `—` for null. */
+export function formatBytes(n) {
+    if (n === null || n === undefined || !Number.isFinite(n) || n < 0)
+        return '—';
+    if (n < 1024)
+        return `${n} B`;
+    const units = ['KiB', 'MiB', 'GiB', 'TiB'];
+    let v = n / 1024;
+    let i = 0;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return `${v >= 100 ? Math.round(v) : v.toFixed(1)} ${units[i]}`;
+}
+const pad = (n) => String(n).padStart(2, '0');
+/**
+ * ISO timestamp as `YYYY-MM-DD HH:MM:SS` in local time (or UTC with
+ * `utc: true`); `—` for null, the input itself if unparseable.
+ */
+export function formatDateTime(iso, opts = {}) {
+    if (!iso)
+        return '—';
+    const t = Date.parse(iso);
+    if (Number.isNaN(t))
+        return iso;
+    const d = new Date(t);
+    const [y, mo, da, h, mi, s] = opts.utc
+        ? [d.getUTCFullYear(), d.getUTCMonth() + 1, d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds()]
+        : [d.getFullYear(), d.getMonth() + 1, d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds()];
+    return `${y}-${pad(mo)}-${pad(da)} ${pad(h)}:${pad(mi)}:${pad(s)}`;
+}
+/** Relative time (`just now`, `5s ago`, `3m ago`, `in 2h`, …) of `iso` against `nowMs`. */
+export function formatRelative(iso, nowMs) {
+    if (!iso)
+        return '—';
+    const t = Date.parse(iso);
+    if (Number.isNaN(t))
+        return iso;
+    const diff = nowMs - t;
+    const abs = Math.abs(diff);
+    if (abs < 2000)
+        return 'just now';
+    const s = Math.round(abs / 1000);
+    const text = s < 60 ? `${s}s` : s < 3600 ? `${Math.round(s / 60)}m` : s < 86400 ? `${Math.round(s / 3600)}h` : `${Math.round(s / 86400)}d`;
+    return diff >= 0 ? `${text} ago` : `in ${text}`;
+}
+/**
+ * Only absolute `http:`/`https:` URLs are allowed as external link targets
+ * (Spec §20.5). Returns the normalized URL or `null`.
+ */
+export function safeHttpUrl(value) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 4096)
+        return null;
+    // Reject control characters and whitespace that browsers would strip before parsing the scheme.
+    if (/[\u0000- \u007f]/.test(value))
+        return null;
+    let u;
+    try {
+        u = new URL(value);
+    }
+    catch {
+        return null;
+    }
+    return u.protocol === 'http:' || u.protocol === 'https:' ? u.href : null;
+}
+/** Internal link target: a hash route like `#/runs/<id>`. */
+export function isInternalHref(value) {
+    return /^#\/[^\s]*$/.test(value) && !/[\u0000-\u001f\u007f]/.test(value);
+}
+/** Shorten `s` to `max` characters with an ellipsis. */
+export function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return `${s.slice(0, Math.max(0, max - 1))}…`;
+}
+/** Pretty JSON for display, cut after `maxChars` (with a marker). */
+export function prettyJson(value, maxChars = 200_000) {
+    let text;
+    try {
+        text = JSON.stringify(value, null, 2) ?? String(value);
+    }
+    catch {
+        text = String(value);
+    }
+    if (text.length > maxChars)
+        return `${text.slice(0, maxChars)}\n… (${text.length - maxChars} more characters not shown)`;
+    return text;
+}
+/**
+ * Unambiguous outcome badges of a run (Spec §21): business `failure` (result
+ * file) vs. technical error (`crashed`, `start_error`, `timed_out`) vs.
+ * `cancelled`; "lifecycle failed" is a separate badge.
+ */
+export function runBadges(run) {
+    const badges = [];
+    switch (run.outcome) {
+        case 'active':
+            badges.push(run.status === 'recovery_pending'
+                ? { label: 'recovery pending', tone: 'warn', title: 'Recovery could not decide whether the process is gone; operator action required' }
+                : { label: run.status, tone: 'info', title: `Active run (technical state ${run.status})` });
+            break;
+        case 'success':
+            badges.push({ label: 'success', tone: 'ok', title: 'Completed; worker reported success' });
+            break;
+        case 'failure':
+            badges.push({
+                label: 'failure (business)',
+                tone: 'warn',
+                title: 'Business result "failure": the worker finished in a controlled way and reported that the task cannot be solved (does not count as technical failure)',
+            });
+            break;
+        case 'technical_error': {
+            const st = run.finalStatus ?? run.status;
+            badges.push({ label: `technical error: ${st}`, tone: 'error', title: `Technical error (${st}); counts towards retry blocks` });
+            break;
+        }
+        case 'cancelled':
+            badges.push({ label: 'cancelled', tone: 'muted', title: 'Cancelled (does not count as technical failure)' });
+            break;
+        default:
+            badges.push({ label: String(run.outcome), tone: 'muted', title: '' });
+    }
+    if (run.lifecycleFailed || run.lifecycleStatus === 'failed') {
+        badges.push({ label: 'lifecycle failed', tone: 'error', title: 'A lifecycle action failed; see Failed Actions' });
+    }
+    else if (run.lifecycleStatus === 'running' && run.outcome !== 'active') {
+        badges.push({ label: 'lifecycle running', tone: 'info', title: 'Lifecycle hook chain is running' });
+    }
+    return badges;
+}
+/** Display value of a check / filter trace value (dry-run never claims `pass` for unevaluated checks). */
+export function checkValueLabel(value) {
+    if (value === true || value === 'pass')
+        return { label: 'pass', tone: 'ok' };
+    if (value === false || value === 'fail')
+        return { label: 'fail', tone: 'error' };
+    if (value === 'not_evaluated')
+        return { label: 'unknown / not evaluated', tone: 'muted' };
+    if (value === 'unknown')
+        return { label: 'unknown', tone: 'warn' };
+    return { label: String(value), tone: 'muted' };
+}
+/** Tone of a planning / dry-run decision. */
+export function decisionTone(decision) {
+    if (decision === 'started' || decision === 'would_start')
+        return 'ok';
+    if (decision === 'pending_checks')
+        return 'info';
+    if (decision.endsWith('unknown') || decision === 'start_failed' || decision === 'blocked')
+        return 'warn';
+    return 'muted';
+}
+/** Tone of an action / lifecycle / notification state. */
+export function stateTone(state) {
+    switch (state) {
+        case 'succeeded':
+        case 'delivered':
+        case 'ok':
+            return 'ok';
+        case 'failed':
+            return 'error';
+        case 'running':
+        case 'pending':
+            return 'info';
+        default:
+            return 'muted';
+    }
+}
+/** One-line summary of a run event (all parts are plain text, rendered via textContent). */
+export function eventSummary(e) {
+    const p = e.payload ?? {};
+    const str = (v) => (typeof v === 'string' ? v : null);
+    if (e.type === 'run.status') {
+        const from = str(p.from);
+        const to = str(p.to) ?? '?';
+        return `${from ? `${from} ` : ''}→ ${to}${str(p.target) ? ` (target ${str(p.target)})` : ''}`;
+    }
+    if (e.type === 'progress' && typeof p.value === 'number') {
+        return `${p.value}%${str(p.message) ? ` ${str(p.message)}` : ''}`;
+    }
+    if (e.type === 'lifecycle.action' || e.type === 'lifecycle.chain') {
+        const err = str(p.error);
+        return [str(p.hook), str(p.name) ?? str(p.type), str(p.status)].filter(Boolean).join(' ') + (err ? `: ${err}` : '');
+    }
+    const message = str(p.message) ?? str(p.reason) ?? str(p.error);
+    if (message !== null)
+        return message;
+    const keys = Object.keys(p).filter((k) => k !== 'type');
+    return keys.length === 0 ? '' : truncate(JSON.stringify(p), 200);
+}

package/dist/ui/public/js/shared/logs.js

@@ -0,0 +1,136 @@
+/**
+ * Paged log window of the run detail (Spec §16: only load the required
+ * ranges, never a whole 100 MB log). Pure state: which byte range
+ * `[start, end)` of the log file is loaded, and the loaded text. The text is
+ * capped at `maxChars`; when it grows beyond, the opposite side is trimmed at
+ * a line boundary and the range adjusted, so the DOM never holds more than
+ * about `maxChars` characters.
+ */
+/** Default page size (bytes) requested by the UI. */
+export const LOG_PAGE_BYTES = 64 * 1024;
+/** Default cap of characters kept in the log view. */
+export const LOG_MAX_CHARS = 1024 * 1024;
+const encoder = new TextEncoder();
+/** UTF-8 byte length of `s`. */
+export function utf8Length(s) {
+    return encoder.encode(s).length;
+}
+/** See module comment. */
+export class LogWindow {
+    pageBytes;
+    maxChars;
+    /** First loaded byte offset. */
+    start = 0;
+    /** Byte offset after the last loaded byte. */
+    end = 0;
+    /** Last known file size. */
+    size = 0;
+    exists = false;
+    /** Number of times text was trimmed (for the UI hint). */
+    trimmed = false;
+    chunks = [];
+    chars = 0;
+    constructor(pageBytes = LOG_PAGE_BYTES, maxChars = LOG_MAX_CHARS) {
+        this.pageBytes = pageBytes;
+        this.maxChars = maxChars;
+    }
+    /** Loaded text. */
+    get text() {
+        if (this.chunks.length > 1)
+            this.chunks = [this.chunks.join('')];
+        return this.chunks[0] ?? '';
+    }
+    /** True if bytes before `start` exist. */
+    get hasEarlier() {
+        return this.start > 0;
+    }
+    /** True if the file has bytes after `end` (as of the last known size). */
+    get hasLater() {
+        return this.end < this.size;
+    }
+    /** Query for the initial view: the last page (`tail`). */
+    tailQuery() {
+        return { tail: this.pageBytes };
+    }
+    /** Query for the page before `start`, `null` if at the beginning. */
+    earlierQuery() {
+        if (this.start <= 0)
+            return null;
+        const offset = Math.max(0, this.start - this.pageBytes);
+        return { offset, limit: this.start - offset };
+    }
+    /** Query for the bytes after `end` (follow / load newer). */
+    laterQuery() {
+        return { offset: this.end, limit: this.pageBytes };
+    }
+    /** Replace the window with `page` (initial load / resync). */
+    reset(page) {
+        this.chunks = page.data ? [page.data] : [];
+        this.chars = page.data.length;
+        this.start = page.offset;
+        this.end = page.offset + page.length;
+        this.size = page.size;
+        this.exists = page.exists;
+        this.trimmed = false;
+        this.trimStart();
+    }
+    /**
+     * Prepend a page that ends at `start`. Returns false if the page does not
+     * fit (range moved meanwhile) – the caller should reload.
+     */
+    prepend(page) {
+        if (page.offset + page.length !== this.start)
+            return false;
+        this.chunks = [page.data + this.text];
+        this.chars += page.data.length;
+        this.start = page.offset;
+        this.size = Math.max(this.size, page.size);
+        this.trimEnd();
+        return true;
+    }
+    /**
+     * Append a page that starts at `end`. Returns false if it does not fit.
+     * The beginning is trimmed if the window grows beyond `maxChars`.
+     */
+    append(page) {
+        this.size = Math.max(this.size, page.size);
+        this.exists = this.exists || page.exists;
+        if (page.offset !== this.end)
+            return false;
+        if (page.length > 0) {
+            this.chunks.push(page.data);
+            this.chars += page.data.length;
+            this.end = page.offset + page.length;
+        }
+        this.trimStart();
+        return true;
+    }
+    trimStart() {
+        if (this.chars <= this.maxChars)
+            return;
+        const text = this.text;
+        let cut = text.length - this.maxChars;
+        const nl = text.indexOf('\n', cut);
+        if (nl >= 0 && nl - cut < 4096)
+            cut = nl + 1;
+        const dropped = text.slice(0, cut);
+        this.chunks = [text.slice(cut)];
+        this.chars = text.length - cut;
+        this.start += utf8Length(dropped);
+        this.trimmed = true;
+    }
+    trimEnd() {
+        if (this.chars <= this.maxChars)
+            return;
+        const text = this.text;
+        let keep = this.maxChars;
+        const nl = text.lastIndexOf('\n', keep);
+        if (nl > 0 && keep - nl < 4096)
+            keep = nl + 1;
+        const dropped = text.slice(keep);
+        this.chunks = [text.slice(0, keep)];
+        this.chars = keep;
+        this.end -= utf8Length(dropped);
+        this.trimmed = true;
+    }
+}

package/dist/ui/public/js/shared/params.js

@@ -0,0 +1,90 @@
+/**
+ * Manual start form (Spec §5.5, §16): builds the request body of
+ * `POST /api/v1/workflows/:id/start` from form values and the workflow's
+ * parameter schema. The server validates again; this only gives early,
+ * readable feedback.
+ */
+/**
+ * @param triggerType workflow trigger (`source` requires an item reference)
+ * @param item raw item input (URL, `#7`, `7`)
+ * @param defs parameter schema
+ * @param values raw form values (strings; booleans as `'true'|'false'|''`)
+ */
+export function buildStartBody(triggerType, item, defs, values) {
+    const errors = [];
+    const body = {};
+    const ref = item.trim();
+    if (triggerType === 'source') {
+        if (!ref)
+            errors.push({ field: 'item', message: 'Source item (URL or number) is required for source workflows' });
+        else
+            body.item = ref;
+    }
+    else if (ref) {
+        errors.push({ field: 'item', message: 'This workflow has no source; leave the item empty' });
+    }
+    const params = {};
+    for (const [name, def] of Object.entries(defs)) {
+        const raw = (values[name] ?? '').trim();
+        if (raw === '') {
+            if (def.required && (def.default === null || def.default === undefined))
+                errors.push({ field: name, message: 'Required parameter is missing' });
+            continue; // server applies the default
+        }
+        switch (def.type) {
+            case 'number': {
+                const n = Number(raw);
+                if (!Number.isFinite(n))
+                    errors.push({ field: name, message: 'Expected a number' });
+                else
+                    params[name] = n;
+                break;
+            }
+            case 'boolean':
+                if (raw !== 'true' && raw !== 'false')
+                    errors.push({ field: name, message: 'Expected true or false' });
+                else
+                    params[name] = raw === 'true';
+                break;
+            case 'enum':
+                if (!(def.values ?? []).includes(raw))
+                    errors.push({ field: name, message: `Expected one of: ${(def.values ?? []).join(', ')}` });
+                else
+                    params[name] = raw;
+                break;
+            default:
+                params[name] = values[name] ?? '';
+        }
+    }
+    if (errors.length > 0)
+        return { ok: false, errors };
+    if (Object.keys(params).length > 0)
+        body.parameters = params;
+    return { ok: true, body };
+}
+/** Runtime override form → `PATCH /workflows/:id/runtime` body (`''` = keep YAML value → `null`). */
+export function buildRuntimeBody(values) {
+    const errors = [];
+    let enabled = null;
+    if (values.enabled === 'true' || values.enabled === 'false')
+        enabled = values.enabled === 'true';
+    else if (values.enabled !== '')
+        errors.push({ field: 'enabled', message: 'Expected true, false or empty' });
+    let priority = null;
+    if (values.priority.trim() !== '') {
+        const n = Number(values.priority);
+        if (!Number.isFinite(n))
+            errors.push({ field: 'priority', message: 'Expected a number' });
+        else
+            priority = n;
+    }
+    let maxConcurrent = null;
+    if (values.maxConcurrent.trim() !== '') {
+        const n = Number(values.maxConcurrent);
+        if (!Number.isInteger(n) || n < 1)
+            errors.push({ field: 'maxConcurrent', message: 'Expected an integer ≥ 1' });
+        else
+            maxConcurrent = n;
+    }
+    return errors.length > 0 ? { ok: false, errors } : { ok: true, body: { enabled, priority, maxConcurrent } };
+}

package/dist/ui/public/js/shared/route.js

@@ -0,0 +1,36 @@
+/**
+ * Hash routing (`#/runs/<id>?tab=logs`): no server-side fallback route is
+ * needed, the static server only serves `/index.html`.
+ */
+/** Parse `location.hash`. Invalid percent-encoding yields the raw segment. */
+export function parseHash(hash) {
+    let h = hash.startsWith('#') ? hash.slice(1) : hash;
+    if (h.startsWith('/'))
+        h = h.slice(1);
+    const q = h.indexOf('?');
+    const pathPart = q >= 0 ? h.slice(0, q) : h;
+    const queryPart = q >= 0 ? h.slice(q + 1) : '';
+    const decode = (s) => {
+        try {
+            return decodeURIComponent(s);
+        }
+        catch {
+            return s;
+        }
+    };
+    const segments = pathPart.split('/').filter((s) => s.length > 0).map(decode);
+    const query = {};
+    for (const [k, v] of new URLSearchParams(queryPart))
+        query[k] = v;
+    return { segments, query };
+}
+/** Build a hash (`#/a/b?x=1`); empty/undefined query values are omitted. */
+export function buildHash(segments, query = {}) {
+    const path = segments.map((s) => encodeURIComponent(s)).join('/');
+    const params = new URLSearchParams();
+    for (const [k, v] of Object.entries(query))
+        if (v !== null && v !== undefined && v !== '')
+            params.set(k, String(v));
+    const qs = params.toString();
+    return `#/${path}${qs ? `?${qs}` : ''}`;
+}

package/dist/ui/public/js/shared/sort.js

@@ -0,0 +1,70 @@
+/**
+ * Client-side column sorting of views (Spec §17: sorting in the browser is
+ * allowed, no further filters). Unknown/empty values always sort last.
+ */
+function isEmpty(c) {
+    if (!c || !c.known)
+        return true;
+    const v = c.value;
+    return v === null || v === undefined || v === '' || (Array.isArray(v) && v.length === 0);
+}
+const collator = typeof Intl !== 'undefined' ? new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' }) : null;
+/** Comparable primitive of a value of column type `type`. */
+function key(value, type) {
+    if (type === 'number' || typeof value === 'number') {
+        const n = typeof value === 'number' ? value : Number(value);
+        if (Number.isFinite(n))
+            return n;
+    }
+    if (type === 'date' || type === 'datetime') {
+        const t = Date.parse(String(value));
+        if (!Number.isNaN(t))
+            return t;
+    }
+    if (typeof value === 'boolean')
+        return value ? 1 : 0;
+    if (Array.isArray(value))
+        return value.map((v) => String(v)).join(', ');
+    if (value !== null && typeof value === 'object')
+        return JSON.stringify(value);
+    return String(value);
+}
+/** Compare two cells (empty last regardless of direction). */
+export function compareCells(a, b, type, direction) {
+    const ea = isEmpty(a);
+    const eb = isEmpty(b);
+    if (ea || eb)
+        return ea === eb ? 0 : ea ? 1 : -1;
+    const ka = key(a.value, type);
+    const kb = key(b.value, type);
+    let r;
+    if (typeof ka === 'number' && typeof kb === 'number')
+        r = ka - kb;
+    else
+        r = collator ? collator.compare(String(ka), String(kb)) : String(ka) < String(kb) ? -1 : String(ka) > String(kb) ? 1 : 0;
+    return direction === 'asc' ? r : -r;
+}
+/** Stable sort of rows by the cell at `column`. Returns a new array. */
+export function sortRows(rows, column, type, direction) {
+    return rows
+        .map((row, index) => ({ row, index }))
+        .sort((x, y) => compareCells(x.row.cells[column], y.row.cells[column], type, direction) || x.index - y.index)
+        .map((x) => x.row);
+}
+/** Next sort state when a column header is clicked. */
+export function nextSort(current, column) {
+    if (!current || current.column !== column)
+        return { column, direction: 'asc' };
+    return { column, direction: current.direction === 'asc' ? 'desc' : 'asc' };
+}
+/** Display text of a cell value (arrays joined, objects as JSON); `''` for empty. */
+export function cellText(c) {
+    if (isEmpty(c))
+        return '';
+    const v = c.value;
+    if (Array.isArray(v))
+        return v.map((x) => (typeof x === 'object' && x !== null ? JSON.stringify(x) : String(x))).join(', ');
+    if (typeof v === 'object' && v !== null)
+        return JSON.stringify(v);
+    return String(v);
+}