@matthesketh/fleet 1.1.0 → 1.6.0

package/dist/tui/routines/hooks/use-logs-stream.js

@@ -0,0 +1,64 @@
+import { spawn } from 'node:child_process';
+import { useEffect, useRef, useState } from 'react';
+const LEVEL_PATTERNS = [
+    [/\b(error|err|failed|fatal)\b/i, 'error'],
+    [/\b(warn|warning)\b/i, 'warn'],
+    [/\b(debug|trace)\b/i, 'debug'],
+];
+function classify(line) {
+    for (const [pattern, level] of LEVEL_PATTERNS) {
+        if (pattern.test(line))
+            return level;
+    }
+    return 'info';
+}
+export function useLogsStream(opts) {
+    const [lines, setLines] = useState([]);
+    const [running, setRunning] = useState(false);
+    const [error, setError] = useState(null);
+    const [version, setVersion] = useState(0);
+    const bufferSize = opts?.bufferSize ?? 500;
+    const lineBufferRef = useRef('');
+    useEffect(() => {
+        if (!opts) {
+            setLines([]);
+            setRunning(false);
+            return;
+        }
+        setLines([]);
+        setError(null);
+        setRunning(true);
+        lineBufferRef.current = '';
+        const child = spawn(opts.command, opts.args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const append = (chunk) => {
+            lineBufferRef.current += chunk;
+            let idx;
+            const newLines = [];
+            while ((idx = lineBufferRef.current.indexOf('\n')) >= 0) {
+                const text = lineBufferRef.current.slice(0, idx);
+                lineBufferRef.current = lineBufferRef.current.slice(idx + 1);
+                if (!text.trim())
+                    continue;
+                newLines.push({ text, level: classify(text), timestamp: new Date() });
+            }
+            if (newLines.length > 0) {
+                setLines(prev => {
+                    const combined = [...prev, ...newLines];
+                    return combined.length > bufferSize ? combined.slice(-bufferSize) : combined;
+                });
+            }
+        };
+        child.stdout?.setEncoding('utf-8');
+        child.stderr?.setEncoding('utf-8');
+        child.stdout?.on('data', append);
+        child.stderr?.on('data', append);
+        child.on('error', err => { setError(err.message); setRunning(false); });
+        child.on('close', () => setRunning(false));
+        return () => {
+            child.kill('SIGTERM');
+            setTimeout(() => { if (!child.killed)
+                child.kill('SIGKILL'); }, 2000);
+        };
+    }, [opts?.command, opts?.args.join(' '), bufferSize, version]);
+    return { lines, running, error, restart: () => setVersion(v => v + 1) };
+}

package/dist/tui/routines/hooks/use-ops-fleet.d.ts

@@ -0,0 +1,20 @@
+import type { AppEntry } from '../../../core/registry.js';
+import { type ServiceStatus } from '../../../core/systemd.js';
+export interface OpsRepoState {
+    name: string;
+    service: ServiceStatus | null;
+    runningContainers: number;
+    totalContainers: number;
+}
+export interface OpsSnapshot {
+    loading: boolean;
+    repos: OpsRepoState[];
+    nginxSites: number | null;
+    nginxOk: boolean | null;
+    dockerDatabasesActive: boolean | null;
+    diskPercent: number | null;
+    refreshedAt: number;
+}
+export declare function useOpsFleet(apps: AppEntry[]): OpsSnapshot & {
+    refresh(): void;
+};

package/dist/tui/routines/hooks/use-ops-fleet.js

@@ -0,0 +1,70 @@
+import { useEffect, useState } from 'react';
+import { execSafe } from '../../../core/exec.js';
+import { getMultipleServiceStatuses } from '../../../core/systemd.js';
+function countContainersByProject(project) {
+    const res = execSafe('docker', [
+        'ps', '--all',
+        '--filter', `label=com.docker.compose.project=${project}`,
+        '--format', '{{.State}}',
+    ], { timeout: 5000 });
+    if (!res.ok)
+        return { running: 0, total: 0 };
+    const states = res.stdout.split('\n').map(s => s.trim()).filter(Boolean);
+    return { running: states.filter(s => s === 'running').length, total: states.length };
+}
+function nginxHealth() {
+    const test = execSafe('nginx', ['-t'], { timeout: 4000 });
+    const list = execSafe('bash', ['-c', "ls /etc/nginx/sites-enabled/ 2>/dev/null | wc -l"], { timeout: 3000 });
+    const count = list.ok ? parseInt(list.stdout.trim(), 10) : null;
+    return { sites: Number.isFinite(count) ? count : null, ok: test.ok };
+}
+function diskPercent(path) {
+    const res = execSafe('bash', ['-c', `df -P ${path} | awk 'NR==2 {gsub("%",""); print $5}'`], { timeout: 3000 });
+    if (!res.ok)
+        return null;
+    const v = parseInt(res.stdout.trim(), 10);
+    return Number.isFinite(v) ? v : null;
+}
+export function useOpsFleet(apps) {
+    const [state, setState] = useState({
+        loading: false,
+        repos: [],
+        nginxSites: null,
+        nginxOk: null,
+        dockerDatabasesActive: null,
+        diskPercent: null,
+        refreshedAt: 0,
+    });
+    const load = () => {
+        setState(s => ({ ...s, loading: true }));
+        const serviceNames = apps.map(a => a.serviceName).filter(Boolean);
+        const allServiceNames = Array.from(new Set([...serviceNames, 'docker-databases']));
+        const serviceMap = getMultipleServiceStatuses(allServiceNames);
+        const repos = apps.map(app => {
+            const counts = countContainersByProject(app.name);
+            return {
+                name: app.name,
+                service: serviceMap.get(app.serviceName) ?? null,
+                runningContainers: counts.running,
+                totalContainers: counts.total,
+            };
+        });
+        const nginx = nginxHealth();
+        const disk = diskPercent('/home');
+        setState({
+            loading: false,
+            repos,
+            nginxSites: nginx.sites,
+            nginxOk: nginx.ok,
+            dockerDatabasesActive: serviceMap.get('docker-databases')?.active ?? null,
+            diskPercent: disk,
+            refreshedAt: Date.now(),
+        });
+    };
+    useEffect(() => {
+        load();
+        const id = setInterval(load, 20_000);
+        return () => clearInterval(id);
+    }, [apps.map(a => a.name).join('|')]);
+    return { ...state, refresh: load };
+}

package/dist/tui/routines/hooks/use-repo-detail.d.ts

@@ -0,0 +1,31 @@
+import type { AppEntry } from '../../../core/registry.js';
+import { type GitStatus } from '../../../core/git.js';
+import { type ServiceStatus } from '../../../core/systemd.js';
+export interface OpenPr {
+    number: number;
+    title: string;
+    author: string;
+    updatedAt: string;
+    url: string;
+    isDraft: boolean;
+}
+export interface LastCommit {
+    hash: string;
+    subject: string;
+    date: string;
+    author: string;
+}
+export interface RepoDetailSnapshot {
+    loading: boolean;
+    error: string | null;
+    git: GitStatus | null;
+    lastCommit: LastCommit | null;
+    openPrs: OpenPr[] | null;
+    service: ServiceStatus | null;
+    runningContainers: number | null;
+    totalContainers: number | null;
+    refreshedAt: number;
+}
+export declare function useRepoDetail(app: AppEntry | null): RepoDetailSnapshot & {
+    refresh(): void;
+};

package/dist/tui/routines/hooks/use-repo-detail.js

@@ -0,0 +1,104 @@
+import { useEffect, useRef, useState } from 'react';
+import { execSafe } from '../../../core/exec.js';
+import { getGitStatus } from '../../../core/git.js';
+import { getMultipleServiceStatuses } from '../../../core/systemd.js';
+function fetchLastCommit(cwd) {
+    const res = execSafe('git', ['-C', cwd, 'log', '-1', '--format=%H%x09%s%x09%ad%x09%an', '--date=iso-strict'], { timeout: 5000 });
+    if (!res.ok || !res.stdout)
+        return null;
+    const [hash, subject, date, author] = res.stdout.split('\t');
+    if (!hash || !subject)
+        return null;
+    return { hash: hash.slice(0, 8), subject, date, author };
+}
+function fetchOpenPrs(cwd) {
+    const res = execSafe('gh', [
+        'pr', 'list', '--state', 'open',
+        '--json', 'number,title,author,updatedAt,url,isDraft',
+        '--limit', '20',
+    ], { cwd, timeout: 8000 });
+    if (!res.ok)
+        return null;
+    try {
+        const raw = JSON.parse(res.stdout);
+        return raw.map(p => ({
+            number: p.number,
+            title: p.title,
+            author: p.author?.login ?? 'unknown',
+            updatedAt: p.updatedAt,
+            url: p.url,
+            isDraft: p.isDraft,
+        }));
+    }
+    catch {
+        return null;
+    }
+}
+function fetchContainerCounts(project) {
+    const res = execSafe('docker', [
+        'ps', '--all',
+        '--filter', `label=com.docker.compose.project=${project}`,
+        '--format', '{{.State}}',
+    ], { timeout: 5000 });
+    if (!res.ok)
+        return null;
+    const states = res.stdout.split('\n').map(s => s.trim()).filter(Boolean);
+    return { running: states.filter(s => s === 'running').length, total: states.length };
+}
+export function useRepoDetail(app) {
+    const [snapshot, setSnapshot] = useState({
+        loading: false,
+        error: null,
+        git: null,
+        lastCommit: null,
+        openPrs: null,
+        service: null,
+        runningContainers: null,
+        totalContainers: null,
+        refreshedAt: 0,
+    });
+    const mounted = useRef(true);
+    useEffect(() => {
+        mounted.current = true;
+        return () => { mounted.current = false; };
+    }, []);
+    const load = () => {
+        if (!app)
+            return;
+        setSnapshot(s => ({ ...s, loading: true, error: null }));
+        try {
+            const cwd = app.composePath ?? '';
+            const git = cwd ? getGitStatus(cwd) : null;
+            const lastCommit = cwd ? fetchLastCommit(cwd) : null;
+            const openPrs = cwd ? fetchOpenPrs(cwd) : null;
+            const service = app.serviceName ? getMultipleServiceStatuses([app.serviceName]).get(app.serviceName) ?? null : null;
+            const containers = fetchContainerCounts(app.name);
+            if (!mounted.current)
+                return;
+            setSnapshot({
+                loading: false,
+                error: null,
+                git,
+                lastCommit,
+                openPrs,
+                service,
+                runningContainers: containers?.running ?? null,
+                totalContainers: containers?.total ?? null,
+                refreshedAt: Date.now(),
+            });
+        }
+        catch (err) {
+            if (!mounted.current)
+                return;
+            setSnapshot(s => ({ ...s, loading: false, error: err.message }));
+        }
+    };
+    useEffect(() => {
+        if (!app)
+            return;
+        load();
+        const id = setInterval(load, 30_000);
+        return () => clearInterval(id);
+    }, [app?.name]);
+    return { ...snapshot, refresh: load };
+}

package/dist/tui/routines/hooks/use-security.d.ts

@@ -0,0 +1,33 @@
+import type { AppEntry } from '../../../core/registry.js';
+export interface GuardianStatus {
+    binaryInstalled: boolean;
+    whitelistExists: boolean;
+    whitelistLines: number | null;
+    runcWhitelisted: boolean | null;
+}
+export interface SshAgentStatus {
+    socketExists: boolean;
+    keyLoaded: boolean | null;
+    keyFingerprint: string | null;
+}
+export interface CertExpiry {
+    domain: string;
+    expiresAt: string | null;
+    daysUntil: number | null;
+}
+export interface SecretAge {
+    app: string;
+    ageDays: number | null;
+    error: string | null;
+}
+export interface SecuritySnapshot {
+    loading: boolean;
+    guardian: GuardianStatus | null;
+    ssh: SshAgentStatus | null;
+    certs: CertExpiry[];
+    secretAges: SecretAge[];
+    refreshedAt: number;
+}
+export declare function useSecurity(apps: AppEntry[]): SecuritySnapshot & {
+    refresh(): void;
+};

package/dist/tui/routines/hooks/use-security.js

@@ -0,0 +1,110 @@
+import { existsSync, statSync } from 'node:fs';
+import { useEffect, useState } from 'react';
+import { execSafe } from '../../../core/exec.js';
+const SSH_AUTH_SOCK_PATH = '/tmp/fleet-ssh-agent.sock';
+const GUARDIAN_WHITELIST = '/etc/guardian/whitelist';
+function checkGuardian() {
+    const binary = existsSync('/usr/local/bin/guardiand');
+    const whitelistExists = existsSync(GUARDIAN_WHITELIST);
+    let whitelistLines = null;
+    let runcWhitelisted = null;
+    if (whitelistExists) {
+        const res = execSafe('bash', ['-c', `wc -l < ${GUARDIAN_WHITELIST} && grep -c '^/runc$' ${GUARDIAN_WHITELIST}`], { timeout: 3000 });
+        if (res.ok) {
+            const lines = res.stdout.split('\n').map(s => parseInt(s.trim(), 10));
+            whitelistLines = Number.isFinite(lines[0]) ? lines[0] : null;
+            runcWhitelisted = lines[1] ? lines[1] > 0 : false;
+        }
+    }
+    return { binaryInstalled: binary, whitelistExists, whitelistLines, runcWhitelisted };
+}
+function checkSshAgent() {
+    const socketExists = existsSync(SSH_AUTH_SOCK_PATH);
+    if (!socketExists)
+        return { socketExists: false, keyLoaded: null, keyFingerprint: null };
+    const res = execSafe('ssh-add', ['-l'], {
+        env: { SSH_AUTH_SOCK: SSH_AUTH_SOCK_PATH },
+        timeout: 3000,
+    });
+    if (!res.ok || !res.stdout)
+        return { socketExists: true, keyLoaded: false, keyFingerprint: null };
+    const line = res.stdout.split('\n')[0] ?? '';
+    const fp = line.split(/\s+/)[1] ?? null;
+    return { socketExists: true, keyLoaded: true, keyFingerprint: fp };
+}
+function certExpiryFor(domain) {
+    const paths = [
+        `/etc/letsencrypt/live/${domain}/fullchain.pem`,
+        `/etc/nginx/ssl/${domain}/fullchain.pem`,
+    ];
+    for (const path of paths) {
+        if (!existsSync(path))
+            continue;
+        const res = execSafe('openssl', ['x509', '-enddate', '-noout', '-in', path], { timeout: 3000 });
+        if (!res.ok)
+            continue;
+        const m = res.stdout.match(/notAfter=(.+)/);
+        if (!m)
+            continue;
+        const expiresAt = new Date(m[1]);
+        if (isNaN(expiresAt.getTime()))
+            continue;
+        const daysUntil = Math.floor((expiresAt.getTime() - Date.now()) / 86_400_000);
+        return { domain, expiresAt: expiresAt.toISOString(), daysUntil };
+    }
+    return { domain, expiresAt: null, daysUntil: null };
+}
+function secretAgeFor(app) {
+    const secretsPath = `${app.composePath}/secrets/vault.age`;
+    if (!existsSync(secretsPath))
+        return { app: app.name, ageDays: null, error: 'no vault.age' };
+    try {
+        const stat = statSync(secretsPath);
+        const ageDays = Math.floor((Date.now() - stat.mtimeMs) / 86_400_000);
+        return { app: app.name, ageDays, error: null };
+    }
+    catch (err) {
+        return { app: app.name, ageDays: null, error: err.message };
+    }
+}
+export function useSecurity(apps) {
+    const [state, setState] = useState({
+        loading: false,
+        guardian: null,
+        ssh: null,
+        certs: [],
+        secretAges: [],
+        refreshedAt: 0,
+    });
+    const load = () => {
+        setState(s => ({ ...s, loading: true }));
+        const guardian = checkGuardian();
+        const ssh = checkSshAgent();
+        const domains = new Set();
+        for (const app of apps)
+            for (const d of app.domains)
+                domains.add(d);
+        const certs = [];
+        for (const d of domains)
+            certs.push(certExpiryFor(d));
+        certs.sort((a, b) => (a.daysUntil ?? Infinity) - (b.daysUntil ?? Infinity));
+        const secretAges = apps
+            .filter(a => a.secretsManaged)
+            .map(secretAgeFor)
+            .sort((a, b) => (b.ageDays ?? 0) - (a.ageDays ?? 0));
+        setState({
+            loading: false,
+            guardian,
+            ssh,
+            certs,
+            secretAges,
+            refreshedAt: Date.now(),
+        });
+    };
+    useEffect(() => {
+        load();
+        const id = setInterval(load, 60_000);
+        return () => clearInterval(id);
+    }, [apps.map(a => a.name).join('|')]);
+    return { ...state, refresh: load };
+}

package/dist/tui/routines/hooks/use-signals.d.ts

@@ -0,0 +1,9 @@
+import type { Signal } from '../../../core/routines/schema.js';
+import type { SignalCollector, SignalTarget } from '../../../core/routines/signals-collector.js';
+export interface UseSignalsResult {
+    snapshot: Map<string, Signal[]>;
+    loading: boolean;
+    lastRefreshed: number;
+    refresh(force?: boolean): Promise<void>;
+}
+export declare function useSignals(collector: SignalCollector, targets: SignalTarget[], intervalMs?: number): UseSignalsResult;

package/dist/tui/routines/hooks/use-signals.js

@@ -0,0 +1,60 @@
+import { useEffect, useRef, useState } from 'react';
+export function useSignals(collector, targets, intervalMs = 30_000) {
+    const [snapshot, setSnapshot] = useState(new Map());
+    const [loading, setLoading] = useState(false);
+    const [lastRefreshed, setLastRefreshed] = useState(0);
+    const mounted = useRef(true);
+    const targetsKey = targets.map(t => t.repoName).join('|');
+    useEffect(() => {
+        mounted.current = true;
+        return () => { mounted.current = false; };
+    }, []);
+    useEffect(() => {
+        let cancelled = false;
+        const run = async (force = false) => {
+            if (cancelled)
+                return;
+            setLoading(true);
+            try {
+                if (force) {
+                    await collector.collect(targets.map(target => ({ target, force: true })));
+                }
+                else {
+                    await collector.collect(targets.map(target => ({ target })));
+                }
+                if (cancelled || !mounted.current)
+                    return;
+                const next = new Map();
+                for (const t of targets)
+                    next.set(t.repoName, collector.readCached(t.repoName));
+                setSnapshot(next);
+                setLastRefreshed(Date.now());
+            }
+            finally {
+                if (mounted.current && !cancelled)
+                    setLoading(false);
+            }
+        };
+        void run();
+        const id = setInterval(() => void run(), intervalMs);
+        return () => {
+            cancelled = true;
+            clearInterval(id);
+        };
+    }, [collector, targetsKey, intervalMs]);
+    const refresh = async (force = false) => {
+        setLoading(true);
+        try {
+            await collector.collect(targets.map(target => ({ target, force })));
+            const next = new Map();
+            for (const t of targets)
+                next.set(t.repoName, collector.readCached(t.repoName));
+            setSnapshot(next);
+            setLastRefreshed(Date.now());
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    return { snapshot, loading, lastRefreshed, refresh };
+}

package/dist/tui/routines/runtime.d.ts

@@ -0,0 +1,20 @@
+import type Database from 'better-sqlite3';
+import type { RoutineEngine } from '../../core/routines/engine.js';
+import { RoutineStore } from '../../core/routines/store.js';
+import { SignalCollector } from '../../core/routines/signals-collector.js';
+export interface RoutinesRuntime {
+    engine: RoutineEngine;
+    store: RoutineStore;
+    collector: SignalCollector;
+    db: Database.Database;
+    seeded: {
+        seeded: number;
+        skipped: number;
+    };
+    close(): void;
+}
+export interface RuntimeOptions {
+    dataDir?: string;
+    seedDefaults?: boolean;
+}
+export declare function createRuntime(opts?: RuntimeOptions): RoutinesRuntime;

package/dist/tui/routines/runtime.js

@@ -0,0 +1,40 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createStdoutNotifier } from '../../adapters/notifier/index.js';
+import { builtInSignalProviders } from '../../adapters/signals/index.js';
+import { closeDb, openDb } from '../../core/routines/db.js';
+import { builtInDefaultRoutines } from '../../core/routines/defaults.js';
+import { RoutineEngine as Engine } from '../../core/routines/engine.js';
+import { createClaudeCliRunner } from '../../adapters/runner/claude-cli.js';
+import { createMcpCallRunner } from '../../adapters/runner/mcp-call.js';
+import { createShellRunner } from '../../adapters/runner/shell.js';
+import { createSystemdTimerAdapter } from '../../adapters/scheduler/systemd-timer.js';
+import { RoutineStore } from '../../core/routines/store.js';
+import { SignalCollector } from '../../core/routines/signals-collector.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_DATA_DIR = join(__dirname, '..', '..', '..', 'data');
+export function createRuntime(opts = {}) {
+    const dataDir = opts.dataDir ?? DEFAULT_DATA_DIR;
+    const db = openDb({ path: join(dataDir, 'fleet.db') });
+    const store = new RoutineStore(join(dataDir, 'routines.json'));
+    const seeded = opts.seedDefaults === false
+        ? { seeded: 0, skipped: 0 }
+        : store.seedDefaults(builtInDefaultRoutines());
+    const scheduler = createSystemdTimerAdapter();
+    const engine = new Engine({
+        store,
+        db,
+        runners: [createShellRunner(), createClaudeCliRunner(), createMcpCallRunner()],
+        scheduler: scheduler.available() ? scheduler : null,
+        notifiers: [createStdoutNotifier()],
+    });
+    const collector = new SignalCollector({ providers: builtInSignalProviders(), db, concurrency: 4 });
+    return {
+        engine,
+        store,
+        collector,
+        db,
+        seeded,
+        close: () => closeDb(),
+    };
+}

package/dist/tui/routines/tabs/CostTab.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { RoutineEngine } from '../../../core/routines/engine.js';
+export interface CostTabProps {
+    engine: RoutineEngine;
+    dailyBudgetUsd?: number;
+}
+export declare function CostTab({ engine, dailyBudgetUsd }: CostTabProps): React.JSX.Element;

package/dist/tui/routines/tabs/CostTab.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { Box, Text } from 'ink';
+import { LineChart } from '@matthesketh/ink-chart';
+import { costByRoutine, costRollup, dailyCostSeries } from '../../../core/routines/cost-queries.js';
+import { formatUsd, truncate } from '../../../tui/routines/format.js';
+function usdColor(usd, soft = 1, hard = 5) {
+    if (usd >= hard)
+        return 'red';
+    if (usd >= soft)
+        return 'yellow';
+    return 'green';
+}
+export function CostTab({ engine, dailyBudgetUsd = 10 }) {
+    const { rollup, byRoutine, daily } = useMemo(() => ({
+        rollup: costRollup(engine.db),
+        byRoutine: costByRoutine(engine.db, 30, 10),
+        daily: dailyCostSeries(engine.db, 14),
+    }), [engine.db]);
+    const projectedDaily = rollup.usdToday;
+    const dailyBudgetExceeded = projectedDaily > dailyBudgetUsd;
+    const series = daily.map(d => d.usd);
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: "Cost / usage" }), _jsxs(Text, { color: usdColor(rollup.usdToday, dailyBudgetUsd / 2, dailyBudgetUsd), children: ["today ", formatUsd(rollup.usdToday)] }), _jsxs(Text, { color: "gray", children: ["week ", formatUsd(rollup.usdWeek)] }), _jsxs(Text, { color: "gray", children: ["month ", formatUsd(rollup.usdMonth)] }), dailyBudgetExceeded && (_jsxs(Text, { color: "red", bold: true, children: ["over daily budget (", formatUsd(dailyBudgetUsd), ")"] }))] }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Daily spend (last 14 days)" }), series.every(v => v === 0) ? (_jsx(Text, { color: "gray", children: "  no claude-cli runs with cost yet" })) : (_jsx(LineChart, { data: series, width: 60, height: 8, color: "cyan", showAxis: true, label: "USD / day" }))] }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Top routines by spend (30d)" }), byRoutine.length === 0 && _jsx(Text, { color: "gray", children: "  no runs yet" }), _jsxs(Box, { children: [_jsx(Box, { width: 24, children: _jsx(Text, { bold: true, children: "ROUTINE" }) }), _jsx(Box, { width: 10, children: _jsx(Text, { bold: true, children: "RUNS" }) }), _jsx(Box, { width: 12, children: _jsx(Text, { bold: true, children: "USD" }) }), _jsx(Box, { width: 14, children: _jsx(Text, { bold: true, children: "IN TOKENS" }) }), _jsx(Box, { width: 14, children: _jsx(Text, { bold: true, children: "OUT TOKENS" }) }), _jsx(Text, { bold: true, children: "AVG / RUN" })] }), byRoutine.map(row => (_jsxs(Box, { children: [_jsx(Box, { width: 24, children: _jsx(Text, { children: truncate(row.routineId, 22) }) }), _jsx(Box, { width: 10, children: _jsx(Text, { children: row.runs }) }), _jsx(Box, { width: 12, children: _jsx(Text, { color: usdColor(row.usd), children: formatUsd(row.usd) }) }), _jsx(Box, { width: 14, children: _jsx(Text, { color: "gray", children: row.inputTokens.toLocaleString() }) }), _jsx(Box, { width: 14, children: _jsx(Text, { color: "gray", children: row.outputTokens.toLocaleString() }) }), _jsx(Text, { color: "gray", children: row.runs > 0 ? formatUsd(row.usd / row.runs) : '—' })] }, row.routineId)))] }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Last 14 days (buckets)" }), daily.map(bucket => (_jsxs(Box, { children: [_jsx(Box, { width: 12, children: _jsx(Text, { color: "gray", children: bucket.date }) }), _jsx(Box, { width: 12, children: _jsx(Text, { color: usdColor(bucket.usd), children: formatUsd(bucket.usd) }) }), _jsxs(Text, { color: "gray", children: [bucket.runs, " runs"] })] }, bucket.date)))] })] }));
+}

