@a9s/cli 0.0.1 → 0.1.0

package/dist/src/features/AppMainView.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLayoutEffect, useMemo } from "react";
+import { Box, Text } from "ink";
+import { useAtomValue } from "jotai";
+import { Table } from "../components/Table/index.js";
+import { HelpPanel } from "../components/HelpPanel.js";
+import { YankHelpPanel } from "../components/YankHelpPanel.js";
+import { DetailPanel } from "../components/DetailPanel.js";
+import { ErrorStatePanel } from "../components/ErrorStatePanel.js";
+import { TableSkeleton } from "../components/TableSkeleton.js";
+import { DiffViewer } from "../components/DiffViewer.js";
+import { debugLog } from "../utils/debugLogger.js";
+import { revealSecretsAtom } from "../state/atoms.js";
+import { truncateSecretForTable } from "../utils/secretDisplay.js";
+import { getCellValue } from "../types.js";
+export function AppMainView({ helpPanel, helpTabs, pickers, error, describeState, isLoading, filteredRows, uploadPending, uploadPreview, columns, selectedIndex, scrollOffset, filterText, adapter, termCols, tableHeight, headerMarkers, yankHelpOpen, yankOptions, yankHelpRow, panelScrollOffset, }) {
+    const revealSecrets = useAtomValue(revealSecretsAtom);
+    // Format secret values for display ONLY - original rows (via filteredRows) stay unchanged for editing
+    const displayRows = useMemo(() => {
+        return filteredRows.map((row) => {
+            const hasSecrets = Object.values(row.cells).some((cell) => {
+                return typeof cell === "object" && cell?.type === "secret";
+            });
+            if (!hasSecrets) {
+                return row;
+            }
+            // Format secret cells for display
+            return {
+                ...row,
+                cells: Object.fromEntries(Object.entries(row.cells).map(([key, cell]) => {
+                    if (typeof cell === "object" && cell?.type === "secret") {
+                        return [
+                            key,
+                            {
+                                ...cell,
+                                displayName: truncateSecretForTable(cell.displayName, revealSecrets, 50),
+                            },
+                        ];
+                    }
+                    return [key, cell];
+                })),
+            };
+        });
+    }, [filteredRows, revealSecrets]);
+    useLayoutEffect(() => {
+        debugLog(adapter.id, `AppMainView render`, {
+            isLoading,
+            filteredRowsCount: filteredRows.length,
+            columnsCount: columns.length,
+            isHelp: helpPanel.helpOpen,
+            hasDescribe: !!describeState,
+            hasPicker: !!pickers.activePicker,
+            hasYankHelp: yankHelpOpen,
+            hasError: !!error,
+        });
+    }, [
+        adapter.id,
+        isLoading,
+        filteredRows.length,
+        columns.length,
+        helpPanel.helpOpen,
+        describeState,
+        pickers.activePicker,
+        yankHelpOpen,
+        error,
+    ]);
+    if (helpPanel.helpOpen) {
+        return (_jsx(Box, { width: "100%", borderStyle: "round", borderColor: "blue", children: _jsx(HelpPanel, { title: "Keyboard Help", scopeLabel: "All modes reference", tabs: helpTabs, activeTab: helpPanel.helpTabIndex, terminalWidth: termCols, maxRows: helpPanel.helpVisibleRows, scrollOffset: helpPanel.helpScrollOffset }) }));
+    }
+    if (pickers.activePicker) {
+        const ap = pickers.activePicker;
+        // Pickers don't show secrets, use unformatted rows
+        return (_jsx(Table, { rows: ap.filteredRows, columns: ap.columns, selectedIndex: ap.selectedIndex, filterText: ap.filter, terminalWidth: termCols, maxHeight: tableHeight, scrollOffset: ap.scrollOffset, contextLabel: ap.contextLabel }));
+    }
+    if (yankHelpOpen) {
+        return (_jsx(Box, { width: "100%", borderStyle: "round", borderColor: "cyan", children: _jsx(YankHelpPanel, { options: yankOptions, row: yankHelpRow }) }));
+    }
+    if (uploadPending) {
+        // Overhead: border 2 + header 4 + separators 2 + DiffViewer header+divider 2 = 10
+        const diffVisibleLines = Math.max(1, tableHeight - 10);
+        return (_jsxs(Box, { width: "100%", borderStyle: "round", borderColor: "yellow", flexDirection: "column", children: [_jsxs(Box, { paddingX: 1, paddingY: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "yellow", children: "\u26A0 Overwrite Secret on AWS?" }), _jsx(Text, { color: "gray", children: "This will update the secret permanently." })] }), _jsx(Box, { paddingX: 1, paddingY: 1, borderTop: true, borderColor: "gray", children: uploadPreview ? (_jsx(DiffViewer, { oldValue: uploadPreview.old, newValue: uploadPreview.new, scrollOffset: panelScrollOffset, visibleLines: diffVisibleLines })) : (_jsx(Text, { color: "gray", children: "Loading preview..." })) }), _jsx(Box, { paddingX: 1, paddingY: 1, borderTop: true, borderColor: "gray", children: _jsxs(Text, { children: ["Press", " ", _jsx(Text, { bold: true, color: "green", children: "y" }), " ", "to confirm or", " ", _jsx(Text, { bold: true, color: "red", children: "n" }), " ", "to cancel"] }) })] }));
+    }
+    if (describeState) {
+        // Overhead: border 2 + title 1 + separator 1 + footer 2 = 6
+        const detailVisibleLines = Math.max(1, tableHeight - 6);
+        return (_jsx(Box, { width: "100%", borderStyle: "round", borderColor: "gray", children: _jsx(DetailPanel, { title: getCellValue(describeState.row.cells.name) ?? describeState.row.id, fields: describeState.fields ?? [], isLoading: describeState.loading, scrollOffset: panelScrollOffset, visibleLines: detailVisibleLines }) }));
+    }
+    if (isLoading) {
+        return (_jsx(TableSkeleton, { columns: columns, terminalWidth: termCols, rows: 1, contextLabel: adapter.getContextLabel?.() ?? "" }));
+    }
+    if (error) {
+        return (_jsx(ErrorStatePanel, { title: `Failed to load ${adapter.label}`, message: error, hint: "Press r to retry" }));
+    }
+    return (_jsx(Table, { rows: displayRows, columns: columns, selectedIndex: selectedIndex, filterText: filterText, terminalWidth: termCols, maxHeight: tableHeight, scrollOffset: scrollOffset, contextLabel: adapter.getContextLabel?.() ?? "", ...(headerMarkers ? { headerMarkers } : {}) }));
+}

