@matthesketh/fleet 1.0.0

package/dist/tui/exec-bridge.js

@@ -0,0 +1,57 @@
+import { execFile } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FLEET_BIN = join(__dirname, '..', '..', 'dist', 'index.js');
+export function runFleetCommand(args) {
+    return new Promise((resolve) => {
+        const child = execFile('node', [FLEET_BIN, ...args], {
+            encoding: 'utf-8',
+            timeout: 30_000,
+            maxBuffer: 5 * 1024 * 1024,
+        }, (err, stdout, stderr) => {
+            if (err) {
+                resolve({ ok: false, output: stderr || err.message });
+            }
+            else {
+                resolve({ ok: true, output: stdout });
+            }
+        });
+    });
+}
+export function runFleetJson(args) {
+    return runFleetCommand([...args, '--json']).then(result => {
+        if (!result.ok)
+            return null;
+        try {
+            return JSON.parse(result.output);
+        }
+        catch {
+            return null;
+        }
+    });
+}
+export function streamFleetCommand(args) {
+    const child = execFile('node', [FLEET_BIN, ...args], {
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    const callbacks = [];
+    child.stdout?.on('data', (chunk) => {
+        const lines = chunk.toString().split('\n').filter(Boolean);
+        for (const line of lines) {
+            for (const cb of callbacks)
+                cb(line);
+        }
+    });
+    child.stderr?.on('data', (chunk) => {
+        const lines = chunk.toString().split('\n').filter(Boolean);
+        for (const line of lines) {
+            for (const cb of callbacks)
+                cb(line);
+        }
+    });
+    return {
+        kill: () => child.kill(),
+        onData: (cb) => callbacks.push(cb),
+    };
+}

package/dist/tui/hooks/use-fleet-data.d.ts

@@ -0,0 +1,9 @@
+import type { StatusData } from '../../commands/status.js';
+interface FleetData {
+    status: StatusData | null;
+    loading: boolean;
+    error: string | null;
+    refresh: () => void;
+}
+export declare function useFleetData(autoRefreshMs?: number): FleetData;
+export {};

package/dist/tui/hooks/use-fleet-data.js

@@ -0,0 +1,30 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { runFleetJson } from '../exec-bridge.js';
+import { useInterval } from './use-interval.js';
+export function useFleetData(autoRefreshMs = 10_000) {
+    const [status, setStatus] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const initialised = useRef(false);
+    const refresh = useCallback(() => {
+        // Only show loading spinner on the very first fetch
+        if (!initialised.current)
+            setLoading(true);
+        runFleetJson(['status']).then(data => {
+            initialised.current = true;
+            if (data) {
+                setStatus(data);
+                setError(null);
+            }
+            else {
+                setError('Failed to fetch status');
+            }
+            setLoading(false);
+        });
+    }, []);
+    useEffect(() => {
+        refresh();
+    }, [refresh]);
+    useInterval(refresh, autoRefreshMs);
+    return { status, loading, error, refresh };
+}

package/dist/tui/hooks/use-health.d.ts

@@ -0,0 +1,9 @@
+import type { HealthResult } from '../../core/health.js';
+interface HealthData {
+    results: HealthResult[];
+    loading: boolean;
+    error: string | null;
+    refresh: () => void;
+}
+export declare function useHealth(autoRefreshMs?: number): HealthData;
+export {};

package/dist/tui/hooks/use-health.js

@@ -0,0 +1,29 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { runFleetJson } from '../exec-bridge.js';
+import { useInterval } from './use-interval.js';
+export function useHealth(autoRefreshMs = 15_000) {
+    const [results, setResults] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const initialised = useRef(false);
+    const refresh = useCallback(() => {
+        if (!initialised.current)
+            setLoading(true);
+        runFleetJson(['health']).then(data => {
+            initialised.current = true;
+            if (data) {
+                setResults(data);
+                setError(null);
+            }
+            else {
+                setError('Failed to fetch health data');
+            }
+            setLoading(false);
+        });
+    }, []);
+    useEffect(() => {
+        refresh();
+    }, [refresh]);
+    useInterval(refresh, autoRefreshMs);
+    return { results, loading, error, refresh };
+}

package/dist/tui/hooks/use-interval.d.ts

@@ -0,0 +1 @@
+export declare function useInterval(callback: () => void, delayMs: number | null): void;

package/dist/tui/hooks/use-interval.js

@@ -0,0 +1,13 @@
+import { useEffect, useRef } from 'react';
+export function useInterval(callback, delayMs) {
+    const savedCallback = useRef(callback);
+    useEffect(() => {
+        savedCallback.current = callback;
+    }, [callback]);
+    useEffect(() => {
+        if (delayMs === null)
+            return;
+        const id = setInterval(() => savedCallback.current(), delayMs);
+        return () => clearInterval(id);
+    }, [delayMs]);
+}

package/dist/tui/hooks/use-keyboard.d.ts

@@ -0,0 +1 @@
+export declare function useKeyboard(): void;

package/dist/tui/hooks/use-keyboard.js

@@ -0,0 +1,44 @@
+import { useInput } from 'ink';
+import { useAppState, useAppDispatch, nextTopView } from '../state.js';
+export function useKeyboard() {
+    const state = useAppState();
+    const dispatch = useAppDispatch();
+    useInput((input, key) => {
+        // Confirm dialog takes priority
+        if (state.confirmAction) {
+            if (input === 'y' || input === 'Y') {
+                state.confirmAction.onConfirm();
+                dispatch({ type: 'CANCEL_CONFIRM' });
+            }
+            else if (input === 'n' || input === 'N' || key.escape) {
+                dispatch({ type: 'CANCEL_CONFIRM' });
+            }
+            return;
+        }
+        // Redact toggle (not in text-input views)
+        if (input === 'x' && state.currentView !== 'secret-edit') {
+            dispatch({ type: 'TOGGLE_REDACT' });
+            return;
+        }
+        // Quit
+        if (input === 'q') {
+            process.exit(0);
+        }
+        // Tab cycles top-level views (only from top-level views)
+        if (key.tab) {
+            const topViews = ['dashboard', 'health', 'secrets'];
+            const base = topViews.includes(state.currentView)
+                ? state.currentView
+                : state.previousView ?? 'dashboard';
+            dispatch({ type: 'NAVIGATE', view: nextTopView(base) });
+            return;
+        }
+        // Escape goes back
+        if (key.escape) {
+            if (state.previousView) {
+                dispatch({ type: 'GO_BACK' });
+            }
+            return;
+        }
+    });
+}

package/dist/tui/hooks/use-secrets.d.ts

@@ -0,0 +1,47 @@
+interface SecretItem {
+    key: string;
+    maskedValue: string;
+}
+interface AppSecretInfo {
+    app: string;
+    type: string;
+    keyCount: number;
+    lastSealedAt: string;
+}
+interface SecretsState {
+    initialized: boolean;
+    sealed: boolean;
+    apps: AppSecretInfo[];
+    secrets: SecretItem[];
+    revealedValues: Record<string, string>;
+    loading: boolean;
+    error: string | null;
+}
+interface SecretsActions {
+    refresh: () => void;
+    loadAppSecrets: (app: string) => void;
+    saveSecret: (app: string, key: string, value: string) => {
+        ok: boolean;
+        error?: string;
+    };
+    deleteSecret: (app: string, key: string) => {
+        ok: boolean;
+        error?: string;
+    };
+    revealSecret: (app: string, key: string) => void;
+    hideSecret: (key: string) => void;
+    unseal: () => {
+        ok: boolean;
+        error?: string;
+    };
+    seal: () => {
+        ok: boolean;
+        error?: string;
+    };
+    importEnv: (app: string, path: string) => {
+        ok: boolean;
+        error?: string;
+    };
+}
+export declare function useSecrets(): SecretsState & SecretsActions;
+export {};

package/dist/tui/hooks/use-secrets.js

@@ -0,0 +1,152 @@
+import { useState, useCallback } from 'react';
+import { isInitialized, isSealed, loadManifest, listSecrets, decryptApp, sealApp } from '../../core/secrets.js';
+import { setSecret, getSecret, unsealAll, sealFromRuntime, importEnvFile } from '../../core/secrets-ops.js';
+export function useSecrets() {
+    const [state, setState] = useState({
+        initialized: false,
+        sealed: true,
+        apps: [],
+        secrets: [],
+        revealedValues: {},
+        loading: false,
+        error: null,
+    });
+    const refresh = useCallback(() => {
+        try {
+            const init = isInitialized();
+            if (!init) {
+                setState(prev => ({ ...prev, initialized: false, sealed: true, apps: [] }));
+                return;
+            }
+            const sealed = isSealed();
+            const manifest = loadManifest();
+            const apps = Object.entries(manifest.apps).map(([app, entry]) => ({
+                app,
+                type: entry.type,
+                keyCount: entry.keyCount,
+                lastSealedAt: entry.lastSealedAt,
+            }));
+            setState(prev => ({ ...prev, initialized: true, sealed, apps, error: null }));
+        }
+        catch (err) {
+            setState(prev => ({
+                ...prev,
+                error: err instanceof Error ? err.message : 'Failed to load secrets state',
+            }));
+        }
+    }, []);
+    const loadAppSecrets = useCallback((app) => {
+        try {
+            const items = listSecrets(app);
+            setState(prev => ({ ...prev, secrets: items, revealedValues: {}, error: null }));
+        }
+        catch (err) {
+            setState(prev => ({
+                ...prev,
+                secrets: [],
+                error: err instanceof Error ? err.message : 'Failed to load secrets',
+            }));
+        }
+    }, []);
+    const saveSecret = useCallback((app, key, value) => {
+        try {
+            setSecret(app, key, value);
+            // Re-unseal to update runtime
+            try {
+                unsealAll();
+            }
+            catch { /* runtime may not exist yet */ }
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err instanceof Error ? err.message : 'Failed to save secret' };
+        }
+    }, []);
+    const deleteSecret = useCallback((app, key) => {
+        try {
+            const plaintext = decryptApp(app);
+            const manifest = loadManifest();
+            const entry = manifest.apps[app];
+            if (entry.type === 'env') {
+                const lines = plaintext.split('\n').filter((line) => {
+                    const eqIdx = line.indexOf('=');
+                    return !(eqIdx > 0 && line.substring(0, eqIdx) === key);
+                });
+                sealApp(app, lines.join('\n'), entry.sourceFile);
+            }
+            try {
+                unsealAll();
+            }
+            catch { /* runtime may not exist */ }
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err instanceof Error ? err.message : 'Failed to delete secret' };
+        }
+    }, []);
+    const revealSecret = useCallback((app, key) => {
+        try {
+            const value = getSecret(app, key);
+            if (value !== null) {
+                setState(prev => ({
+                    ...prev,
+                    revealedValues: { ...prev.revealedValues, [key]: value },
+                }));
+            }
+        }
+        catch {
+            // ignore reveal errors
+        }
+    }, []);
+    const hideSecret = useCallback((key) => {
+        setState(prev => {
+            const { [key]: _, ...rest } = prev.revealedValues;
+            return { ...prev, revealedValues: rest };
+        });
+    }, []);
+    const unseal = useCallback(() => {
+        try {
+            unsealAll();
+            setState(prev => ({ ...prev, sealed: false }));
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err instanceof Error ? err.message : 'Failed to unseal' };
+        }
+    }, []);
+    const seal = useCallback(() => {
+        try {
+            sealFromRuntime();
+            setState(prev => ({ ...prev, sealed: true }));
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err instanceof Error ? err.message : 'Failed to seal' };
+        }
+    }, []);
+    const importEnv = useCallback((app, path) => {
+        try {
+            importEnvFile(app, path);
+            try {
+                unsealAll();
+            }
+            catch { /* ok */ }
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err instanceof Error ? err.message : 'Failed to import' };
+        }
+    }, []);
+    return {
+        ...state,
+        refresh,
+        loadAppSecrets,
+        saveSecret,
+        deleteSecret,
+        revealSecret,
+        hideSecret,
+        unseal,
+        seal,
+        importEnv,
+    };
+}

