@gaia-ai/addon-gaia-ui 0.6.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 keytec GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @gaia-ai/addon-gaia-ui
+
+GAIA TUI: interactive terminal UI (project dashboard, ticket list, ticket detail) as a dropsh `tui` renderer plugin.
+
+Part of the GAIA CLI. Install the meta package `@gaia-ai/gaia` to get the `gaia` CLI with all addons. Source: https://git.key-tec.de/keytec/gaia (gaia-cli/).

package/dist/src/Component/agent-list/index.d.ts

@@ -0,0 +1,6 @@
+import type { HostedAgent } from '../../types.js';
+/** A fixed-column flat table for the Ticket-Agents screen: header + one line per
+ *  live agent (its label · the project/group it runs for). One physical row per
+ *  entry, so the Kernel's `1 + index` selection math holds. The agents are the
+ *  host's live set (from `list(group)`); a finished agent drops out on refresh. */
+export declare function agentListRows(agents: HostedAgent[]): string[];

package/dist/src/Component/agent-list/index.js

@@ -0,0 +1,14 @@
+import { pad } from '../../lib/format.js';
+/** A fixed-column flat table for the Ticket-Agents screen: header + one line per
+ *  live agent (its label · the project/group it runs for). One physical row per
+ *  entry, so the Kernel's `1 + index` selection math holds. The agents are the
+ *  host's live set (from `list(group)`); a finished agent drops out on refresh. */
+export function agentListRows(agents) {
+    const header = `${pad('AGENT', 32)} PROJECT`;
+    if (agents.length === 0)
+        return [header, 'No ticket agents.'];
+    return [
+        header,
+        ...agents.map((a) => `${pad(a.label || a.id, 32)} ${a.group}`),
+    ];
+}

package/dist/src/Component/comment-item/index.d.ts

@@ -0,0 +1,21 @@
+/** One collapsible comment entry for the Comments tab. */
+export interface CommentItem {
+    type: string;
+    author: string;
+    created: string | null;
+    bodyLines: string[];
+    preview: string;
+}
+/** The rendered Comments-tab view. */
+export interface CommentsTabView {
+    lines: string[];
+    boldRows: Set<number>;
+    headerRows: number[];
+    selectable: number;
+}
+/** The relative age of a comment's ISO `created`, or '—' when unknown. */
+export declare function relativeCreated(created: string | null | undefined, nowSeconds: number): string;
+export declare function commentsTabView(items: CommentItem[], { expanded, nowSeconds, }?: {
+    expanded?: Set<number>;
+    nowSeconds?: number;
+}): CommentsTabView;

package/dist/src/Component/comment-item/index.js

@@ -0,0 +1,39 @@
+import { humanizeAge } from '../../Deriver/liveness.js';
+/** The relative age of a comment's ISO `created`, or '—' when unknown. */
+export function relativeCreated(created, nowSeconds) {
+    const ms = created ? Date.parse(created) : Number.NaN;
+    return Number.isNaN(ms)
+        ? '—'
+        : humanizeAge(Math.floor(ms / 1000), nowSeconds);
+}
+// The Comments tab: one collapsible entry per comment. Collapsed = a single
+// caret header row (`▸ type · author · age · preview`); expanded (`▾`) appends
+// the full body, one physical row per body line. `headerRows[i]` is the row
+// index of comment i's header (for selection highlight + scroll).
+export function commentsTabView(items, { expanded = new Set(), nowSeconds = 0, } = {}) {
+    if (!items.length) {
+        return {
+            lines: ['No comments.'],
+            boldRows: new Set(),
+            headerRows: [],
+            selectable: 0,
+        };
+    }
+    const lines = [];
+    const boldRows = new Set();
+    const headerRows = [];
+    items.forEach((item, i) => {
+        headerRows.push(lines.length);
+        boldRows.add(lines.length);
+        const caret = expanded.has(i) ? '▾' : '▸';
+        const age = relativeCreated(item.created, nowSeconds);
+        const author = item.author || '—';
+        lines.push(`${caret} ${item.type} · ${author} · ${age} · ${item.preview}`);
+        if (expanded.has(i)) {
+            for (const bodyLine of item.bodyLines)
+                lines.push(`    ${bodyLine}`);
+            lines.push('');
+        }
+    });
+    return { lines, boldRows, headerRows, selectable: items.length };
+}

package/dist/src/Component/create-form/index.d.ts