package/dist/src/hooks/inputEvents.js

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

package/dist/src/hooks/mainInputScopes.js

@@ -0,0 +1,68 @@
+import { KB } from "../constants/keys.js";
+export function resolveHelpScopeAction(input, action) {
+    switch (action) {
+        case KB.HELP_CLOSE:
+            return { type: "close" };
+        case KB.HELP_PREV_TAB:
+            return { type: "prevTab" };
+        case KB.HELP_NEXT_TAB:
+            return { type: "nextTab" };
+        case KB.HELP_SCROLL_UP:
+            return { type: "scrollUp" };
+        case KB.HELP_SCROLL_DOWN:
+            return { type: "scrollDown" };
+        default:
+            return /^[1-9]$/.test(input) ? { type: "goToTab", input } : { type: "none" };
+    }
+}
+export function resolvePickerScopeAction(key, pickerMode, action) {
+    if (pickerMode === "search" && !key.escape) {
+        return { type: "consume" };
+    }
+    switch (action) {
+        case KB.PICKER_CLOSE:
+            return { type: "close" };
+        case KB.PICKER_FILTER:
+            return { type: "search" };
+        case KB.PICKER_DOWN:
+            return { type: "down" };
+        case KB.PICKER_UP:
+            return { type: "up" };
+        case KB.PICKER_TOP:
+            return { type: "top" };
+        case KB.PICKER_BOTTOM:
+            return { type: "bottom" };
+        case KB.PICKER_CONFIRM:
+            return { type: "confirm" };
+        default:
+            return { type: "none" };
+    }
+}
+export function resolveNavigateScopeAction(action) {
+    switch (action) {
+        case KB.SEARCH_MODE:
+            return { type: "search" };
+        case KB.COMMAND_MODE:
+            return { type: "command" };
+        case KB.QUIT:
+            return { type: "quit" };
+        case KB.REFRESH:
+            return { type: "refresh" };
+        case KB.REVEAL_TOGGLE:
+            return { type: "reveal" };
+        case KB.YANK_MODE:
+            return { type: "yank" };
+        case KB.DETAILS:
+            return { type: "details" };
+        case KB.EDIT:
+            return { type: "edit" };
+        case KB.GO_BOTTOM:
+            return { type: "bottom" };
+        case KB.GO_TOP:
+            return { type: "top" };
+        case KB.NAVIGATE_INTO:
+            return { type: "enter" };
+        default:
+            return { type: "none" };
+    }
+}

