@a9s/cli 0.0.1 → 0.1.0

package/dist/src/App.js

@@ -0,0 +1,476 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Box, Text, useApp } from "ink";
+import { useAtom } from "jotai";
+import clipboardy from "clipboardy";
+import { HUD } from "./components/HUD.js";
+import { ModeBar } from "./components/ModeBar.js";
+import { AdvancedTextInput } from "./components/AdvancedTextInput.js";
+import { FullscreenBox, useScreenSize } from "./utils/withFullscreen.js";
+import { useHelpPanel } from "./hooks/useHelpPanel.js";
+import { useAwsContext } from "./hooks/useAwsContext.js";
+import { useAwsRegions } from "./hooks/useAwsRegions.js";
+import { useAwsProfiles } from "./hooks/useAwsProfiles.js";
+import { useMainInput } from "./hooks/useMainInput.js";
+import { useInputEventProcessor } from "./hooks/useInputEventProcessor.js";
+import { useHierarchyState } from "./hooks/useHierarchyState.js";
+import { useAppController } from "./hooks/useAppController.js";
+import { useCommandRouter } from "./hooks/useCommandRouter.js";
+import { useDetailController } from "./hooks/useDetailController.js";
+import { useActionController } from "./hooks/useActionController.js";
+import { useUiHints } from "./hooks/useUiHints.js";
+import { useAppData } from "./hooks/useAppData.js";
+import { deriveYankHeaderMarkers } from "./hooks/yankHeaderMarkers.js";
+import { AppMainView } from "./features/AppMainView.js";
+import { AVAILABLE_COMMANDS } from "./constants/commands.js";
+import { buildHelpTabs, triggerToString } from "./constants/keybindings.js";
+import { currentlySelectedServiceAtom, selectedRegionAtom, selectedProfileAtom, revealSecretsAtom, } from "./state/atoms.js";
+const INITIAL_AWS_PROFILE = process.env.AWS_PROFILE;
+export function App({ initialService, endpointUrl }) {
+    const { exit } = useApp();
+    const { columns: termCols, rows: termRows } = useScreenSize();
+    const [selectedRegion, setSelectedRegion] = useAtom(selectedRegionAtom);
+    const [selectedProfile, setSelectedProfile] = useAtom(selectedProfileAtom);
+    const [currentService, setCurrentService] = useAtom(currentlySelectedServiceAtom);
+    const [revealSecrets, setRevealSecrets] = useAtom(revealSecretsAtom);
+    const { accountName, accountId, awsProfile, currentIdentity, region } = useAwsContext(endpointUrl, selectedRegion, selectedProfile);
+    const availableRegions = useAwsRegions(selectedRegion, selectedProfile);
+    const availableProfiles = useAwsProfiles();
+    const { reset: resetHierarchy, updateCurrentFilter, pushLevel, popLevel } = useHierarchyState();
+    const { state, actions } = useAppController();
+    useEffect(() => {
+        if (selectedProfile === "$default") {
+            if (INITIAL_AWS_PROFILE === undefined) {
+                delete process.env.AWS_PROFILE;
+            }
+            else {
+                process.env.AWS_PROFILE = INITIAL_AWS_PROFILE;
+            }
+            return;
+        }
+        process.env.AWS_PROFILE = selectedProfile;
+    }, [selectedProfile]);
+    useEffect(() => {
+        setCurrentService(initialService);
+    }, [initialService, setCurrentService]);
+    const HUD_LINES = 3;
+    const MODEBAR_LINES = 1;
+    const HEADER_LINES = 2;
+    const tableHeight = Math.max(1, termRows - HUD_LINES - MODEBAR_LINES - HEADER_LINES - 4);
+    const { adapter, columns, isLoading, error, select, edit, goBack, refresh, path, filteredRows, selectedRow, navigation, pickers, } = useAppData({
+        currentService,
+        endpointUrl,
+        selectedRegion,
+        tableHeight,
+        filterText: state.filterText,
+        availableRegions,
+        availableProfiles,
+    });
+    const [didOpenInitialResources, setDidOpenInitialResources] = useState(false);
+    useEffect(() => {
+        if (didOpenInitialResources)
+            return;
+        pickers.openPicker("resource");
+        setDidOpenInitialResources(true);
+    }, [didOpenInitialResources, pickers]);
+    const switchAdapter = useCallback((serviceId) => {
+        setCurrentService(serviceId);
+        actions.setFilterText("");
+        actions.setDescribeState(null);
+        actions.setSearchEntryFilter(null);
+        actions.setMode("navigate");
+        actions.setYankMode(false);
+        actions.setUploadPending(null);
+        actions.setPendingAction(null);
+        resetHierarchy();
+        navigation.reset();
+    }, [actions, navigation, resetHierarchy, setCurrentService]);
+    const navigateBack = useCallback(() => {
+        if (!adapter.canGoBack())
+            return;
+        void goBack().then(() => {
+            actions.setDescribeState(null);
+            actions.setSearchEntryFilter(null);
+            const { restoredFilter, restoredIndex } = popLevel();
+            actions.setFilterText(restoredFilter);
+            navigation.setIndex(restoredIndex);
+        });
+    }, [actions, adapter, goBack, navigation, popLevel]);
+    const navigateIntoSelection = useCallback(() => {
+        if (!selectedRow)
+            return;
+        if (selectedRow.meta?.type === "object")
+            return;
+        void select(selectedRow).then((result) => {
+            if (result?.action === "navigate") {
+                actions.setSearchEntryFilter(null);
+                pushLevel(navigation.selectedIndex, "");
+                actions.setFilterText("");
+                actions.setDescribeState(null);
+                navigation.reset();
+                return;
+            }
+            if (result.action === "edit" && "needsUpload" in result && result.needsUpload) {
+                actions.setUploadPending({
+                    filePath: result.filePath,
+                    metadata: result.metadata,
+                });
+            }
+        });
+    }, [actions, navigation, pushLevel, select, selectedRow]);
+    const editSelection = useCallback(() => {
+        if (!selectedRow)
+            return;
+        void edit(selectedRow).then((result) => {
+            if (result.action === "edit" && "needsUpload" in result && result.needsUpload) {
+                actions.setUploadPending({
+                    filePath: result.filePath,
+                    metadata: result.metadata,
+                });
+            }
+        });
+    }, [actions, edit, selectedRow]);
+    const { showDetails: showDetailsBase, closeDetails } = useDetailController({
+        adapter,
+        setDescribeState: actions.setDescribeState,
+    });
+    const showDetails = useCallback((row) => {
+        setPanelScrollOffset(0);
+        showDetailsBase(row);
+    }, [showDetailsBase]);
+    const { handleActionEffect, submitPendingAction } = useActionController({
+        adapter,
+        refresh,
+        setPendingAction: actions.setPendingAction,
+        pushFeedback: actions.pushFeedback,
+    });
+    const runAdapterAction = useCallback((actionId, row) => {
+        if (!adapter.capabilities?.actions)
+            return;
+        void adapter.capabilities.actions
+            .executeAction(actionId, { row })
+            .then((effect) => {
+            handleActionEffect(effect, row);
+        })
+            .catch((err) => {
+            actions.pushFeedback(`Action failed: ${err.message}`, 3000);
+        });
+    }, [actions, adapter.capabilities?.actions, handleActionEffect]);
+    const adapterBindings = useMemo(() => adapter.capabilities?.actions?.getKeybindings() ?? [], [adapter]);
+    const helpTabs = useMemo(() => buildHelpTabs(adapter.id, adapterBindings), [adapter.id, adapterBindings]);
+    const helpContainerHeight = Math.max(1, termRows - HUD_LINES - MODEBAR_LINES);
+    const helpPanel = useHelpPanel(helpTabs, helpContainerHeight);
+    const nameOption = {
+        trigger: { type: "key", char: "n" },
+        label: "copy name",
+        feedback: "Copied Name",
+        headerKey: "name",
+        isRelevant: () => true,
+        resolve: async (row) => {
+            const nameCell = row.cells.name;
+            if (!nameCell)
+                return null;
+            return typeof nameCell === "string" ? nameCell : nameCell.displayName;
+        },
+    };
+    const yankOptions = useMemo(() => {
+        const adapterOptions = selectedRow
+            ? (adapter.capabilities?.yank?.getYankOptions(selectedRow) ?? [])
+            : [];
+        return [nameOption, ...adapterOptions];
+    }, [adapter, selectedRow]);
+    const yankHint = useMemo(() => [...yankOptions.map((o) => `${triggerToString(o.trigger)} · ${o.label}`), "Esc cancel"].join(" • "), [yankOptions]);
+    const yankHeaderMarkers = useMemo(() => deriveYankHeaderMarkers(state.yankMode, yankOptions), [state.yankMode, yankOptions]);
+    // Compute context for keybinding hints
+    const uiHintsContext = useMemo(() => {
+        // Check if any visible row contains secret cells
+        const hasSecretData = filteredRows.some((row) => Object.values(row.cells).some((cell) => typeof cell === "object" && cell?.type === "secret"));
+        // Only show reveal toggle if there are secrets AND they're currently hidden
+        return { hasHiddenSecrets: hasSecretData && !revealSecrets };
+    }, [filteredRows, revealSecrets]);
+    const { bottomHint } = useUiHints({
+        mode: state.mode,
+        helpOpen: helpPanel.helpOpen,
+        pickers,
+        pendingAction: state.pendingAction,
+        uploadPending: state.uploadPending,
+        describeState: state.describeState,
+        yankMode: state.yankMode,
+        adapterBindings,
+        yankHint,
+        context: uiHintsContext,
+    });
+    const commandRouter = useCommandRouter({
+        setSelectedRegion,
+        setSelectedProfile,
+        switchAdapter,
+        openProfilePicker: () => pickers.openPicker("profile"),
+        openRegionPicker: () => pickers.openPicker("region"),
+        openResourcePicker: () => pickers.openPicker("resource"),
+        exit,
+    });
+    const handleFilterChange = useCallback((value) => {
+        if (pickers.activePicker) {
+            pickers.activePicker.setFilter(value);
+            return;
+        }
+        actions.setFilterText(value);
+        updateCurrentFilter(value);
+    }, [actions, pickers, updateCurrentFilter]);
+    const handleFilterSubmit = useCallback(() => {
+        if (pickers.activePicker) {
+            pickers.activePicker.confirmSearch();
+            return;
+        }
+        actions.setSearchEntryFilter(null);
+        actions.setMode("navigate");
+    }, [actions, pickers]);
+    const handleCommandSubmit = useCallback(() => {
+        const command = state.commandText.trim();
+        actions.setCommandText("");
+        actions.setMode("navigate");
+        commandRouter(command);
+    }, [actions, commandRouter, state.commandText]);
+    const [uploadPreview, setUploadPreview] = useState({ old: "", new: "" });
+    const [panelScrollOffset, setPanelScrollOffset] = useState(0);
+    const handleUploadDecision = useCallback((confirmed) => {
+        if (!state.uploadPending)
+            return;
+        if (!confirmed) {
+            actions.pushFeedback("Upload cancelled", 2000);
+            actions.setUploadPending(null);
+            setUploadPreview({ old: "", new: "" });
+            return;
+        }
+        void (async () => {
+            try {
+                await adapter.capabilities?.edit?.uploadFile(state.uploadPending.filePath, state.uploadPending.metadata);
+                actions.pushFeedback("✓ Uploaded successfully", 2000);
+                // Refresh to show updated data
+                await refresh();
+            }
+            catch (err) {
+                actions.pushFeedback(`✗ Upload failed: ${err.message}`, 3000);
+            }
+            finally {
+                actions.setUploadPending(null);
+                setUploadPreview({ old: "", new: "" });
+            }
+        })();
+    }, [actions, adapter.capabilities?.edit, state.uploadPending, refresh]);
+    // Load preview when uploadPending changes
+    useEffect(() => {
+        if (state.uploadPending) {
+            setPanelScrollOffset(0);
+            void (async () => {
+                try {
+                    const { readFile } = await import("fs/promises");
+                    const newContent = await readFile(state.uploadPending.filePath, "utf-8");
+                    // Try to get old value from adapter (current value from AWS)
+                    let oldContent = "";
+                    const meta = state.uploadPending.metadata;
+                    // For Secrets Manager fields: fetch the current field value
+                    if (meta.fieldKey && meta.secretArn) {
+                        try {
+                            const { runAwsJsonAsync } = await import("./utils/aws.js");
+                            const regionArgs = selectedRegion ? ["--region", selectedRegion] : [];
+                            const secretData = await runAwsJsonAsync([
+                                "secretsmanager",
+                                "get-secret-value",
+                                "--secret-id",
+                                meta.secretArn,
+                                ...regionArgs,
+                            ]);
+                            const secretString = secretData.SecretString || "";
+                            // $RAW field is the whole secret value, not a JSON field
+                            if (meta.fieldKey === "$RAW") {
+                                oldContent = secretString;
+                            }
+                            else {
+                                // Regular JSON field - parse and extract
+                                try {
+                                    const parsed = JSON.parse(secretString);
+                                    oldContent = parsed[meta.fieldKey] || "";
+                                }
+                                catch {
+                                    // Not JSON - oldContent stays empty
+                                }
+                            }
+                        }
+                        catch {
+                            // Failed to fetch
+                        }
+                    }
+                    // For whole secrets: fetch current secret value
+                    else if (meta.secretArn && !meta.fieldKey) {
+                        try {
+                            const { runAwsJsonAsync } = await import("./utils/aws.js");
+                            const regionArgs = selectedRegion ? ["--region", selectedRegion] : [];
+                            const secretData = await runAwsJsonAsync([
+                                "secretsmanager",
+                                "get-secret-value",
+                                "--secret-id",
+                                meta.secretArn,
+                                ...regionArgs,
+                            ]);
+                            oldContent = secretData.SecretString || "";
+                        }
+                        catch {
+                            // Failed to fetch
+                        }
+                    }
+                    setUploadPreview({ old: oldContent, new: newContent });
+                }
+                catch {
+                    setUploadPreview({ old: "", new: "[Unable to load preview]" });
+                }
+            })();
+        }
+    }, [state.uploadPending, selectedRegion]);
+    const commandAutocomplete = useCallback(() => {
+        const match = AVAILABLE_COMMANDS.find((cmd) => cmd.toLowerCase().startsWith(state.commandText.toLowerCase()));
+        if (!match)
+            return;
+        actions.setCommandText(match);
+        actions.bumpCommandCursorToEnd();
+    }, [actions, state.commandText]);
+    const inputRuntime = useMemo(() => ({
+        mode: state.mode,
+        filterText: state.filterText,
+        commandText: state.commandText,
+        searchEntryFilter: state.searchEntryFilter,
+        yankMode: state.yankMode,
+        yankHelpOpen: state.yankHelpOpen,
+        selectedRow,
+        helpOpen: helpPanel.helpOpen,
+        pickerMode: pickers.activePicker?.pickerMode ?? null,
+        describeOpen: Boolean(state.describeState),
+        uploadPending: Boolean(state.uploadPending),
+        pendingActionType: state.pendingAction?.effect.type ?? null,
+    }), [helpPanel.helpOpen, pickers.activePicker?.pickerMode, selectedRow, state]);
+    const inputDispatch = useInputEventProcessor({
+        runtime: inputRuntime,
+        actions: {
+            app: { exit },
+            help: {
+                open: helpPanel.open,
+                close: helpPanel.close,
+                prevTab: helpPanel.goToPrevTab,
+                nextTab: helpPanel.goToNextTab,
+                scrollUp: helpPanel.scrollUp,
+                scrollDown: helpPanel.scrollDown,
+                goToTab: helpPanel.goToTab,
+            },
+            picker: {
+                close: pickers.closeActivePicker,
+                cancelSearch: () => pickers.activePicker?.cancelSearch(),
+                startSearch: () => pickers.activePicker?.startSearch(),
+                moveDown: () => pickers.activePicker?.moveDown(),
+                moveUp: () => pickers.activePicker?.moveUp(),
+                top: () => pickers.activePicker?.toTop(),
+                bottom: () => pickers.activePicker?.toBottom(),
+                confirm: () => pickers.confirmActivePickerSelection({
+                    onSelectResource: switchAdapter,
+                    onSelectRegion: setSelectedRegion,
+                    onSelectProfile: setSelectedProfile,
+                }),
+            },
+            mode: {
+                cancelSearchOrCommand: () => {
+                    if (state.mode === "search") {
+                        if (state.searchEntryFilter !== null && state.filterText !== "") {
+                            handleFilterChange(state.searchEntryFilter);
+                        }
+                        actions.setSearchEntryFilter(null);
+                    }
+                    actions.setMode("navigate");
+                },
+                clearFilterOrNavigateBack: () => {
+                    if (state.filterText !== "") {
+                        handleFilterChange("");
+                    }
+                    else {
+                        navigateBack();
+                    }
+                },
+                startSearch: () => {
+                    actions.setSearchEntryFilter(state.filterText);
+                    actions.setMode("search");
+                },
+                startCommand: () => {
+                    actions.setCommandText("");
+                    actions.setMode("command");
+                },
+                commandAutocomplete,
+            },
+            navigation: {
+                refresh: () => {
+                    void refresh();
+                },
+                revealToggle: () => {
+                    setRevealSecrets(!revealSecrets);
+                },
+                showDetails: () => showDetails(selectedRow),
+                editSelection,
+                top: navigation.toTop,
+                bottom: navigation.toBottom,
+                enter: navigateIntoSelection,
+            },
+            scroll: {
+                up: () => {
+                    if (state.uploadPending || state.describeState) {
+                        setPanelScrollOffset((p) => Math.max(0, p - 1));
+                    }
+                    else {
+                        navigation.moveUp();
+                    }
+                },
+                down: () => {
+                    if (state.uploadPending || state.describeState) {
+                        setPanelScrollOffset((p) => p + 1);
+                    }
+                    else {
+                        navigation.moveDown();
+                    }
+                },
+            },
+            yank: {
+                enter: () => {
+                    actions.setYankMode(true);
+                    actions.setYankHelpOpen(false);
+                },
+                cancel: () => {
+                    actions.setYankMode(false);
+                    actions.setYankHelpOpen(false);
+                },
+                openHelp: () => {
+                    actions.setYankHelpOpen(true);
+                },
+                closeHelp: () => {
+                    actions.setYankHelpOpen(false);
+                },
+            },
+            details: {
+                close: closeDetails,
+            },
+            pending: {
+                cancelPrompt: () => actions.setPendingAction(null),
+                submit: (confirmed) => submitPendingAction(state.pendingAction, confirmed),
+            },
+            upload: {
+                decide: handleUploadDecision,
+            },
+            adapterAction: {
+                run: runAdapterAction,
+                bindings: adapterBindings,
+            },
+        },
+        yankOptions,
+        pushYankFeedback: actions.pushFeedback,
+        writeClipboard: clipboardy.write,
+        hasCommandAutocomplete: (text) => AVAILABLE_COMMANDS.some((cmd) => cmd.toLowerCase().startsWith(text.toLowerCase())),
+    });
+    useMainInput(inputDispatch);
+    const activePickerFilter = pickers.activePicker?.filter ?? state.filterText;
+    return (_jsx(FullscreenBox, { children: _jsxs(Box, { flexDirection: "column", width: termCols, height: termRows, children: [_jsx(HUD, { serviceLabel: adapter.label, hudColor: adapter.hudColor, path: path, accountName: accountName, accountId: accountId, awsProfile: awsProfile, currentIdentity: currentIdentity, region: region, terminalWidth: termCols, loading: isLoading || Boolean(state.describeState?.loading) }), _jsx(Box, { flexDirection: "row", width: "100%", flexGrow: 1, children: _jsx(AppMainView, { helpPanel: helpPanel, helpTabs: helpTabs, pickers: pickers, error: error, describeState: state.describeState, isLoading: isLoading, filteredRows: filteredRows, columns: columns, selectedIndex: navigation.selectedIndex, scrollOffset: navigation.scrollOffset, filterText: state.filterText, adapter: adapter, termCols: termCols, tableHeight: tableHeight, yankHelpOpen: state.yankHelpOpen, yankOptions: yankOptions, yankHelpRow: selectedRow, uploadPending: state.uploadPending, uploadPreview: uploadPreview, panelScrollOffset: panelScrollOffset, ...(yankHeaderMarkers ? { headerMarkers: yankHeaderMarkers } : {}) }) }), !helpPanel.helpOpen && state.yankFeedbackMessage && (_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "green", children: state.yankFeedbackMessage }) })), state.pendingAction && state.pendingAction.effect.type === "prompt" && (_jsxs(Box, { paddingX: 1, children: [_jsxs(Text, { color: "cyan", children: [state.pendingAction.effect.label, " "] }), _jsx(AdvancedTextInput, { value: state.pendingAction.inputValue, onChange: (value) => actions.setPendingInputValue(value), onSubmit: () => submitPendingAction(state.pendingAction, true), focus: true })] })), state.pendingAction && state.pendingAction.effect.type === "confirm" && (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: "yellow", children: [state.pendingAction.effect.message, " (y/n)"] }) })), _jsx(ModeBar, { mode: state.mode, filterText: activePickerFilter, commandText: state.commandText, commandCursorToEndToken: state.commandCursorToEndToken, hintOverride: bottomHint, pickerSearchActive: pickers.activePicker?.pickerMode === "search", onFilterChange: handleFilterChange, onCommandChange: actions.setCommandText, onFilterSubmit: handleFilterSubmit, onCommandSubmit: handleCommandSubmit })] }) }));
+}

