dev-cockpit 0.1.0

package/dist/cockpit/help/loader.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Help-tab content loader.
+ *
+ * Resolves a docs/ folder by walking up from a given module URL, looking for
+ * a directory containing both `package.json` and `docs/index.md`. This works
+ * across three contexts:
+ *   - tsx-from-source     → src/cockpit/help/loader.ts → ../../../docs
+ *   - dist/-from-build    → dist/cockpit/help/loader.js → ../../../docs
+ *   - npm i installed     → node_modules/<pkg>/dist/.../loader.js → <pkg>/docs
+ *
+ * The loader supports merging multiple sources: core docs first, then any
+ * profile-supplied sources (paths or inline pages). Sources later in the list
+ * override earlier ones by slug. A source with `omit: true` removes that slug.
+ *
+ * `docs/index.md` defines the ordered page list for that source. Each entry
+ * is a markdown bullet of the form:
+ *   - [Title](./slug.md) — optional summary
+ *
+ * The index page is itself returned as the first HelpPage (slug = 'index').
+ */
+import type { HelpPage } from './types.js';
+/** Walk up from `startUrl` (or this module by default) for package.json + docs/index.md. */
+export declare function resolveDocsRoot(startUrl?: string): string | null;
+/** Parse the markdown index into an ordered list of page slugs. */
+export declare function parseIndex(indexBody: string): Array<{
+    slug: string;
+    title: string;
+}>;
+/** Load all pages (in index order) from a single docs/ directory. */
+export declare function loadPagesFromDir(docsRoot: string): HelpPage[];
+/** A help source contributed by config or a profile. */
+export interface HelpSourceInput {
+    /** Filesystem path to a docs/ directory. */
+    path?: string;
+    /** Inline page; if `id`/`slug` matches an existing page, replaces it. */
+    page?: HelpPage;
+    /** Slug to omit from the merged list. Use with `omit: true`. */
+    id?: string;
+    /** When true, removes the page with this id from the merged list. */
+    omit?: boolean;
+}
+export interface LoadHelpPagesOptions {
+    /**
+     * Module URL whose docs/ should be loaded as the **core** source.
+     * Default: this module's URL — i.e., dev-cockpit's bundled docs.
+     */
+    coreUrl?: string;
+    /** Additional sources applied AFTER core. Later sources override earlier ones by slug. */
+    sources?: HelpSourceInput[];
+    /** Slug to land on first. If absent, the first page is used. */
+    defaultPage?: string;
+}
+export interface LoadHelpPagesResult {
+    pages: HelpPage[];
+    defaultIndex: number;
+}
+/**
+ * Load and merge help pages from core + any contributed sources.
+ *
+ * Returns `null` only if the core docs root cannot be found AND no sources
+ * provide pages. Otherwise returns a non-empty merged list with `defaultIndex`
+ * pointing at `defaultPage` (or 0 when `defaultPage` is absent / unknown).
+ */
+export declare function loadHelpPages(opts?: LoadHelpPagesOptions): LoadHelpPagesResult | null;
+//# sourceMappingURL=loader.d.ts.map

package/dist/cockpit/help/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/cockpit/help/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,4FAA4F;AAC5F,wBAAgB,eAAe,CAAC,QAAQ,GAAE,MAAwB,GAAG,MAAM,GAAG,IAAI,CAWjF;AAED,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAUpF;AAED,qEAAqE;AACrE,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,EAAE,CAsB7D;AAED,wDAAwD;AACxD,MAAM,WAAW,eAAe;IAC9B,4CAA4C;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,gEAAgE;IAChE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,qEAAqE;IACrE,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0FAA0F;IAC1F,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,gEAAgE;IAChE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,GAAE,oBAAyB,GAAG,mBAAmB,GAAG,IAAI,CA2CzF"}

package/dist/cockpit/help/loader.js