package/dist/src/hooks/mainInputScopes.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { KB } from "../constants/keys.js";
+import { resolveHelpScopeAction, resolveNavigateScopeAction, resolvePickerScopeAction, } from "./mainInputScopes.js";
+describe("mainInputScopes", () => {
+    const plainKey = { escape: false };
+    const escapeKey = { escape: true };
+    it("resolves help actions", () => {
+        expect(resolveHelpScopeAction("", KB.HELP_CLOSE)).toEqual({ type: "close" });
+        expect(resolveHelpScopeAction("2", null)).toEqual({ type: "goToTab", input: "2" });
+    });
+    it("resolves picker search consume behavior", () => {
+        expect(resolvePickerScopeAction(plainKey, "search", null)).toEqual({
+            type: "consume",
+        });
+        expect(resolvePickerScopeAction(escapeKey, "search", KB.PICKER_CLOSE)).toEqual({
+            type: "close",
+        });
+    });
+    it("maps navigate key actions", () => {
+        expect(resolveNavigateScopeAction(KB.SEARCH_MODE)).toEqual({ type: "search" });
+        expect(resolveNavigateScopeAction(KB.DETAILS)).toEqual({ type: "details" });
+        expect(resolveNavigateScopeAction(null)).toEqual({ type: "none" });
+    });
+});

package/dist/src/hooks/useActionController.js

@@ -0,0 +1,78 @@
+import { useCallback } from "react";
+export function useActionController({ adapter, refresh, setPendingAction, pushFeedback, }) {
+    const handleSingleEffect = useCallback((effect, row) => {
+        switch (effect.type) {
+            case "none":
+                return;
+            case "refresh":
+                void refresh();
+                setPendingAction(null);
+                return;
+            case "feedback":
+                pushFeedback(effect.message, 2500);
+                setPendingAction(null);
+                return;
+            case "clipboard":
+                pushFeedback(effect.feedback, 2500);
+                setPendingAction(null);
+                return;
+            case "error":
+                pushFeedback(effect.message, 3000);
+                setPendingAction(null);
+                return;
+            case "prompt":
+                setPendingAction({
+                    effect,
+                    row,
+                    inputValue: effect.defaultValue ?? "",
+                    accumulatedData: effect.data ?? {},
+                });
+                return;
+            case "confirm":
+                setPendingAction({
+                    effect,
+                    row,
+                    inputValue: "",
+                    accumulatedData: effect.data ?? {},
+                });
+        }
+    }, [pushFeedback, refresh, setPendingAction]);
+    const handleActionEffect = useCallback((effect, row) => {
+        if (effect.type === "multi") {
+            for (const next of effect.effects) {
+                handleSingleEffect(next, row);
+            }
+            return;
+        }
+        handleSingleEffect(effect, row);
+    }, [handleSingleEffect]);
+    const submitPendingAction = useCallback((pendingAction, confirmed) => {
+        if (!pendingAction || !adapter.capabilities?.actions)
+            return;
+        const effect = pendingAction.effect;
+        if (effect.type === "confirm" && !confirmed) {
+            setPendingAction(null);
+            return;
+        }
+        const nextData = {
+            ...pendingAction.accumulatedData,
+            path: pendingAction.inputValue,
+        };
+        void adapter.capabilities.actions
+            .executeAction(effect.nextActionId, {
+            row: pendingAction.row,
+            data: nextData,
+        })
+            .then((nextEffect) => {
+            handleActionEffect(nextEffect, pendingAction.row);
+        })
+            .catch((err) => {
+            pushFeedback(`Action failed: ${err.message}`, 3000);
+            setPendingAction(null);
+        });
+    }, [adapter.capabilities?.actions, handleActionEffect, pushFeedback, setPendingAction]);
+    return {
+        handleActionEffect,
+        submitPendingAction,
+    };
+}