package/dist/src/adapters/ServiceAdapter.js

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

package/dist/src/adapters/capabilities/ActionCapability.js

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

package/dist/src/adapters/capabilities/DetailCapability.js

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

package/dist/src/adapters/capabilities/EditCapability.js

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

package/dist/src/adapters/capabilities/YankCapability.js

@@ -0,0 +1,42 @@
+/**
+ * Generic factory — the single implementation of getYankOptions.
+ * Parses row.meta via schema, filters by isRelevant, wraps with typed resolve.
+ */
+export function createYankCapability(options, schema, ctx) {
+    const parse = (row) => {
+        const result = schema.safeParse(row.meta);
+        if (!result.success)
+            return null;
+        return { id: row.id, cells: row.cells, meta: result.data };
+    };
+    return {
+        getYankOptions(row) {
+            const typedRow = parse(row);
+            if (!typedRow)
+                return [];
+            return options
+                .filter((def) => def.isRelevant(typedRow))
+                .map((def) => {
+                const option = {
+                    trigger: def.trigger,
+                    label: def.label,
+                    feedback: def.feedback,
+                    isRelevant: (r) => {
+                        const tr = parse(r);
+                        return tr !== null && def.isRelevant(tr);
+                    },
+                    resolve: (r) => {
+                        const tr = parse(r);
+                        if (!tr)
+                            return Promise.resolve(null);
+                        return def.resolve(tr, ctx);
+                    },
+                };
+                if (def.headerKey !== undefined) {
+                    option.headerKey = def.headerKey;
+                }
+                return option;
+            });
+        },
+    };
+}

package/dist/src/adapters/capabilities/YankCapability.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { createYankCapability } from "./YankCapability.js";
+import { textCell } from "../../types.js";
+describe("createYankCapability", () => {
+    it("propagates headerKey to public yank options", async () => {
+        const capability = createYankCapability([
+            {
+                trigger: { type: "key", char: "n" },
+                label: "copy name",
+                feedback: "Copied Name",
+                headerKey: "name",
+                isRelevant: () => true,
+                resolve: async () => "hello",
+            },
+        ], z.object({ type: z.literal("bucket") }), {});
+        const options = capability.getYankOptions({
+            id: "row",
+            cells: { name: textCell("test") },
+            meta: { type: "bucket" },
+        });
+        expect(options[0]?.headerKey).toBe("name");
+        await expect(options[0]?.resolve({
+            id: "row",
+            cells: { name: textCell("test") },
+            meta: { type: "bucket" },
+        })).resolves.toBe("hello");
+    });
+});