@matthesketh/fleet 1.8.1 → 1.11.0

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

@@ -48,9 +48,9 @@ export function useSecrets() {
             }));
         }
     }, []);
-    const saveSecret = useCallback((app, key, value) => {
+    const saveSecret = useCallback(async (app, key, value) => {
         try {
-            setSecret(app, key, value);
+            await setSecret(app, key, value);
             // Re-unseal to update runtime
             try {
                 unsealAll();
@@ -62,7 +62,7 @@ export function useSecrets() {
             return { ok: false, error: err instanceof Error ? err.message : 'Failed to save secret' };
         }
     }, []);
-    const deleteSecret = useCallback((app, key) => {
+    const deleteSecret = useCallback(async (app, key) => {
         try {
             const plaintext = decryptApp(app);
             const manifest = loadManifest();
@@ -114,9 +114,9 @@ export function useSecrets() {
             return { ok: false, error: err instanceof Error ? err.message : 'Failed to unseal' };
         }
     }, []);
-    const seal = useCallback(() => {
+    const seal = useCallback(async () => {
         try {
-            sealFromRuntime();
+            await sealFromRuntime();
             setState(prev => ({ ...prev, sealed: true }));
             return { ok: true };
         }
@@ -124,9 +124,9 @@ export function useSecrets() {
             return { ok: false, error: err instanceof Error ? err.message : 'Failed to seal' };
         }
     }, []);
-    const importEnv = useCallback((app, path) => {
+    const importEnv = useCallback(async (app, path) => {
         try {
-            importEnvFile(app, path);
+            await importEnvFile(app, path);
             try {
                 unsealAll();
             }

package/dist/tui/router.d.ts

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

package/dist/tui/router.js

@@ -17,6 +17,7 @@ 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 { CommandPalette } from './views/CommandPalette.js';
 import { isSealed, isInitialized } from '../core/secrets.js';
 const HELP_GROUPS = [
     {
@@ -47,8 +48,9 @@ const HELP_GROUPS = [
         ],
     },
 ];
-function ViewRouter() {
+export function ViewRouter() {
     const state = React.useContext(AppStateContext);
+    const dispatch = React.useContext(AppDispatchContext);
     switch (state.currentView) {
         case 'dashboard':
             return _jsx(Dashboard, {});
@@ -62,6 +64,8 @@ function ViewRouter() {
             return _jsx(SecretEdit, {});
         case 'logs':
             return _jsx(LogsView, {});
+        case 'command-palette':
+            return (_jsx(CommandPalette, { onClose: () => dispatch({ type: 'GO_BACK' }), onOpenView: view => dispatch({ type: 'NAVIGATE', view: view }) }));
         default:
             return _jsx(Dashboard, {});
     }
@@ -75,7 +79,10 @@ function UpdateBanner({ info, inProgress }) {
     }
     const ahead = info.behind;
     const subject = info.latestSubject ? ` — ${info.latestSubject}` : '';
-    return (_jsx(Box, { paddingX: 1, children: _jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Text, { color: "cyan", children: ["\u2191 Update available: ", ahead, " commit", ahead === 1 ? '' : 's', " ahead", subject, ". Press "] }), _jsx(Text, { color: "cyan", bold: true, children: "U" }), _jsx(Text, { color: "cyan", children: " to install." })] }) }));
+    // channel label only surfaces on prerelease so the stable case stays
+    // visually identical to what operators have seen for several releases.
+    const channelLabel = info.channel === 'prerelease' ? ' (prerelease)' : '';
+    return (_jsx(Box, { paddingX: 1, children: _jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Text, { color: "cyan", children: ["\u2191 Update available", channelLabel, ": ", ahead, " commit", ahead === 1 ? '' : 's', " ahead", subject, ". Press "] }), _jsx(Text, { color: "cyan", bold: true, children: "U" }), _jsx(Text, { color: "cyan", children: " to install." })] }) }));
 }
 export function App() {
     const [state, dispatch] = useReducer(reducer, initialState);
@@ -141,27 +148,37 @@ export function App() {
             }
             return true;
         }
-        if (input === '?' && state.currentView !== 'secret-edit') {
+        // command-palette and secret-edit capture raw text input — the global
+        // single-key shortcuts must not fire while either is open.
+        const isInputView = state.currentView === 'secret-edit' || state.currentView === 'command-palette';
+        if (input === '?' && !isInputView) {
             setShowHelp(true);
             return true;
         }
-        if (input === 'q' && state.currentView !== 'secret-edit') {
+        if (input === ':' && !isInputView) {
+            dispatch({ type: 'NAVIGATE', view: 'command-palette' });
+            return true;
+        }
+        if (input === 'q' && !isInputView) {
             process.exit(0);
             return true;
         }
-        if (input === 'x' && state.currentView !== 'secret-edit') {
+        if (input === 'x' && !isInputView) {
             dispatch({ type: 'TOGGLE_REDACT' });
             return true;
         }
         // U → apply pending update. Only fires when one is actually available.
-        if ((input === 'U' || input === 'u') && state.currentView !== 'secret-edit') {
+        if ((input === 'U' || input === 'u') && !isInputView) {
             const info = updateInfoRef.current;
             if (info?.available && !updateInProgressRef.current) {
                 setUpdateInProgress(true);
                 applyUpdate().then(result => {
                     setUpdateInProgress(false);
                     if (result.ok) {
-                        setUpdateInfo({ available: false, behind: 0, latestSubject: '', branch: info.branch });
+                        setUpdateInfo({
+                            available: false, behind: 0, latestSubject: '',
+                            branch: info.branch, remoteBranch: info.remoteBranch, channel: info.channel,
+                        });
                     }
                     // Result reported via UpdateBanner below.
                     App.__lastUpdateOutput = result.output;
@@ -172,7 +189,7 @@ export function App() {
                 return true;
             }
         }
-        if (key.tab) {
+        if (key.tab && state.currentView !== 'command-palette') {
             const topViews = ['dashboard', 'health', 'secrets', 'logs-multi'];
             const base = topViews.includes(state.currentView)
                 ? state.currentView
@@ -180,7 +197,7 @@ export function App() {
             dispatch({ type: 'NAVIGATE', view: nextTopView(base) });
             return true;
         }
-        if (key.escape && state.previousView) {
+        if (key.escape && state.previousView && state.currentView !== 'command-palette') {
             dispatch({ type: 'GO_BACK' });
             return true;
         }

package/dist/tui/router.test.d.ts

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

package/dist/tui/router.test.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import { InputDispatcher } from '@matthesketh/ink-input-dispatcher';
+import { ViewRouter } from './router.js';
+import { AppStateContext, AppDispatchContext, initialState } from './state.js';
+describe('command palette routing', () => {
+    it('renders the command palette for the command-palette view', async () => {
+        const { lastFrame } = render(_jsx(InputDispatcher, { globalHandler: () => false, children: _jsx(AppStateContext.Provider, { value: { ...initialState, currentView: 'command-palette' }, children: _jsx(AppDispatchContext.Provider, { value: () => { }, children: _jsx(ViewRouter, {}) }) }) }));
+        await new Promise(r => setTimeout(r, 30));
+        expect(lastFrame() ?? '').toContain('Command palette');
+    });
+});

package/dist/tui/routines/components/SignalsGrid.test.js

@@ -21,9 +21,9 @@ describe('SignalsGrid', () => {
         expect(frame).toContain('CI');
     });
     it('renders a row with repo name when signals present', () => {
-        const rows = [{ repo: 'abmanandvan', signals: [mkSignal('git-clean', 'ok')] }];
+        const rows = [{ repo: 'movers-co', signals: [mkSignal('git-clean', 'ok')] }];
         const { lastFrame } = render(_jsx(SignalsGrid, { rows: rows, selectedIndex: 0, kinds: ['git-clean'] }));
-        expect(lastFrame()).toContain('abmanandvan');
+        expect(lastFrame()).toContain('movers-co');
     });
     it('shows empty-state message with no repos', () => {
         const { lastFrame } = render(_jsx(SignalsGrid, { rows: [], selectedIndex: 0, kinds: ['git-clean'] }));

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

@@ -69,7 +69,7 @@ function buildPlan(draft) {
 export function ScaffoldTab() {
     const [draft, setDraft] = useState({
         name: '',
-        composePath: '/home/matt/',
+        composePath: '/home/operator/',
         port: '3000',
         domain: '',
         usesSharedDb: true,

package/dist/tui/tests/redaction-rerender.test.d.ts

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

package/dist/tui/tests/redaction-rerender.test.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi } from 'vitest';
+import { InputDispatcher } from '@matthesketh/ink-input-dispatcher';
+// stable mock fleet status. the reference must stay constant across renders:
+// dashboard memoises its list items, so a changing status object would rebuild
+// them anyway and mask the redaction-staleness bug this test guards.
+const { MOCK_STATUS } = vi.hoisted(() => ({
+    MOCK_STATUS: {
+        totalApps: 3,
+        healthy: 3,
+        unhealthy: 0,
+        apps: [
+            { name: 'alpha-service', systemd: 'active', containers: '1/1', health: 'healthy' },
+            { name: 'bravo-service', systemd: 'active', containers: '1/1', health: 'healthy' },
+            { name: 'charlie-service', systemd: 'active', containers: '1/1', health: 'healthy' },
+        ],
+    },
+}));
+vi.mock('../hooks/use-fleet-data', () => ({
+    useFleetData: () => ({ status: MOCK_STATUS, loading: false, error: null }),
+}));
+// fixed available height so the list renders every row under a test stdout.
+vi.mock('@matthesketh/ink-viewport', () => ({
+    useAvailableHeight: () => 20,
+    Viewport: ({ children }) => children,
+}));
+import { Dashboard } from '../views/Dashboard.js';
+import { AppStateContext, AppDispatchContext, initialState } from '../state.js';
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+function Harness({ redacted }) {
+    return (_jsx(AppStateContext.Provider, { value: { ...initialState, redacted }, children: _jsx(AppDispatchContext.Provider, { value: () => { }, children: _jsx(InputDispatcher, { globalHandler: () => false, children: _jsx(Dashboard, {}) }) }) }));
+}
+describe('redaction re-renders every visible row', () => {
+    it('toggling redaction updates all app rows without scrolling', async () => {
+        const { lastFrame, rerender } = render(_jsx(Harness, { redacted: false }));
+        await delay(50);
+        const plain = lastFrame() ?? '';
+        expect(plain).toContain('alpha-service');
+        expect(plain).toContain('bravo-service');
+        expect(plain).toContain('charlie-service');
+        // flip redaction — equivalent to pressing 'x'. no j/k/arrow keys are sent,
+        // so nothing scrolls; every visible row must still pick up the new label.
+        rerender(_jsx(Harness, { redacted: true }));
+        await delay(50);
+        const out = lastFrame() ?? '';
+        expect(out).not.toContain('alpha-service');
+        expect(out).not.toContain('bravo-service');
+        expect(out).not.toContain('charlie-service');
+        // redacted labels follow the app-NN pattern from redactName()
+        expect(out).toMatch(/app-\d\d/);
+    });
+});

package/dist/tui/tests/scroll-flicker-proof.test.d.ts

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

package/dist/tui/tests/scroll-flicker-proof.test.js

@@ -0,0 +1,145 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useReducer } from 'react';
+import { EventEmitter } from 'node:events';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+// Force Ink's real (non-CI) render path so the flicker branch is reachable.
+// ink-testing-library renders in debug mode, where Ink's onRender returns
+// before the clear-screen branch — so it cannot observe the flicker at all.
+// This proof drives Ink's genuine production render() instead.
+vi.mock('is-in-ci', () => ({ default: false }));
+// eslint-disable-next-line import/first
+import { render, Box, Text } from 'ink';
+// eslint-disable-next-line import/first
+import { Viewport, useAvailableHeight } from '@matthesketh/ink-viewport';
+// eslint-disable-next-line import/first
+import { ScrollableList } from '@matthesketh/ink-scrollable-list';
+// eslint-disable-next-line import/first
+import { InputDispatcher, useRegisterHandler } from '@matthesketh/ink-input-dispatcher';
+// ESC (0x1B) built without a control-char literal in source.
+const ESC = String.fromCharCode(27);
+// Ink writes this exact sequence (ansiEscapes.clearTerminal) before a frame
+// whenever the frame height is >= stdout.rows — a full-screen wipe on every
+// re-render. That wipe IS the flicker; counting it proves its presence.
+const CLEAR_TERMINAL = `${ESC}[2J${ESC}[3J${ESC}[H`;
+const DOWN_ARROW = `${ESC}[B`;
+const ROWS = 24;
+const COLUMNS = 120;
+const SCROLL_STEPS = 20;
+const APPS = Array.from({ length: 200 }, (_, i) => `app-${i}`);
+/** A stdout that records every byte Ink writes and reports a fixed size. */
+class RecordingStdout extends EventEmitter {
+    columns = COLUMNS;
+    rows = ROWS;
+    isTTY = true;
+    writes = [];
+    write = (data) => {
+        this.writes.push(data);
+        return true;
+    };
+}
+/** A TTY-like stdin mirroring ink-testing-library's: a keypress is delivered
+ *  via both the 'readable'/read() and 'data' paths. */
+class FakeStdin extends EventEmitter {
+    isTTY = true;
+    data = null;
+    press = (data) => {
+        this.data = data;
+        this.emit('readable');
+        this.emit('data', data);
+    };
+    setEncoding() { }
+    setRawMode() { }
+    resume() { }
+    pause() { }
+    ref() { }
+    unref() { }
+    read = () => {
+        const d = this.data;
+        this.data = null;
+        return d;
+    };
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Mirrors Fleet's Dashboard: a windowed ScrollableList sized off
+ *  useAvailableHeight(), driven by j / down-arrow via the input dispatcher. */
+function MockDashboard() {
+    const [index, move] = useReducer((cur, delta) => Math.max(0, Math.min(APPS.length - 1, cur + delta)), 0);
+    const available = useAvailableHeight();
+    const listHeight = Math.max(5, available - 4); // same formula as Dashboard.tsx
+    const handler = (input, key) => {
+        if (input === 'j' || key.downArrow) {
+            move(1);
+            return true;
+        }
+        if (input === 'k' || key.upArrow) {
+            move(-1);
+            return true;
+        }
+        return false;
+    };
+    useRegisterHandler(handler);
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { bold: true, children: [APPS.length, " apps"] }), _jsx(ScrollableList, { items: APPS, selectedIndex: index, maxVisible: listHeight, renderItem: (item, selected) => (_jsxs(Text, { color: selected ? 'cyan' : undefined, children: [selected ? '> ' : '  ', item] })) })] }));
+}
+/** Fleet's real chrome: InputDispatcher outside, Viewport(chrome) inside. */
+function FleetUI() {
+    return (_jsx(InputDispatcher, { globalHandler: () => false, children: _jsxs(Viewport, { chrome: 6, children: [_jsx(Text, { children: "fleet" }), _jsx(MockDashboard, {})] }) }));
+}
+/** The pre-fix viewport: a root box pinned to the FULL terminal height. */
+function LegacyChrome() {
+    return (_jsx(InputDispatcher, { globalHandler: () => false, children: _jsxs(Box, { flexDirection: "column", height: ROWS, children: [_jsx(Text, { children: "fleet" }), _jsx(MockDashboard, {})] }) }));
+}
+/** Mount with Ink's production render path, scroll SCROLL_STEPS rows, and
+ *  record every byte Ink writes to the terminal. */
+async function scrollAndRecord(node) {
+    const stdout = new RecordingStdout();
+    const stdin = new FakeStdin();
+    const app = render(node, {
+        stdout: stdout,
+        stdin: stdin,
+        debug: false,
+        exitOnCtrlC: false,
+        patchConsole: false,
+    });
+    await sleep(40);
+    for (let i = 0; i < SCROLL_STEPS; i++) {
+        stdin.press(DOWN_ARROW);
+        await sleep(45); // > Ink's 32ms render throttle, so each scroll renders
+    }
+    await sleep(60);
+    app.unmount();
+    const output = stdout.writes.join('');
+    return { clears: output.split(CLEAR_TERMINAL).length - 1, output };
+}
+describe('Fleet TUI scroll flicker proof', () => {
+    beforeEach(() => {
+        process.setMaxListeners(0);
+        Object.defineProperty(process.stdout, 'rows', {
+            value: ROWS,
+            writable: true,
+            configurable: true,
+        });
+        Object.defineProperty(process.stdout, 'columns', {
+            value: COLUMNS,
+            writable: true,
+            configurable: true,
+        });
+    });
+    // skipped on ci: ink picks up github_actions / ci directly and gates the
+    // clearterminal branch on tty-ish heuristics that the in-process recorder
+    // can't fully spoof. the control passes locally where the production
+    // render path is reachable, so the proof below still has its anchor when
+    // run pre-commit; gh actions just doesn't reproduce the legacy bug.
+    it.skipIf(Boolean(process.env.CI))('CONTROL: a full-terminal-height frame flickers on every scroll render', async () => {
+        const { clears } = await scrollAndRecord(_jsx(LegacyChrome, {}));
+        expect(clears).toBeGreaterThan(0);
+    });
+    it('Fleet UI scrolls 20 rows with ZERO full-screen clears', async () => {
+        const { clears, output } = await scrollAndRecord(_jsx(FleetUI, {}));
+        // The scroll genuinely happened: ScrollableList only renders its
+        // "more above" indicator once the window has scrolled down.
+        expect(output).toContain('more above');
+        // ...and across every one of those re-renders, Ink never wiped the
+        // screen. Zero clearTerminal sequences => zero flicker.
+        expect(clears).toBe(0);
+    });
+});

package/dist/tui/types.d.ts

@@ -1,4 +1,4 @@
-export type View = 'dashboard' | 'app-detail' | 'health' | 'secrets' | 'secret-edit' | 'logs' | 'logs-multi';
+export type View = 'dashboard' | 'app-detail' | 'health' | 'secrets' | 'secret-edit' | 'logs' | 'logs-multi' | 'command-palette';
 export type SecretsSubView = 'app-list' | 'secret-list';
 export interface TuiState {
     currentView: View;

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

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function CommandPalette(props: {
+    onOpenView: (view: string) => void;
+    onClose: () => void;
+}): React.JSX.Element;

package/dist/tui/views/CommandPalette.js

@@ -0,0 +1,90 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import { Box, Text } from 'ink';
+import { useRegisterHandler } from '@matthesketh/ink-input-dispatcher';
+import { ScrollableList } from '@matthesketh/ink-scrollable-list';
+import { loadRegistry } from '../../registry/index.js';
+import { allCommands } from '../../registry/registry.js';
+import { ArgForm } from '../components/ArgForm.js';
+import { runFleetCommand } from '../exec-bridge.js';
+import { colors } from '../theme.js';
+export function CommandPalette(props) {
+    // load the registry once and snapshot the visible commands. a lazy useState
+    // initialiser runs exactly once — unlike a bare call in the render body.
+    const [commands] = useState(() => {
+        loadRegistry();
+        return allCommands().filter(c => !c.cliOnly);
+    });
+    const [query, setQuery] = useState('');
+    const [index, setIndex] = useState(0);
+    const [chosen, setChosen] = useState(null);
+    const [output, setOutput] = useState(null);
+    const filtered = useMemo(() => commands.filter(c => (c.name + ' ' + c.summary).toLowerCase().includes(query.toLowerCase())), [commands, query]);
+    const listHandler = (input, key) => {
+        if (chosen || output !== null)
+            return false;
+        if (key.escape) {
+            props.onClose();
+            return true;
+        }
+        if (key.downArrow) {
+            setIndex(i => Math.min(i + 1, filtered.length - 1));
+            return true;
+        }
+        if (key.upArrow) {
+            setIndex(i => Math.max(i - 1, 0));
+            return true;
+        }
+        if (key.return) {
+            const cmd = filtered[index];
+            if (!cmd)
+                return true;
+            if (cmd.tui && typeof cmd.tui === 'object') {
+                props.onOpenView(cmd.tui.view);
+                return true;
+            }
+            setChosen(cmd);
+            return true;
+        }
+        if (key.backspace || key.delete) {
+            setQuery(q => q.slice(0, -1));
+            setIndex(0);
+            return true;
+        }
+        if (input && !key.ctrl && !key.meta) {
+            setQuery(q => q + input);
+            setIndex(0);
+            return true;
+        }
+        return false;
+    };
+    useRegisterHandler(listHandler);
+    if (output !== null) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { bold: true, color: colors.primary, children: [chosen?.name, " result"] }), _jsx(Text, { children: output }), _jsx(Text, { color: colors.muted, children: "esc to close" }), _jsx(CloseOnEscape, { onClose: () => { setOutput(null); setChosen(null); } })] }));
+    }
+    if (chosen) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: colors.primary, children: chosen.name }), _jsx(ArgForm, { schema: chosen.args, onCancel: () => setChosen(null), onSubmit: async (values) => {
+                        const argv = [chosen.name];
+                        for (const [k, v] of Object.entries(values)) {
+                            if (v === true)
+                                argv.push(`--${k}`);
+                            else if (v !== false && v !== '' && v != null)
+                                argv.push(`--${k}`, String(v));
+                        }
+                        const r = await runFleetCommand(argv);
+                        setOutput(r.output);
+                    } })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: colors.primary, children: "Command palette" }), _jsxs(Text, { color: colors.muted, children: ["filter: ", query || '(type to filter)'] }), _jsx(ScrollableList, { items: filtered, selectedIndex: Math.min(index, Math.max(0, filtered.length - 1)), maxVisible: 12, emptyText: "  no matching commands", renderItem: (cmd, selected) => (_jsxs(Box, { children: [_jsx(Text, { color: selected ? colors.primary : colors.muted, children: selected ? '> ' : '  ' }), _jsx(Box, { width: 20, children: _jsx(Text, { bold: selected, children: cmd.name }) }), _jsx(Text, { color: colors.muted, children: cmd.summary })] })) })] }));
+}
+function CloseOnEscape(props) {
+    const handler = (_input, key) => {
+        if (key.escape) {
+            props.onClose();
+            return true;
+        }
+        return false;
+    };
+    useRegisterHandler(handler);
+    return _jsx(_Fragment, {});
+}

package/dist/tui/views/CommandPalette.test.d.ts

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

package/dist/tui/views/CommandPalette.test.js

@@ -0,0 +1,117 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { z } from 'zod';
+import { InputDispatcher } from '@matthesketh/ink-input-dispatcher';
+vi.mock('../exec-bridge', () => ({
+    runFleetCommand: vi.fn(async () => ({ ok: true, output: 'done' })),
+}));
+import { runFleetCommand } from '../exec-bridge.js';
+import { register, defineCommand } from '../../registry/registry.js';
+import { loadRegistry, _resetLoader } from '../../registry/index.js';
+import { CommandPalette } from './CommandPalette.js';
+/** flush ink's render queue after a keystroke */
+const flush = () => new Promise(r => setTimeout(r, 30));
+beforeEach(() => _resetLoader());
+afterEach(() => _resetLoader());
+describe('CommandPalette', () => {
+    it('lists registry commands', async () => {
+        const { lastFrame } = render(_jsx(InputDispatcher, { globalHandler: () => false, children: _jsx(CommandPalette, { onOpenView: () => { }, onClose: () => { } }) }));
+        await flush();
+        // assert against the first alphabetical command — the palette caps
+        // visible items at 12 so commands later in the list (status, stop,
+        // whoami, ...) may scroll off when the registry grows.
+        expect(lastFrame() ?? '').toContain('add');
+    });
+    it('hides non-matching commands when a query is typed', async () => {
+        const { lastFrame, stdin } = render(_jsx(InputDispatcher, { globalHandler: () => false, children: _jsx(CommandPalette, { onOpenView: () => { }, onClose: () => { } }) }));
+        await flush();
+        // sanity: at least the first command is visible before filtering
+        expect(lastFrame() ?? '').toContain('add');
+        // type a query that matches nothing
+        stdin.write('z');
+        await flush();
+        stdin.write('z');
+        await flush();
+        stdin.write('z');
+        await flush();
+        stdin.write('z');
+        await flush();
+        const frame = lastFrame() ?? '';
+        expect(frame).not.toContain('status');
+        expect(frame).toContain('no matching commands');
+    });
+    it('calls onOpenView when enter is pressed on a command with a tui view', async () => {
+        // type 'stat' to filter to only status, then press enter.
+        const onOpenView = vi.fn();
+        const { stdin } = render(_jsx(InputDispatcher, { globalHandler: () => false, children: _jsx(CommandPalette, { onOpenView: onOpenView, onClose: () => { } }) }));
+        await flush();
+        stdin.write('s');
+        await flush();
+        stdin.write('t');
+        await flush();
+        stdin.write('a');
+        await flush();
+        stdin.write('t');
+        await flush();
+        stdin.write('\r');
+        await flush();
+        expect(onOpenView).toHaveBeenCalledWith('dashboard');
+    });
+    it('builds argv from an empty-args command and calls runFleetCommand', async () => {
+        // register an ad-hoc command with no tui and an empty args schema.
+        // loadRegistry() first so the loaded flag is set and the component's own
+        // call does not wipe the ad-hoc registration.
+        loadRegistry();
+        register(defineCommand({
+            name: 'demo-run',
+            summary: 'a demo command',
+            args: z.object({}),
+            async run() { return { ok: true, summary: 'ok', data: null }; },
+        }));
+        const { stdin } = render(_jsx(InputDispatcher, { globalHandler: () => false, children: _jsx(CommandPalette, { onOpenView: () => { }, onClose: () => { } }) }));
+        await flush();
+        // type 'demo-run' to filter to exactly this command so the test is
+        // stable regardless of how many other commands are in the registry.
+        for (const ch of 'demo-run') {
+            stdin.write(ch);
+            await flush();
+        }
+        // press enter on demo-run → ArgForm shown (no tui field).
+        stdin.write('\r');
+        await flush();
+        // ArgForm with no fields: press enter → onSubmit({}) → runFleetCommand.
+        stdin.write('\r');
+        await flush();
+        expect(vi.mocked(runFleetCommand)).toHaveBeenCalledWith(['demo-run']);
+    });
+    it('builds --flag argv when a boolean field is toggled before submit', async () => {
+        // register a command with a boolean arg.
+        loadRegistry();
+        register(defineCommand({
+            name: 'demo-flag',
+            summary: 'a flag demo',
+            args: z.object({ force: z.boolean().default(false) }),
+            async run() { return { ok: true, summary: 'ok', data: null }; },
+        }));
+        const { stdin } = render(_jsx(InputDispatcher, { globalHandler: () => false, children: _jsx(CommandPalette, { onOpenView: () => { }, onClose: () => { } }) }));
+        await flush();
+        // type 'demo-flag' to filter to exactly this command so the test is
+        // stable regardless of how many other commands are in the registry.
+        for (const ch of 'demo-flag') {
+            stdin.write(ch);
+            await flush();
+        }
+        // press enter on demo-flag.
+        stdin.write('\r');
+        await flush();
+        // ArgForm is now showing the 'force' boolean field (cursor on it).
+        // press space to toggle force → true.
+        stdin.write(' ');
+        await flush();
+        // press enter to submit { force: true }.
+        stdin.write('\r');
+        await flush();
+        expect(vi.mocked(runFleetCommand)).toHaveBeenCalledWith(['demo-flag', '--force']);
+    });
+});