package/dist/tui/router.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function App(): React.JSX.Element;

package/dist/tui/router.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useReducer, useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { reducer, initialState, AppStateContext, AppDispatchContext } from './state.js';
+import { useKeyboard } from './hooks/use-keyboard.js';
+import { Header } from './components/Header.js';
+import { KeyHint } from './components/KeyHint.js';
+import { Confirm } from './components/Confirm.js';
+import { Dashboard } from './views/Dashboard.js';
+import { AppDetail } from './views/AppDetail.js';
+import { SecretsView } from './views/SecretsView.js';
+import { SecretEdit } from './views/SecretEdit.js';
+import { HealthView } from './views/HealthView.js';
+import { LogsView } from './views/LogsView.js';
+import { isSealed, isInitialized } from '../core/secrets.js';
+function ViewRouter() {
+    const state = React.useContext(AppStateContext);
+    switch (state.currentView) {
+        case 'dashboard':
+            return _jsx(Dashboard, {});
+        case 'app-detail':
+            return _jsx(AppDetail, {});
+        case 'health':
+            return _jsx(HealthView, {});
+        case 'secrets':
+            return _jsx(SecretsView, {});
+        case 'secret-edit':
+            return _jsx(SecretEdit, {});
+        case 'logs':
+            return _jsx(LogsView, {});
+        default:
+            return _jsx(Dashboard, {});
+    }
+}
+function KeyboardHandler() {
+    useKeyboard();
+    return null;
+}
+export function App() {
+    const [state, dispatch] = useReducer(reducer, initialState);
+    const [vaultSealed, setVaultSealed] = useState(true);
+    useEffect(() => {
+        try {
+            if (isInitialized()) {
+                setVaultSealed(isSealed());
+            }
+        }
+        catch {
+            // vault may not be set up
+        }
+        const interval = setInterval(() => {
+            try {
+                if (isInitialized()) {
+                    const sealed = isSealed();
+                    setVaultSealed(prev => prev === sealed ? prev : sealed);
+                }
+            }
+            catch {
+                // ignore
+            }
+        }, 5000);
+        return () => clearInterval(interval);
+    }, []);
+    return (_jsx(AppStateContext.Provider, { value: state, children: _jsxs(AppDispatchContext.Provider, { value: dispatch, children: [_jsx(KeyboardHandler, {}), _jsxs(Box, { flexDirection: "column", height: process.stdout.rows || 24, children: [_jsx(Header, { vaultSealed: vaultSealed }), _jsxs(Box, { flexGrow: 1, flexDirection: "column", children: [_jsx(ViewRouter, {}), _jsx(Confirm, {}), state.error && (_jsx(Box, { paddingX: 1, children: _jsx(Box, { borderStyle: "round", borderColor: "red", paddingX: 1, children: _jsx(Text, { color: "red", children: state.error }) }) }))] }), _jsx(KeyHint, {})] })] }) }));
+}

