@a9s/cli 0.0.1 → 1.0.6

package/dist/src/hooks/useAwsRegions.js

@@ -0,0 +1,105 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { useEffect, useState } from "react";
+const execFileAsync = promisify(execFile);
+const STATIC_FALLBACK_REGIONS = [
+    "us-east-1",
+    "us-east-2",
+    "us-west-1",
+    "us-west-2",
+    "ca-central-1",
+    "ca-west-1",
+    "sa-east-1",
+    "eu-west-1",
+    "eu-west-2",
+    "eu-west-3",
+    "eu-central-1",
+    "eu-central-2",
+    "eu-north-1",
+    "eu-south-1",
+    "eu-south-2",
+    "af-south-1",
+    "ap-south-1",
+    "ap-south-2",
+    "ap-southeast-1",
+    "ap-southeast-2",
+    "ap-southeast-3",
+    "ap-southeast-4",
+    "ap-northeast-1",
+    "ap-northeast-2",
+    "ap-northeast-3",
+    "me-south-1",
+    "me-central-1",
+    "il-central-1",
+];
+let cachedRegions = null;
+let pendingRegionsPromise = null;
+async function fetchRegions(profile, region) {
+    const args = [
+        "ec2",
+        "describe-regions",
+        "--all-regions",
+        "--query",
+        "Regions[].RegionName",
+        "--output",
+        "json",
+    ];
+    const env = { ...process.env };
+    if (profile)
+        env.AWS_PROFILE = profile;
+    if (region)
+        env.AWS_REGION = region;
+    try {
+        const { stdout } = await execFileAsync("aws", args, {
+            timeout: 3000,
+            env,
+        });
+        const parsed = JSON.parse(stdout);
+        if (Array.isArray(parsed)) {
+            const normalized = parsed
+                .filter((x) => typeof x === "string")
+                .map((x) => x.trim())
+                .filter(Boolean)
+                .sort((a, b) => a.localeCompare(b));
+            if (normalized.length > 0)
+                return normalized;
+        }
+    }
+    catch {
+        // fall back below
+    }
+    return [...STATIC_FALLBACK_REGIONS];
+}
+export function useAwsRegions(selectedRegion, selectedProfile) {
+    const isLocal = Boolean(process.env.AWS_ENDPOINT_URL);
+    const toOptions = (regions) => regions.map((name) => ({
+        name,
+        description: isLocal ? "Local endpoint / emulated" : "AWS commercial region",
+    }));
+    const [regionOptions, setRegionOptions] = useState(toOptions(cachedRegions ?? [...STATIC_FALLBACK_REGIONS]));
+    const explicitProfile = selectedProfile && selectedProfile !== "$default" ? selectedProfile : undefined;
+    useEffect(() => {
+        let alive = true;
+        if (cachedRegions) {
+            setRegionOptions(toOptions(cachedRegions));
+            return () => {
+                alive = false;
+            };
+        }
+        if (!pendingRegionsPromise) {
+            pendingRegionsPromise = fetchRegions(explicitProfile ?? process.env.AWS_PROFILE, selectedRegion ?? process.env.AWS_REGION).then((result) => {
+                cachedRegions = result;
+                return result;
+            });
+        }
+        void pendingRegionsPromise.then((result) => {
+            if (!alive)
+                return;
+            setRegionOptions(toOptions(result));
+        });
+        return () => {
+            alive = false;
+        };
+    }, [explicitProfile, selectedRegion]);
+    return regionOptions;
+}

package/dist/src/hooks/useCommandRouter.js