package/dist/src/hooks/useAppController.js

@@ -0,0 +1,102 @@
+import { useCallback, useEffect, useMemo, useReducer, useRef } from "react";
+export const initialAppControllerState = {
+    mode: "navigate",
+    filterText: "",
+    commandText: "",
+    searchEntryFilter: null,
+    commandCursorToEndToken: 0,
+    yankMode: false,
+    yankHelpOpen: false,
+    yankFeedbackMessage: null,
+    uploadPending: null,
+    describeState: null,
+    pendingAction: null,
+};
+export function appControllerReducer(state, action) {
+    switch (action.type) {
+        case "setMode":
+            return { ...state, mode: action.mode };
+        case "setFilterText":
+            return { ...state, filterText: action.value };
+        case "setCommandText":
+            return { ...state, commandText: action.value };
+        case "setSearchEntryFilter":
+            return { ...state, searchEntryFilter: action.value };
+        case "bumpCommandCursorToEnd":
+            return {
+                ...state,
+                commandCursorToEndToken: state.commandCursorToEndToken + 1,
+            };
+        case "setYankMode":
+            return { ...state, yankMode: action.value };
+        case "setYankHelpOpen":
+            return { ...state, yankHelpOpen: action.value };
+        case "setYankFeedback":
+            return { ...state, yankFeedbackMessage: action.value };
+        case "setUploadPending":
+            return { ...state, uploadPending: action.value };
+        case "setDescribeState":
+            return {
+                ...state,
+                describeState: typeof action.value === "function" ? action.value(state.describeState) : action.value,
+            };
+        case "setPendingAction":
+            return { ...state, pendingAction: action.value };
+        case "setPendingInputValue":
+            return state.pendingAction
+                ? {
+                    ...state,
+                    pendingAction: {
+                        ...state.pendingAction,
+                        inputValue: action.value,
+                    },
+                }
+                : state;
+        default:
+            return state;
+    }
+}
+export function useAppController() {
+    const [state, dispatch] = useReducer(appControllerReducer, initialAppControllerState);
+    const feedbackTimerRef = useRef(null);
+    const clearFeedbackTimer = useCallback(() => {
+        if (feedbackTimerRef.current) {
+            clearTimeout(feedbackTimerRef.current);
+            feedbackTimerRef.current = null;
+        }
+    }, []);
+    useEffect(() => {
+        return () => {
+            clearFeedbackTimer();
+        };
+    }, [clearFeedbackTimer]);
+    const actions = useMemo(() => ({
+        setMode: (mode) => dispatch({ type: "setMode", mode }),
+        setFilterText: (value) => dispatch({ type: "setFilterText", value }),
+        setCommandText: (value) => dispatch({ type: "setCommandText", value }),
+        setSearchEntryFilter: (value) => dispatch({ type: "setSearchEntryFilter", value }),
+        bumpCommandCursorToEnd: () => dispatch({ type: "bumpCommandCursorToEnd" }),
+        setYankMode: (value) => dispatch({ type: "setYankMode", value }),
+        setYankHelpOpen: (value) => dispatch({ type: "setYankHelpOpen", value }),
+        setUploadPending: (value) => dispatch({ type: "setUploadPending", value }),
+        setDescribeState: (value) => dispatch({ type: "setDescribeState", value }),
+        setPendingAction: (value) => dispatch({ type: "setPendingAction", value }),
+        setPendingInputValue: (value) => dispatch({ type: "setPendingInputValue", value }),
+        clearFeedback: () => {
+            clearFeedbackTimer();
+            dispatch({ type: "setYankFeedback", value: null });
+        },
+        pushFeedback: (message, durationMs = 1500) => {
+            clearFeedbackTimer();
+            dispatch({ type: "setYankFeedback", value: message });
+            feedbackTimerRef.current = setTimeout(() => {
+                dispatch({ type: "setYankFeedback", value: null });
+                feedbackTimerRef.current = null;
+            }, durationMs);
+        },
+    }), [clearFeedbackTimer]);
+    return {
+        state,
+        actions,
+    };
+}