@@ -0,0 +1,118 @@
+/**
+ * Help-tab content loader.
+ *
+ * Resolves a docs/ folder by walking up from a given module URL, looking for
+ * a directory containing both `package.json` and `docs/index.md`. This works
+ * across three contexts:
+ *   - tsx-from-source     → src/cockpit/help/loader.ts → ../../../docs
+ *   - dist/-from-build    → dist/cockpit/help/loader.js → ../../../docs
+ *   - npm i installed     → node_modules/<pkg>/dist/.../loader.js → <pkg>/docs
+ *
+ * The loader supports merging multiple sources: core docs first, then any
+ * profile-supplied sources (paths or inline pages). Sources later in the list
+ * override earlier ones by slug. A source with `omit: true` removes that slug.
+ *
+ * `docs/index.md` defines the ordered page list for that source. Each entry
+ * is a markdown bullet of the form:
+ *   - [Title](./slug.md) — optional summary
+ *
+ * The index page is itself returned as the first HelpPage (slug = 'index').
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Walk up from `startUrl` (or this module by default) for package.json + docs/index.md. */
+export function resolveDocsRoot(startUrl = import.meta.url) {
+    let dir = path.dirname(fileURLToPath(startUrl));
+    while (dir !== path.dirname(dir)) {
+        const pkgJson = path.join(dir, 'package.json');
+        const docsIndex = path.join(dir, 'docs', 'index.md');
+        if (fs.existsSync(pkgJson) && fs.existsSync(docsIndex)) {
+            return path.join(dir, 'docs');
+        }
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+/** Parse the markdown index into an ordered list of page slugs. */
+export function parseIndex(indexBody) {
+    const out = [];
+    const linkRe = /^\s*[-*]\s+\[([^\]]+)\]\((?:\.\/)?([^)]+?)\.md\)/;
+    for (const line of indexBody.split(/\r?\n/)) {
+        const match = linkRe.exec(line);
+        if (match && match[1] && match[2]) {
+            out.push({ title: match[1], slug: match[2] });
+        }
+    }
+    return out;
+}
+/** Load all pages (in index order) from a single docs/ directory. */
+export function loadPagesFromDir(docsRoot) {
+    const indexPath = path.join(docsRoot, 'index.md');
+    let indexBody;
+    try {
+        indexBody = fs.readFileSync(indexPath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const pages = [{ slug: 'index', title: 'Index', path: indexPath, body: indexBody }];
+    for (const entry of parseIndex(indexBody)) {
+        const pagePath = path.join(docsRoot, `${entry.slug}.md`);
+        try {
+            const body = fs.readFileSync(pagePath, 'utf8');
+            pages.push({ slug: entry.slug, title: entry.title, path: pagePath, body });
+        }
+        catch {
+            // Missing page file — skip silently.
+        }
+    }
+    return pages;
+}
+/**
+ * Load and merge help pages from core + any contributed sources.
+ *
+ * Returns `null` only if the core docs root cannot be found AND no sources
+ * provide pages. Otherwise returns a non-empty merged list with `defaultIndex`
+ * pointing at `defaultPage` (or 0 when `defaultPage` is absent / unknown).
+ */
+export function loadHelpPages(opts = {}) {
+    const coreUrl = opts.coreUrl ?? import.meta.url;
+    const corePages = [];
+    const coreRoot = resolveDocsRoot(coreUrl);
+    if (coreRoot) {
+        corePages.push(...loadPagesFromDir(coreRoot));
+    }
+    // Merge sources in order. Map keyed by slug preserves first-write insertion
+    // order; later sources REPLACE by re-assigning the same key.
+    const merged = new Map();
+    for (const page of corePages) {
+        merged.set(page.slug, page);
+    }
+    for (const src of opts.sources ?? []) {
+        if (src.omit && src.id) {
+            merged.delete(src.id);
+            continue;
+        }
+        if (src.page) {
+            merged.set(src.page.slug, src.page);
+            continue;
+        }
+        if (src.path) {
+            const pages = loadPagesFromDir(src.path);
+            for (const p of pages) {
+                merged.set(p.slug, p);
+            }
+        }
+    }
+    const pages = Array.from(merged.values());
+    if (pages.length === 0)
+        return null;
+    let defaultIndex = 0;
+    if (opts.defaultPage) {
+        const idx = pages.findIndex((p) => p.slug === opts.defaultPage);
+        if (idx >= 0)
+            defaultIndex = idx;
+    }
+    return { pages, defaultIndex };
+}

package/dist/cockpit/help/renderer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Markdown → terminal ANSI renderer.
+ *
+ * marked + marked-terminal — the latter emits an ANSI string handed to Ink's
+ * <Text>. Ink passes ANSI through to stdout. Tradeoff accepted: long lines
+ * wrap at the terminal column boundary, which is fine for prose docs.
+ *
+ * Renderer is configured once at module load (marked-terminal mutates the
+ * shared marked instance).
+ */
+/**
+ * Render a markdown string to ANSI-colored terminal output.
+ * Always returns a string; never throws on well-formed markdown.
+ */
+export declare function renderMarkdown(markdown: string): string;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/cockpit/help/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../../src/cockpit/help/renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAaH;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CASvD"}

package/dist/cockpit/help/renderer.js

@@ -0,0 +1,35 @@
+/**
+ * Markdown → terminal ANSI renderer.
+ *
+ * marked + marked-terminal — the latter emits an ANSI string handed to Ink's
+ * <Text>. Ink passes ANSI through to stdout. Tradeoff accepted: long lines
+ * wrap at the terminal column boundary, which is fine for prose docs.
+ *
+ * Renderer is configured once at module load (marked-terminal mutates the
+ * shared marked instance).
+ */
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+let configured = false;
+function ensureConfigured() {
+    if (configured)
+        return;
+    marked.use(markedTerminal());
+    configured = true;
+}
+/**
+ * Render a markdown string to ANSI-colored terminal output.
+ * Always returns a string; never throws on well-formed markdown.
+ */
+export function renderMarkdown(markdown) {
+    ensureConfigured();
+    if (!markdown)
+        return '';
+    try {
+        const out = marked.parse(markdown);
+        return typeof out === 'string' ? out : markdown;
+    }
+    catch {
+        return markdown;
+    }
+}

package/dist/cockpit/help/types.d.ts

@@ -0,0 +1,12 @@
+/** A markdown page loaded from a docs/ directory. */
+export interface HelpPage {
+    /** Filename minus extension, e.g. "install". Used as the merge id. */
+    slug: string;
+    /** Human-readable title shown in the page selector. */
+    title: string;
+    /** Absolute path to the source file (used for diagnostics). Empty when content is inline. */
+    path: string;
+    /** Raw markdown body. */
+    body: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cockpit/help/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cockpit/help/types.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,MAAM,WAAW,QAAQ;IACvB,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAC;IACd,6FAA6F;IAC7F,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;CACd"}

package/dist/cockpit/help/types.js

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

package/dist/cockpit/hooks/useCockpitStore.d.ts

@@ -0,0 +1,3 @@
+import type { CockpitState } from '../state/store.js';
+export declare function useCockpitStore<T>(selector: (state: CockpitState) => T): T;
+//# sourceMappingURL=useCockpitStore.d.ts.map

package/dist/cockpit/hooks/useCockpitStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCockpitStore.d.ts","sourceRoot":"","sources":["../../../src/cockpit/hooks/useCockpitStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,CAAC,GAAG,CAAC,CAE1E"}

package/dist/cockpit/hooks/useCockpitStore.js

@@ -0,0 +1,5 @@
+import { useSyncExternalStore } from 'react';
+import { cockpitStore } from '../state/store.js';
+export function useCockpitStore(selector) {
+    return useSyncExternalStore(cockpitStore.subscribe, () => selector(cockpitStore.getState()));
+}

package/dist/cockpit/hooks/useGlobalKeys.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Global keyboard handler for the cockpit TUI.
+ *
+ * Globals (active in every tab):
+ *   ← / →               cycle tabs (backward / forward)
+ *   tab / shift+tab     cycle tabs (alias) — except inside Help, where these
+ *                       are repurposed for page navigation. Use ←/→ to leave.
+ *   q                   onQuit()
+ *   n                   toggleSessionNotifications
+ *
+ * Per-tab keys are dispatched to the relevant handler callback. Domain-aware
+ * behavior (rebuild, lint, remediation lookup, editor launch) lives in the
+ * profile / consumer; this hook just routes keystrokes to the handlers and
+ * manages the minimum-visibility-hold for in-flight banners.
+ */
+import type { RepoState } from '../state/store.js';
+/** Result of a kicked-off async action — the hook tracks its in-flight state. */
+export interface AsyncActionDispatch {
+    /** Banner / row label while the action is in flight. */
+    label: string;
+    /** Promise resolving when the action completes (success or failure). */
+    promise: Promise<void>;
+}
+export interface RemediationDispatch extends AsyncActionDispatch {
+    healthId: string;
+    healthLabel: string;
+}
+export interface UseGlobalKeysOptions {
+    onQuit: () => void;
+    /**
+     * Triggered by `r` on Repos pane. Returns dispatch info if the action started,
+     * or null to skip (e.g., docker entry with no restart handler wired).
+     */
+    runRepoAction?: (repoKey: string, repo: RepoState) => AsyncActionDispatch | null;
+    /** Triggered by `w` on Repos for repo-kind entries. Fire-and-forget. */
+    onWatchToggle?: (repoKey: string, repo: RepoState) => void;
+    /** Triggered by `l` on Repos for repo-kind entries. Fire-and-forget. */
+    onLint?: (repoKey: string, repo: RepoState) => void;
+    /**
+     * Triggered by `e` on Output pane. Receives the most recent error with file:line
+     * (or `null` if no such error exists). Synchronous.
+     */
+    onOpenError?: (error: {
+        file: string;
+        line: number;
+        service: string;
+        text: string;
+    } | null) => void;
+    /**
+     * Triggered by an uppercase letter on Health pane. Returns dispatch info
+     * with healthId/healthLabel if a check matched, or null to skip.
+     */
+    runRemediation?: (remediationKey: string) => RemediationDispatch | null;
+}
+export declare function useGlobalKeys(opts: UseGlobalKeysOptions): void;
+//# sourceMappingURL=useGlobalKeys.d.ts.map

package/dist/cockpit/hooks/useGlobalKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGlobalKeys.d.ts","sourceRoot":"","sources":["../../../src/cockpit/hooks/useGlobalKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AASnD,iFAAiF;AACjF,MAAM,WAAW,mBAAmB;IAClC,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,IAAI,CAAC;IAEnB;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,KAAK,mBAAmB,GAAG,IAAI,CAAC;IACjF,wEAAwE;IACxE,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;IAC3D,wEAAwE;IACxE,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;IAEpD;;;OAGG;IACH,WAAW,CAAC,EAAE,CACZ,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,KACxE,IAAI,CAAC;IAEV;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,mBAAmB,GAAG,IAAI,CAAC;CACzE;AAYD,wBAAgB,aAAa,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAwJ9D"}

package/dist/cockpit/hooks/useGlobalKeys.js

@@ -0,0 +1,173 @@
+/**
+ * Global keyboard handler for the cockpit TUI.
+ *
+ * Globals (active in every tab):
+ *   ← / →               cycle tabs (backward / forward)
+ *   tab / shift+tab     cycle tabs (alias) — except inside Help, where these
+ *                       are repurposed for page navigation. Use ←/→ to leave.
+ *   q                   onQuit()
+ *   n                   toggleSessionNotifications
+ *
+ * Per-tab keys are dispatched to the relevant handler callback. Domain-aware
+ * behavior (rebuild, lint, remediation lookup, editor launch) lives in the
+ * profile / consumer; this hook just routes keystrokes to the handlers and
+ * manages the minimum-visibility-hold for in-flight banners.
+ */
+import { useInput } from 'ink';
+import { cockpitStore } from '../state/store.js';
+/**
+ * Minimum time an in-flight-action banner stays visible, even if the
+ * underlying work completes faster. Without this, fast-finishing actions
+ * (instant failures, no-op installs) flash by unnoticed.
+ */
+const MIN_ACTION_BANNER_MS = 1500;
+function withMinHold(promise, onDone) {
+    const startedAt = Date.now();
+    void promise.finally(() => {
+        const elapsed = Date.now() - startedAt;
+        const remaining = Math.max(0, MIN_ACTION_BANNER_MS - elapsed);
+        if (remaining === 0)
+            onDone();
+        else
+            setTimeout(onDone, remaining);
+    });
+}
+export function useGlobalKeys(opts) {
+    const { onQuit, runRepoAction, onWatchToggle, onLint, onOpenError, runRemediation } = opts;
+    useInput((input, key) => {
+        const state = cockpitStore.getState();
+        // Modal is open — don't process global keys.
+        if (state.activeModal !== null)
+            return;
+        // Tab navigation (always available)
+        if (key.leftArrow) {
+            state.cycleFocus('backward');
+            return;
+        }
+        if (key.rightArrow) {
+            state.cycleFocus('forward');
+            return;
+        }
+        // Tab / Shift-Tab cycle tabs globally — but inside Help they're aliased
+        // to page navigation by the Help pane itself.
+        if (state.focus !== 'help') {
+            if (key.tab && key.shift) {
+                state.cycleFocus('backward');
+                return;
+            }
+            if (key.tab) {
+                state.cycleFocus('forward');
+                return;
+            }
+        }
+        if (input === 'q') {
+            onQuit();
+            return;
+        }
+        if (input === 'n') {
+            state.toggleSessionNotifications();
+            return;
+        }
+        // ── Repos ─────────────────────────────────────────────────────────────
+        if (state.focus === 'repos') {
+            if (key.upArrow) {
+                state.moveSelection('up');
+                return;
+            }
+            if (key.downArrow) {
+                state.moveSelection('down');
+                return;
+            }
+            const selectedKey = state.repoOrder[state.selectedRepoIndex];
+            const selectedEntry = selectedKey ? state.repos[selectedKey] : undefined;
+            if (input === 'r') {
+                if (!selectedKey || !selectedEntry || !runRepoAction)
+                    return;
+                const dispatch = runRepoAction(selectedKey, selectedEntry);
+                if (!dispatch)
+                    return;
+                state.setActiveRepoAction({ repoKey: selectedKey, label: dispatch.label });
+                withMinHold(dispatch.promise, () => cockpitStore.getState().setActiveRepoAction(null));
+                return;
+            }
+            if (input === 'w') {
+                if (selectedKey && selectedEntry && selectedEntry.kind === 'repo' && onWatchToggle) {
+                    onWatchToggle(selectedKey, selectedEntry);
+                }
+                return;
+            }
+            if (input === 'l') {
+                if (selectedKey && selectedEntry && selectedEntry.kind === 'repo' && onLint) {
+                    onLint(selectedKey, selectedEntry);
+                }
+                return;
+            }
+        }
+        // ── Output ────────────────────────────────────────────────────────────
+        if (state.focus === 'output') {
+            if (input === 'c') {
+                state.clearOutput();
+                return;
+            }
+            if (input === '/') {
+                state.setActiveModal('search');
+                return;
+            }
+            if (input === 'f') {
+                state.setActiveModal('filter');
+                return;
+            }
+            if (input === 'e' && onOpenError) {
+                const target = state.recentErrors.find((er) => er.file && typeof er.line === 'number');
+                if (target?.file && typeof target.line === 'number') {
+                    onOpenError({
+                        file: target.file,
+                        line: target.line,
+                        service: target.service,
+                        text: target.text,
+                    });
+                }
+                else {
+                    onOpenError(null);
+                }
+                return;
+            }
+        }
+        // ── Health ────────────────────────────────────────────────────────────
+        if (state.focus === 'health') {
+            if (key.upArrow) {
+                state.moveHealthSelection('up');
+                return;
+            }
+            if (key.downArrow) {
+                state.moveHealthSelection('down');
+                return;
+            }
+            if (key.return) {
+                const selectedCheck = state.health[state.selectedHealthIndex];
+                if (selectedCheck) {
+                    state.toggleHealthExpand(selectedCheck.id);
+                }
+                return;
+            }
+            // Any single letter is treated as a potential remediation key.
+            // The input is uppercased so users can press the key without Shift —
+            // a remediation declared with `key: 'R'` matches both `r` and `R`.
+            const upperInput = input.toUpperCase();
+            if (runRemediation &&
+                upperInput.length === 1 &&
+                upperInput >= 'A' &&
+                upperInput <= 'Z') {
+                const dispatch = runRemediation(upperInput);
+                if (!dispatch)
+                    return;
+                state.setActiveRemediation({
+                    healthId: dispatch.healthId,
+                    healthLabel: dispatch.healthLabel,
+                });
+                withMinHold(dispatch.promise, () => cockpitStore.getState().setActiveRemediation(null));
+                return;
+            }
+        }
+    });
+}

package/dist/cockpit/panes/FilterModal.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare function FilterModal(): React.ReactElement;
+//# sourceMappingURL=FilterModal.d.ts.map

package/dist/cockpit/panes/FilterModal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterModal.d.ts","sourceRoot":"","sources":["../../../src/cockpit/panes/FilterModal.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAMxC,wBAAgB,WAAW,IAAI,KAAK,CAAC,YAAY,CAuChD"}

package/dist/cockpit/panes/FilterModal.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { cockpitStore } from '../state/store.js';
+import { useCockpitStore } from '../hooks/useCockpitStore.js';
+export function FilterModal() {
+    const outputFilter = useCockpitStore((s) => s.outputFilter);
+    const [severityDraft, setSeverityDraft] = useState(outputFilter.severity);
+    const SEVERITIES = [undefined, 'info', 'warn', 'error'];
+    useInput((input, key) => {
+        if (input === 's') {
+            const idx = SEVERITIES.indexOf(severityDraft);
+            const next = SEVERITIES[(idx + 1) % SEVERITIES.length];
+            setSeverityDraft(next);
+        }
+        if (key.return || key.escape) {
+            cockpitStore.getState().setFilter({ ...outputFilter, severity: severityDraft });
+            cockpitStore.getState().setActiveModal(null);
+        }
+    });
+    return (_jsx(Box, { flexGrow: 1, alignItems: "center", justifyContent: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, children: [_jsx(Text, { bold: true, children: " Filter Output " }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { children: "Severity (s to cycle): " }), _jsx(Text, { color: "cyan", children: severityDraft ?? 'all' })] }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "Enter = apply \u00B7 Esc = cancel" })] }) }));
+}