@@ -0,0 +1,56 @@
+import { useCallback } from "react";
+import { SERVICE_REGISTRY } from "../services.js";
+export function parseCommand(input) {
+    const command = input.trim();
+    if (command === "profiles")
+        return { type: "openProfiles" };
+    if (command === "regions")
+        return { type: "openRegions" };
+    if (command === "resources")
+        return { type: "openResources" };
+    const regionMatch = command.match(/^(region|use-region)\s+([a-z0-9-]+)$/i);
+    if (regionMatch?.[2]) {
+        return { type: "setRegion", region: regionMatch[2].toLowerCase() };
+    }
+    const profileMatch = command.match(/^(profile|use-profile)\s+(.+)$/i);
+    if (profileMatch?.[2]) {
+        return { type: "setProfile", profile: profileMatch[2].trim() };
+    }
+    if (command === "quit" || command === "q") {
+        return { type: "quit" };
+    }
+    if (command in SERVICE_REGISTRY) {
+        return { type: "switchService", serviceId: command };
+    }
+    return { type: "unknown" };
+}
+export function useCommandRouter(args) {
+    return useCallback((input) => {
+        const parsed = parseCommand(input);
+        switch (parsed.type) {
+            case "openProfiles":
+                args.openProfilePicker();
+                return;
+            case "openRegions":
+                args.openRegionPicker();
+                return;
+            case "openResources":
+                args.openResourcePicker();
+                return;
+            case "setRegion":
+                args.setSelectedRegion(parsed.region);
+                return;
+            case "setProfile":
+                args.setSelectedProfile(parsed.profile);
+                return;
+            case "quit":
+                args.exit();
+                return;
+            case "switchService":
+                args.switchAdapter(parsed.serviceId);
+                return;
+            case "unknown":
+                return;
+        }
+    }, [args]);
+}

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

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { parseCommand } from "./useCommandRouter.js";
+describe("parseCommand", () => {
+    it("parses picker commands", () => {
+        expect(parseCommand("profiles")).toEqual({ type: "openProfiles" });
+        expect(parseCommand("regions")).toEqual({ type: "openRegions" });
+        expect(parseCommand("resources")).toEqual({ type: "openResources" });
+    });
+    it("parses region and profile setters", () => {
+        expect(parseCommand("use-region EU-WEST-1")).toEqual({
+            type: "setRegion",
+            region: "eu-west-1",
+        });
+        expect(parseCommand("profile dev-admin ")).toEqual({
+            type: "setProfile",
+            profile: "dev-admin",
+        });
+    });
+    it("parses service switches and quit", () => {
+        expect(parseCommand("s3")).toEqual({ type: "switchService", serviceId: "s3" });
+        expect(parseCommand("q")).toEqual({ type: "quit" });
+        expect(parseCommand("quit")).toEqual({ type: "quit" });
+    });
+    it("returns unknown for unsupported commands", () => {
+        expect(parseCommand("something-else")).toEqual({ type: "unknown" });
+    });
+});

package/dist/src/hooks/useDetailController.js

@@ -0,0 +1,57 @@
+import { useCallback, useRef } from "react";
+import { getCellValue } from "../types.js";
+export function applyDetailSuccess(prev, requestId, fields) {
+    if (!prev || prev.requestId !== requestId)
+        return prev;
+    return { ...prev, fields, loading: false };
+}
+export function applyDetailError(prev, requestId, selectedRow, error) {
+    if (!prev || prev.requestId !== requestId)
+        return prev;
+    return {
+        ...prev,
+        fields: [
+            {
+                label: "Name",
+                value: selectedRow.cells.name ? getCellValue(selectedRow.cells.name) : selectedRow.id,
+            },
+            { label: "Error", value: error.message },
+        ],
+        loading: false,
+    };
+}
+export function useDetailController({ adapter, setDescribeState }) {
+    const requestSeqRef = useRef(0);
+    const showDetails = useCallback((selectedRow) => {
+        if (!selectedRow)
+            return;
+        requestSeqRef.current += 1;
+        const requestId = requestSeqRef.current;
+        setDescribeState({ row: selectedRow, fields: null, loading: true, requestId });
+        void (async () => {
+            try {
+                const fields = adapter.capabilities?.detail
+                    ? await adapter.capabilities.detail.getDetails(selectedRow)
+                    : [
+                        {
+                            label: "Name",
+                            value: selectedRow.cells.name
+                                ? getCellValue(selectedRow.cells.name)
+                                : selectedRow.id,
+                        },
+                        { label: "Type", value: String(selectedRow.meta?.type ?? "Unknown") },
+                        { label: "Details", value: "Not available for this service" },
+                    ];
+                setDescribeState((prev) => applyDetailSuccess(prev, requestId, fields));
+            }
+            catch (error) {
+                setDescribeState((prev) => applyDetailError(prev, requestId, selectedRow, error));
+            }
+        })();
+    }, [adapter, setDescribeState]);
+    const closeDetails = useCallback(() => setDescribeState(null), [setDescribeState]);
+    return {
+        showDetails,
+        closeDetails,
+    };
+}

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { applyDetailError, applyDetailSuccess } from "./useDetailController.js";
+import { textCell } from "../types.js";
+describe("detail state stale-request guards", () => {
+    const row = { id: "file.txt", cells: { name: textCell("file.txt") } };
+    it("applies success only when request id is current", () => {
+        const current = {
+            row,
+            fields: null,
+            loading: true,
+            requestId: 4,
+        };
+        const staleResult = applyDetailSuccess(current, 3, [{ label: "Size", value: "10" }]);
+        expect(staleResult).toEqual(current);
+        const freshResult = applyDetailSuccess(current, 4, [{ label: "Size", value: "10" }]);
+        expect(freshResult?.loading).toBe(false);
+        expect(freshResult?.fields).toEqual([{ label: "Size", value: "10" }]);
+    });
+    it("applies error only when request id is current", () => {
+        const current = {
+            row,
+            fields: null,
+            loading: true,
+            requestId: 9,
+        };
+        const staleResult = applyDetailError(current, 8, row, new Error("boom"));
+        expect(staleResult).toEqual(current);
+        const freshResult = applyDetailError(current, 9, row, new Error("boom"));
+        expect(freshResult?.loading).toBe(false);
+        expect(freshResult?.fields?.[1]?.value).toBe("boom");
+    });
+});

package/dist/src/hooks/useHelpPanel.js