package/dist/src/hooks/useAppController.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { appControllerReducer, initialAppControllerState } from "./useAppController.js";
+import { textCell } from "../types.js";
+describe("appControllerReducer", () => {
+    it("enters and exits search mode", () => {
+        const searching = appControllerReducer(initialAppControllerState, {
+            type: "setMode",
+            mode: "search",
+        });
+        expect(searching.mode).toBe("search");
+        const navigating = appControllerReducer(searching, {
+            type: "setMode",
+            mode: "navigate",
+        });
+        expect(navigating.mode).toBe("navigate");
+    });
+    it("updates pending prompt input deterministically", () => {
+        const withPrompt = appControllerReducer(initialAppControllerState, {
+            type: "setPendingAction",
+            value: {
+                effect: {
+                    type: "prompt",
+                    label: "Path",
+                    nextActionId: "next",
+                },
+                row: null,
+                inputValue: "",
+                accumulatedData: {},
+            },
+        });
+        const updated = appControllerReducer(withPrompt, {
+            type: "setPendingInputValue",
+            value: "s3://bucket/key",
+        });
+        expect(updated.pendingAction?.inputValue).toBe("s3://bucket/key");
+    });
+    it("supports details open and close transitions", () => {
+        const opened = appControllerReducer(initialAppControllerState, {
+            type: "setDescribeState",
+            value: {
+                row: { id: "1", cells: { name: textCell("obj") } },
+                fields: null,
+                loading: true,
+                requestId: 1,
+            },
+        });
+        expect(opened.describeState?.loading).toBe(true);
+        const closed = appControllerReducer(opened, {
+            type: "setDescribeState",
+            value: null,
+        });
+        expect(closed.describeState).toBeNull();
+    });
+});

package/dist/src/hooks/useAppData.js

@@ -0,0 +1,48 @@
+import { useMemo, useLayoutEffect } from "react";
+import { SERVICE_REGISTRY } from "../services.js";
+import { useServiceView } from "./useServiceView.js";
+import { useNavigation } from "./useNavigation.js";
+import { usePickerManager } from "./usePickerManager.js";
+import { debugLog } from "../utils/debugLogger.js";
+export function useAppData({ currentService, endpointUrl, selectedRegion, tableHeight, filterText, availableRegions, availableProfiles, }) {
+    const adapter = useMemo(() => {
+        debugLog(currentService, `useAppData: adapter created`);
+        return SERVICE_REGISTRY[currentService](endpointUrl, selectedRegion);
+    }, [currentService, endpointUrl, selectedRegion]);
+    const { rows, columns, isLoading, error, select, edit, goBack, refresh, path } = useServiceView(adapter);
+    useLayoutEffect(() => {
+        debugLog(adapter.id, `useAppData: received rows from useServiceView`, {
+            rowCount: rows.length,
+            isLoading,
+            "state.adapterId": rows.length > 0 ? "has-data" : "empty",
+        });
+    }, [rows.length, isLoading, adapter.id]);
+    const filteredRows = useMemo(() => {
+        if (!filterText)
+            return rows;
+        const lowerFilter = filterText.toLowerCase();
+        return rows.filter((row) => Object.values(row.cells).some((cell) => {
+            const value = typeof cell === "string" ? cell : cell.displayName;
+            return value.toLowerCase().includes(lowerFilter);
+        }));
+    }, [filterText, rows]);
+    const navigation = useNavigation(filteredRows.length, tableHeight);
+    const selectedRow = filteredRows[navigation.selectedIndex] ?? null;
+    const pickers = usePickerManager({ tableHeight, availableRegions, availableProfiles });
+    return {
+        adapter,
+        rows,
+        columns,
+        isLoading,
+        error,
+        select,
+        edit,
+        goBack,
+        refresh,
+        path,
+        filteredRows,
+        selectedRow,
+        navigation,
+        pickers,
+    };
+}

package/dist/src/hooks/useAwsContext.js