package/dist/tui/state.d.ts

@@ -0,0 +1,12 @@
+import { type Dispatch } from 'react';
+import type { TuiState, Action, View } from './types.js';
+export declare const initialState: TuiState;
+export declare function reducer(state: TuiState, action: Action): TuiState;
+export declare function nextTopView(current: View): View;
+export declare function redactName(name: string): string;
+export declare function useRedact(): (name: string) => string;
+export declare const AppStateContext: import("react").Context<TuiState>;
+export declare const AppDispatchContext: import("react").Context<Dispatch<Action>>;
+export declare function useAppState(): TuiState;
+export declare function useAppDispatch(): Dispatch<Action>;
+export declare function useTui(): [TuiState, Dispatch<Action>];

package/dist/tui/state.js

@@ -0,0 +1,83 @@
+import { createContext, useContext } from 'react';
+const TOP_VIEWS = ['dashboard', 'health', 'secrets'];
+export const initialState = {
+    currentView: 'dashboard',
+    previousView: null,
+    selectedApp: null,
+    selectedSecret: null,
+    redacted: false,
+    loading: false,
+    error: null,
+    confirmAction: null,
+};
+export function reducer(state, action) {
+    switch (action.type) {
+        case 'NAVIGATE':
+            return {
+                ...state,
+                previousView: state.currentView,
+                currentView: action.view,
+                error: null,
+                confirmAction: null,
+            };
+        case 'GO_BACK':
+            return {
+                ...state,
+                currentView: state.previousView ?? 'dashboard',
+                previousView: null,
+                selectedSecret: null,
+                error: null,
+                confirmAction: null,
+            };
+        case 'SELECT_APP':
+            return { ...state, selectedApp: action.app };
+        case 'SELECT_SECRET':
+            return { ...state, selectedSecret: action.key };
+        case 'SET_LOADING':
+            return { ...state, loading: action.loading };
+        case 'SET_ERROR':
+            return { ...state, error: action.error };
+        case 'TOGGLE_REDACT':
+            return { ...state, redacted: !state.redacted };
+        case 'CONFIRM':
+            return { ...state, confirmAction: action.action };
+        case 'CANCEL_CONFIRM':
+            return { ...state, confirmAction: null };
+        default:
+            return state;
+    }
+}
+export function nextTopView(current) {
+    const idx = TOP_VIEWS.indexOf(current);
+    if (idx === -1)
+        return 'dashboard';
+    return TOP_VIEWS[(idx + 1) % TOP_VIEWS.length];
+}
+// Redact utility — stable mapping of real names to "app-01", "app-02", etc.
+const _redactMap = new Map();
+let _redactCounter = 0;
+export function redactName(name) {
+    let label = _redactMap.get(name);
+    if (!label) {
+        label = `app-${String(++_redactCounter).padStart(2, '0')}`;
+        _redactMap.set(name, label);
+    }
+    return label;
+}
+export function useRedact() {
+    const { redacted } = useAppState();
+    if (!redacted)
+        return (n) => n;
+    return redactName;
+}
+export const AppStateContext = createContext(initialState);
+export const AppDispatchContext = createContext(() => { });
+export function useAppState() {
+    return useContext(AppStateContext);
+}
+export function useAppDispatch() {
+    return useContext(AppDispatchContext);
+}
+export function useTui() {
+    return [useAppState(), useAppDispatch()];
+}