@@ -0,0 +1,65 @@
+import { useState, useCallback } from "react";
+export function useHelpPanel(helpTabs, helpContainerHeight) {
+    const [helpOpen, setHelpOpen] = useState(false);
+    const [helpTabIndex, setHelpTabIndex] = useState(0);
+    const [helpScrollOffset, setHelpScrollOffset] = useState(0);
+    const helpTabsCount = helpTabs.length;
+    // Compute visible rows from container height and current tab
+    const baseHelpVisibleRows = Math.max(1, helpContainerHeight - 3);
+    const activeHelpItemsCount = helpTabs[helpTabIndex]?.items.length ?? 0;
+    const overflowRows = Math.max(0, activeHelpItemsCount - baseHelpVisibleRows);
+    const scrollReserveRows = Math.min(3, overflowRows);
+    const helpVisibleRows = overflowRows > 0
+        ? Math.max(1, baseHelpVisibleRows - scrollReserveRows - 1)
+        : Math.max(1, baseHelpVisibleRows - 1);
+    const clampTab = useCallback((idx) => ((idx % helpTabsCount) + helpTabsCount) % helpTabsCount, [helpTabsCount]);
+    const open = useCallback(() => {
+        setHelpScrollOffset(0);
+        setHelpTabIndex(0);
+        setHelpOpen(true);
+    }, []);
+    const openAtTab = useCallback((idx) => {
+        setHelpScrollOffset(0);
+        setHelpTabIndex(clampTab(idx));
+        setHelpOpen(true);
+    }, [clampTab]);
+    const close = useCallback(() => setHelpOpen(false), []);
+    const scrollUp = useCallback(() => setHelpScrollOffset((prev) => Math.max(0, prev - 1)), []);
+    const scrollDown = useCallback(() => {
+        const maxOffset = Math.max(0, (helpTabs[helpTabIndex]?.items.length ?? 0) - helpVisibleRows);
+        setHelpScrollOffset((prev) => Math.min(maxOffset, prev + 1));
+    }, [helpTabs, helpTabIndex, helpVisibleRows]);
+    const goToPrevTab = useCallback(() => {
+        setHelpScrollOffset(0);
+        setHelpTabIndex((prev) => clampTab(prev - 1));
+    }, [clampTab]);
+    const goToNextTab = useCallback(() => {
+        setHelpScrollOffset(0);
+        setHelpTabIndex((prev) => clampTab(prev + 1));
+    }, [clampTab]);
+    /** Returns true if a numeric tab was selected */
+    const goToTab = useCallback((input) => {
+        if (input.length !== 1)
+            return false;
+        const num = Number.parseInt(input, 10);
+        if (Number.isNaN(num) || num < 1 || num > helpTabsCount)
+            return false;
+        setHelpScrollOffset(0);
+        setHelpTabIndex(num - 1);
+        return true;
+    }, [helpTabsCount]);
+    return {
+        helpOpen,
+        helpTabIndex,
+        helpScrollOffset,
+        helpVisibleRows,
+        open,
+        openAtTab,
+        close,
+        scrollUp,
+        scrollDown,
+        goToPrevTab,
+        goToNextTab,
+        goToTab,
+    };
+}

package/dist/src/hooks/useHierarchyState.js

@@ -0,0 +1,39 @@
+import { useCallback } from "react";
+import { useAtom } from "jotai";
+import { hierarchyStateAtom } from "../state/atoms.js";
+export function useHierarchyState() {
+    const [state, setState] = useAtom(hierarchyStateAtom);
+    const reset = useCallback(() => {
+        setState({ filters: [""], indices: [0] });
+    }, [setState]);
+    const updateCurrentFilter = useCallback((value) => {
+        setState((prev) => {
+            const nextFilters = prev.filters.length === 0 ? [value] : [...prev.filters.slice(0, -1), value];
+            return { ...prev, filters: nextFilters };
+        });
+    }, [setState]);
+    const pushLevel = useCallback((selectedIndex, nextFilter = "") => {
+        setState((prev) => ({
+            filters: [...prev.filters, nextFilter],
+            indices: [...prev.indices, selectedIndex],
+        }));
+    }, [setState]);
+    const popLevel = useCallback(() => {
+        const nextFilters = state.filters.length > 1 ? state.filters.slice(0, -1) : state.filters;
+        const nextIndices = state.indices.length > 1 ? state.indices.slice(0, -1) : state.indices;
+        const restoredIndex = state.indices.length > 1
+            ? (state.indices[state.indices.length - 1] ?? 0)
+            : (state.indices[0] ?? 0);
+        const restoredFilter = nextFilters[nextFilters.length - 1] ?? "";
+        setState({ filters: nextFilters, indices: nextIndices });
+        return { restoredFilter, restoredIndex };
+    }, [setState, state.filters, state.indices]);
+    return {
+        filters: state.filters,
+        indices: state.indices,
+        reset,
+        updateCurrentFilter,
+        pushLevel,
+        popLevel,
+    };
+}