@@ -0,0 +1,77 @@
+import { useEffect, useState } from "react";
+import { runAwsCli } from "../utils/aws.js";
+const DEFAULT_REGION = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1";
+export function useAwsContext(endpointUrl, selectedRegion, selectedProfile) {
+    const explicitProfile = selectedProfile && selectedProfile !== "$default" ? selectedProfile : undefined;
+    const envProfile = selectedProfile ?? process.env.AWS_PROFILE ?? "default";
+    const resolvedRegion = selectedRegion ?? DEFAULT_REGION;
+    const [context, setContext] = useState({
+        accountName: "Resolving",
+        accountId: "------------",
+        awsProfile: envProfile,
+        currentIdentity: "resolving",
+        region: resolvedRegion,
+    });
+    useEffect(() => {
+        let alive = true;
+        void (async () => {
+            if (endpointUrl) {
+                const profile = explicitProfile ?? process.env.AWS_PROFILE ?? "local";
+                if (!alive)
+                    return;
+                setContext({
+                    accountName: `LocalStack (${profile})`,
+                    accountId: process.env.AWS_ACCOUNT_ID ?? "000000000000",
+                    awsProfile: selectedProfile ?? profile,
+                    currentIdentity: process.env.AWS_ACCESS_KEY_ID ?? profile,
+                    region: resolvedRegion,
+                });
+                return;
+            }
+            const profile = explicitProfile ?? process.env.AWS_PROFILE ?? "default";
+            const [stsOut, aliasOut] = await Promise.all([
+                runAwsCli(["sts", "get-caller-identity", "--output", "json"], 1500),
+                runAwsCli(["iam", "list-account-aliases", "--output", "json"], 1500),
+            ]);
+            let accountId = "";
+            let userId = "";
+            let arn = "";
+            if (stsOut) {
+                try {
+                    const parsed = JSON.parse(stsOut);
+                    accountId = parsed.Account ?? "";
+                    userId = parsed.UserId ?? "";
+                    arn = parsed.Arn ?? "";
+                }
+                catch {
+                    // ignore parse issues, fallback below
+                }
+            }
+            let alias = "";
+            if (aliasOut) {
+                try {
+                    const parsed = JSON.parse(aliasOut);
+                    alias = parsed.AccountAliases?.[0] ?? "";
+                }
+                catch {
+                    // ignore parse issues, fallback below
+                }
+            }
+            const identity = alias || profile || (accountId ? "AWS Account" : "Unknown Account");
+            const currentIdentity = arn || userId || profile || "unknown";
+            if (!alive)
+                return;
+            setContext({
+                accountName: identity,
+                accountId: accountId || "------------",
+                awsProfile: selectedProfile ?? profile,
+                currentIdentity,
+                region: resolvedRegion,
+            });
+        })();
+        return () => {
+            alive = false;
+        };
+    }, [endpointUrl, explicitProfile, resolvedRegion, selectedProfile]);
+    return context;
+}

package/dist/src/hooks/useAwsProfiles.js

@@ -0,0 +1,53 @@
+import { useEffect, useState } from "react";
+import { runAwsCli } from "../utils/aws.js";
+const DEFAULT_PROFILE = {
+    name: "$default",
+    description: "use process credentials/environment",
+};
+let cachedProfiles = null;
+let pendingProfilesPromise = null;
+async function fetchProfiles() {
+    const stdout = await runAwsCli(["configure", "list-profiles"], 3000);
+    if (!stdout)
+        return [DEFAULT_PROFILE];
+    const profileNames = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (profileNames.length === 0)
+        return [DEFAULT_PROFILE];
+    // Keep startup snappy: avoid N additional AWS CLI calls for region enrichment here.
+    const withMeta = profileNames.map((name) => ({
+        name,
+        description: "configured profile",
+    }));
+    const hasDefault = withMeta.some((p) => p.name === "$default");
+    return hasDefault ? withMeta : [DEFAULT_PROFILE, ...withMeta];
+}
+export function useAwsProfiles() {
+    const [profiles, setProfiles] = useState([]);
+    useEffect(() => {
+        let alive = true;
+        if (cachedProfiles) {
+            setProfiles(cachedProfiles);
+            return () => {
+                alive = false;
+            };
+        }
+        setProfiles([DEFAULT_PROFILE]);
+        if (!pendingProfilesPromise) {
+            pendingProfilesPromise = fetchProfiles().then((result) => {
+                cachedProfiles = result;
+                return result;
+            });
+        }
+        void pendingProfilesPromise.then((result) => {
+            if (alive)
+                setProfiles(result);
+        });
+        return () => {
+            alive = false;
+        };
+    }, []);
+    return profiles;
+}