package/dist/tui/theme.d.ts

@@ -0,0 +1,11 @@
+export declare const colors: {
+    readonly primary: "cyan";
+    readonly success: "green";
+    readonly warning: "yellow";
+    readonly error: "red";
+    readonly info: "blue";
+    readonly muted: "gray";
+    readonly text: "white";
+};
+export declare const statusColor: Record<string, string>;
+export declare const healthColor: Record<string, string>;

package/dist/tui/theme.js

@@ -0,0 +1,23 @@
+export const colors = {
+    primary: 'cyan',
+    success: 'green',
+    warning: 'yellow',
+    error: 'red',
+    info: 'blue',
+    muted: 'gray',
+    text: 'white',
+};
+export const statusColor = {
+    active: 'green',
+    inactive: 'red',
+    failed: 'red',
+    activating: 'yellow',
+    deactivating: 'yellow',
+    'n/a': 'gray',
+};
+export const healthColor = {
+    healthy: 'green',
+    degraded: 'yellow',
+    down: 'red',
+    unknown: 'gray',
+};

package/dist/tui/types.d.ts

@@ -0,0 +1,41 @@
+export type View = 'dashboard' | 'app-detail' | 'health' | 'secrets' | 'secret-edit' | 'logs';
+export interface TuiState {
+    currentView: View;
+    previousView: View | null;
+    selectedApp: string | null;
+    selectedSecret: string | null;
+    redacted: boolean;
+    loading: boolean;
+    error: string | null;
+    confirmAction: ConfirmAction | null;
+}
+export interface ConfirmAction {
+    label: string;
+    description: string;
+    onConfirm: () => void;
+}
+export type Action = {
+    type: 'NAVIGATE';
+    view: View;
+} | {
+    type: 'GO_BACK';
+} | {
+    type: 'SELECT_APP';
+    app: string;
+} | {
+    type: 'SELECT_SECRET';
+    key: string | null;
+} | {
+    type: 'SET_LOADING';
+    loading: boolean;
+} | {
+    type: 'SET_ERROR';
+    error: string | null;
+} | {
+    type: 'TOGGLE_REDACT';
+} | {
+    type: 'CONFIRM';
+    action: ConfirmAction;
+} | {
+    type: 'CANCEL_CONFIRM';
+};

package/dist/tui/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tui/views/AppDetail.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function AppDetail(): React.JSX.Element;