package/dist/cockpit/panes/Health.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Health pane — renders health checks with severity-colored glyphs, labels,
+ * and remediation keys.
+ *
+ * In-flight remediation feedback: when activeRemediation is set, a banner
+ * appears at the top and the running check's row shows "…" + "(running…)"
+ * inline. Subprocess output streams to the Output tab.
+ *
+ * Severity glyphs: ok = ✓ (green), warn = ⚠ (yellow), error = ✗ (red).
+ */
+import React from 'react';
+export declare function Health(): React.ReactElement;
+//# sourceMappingURL=Health.d.ts.map

package/dist/cockpit/panes/Health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Health.d.ts","sourceRoot":"","sources":["../../../src/cockpit/panes/Health.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAY1B,wBAAgB,MAAM,IAAI,KAAK,CAAC,YAAY,CAgE3C"}

package/dist/cockpit/panes/Health.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useCockpitStore } from '../hooks/useCockpitStore.js';
+const SEVERITY_GLYPH = { ok: '✓', warn: '⚠', error: '✗' };
+const SEVERITY_COLOR = {
+    ok: 'green',
+    warn: 'yellow',
+    error: 'red',
+};
+export function Health() {
+    const health = useCockpitStore((s) => s.health);
+    const selectedHealthIndex = useCockpitStore((s) => s.selectedHealthIndex);
+    const expandedHealthId = useCockpitStore((s) => s.expandedHealthId);
+    const focus = useCockpitStore((s) => s.focus);
+    const notificationsEnabledSession = useCockpitStore((s) => s.notificationsEnabledSession);
+    const activeRemediation = useCockpitStore((s) => s.activeRemediation);
+    const isFocused = focus === 'health';
+    if (health.length === 0) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { dimColor: true, children: "running health checks\u2026" }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [activeRemediation && (_jsx(Box, { marginBottom: 1, paddingX: 1, children: _jsxs(Text, { color: "yellow", children: ['… ', activeRemediation.healthLabel, ' running — switch to Output (←) to watch'] }) })), health.map((item, idx) => {
+                const isSelected = isFocused && idx === selectedHealthIndex;
+                const isExpanded = expandedHealthId === item.id;
+                const isRunning = activeRemediation?.healthId === item.id;
+                const glyph = isRunning ? '…' : (SEVERITY_GLYPH[item.severity] ?? '?');
+                const color = isRunning ? 'yellow' : (SEVERITY_COLOR[item.severity] ?? 'white');
+                const remKey = item.remediationKey ? ` [${item.remediationKey}]` : '';
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? 'cyan' : undefined, children: isSelected ? '▶ ' : '  ' }), _jsxs(Text, { color: color, children: [glyph, " "] }), _jsx(Text, { bold: isSelected, children: item.label }), _jsx(Text, { dimColor: true, children: remKey }), isRunning && _jsx(Text, { color: "yellow", children: ' (running…)' })] }), isExpanded && (_jsx(Box, { paddingLeft: 4, children: _jsx(Text, { dimColor: true, children: item.detail }) }))] }, item.id));
+            }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ['notifications: ', _jsx(Text, { color: notificationsEnabledSession ? 'green' : 'yellow', children: notificationsEnabledSession ? 'on' : 'off (session)' })] }) })] }));
+}

package/dist/cockpit/panes/Help.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Help pane — reads pages merged via loader.ts (core docs + profile sources)
+ * and renders the active page through marked-terminal.
+ *
+ * Per-tab keys:
+ *   ↑/↓             scroll body up/down
+ *   j / k           previous / next page
+ *   shift+tab / tab same as j / k (alias for non-vim users; the global
+ *                   tab-cycle handler suspends on Help)
+ *   g / G           jump to top / bottom of body
+ */
+import React from 'react';
+export declare function Help(): React.ReactElement;
+//# sourceMappingURL=Help.d.ts.map

package/dist/cockpit/panes/Help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Help.d.ts","sourceRoot":"","sources":["../../../src/cockpit/panes/Help.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAA+C,MAAM,OAAO,CAAC;AAQpE,wBAAgB,IAAI,IAAI,KAAK,CAAC,YAAY,CAkGzC"}