@@ -0,0 +1,3 @@
+import type { CreateFormOptions, CreateFormState } from '../../Service/create-form.js';
+/** Render the "New ticket" popup form as plain rows (the kernel frames it). */
+export declare function createFormLines(s: CreateFormState, opts: CreateFormOptions): string[];

package/dist/src/Component/create-form/index.js

@@ -0,0 +1,26 @@
+const labelOf = (list, id) => list.find((o) => o.id === id)?.label ?? '—';
+/** Render the "New ticket" popup form as plain rows (the kernel frames it). */
+export function createFormLines(s, opts) {
+    const mark = (i) => (s.active === i ? '▸ ' : '  ');
+    const lines = [];
+    lines.push(`${mark(0)}Description:`);
+    const body = s.description.length ? s.description.split('\n') : ['<empty>'];
+    for (const line of body)
+        lines.push(`    ${line}`);
+    lines.push(`${mark(1)}Assignee:  < ${labelOf(opts.users, s.assignee)} >`);
+    lines.push(`${mark(2)}Conductor: < ${labelOf(opts.conductors, s.conductor)} >`);
+    lines.push(`${mark(3)}Labels:`);
+    if (opts.labels.length === 0) {
+        lines.push('    (none available)');
+    }
+    else {
+        opts.labels.forEach((o, i) => {
+            const box = s.labels.has(o.id) ? '[x]' : '[ ]';
+            const cursor = s.active === 3 && s.labelCursor === i ? '›' : ' ';
+            lines.push(`   ${cursor}${box} ${o.label}`);
+        });
+    }
+    lines.push(`${mark(4)}Workflow:  < ${labelOf(opts.workflows, s.workflow)} >`);
+    lines.push(`${mark(5)}[ Create ticket ]`);
+    return lines;
+}

package/dist/src/Component/dashboard-list/index.d.ts

@@ -0,0 +1,8 @@
+/** The minimum shape a dashboard row needs to render. */
+export interface DashboardRowInput {
+    project: string;
+    derivedStatus: string;
+    ageLabel: string;
+}
+/** One line per project: name, derived status, relative age. */
+export declare function dashboardRows(projects: DashboardRowInput[]): string[];

package/dist/src/Component/dashboard-list/index.js

@@ -0,0 +1,7 @@
+import { pad } from '../../lib/format.js';
+/** One line per project: name, derived status, relative age. */
+export function dashboardRows(projects) {
+    if (projects.length === 0)
+        return ['No projects.'];
+    return projects.map((p) => `${pad(p.project, 24)} ${pad(p.derivedStatus, 14)} ${p.ageLabel}`);
+}

package/dist/src/Component/run-table/index.d.ts

@@ -0,0 +1,10 @@
+import type { RunRow } from '../../Service/run-data.js';
+/**
+ * A fixed-column flat table of a project's runs: header + one line per run.
+ * Columns RUN · TICKET · STATE · PHASE · AGENT · STARTED, mirroring
+ * `ticketTableRows` (1 logical entry = 1 physical row). STATE is the derived
+ * liveness status and STARTED is the relative start age.
+ */
+export declare function runTableRows(runs: RunRow[], nowSeconds: number, { emptyMessage }?: {
+    emptyMessage?: string | undefined;
+}): string[];

package/dist/src/Component/run-table/index.js

@@ -0,0 +1,20 @@
+import { deriveRunStatus, runStartedAge } from '../../Deriver/run-status.js';
+import { pad } from '../../lib/format.js';
+/**
+ * A fixed-column flat table of a project's runs: header + one line per run.
+ * Columns RUN · TICKET · STATE · PHASE · AGENT · STARTED, mirroring
+ * `ticketTableRows` (1 logical entry = 1 physical row). STATE is the derived
+ * liveness status and STARTED is the relative start age.
+ */
+export function runTableRows(runs, nowSeconds, { emptyMessage } = {}) {
+    const header = `${pad('RUN', 8)} ${pad('TICKET', 10)} ${pad('STATE', 8)} ${pad('PHASE', 10)} ${pad('AGENT', 8)} STARTED`;
+    if (runs.length === 0)
+        return [header, emptyMessage ?? 'No runs for this project.'];
+    return [
+        header,
+        ...runs.map((r) => {
+            const run = `#${r.drupalId ?? r.id.slice(0, 6)}`;
+            return `${pad(run, 8)} ${pad(r.ticketIdentifier, 10)} ${pad(deriveRunStatus(r, nowSeconds), 8)} ${pad(r.phase, 10)} ${pad(r.agent, 8)} ${runStartedAge(r, nowSeconds)}`;
+        }),
+    ];
+}