package/dist/tui/routines/tabs/DashboardTab.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { Signal } from '../../../core/routines/schema.js';
+import { type SignalsGridRow } from '../components/SignalsGrid.js';
+export interface DashboardTabProps {
+    rows: SignalsGridRow[];
+    selectedIndex: number;
+    loading: boolean;
+    lastRefreshed: number;
+    signalsByRepo: Map<string, Signal[]>;
+    seededNotice: {
+        seeded: number;
+        skipped: number;
+    };
+}
+export declare function DashboardTab({ rows, selectedIndex, loading, lastRefreshed, signalsByRepo, seededNotice, }: DashboardTabProps): React.JSX.Element;

package/dist/tui/routines/tabs/DashboardTab.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { AlertsPanel } from '../components/AlertsPanel.js';
+import { SignalsGrid } from '../components/SignalsGrid.js';
+import { formatRelative } from '../format.js';
+const SLICE_ONE_KINDS = ['git-clean', 'container-up', 'ci-status'];
+export function DashboardTab({ rows, selectedIndex, loading, lastRefreshed, signalsByRepo, seededNotice, }) {
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: "Fleet dashboard" }), _jsxs(Text, { color: "gray", children: [rows.length, " repos"] }), loading ? (_jsxs(Text, { color: "cyan", children: [_jsx(Spinner, { type: "dots" }), " refreshing"] })) : (_jsxs(Text, { color: "gray", children: ["updated ", formatRelative(new Date(lastRefreshed).toISOString())] })), seededNotice.seeded > 0 && (_jsxs(Text, { color: "magenta", children: ["seeded ", seededNotice.seeded, " default routine", seededNotice.seeded === 1 ? '' : 's'] }))] }), _jsx(SignalsGrid, { rows: rows, selectedIndex: selectedIndex, kinds: SLICE_ONE_KINDS }), _jsx(AlertsPanel, { signals: signalsByRepo })] }));
+}

package/dist/tui/routines/tabs/GitTab.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { AppEntry } from '../../../core/registry.js';
+export interface GitTabProps {
+    apps: AppEntry[];
+}
+export declare function GitTab({ apps }: GitTabProps): React.JSX.Element;