package/dist/src/Component/section-list/index.d.ts

@@ -0,0 +1,9 @@
+/** A titled block of already-flattened physical rows. */
+export interface Section {
+    heading: string;
+    lines: string[];
+}
+export declare function flattenSections(sections: Section[]): {
+    lines: string[];
+    boldRows: Set<number>;
+};

package/dist/src/Component/section-list/index.js

@@ -0,0 +1,27 @@
+// Flatten `{heading, lines}` sections into plain rows plus the indices that are
+// bold (section headings + markdown ATX headings). Headings carry NO ANSI here —
+// the draw step applies bold after fit(), so sanitizeDisplay never sees (and
+// never strips) the ESC.
+export function flattenSections(sections) {
+    const lines = [];
+    const boldRows = new Set();
+    for (const section of sections) {
+        boldRows.add(lines.length);
+        lines.push(section.heading);
+        for (const line of section.lines) {
+            // Minimal markdown: an ATX heading (`#`…`######`) renders as bold with the
+            // markers stripped — same rule as a section heading, styled after fit().
+            // Bullets and code fences stay raw by design (explicit v1 decision).
+            const md = /^(#{1,6})\s+(.*)$/.exec(line);
+            if (md) {
+                boldRows.add(lines.length);
+                lines.push(md[2] ?? '');
+            }
+            else {
+                lines.push(line);
+            }
+        }
+        lines.push('');
+    }
+    return { lines, boldRows };
+}

package/dist/src/Component/tab-bar/index.d.ts

@@ -0,0 +1,9 @@
+/** One ticket-detail tab: its id, label, and the section headings it groups. */
+export interface DetailTab {
+    id: string;
+    label: string;
+    headings: string[];
+}
+export declare const DETAIL_TABS: DetailTab[];
+/** The tab bar as a single row; the active tab is bracketed. */
+export declare function tabBar(activeIndex: number): string;

package/dist/src/Component/tab-bar/index.js

@@ -0,0 +1,22 @@
+// The ticket-detail screen is split into tabs so only one tab's content draws at
+// a time (keeps the fixed-height window small) — Sub-tickets + Referenced share a
+// Related tab, Comments is its own tab with collapsible entries (owned by the
+// plugin's draw loop, which needs the interactive expand state).
+export const DETAIL_TABS = [
+    {
+        id: 'overview',
+        label: 'Overview',
+        headings: ['Description', 'Branch', 'Links', 'Environments'],
+    },
+    { id: 'comments', label: 'Comments', headings: [] },
+    {
+        id: 'related',
+        label: 'Related',
+        headings: ['Sub-tickets', 'Referenced tickets'],
+    },
+    { id: 'runs', label: 'Runs', headings: ['Runs'] },
+];
+/** The tab bar as a single row; the active tab is bracketed. */
+export function tabBar(activeIndex) {
+    return DETAIL_TABS.map((t, i) => i === activeIndex ? `[${t.label}]` : ` ${t.label} `).join(' ');
+}

package/dist/src/Component/ticket-detail/index.d.ts

@@ -0,0 +1,30 @@
+import type { TicketDetailDocument } from '../../types.js';
+import type { CommentItem } from '../comment-item/index.js';
+import type { Section } from '../section-list/index.js';
+/**
+ * The ticket detail sections, each with an explicit empty state:
+ * Description, Comments, Sub-tickets, Runs, Referenced tickets, Links,
+ * Branch, Environments.
+ */
+export declare function detailSections(document: TicketDetailDocument): Section[];
+/** The detailSections that belong to a given (non-comments) tab, in tab order. */
+export declare function sectionsForTab(document: TicketDetailDocument, tabIndex: number): Section[];
+/**
+ * One item per comment for the collapsible Comments tab: type, author, created
+ * (raw ISO — the plugin formats the relative age), the body split into physical
+ * lines, and a first-line preview for the collapsed header.
+ */
+export declare function commentItems(document: TicketDetailDocument): CommentItem[];
+export declare function detailLines(detail?: TicketDetailDocument | null): {
+    lines: string[];
+    boldRows: Set<number>;
+};
+export declare function tabViewLines(detail: TicketDetailDocument | null | undefined, tabIndex: number, { expanded, nowSeconds, }?: {
+    expanded?: Set<number>;
+    nowSeconds?: number;
+}): {
+    lines: string[];
+    boldRows: Set<number>;
+    headerRows: number[];
+    selectable: number;
+};

package/dist/src/Component/ticket-detail/index.js

@@ -0,0 +1,129 @@
+// The ticket-detail screen: composes section-list (flatten + markdown bold),
+// tab-bar (DETAIL_TABS) and comment-item (the collapsible Comments tab) into
+// the two shapes the plugin's draw loop consumes — the whole document
+// flattened (`detailLines`, non-TTY/back-compat) and one tab at a time
+// (`tabViewLines`, the interactive screen).
+import { asString } from '../../lib/format.js';
+import { commentsTabView } from '../comment-item/index.js';
+import { flattenSections } from '../section-list/index.js';
+import { DETAIL_TABS } from '../tab-bar/index.js';
+function fieldValue(value) {
+    if (value && typeof value === 'object' && 'value' in value) {
+        const inner = value.value;
+        if (typeof inner === 'string')
+            return inner;
+    }
+    return typeof value === 'string' ? value : '';
+}
+function refCount(document, name) {
+    const data = document.data?.relationships?.[name]?.data;
+    return Array.isArray(data) ? data.length : data ? 1 : 0;
+}
+function commentResources(document) {
+    return (document.included ?? []).filter((r) => r.type === 'gaia_comment--gaia_comment');
+}
+/**
+ * The ticket detail sections, each with an explicit empty state:
+ * Description, Comments, Sub-tickets, Runs, Referenced tickets, Links,
+ * Branch, Environments.
+ */
+export function detailSections(document) {
+    const a = document.data?.attributes ?? {};
+    const sections = [];
+    const description = fieldValue(a.description);
+    sections.push({
+        heading: 'Description',
+        lines: description ? description.split('\n') : ['No description.'],
+    });
+    const comments = commentResources(document);
+    sections.push({
+        heading: 'Comments',
+        // One physical line per body line: a `— type ·` marker followed by the body
+        // split on '\n' (mirrors the Description section). Keeping a multi-line body
+        // in a single entry breaks draw()'s one-entry-one-row invariant (AC-4).
+        lines: comments.length
+            ? comments.flatMap((c) => {
+                const type = asString(c.attributes?.gaia_comment_type) ?? 'comment';
+                const body = fieldValue(c.attributes?.body);
+                return [`— ${type} ·`, ...(body ? body.split('\n') : [''])];
+            })
+            : ['No comments.'],
+    });
+    const relSection = (heading, rel) => {
+        const n = refCount(document, rel);
+        sections.push({
+            heading,
+            lines: n
+                ? [`${n} ${heading.toLowerCase()}`]
+                : [`No ${heading.toLowerCase()}.`],
+        });
+    };
+    relSection('Sub-tickets', 'sub_tickets');
+    relSection('Runs', 'runs');
+    relSection('Referenced tickets', 'referenced_tickets');
+    const links = Array.isArray(a.links) ? a.links : [];
+    sections.push({
+        heading: 'Links',
+        lines: links.length
+            ? links.map((l) => {
+                const link = l;
+                return `${link.title ?? ''} ${link.uri ?? link.url ?? ''}`.trim();
+            })
+            : ['No links.'],
+    });
+    sections.push({
+        heading: 'Branch',
+        lines: [
+            `branch: ${asString(a.branch_name) ?? '—'}`,
+            `base:   ${asString(a.base_branch) ?? '—'}`,
+        ],
+    });
+    relSection('Environments', 'environments');
+    return sections;
+}
+/** The detailSections that belong to a given (non-comments) tab, in tab order. */
+export function sectionsForTab(document, tabIndex) {
+    const tab = DETAIL_TABS[tabIndex];
+    const headings = tab?.headings ?? [];
+    if (!headings.length)
+        return [];
+    const byHeading = new Map(detailSections(document).map((s) => [s.heading, s]));
+    return headings
+        .map((h) => byHeading.get(h))
+        .filter((s) => s !== undefined);
+}
+/**
+ * One item per comment for the collapsible Comments tab: type, author, created
+ * (raw ISO — the plugin formats the relative age), the body split into physical
+ * lines, and a first-line preview for the collapsed header.
+ */
+export function commentItems(document) {
+    const comments = commentResources(document);
+    return comments.map((c) => {
+        const type = asString(c.attributes?.gaia_comment_type) ?? 'comment';
+        const author = asString(c.attributes?.author_name) ?? '';
+        const created = asString(c.attributes?.created) ?? null;
+        const body = fieldValue(c.attributes?.body);
+        const bodyLines = body ? body.split('\n') : [''];
+        return { type, author, created, bodyLines, preview: bodyLines[0] ?? '' };
+    });
+}
+// The whole ticket-detail document flattened (all sections). Reserved helper —
+// currently unused by the interactive screen (which renders one tab at a time
+// via tabViewLines); kept as a tested convenience for a full-document render.
+export function detailLines(detail) {
+    return flattenSections(detailSections(detail ?? {}));
+}
+// The rows for one detail tab. The Comments tab is the collapsible list; every
+// other tab flattens just its own sections. Returns `selectable`/`headerRows`
+// so the draw loop can highlight + scroll the selected comment (0 elsewhere).
+export function tabViewLines(detail, tabIndex, { expanded = new Set(), nowSeconds = 0, } = {}) {
+    if (DETAIL_TABS[tabIndex]?.id === 'comments') {
+        return commentsTabView(commentItems(detail ?? {}), {
+            expanded,
+            nowSeconds,
+        });
+    }
+    const { lines, boldRows } = flattenSections(sectionsForTab(detail ?? {}, tabIndex));
+    return { lines, boldRows, headerRows: [], selectable: 0 };
+}

package/dist/src/Component/ticket-table/index.d.ts

@@ -0,0 +1,5 @@
+import type { TicketRow } from '../../Service/project-data.js';
+/** A fixed-column flat table: header + one line per ticket. */
+export declare function ticketTableRows(tickets: TicketRow[], { emptyMessage }?: {
+    emptyMessage?: string | undefined;
+}): string[];

package/dist/src/Component/ticket-table/index.js

@@ -0,0 +1,14 @@
+import { pad } from '../../lib/format.js';
+/** A fixed-column flat table: header + one line per ticket. */
+export function ticketTableRows(tickets, { emptyMessage } = {}) {
+    const header = `${pad('IDENTIFIER', 10)} ${pad('STATE', 8)} ${pad('PRIO', 5)} ${pad('WHO', 4)} ${pad('RUN', 8)} ${pad('PARENT', 10)} ${pad('COND', 14)} TITLE`;
+    if (tickets.length === 0)
+        return [header, emptyMessage ?? 'No tickets.'];
+    return [
+        header,
+        ...tickets.map((t) => {
+            const labels = t.labels?.length ? `  [${t.labels.join(',')}]` : '';
+            return `${pad(t.identifier, 10)} ${pad(t.state, 8)} ${pad(t.priority ?? '—', 5)} ${pad(t.assigneeInitials || '—', 4)} ${pad(t.derivedStatus, 8)} ${pad(t.parent ?? '—', 10)} ${pad(t.conductor ?? '—', 14)} ${t.title}${labels}`;
+        }),
+    ];
+}

package/dist/src/Component/top-tabs/index.d.ts

@@ -0,0 +1,8 @@
+/** One top-level TUI tab: its id and label. */
+export interface TopTab {
+    id: string;
+    label: string;
+}
+export declare const TOP_TABS: TopTab[];
+/** The top tab bar as a single row; the active tab is bracketed. */
+export declare function topTabBar(activeId: string): string;

package/dist/src/Component/top-tabs/index.js

@@ -0,0 +1,13 @@
+// The top-level navigation tabs. `tickets` is the project/ticket drill-down;
+// `ticket-agents` is the managed create-agent list (GAIA-190); `runs` is the
+// project-scoped run overview (GAIA-192). `conductors` is a planned follow-up
+// (tracked separately) — not wired yet.
+export const TOP_TABS = [
+    { id: 'tickets', label: 'Tickets' },
+    { id: 'ticket-agents', label: 'Ticket-Agents' },
+    { id: 'runs', label: 'Runs' },
+];
+/** The top tab bar as a single row; the active tab is bracketed. */
+export function topTabBar(activeId) {
+    return TOP_TABS.map((t) => t.id === activeId ? `[${t.label}]` : ` ${t.label} `).join('  ');
+}

package/dist/src/Deriver/liveness.d.ts

@@ -0,0 +1,12 @@
+/** The derived liveness state of a conductor. */
+export type ConductorStatus = 'running' | 'stale' | 'offline' | 'registry-only';
+/** The raw liveness inputs derived from a `gaia_conductor` record. */
+export interface ConductorInput {
+    present?: boolean;
+    status?: string | null;
+    lastSeen?: number | null;
+    leaseExpiresAt?: number | null;
+}
+export declare function deriveConductorStatus(conductor: ConductorInput, nowSeconds: number): ConductorStatus;
+/** A short relative age label ("just now", "3m ago", …); '—' when unknown. */
+export declare function humanizeAge(lastSeenSeconds: number | null, nowSeconds: number): string;

package/dist/src/Deriver/liveness.js

@@ -0,0 +1,34 @@
+// Conductor liveness derivation. Mirrors the server-side ConductorDeriver
+// (web/modules/custom/gaia_core/modules/gaia_dashboard/src/Dashboard/ConductorDeriver.php)
+// and the CLI `classify()` in gaia-cli/conductor/src/commands/conductor.ts:
+// no gaia_conductor record → registry-only; status 'offline' → offline; else
+// stale when last_seen older than 600s OR the lease has expired; else running.
+const STALE_WINDOW_SECONDS = 600;
+export function deriveConductorStatus(conductor, nowSeconds) {
+    if (!conductor?.present)
+        return 'registry-only';
+    if (conductor.status === 'offline')
+        return 'offline';
+    if (conductor.lastSeen == null)
+        return 'stale';
+    if (nowSeconds - conductor.lastSeen > STALE_WINDOW_SECONDS)
+        return 'stale';
+    if (conductor.leaseExpiresAt != null &&
+        conductor.leaseExpiresAt < nowSeconds) {
+        return 'stale';
+    }
+    return 'running';
+}
+/** A short relative age label ("just now", "3m ago", …); '—' when unknown. */
+export function humanizeAge(lastSeenSeconds, nowSeconds) {
+    if (lastSeenSeconds == null)
+        return '—';
+    const delta = Math.max(0, nowSeconds - lastSeenSeconds);
+    if (delta < 45)
+        return 'just now';
+    if (delta < 3600)
+        return `${Math.round(delta / 60)}m ago`;
+    if (delta < 86_400)
+        return `${Math.round(delta / 3600)}h ago`;
+    return `${Math.round(delta / 86_400)}d ago`;
+}

package/dist/src/Deriver/run-status.d.ts

@@ -0,0 +1,12 @@
+import type { RunRow } from '../Service/run-data.js';
+/** The derived, display-facing status of a run. */
+export type RunStatus = 'running' | 'stale' | 'claimed' | 'done' | 'expired' | 'failed' | string;
+/**
+ * Derive the run's display status. Terminal states (`done`/`expired`/`failed`)
+ * pass through. An active run (`running`/`claimed`) is `stale` when its
+ * heartbeat is older than the liveness window OR its claim has expired; else it
+ * keeps its own state.
+ */
+export declare function deriveRunStatus(row: RunRow, nowSeconds: number): RunStatus;
+/** A short relative age of the run's start ("just now", "1h ago", …), '—'. */
+export declare function runStartedAge(row: RunRow, nowSeconds: number): string;

package/dist/src/Deriver/run-status.js

@@ -0,0 +1,36 @@
+import { humanizeAge } from './liveness.js';
+const STALE_WINDOW_SECONDS = 600;
+/** Parse an ISO timestamp (or a numeric unix value) to unix seconds, or null. */
+function toSeconds(value) {
+    if (value == null)
+        return null;
+    if (typeof value === 'number')
+        return value;
+    const ms = Date.parse(value);
+    if (!Number.isNaN(ms))
+        return Math.floor(ms / 1000);
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+}
+/**
+ * Derive the run's display status. Terminal states (`done`/`expired`/`failed`)
+ * pass through. An active run (`running`/`claimed`) is `stale` when its
+ * heartbeat is older than the liveness window OR its claim has expired; else it
+ * keeps its own state.
+ */
+export function deriveRunStatus(row, nowSeconds) {
+    const state = row.state;
+    if (state !== 'running' && state !== 'claimed')
+        return state;
+    const hb = toSeconds(row.heartbeat);
+    if (hb != null && nowSeconds - hb > STALE_WINDOW_SECONDS)
+        return 'stale';
+    const claim = toSeconds(row.claimExpiresAt);
+    if (claim != null && claim < nowSeconds)
+        return 'stale';
+    return state;
+}
+/** A short relative age of the run's start ("just now", "1h ago", …), '—'. */
+export function runStartedAge(row, nowSeconds) {
+    return humanizeAge(toSeconds(row.startedAt), nowSeconds);
+}

package/dist/src/Kernel/tui-kernel.d.ts

@@ -0,0 +1,2 @@
+import type { RendererServices, TuiOptions } from '../types.js';
+export declare function runTicketTui(_document: unknown, _context: unknown, services: RendererServices, options?: TuiOptions): Promise<void>;