@a9s/cli 0.0.1 → 1.0.6

package/dist/src/hooks/yankHeaderMarkers.js

@@ -0,0 +1,23 @@
+export function deriveYankHeaderMarkers(yankMode, yankOptions) {
+    if (!yankMode)
+        return undefined;
+    const map = new Map();
+    for (const option of yankOptions) {
+        if (!option.headerKey)
+            continue;
+        if (option.trigger.type !== "key")
+            continue;
+        const token = option.trigger.char;
+        const prev = map.get(option.headerKey) ?? [];
+        if (!prev.includes(token)) {
+            map.set(option.headerKey, [...prev, token]);
+        }
+    }
+    if (map.size === 0)
+        return undefined;
+    const markers = {};
+    for (const [key, tokens] of map.entries()) {
+        markers[key] = tokens;
+    }
+    return markers;
+}

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

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { deriveYankHeaderMarkers } from "./yankHeaderMarkers.js";
+describe("deriveYankHeaderMarkers", () => {
+    it("returns undefined when yank mode is inactive", () => {
+        const result = deriveYankHeaderMarkers(false, [
+            {
+                trigger: { type: "key", char: "n" },
+                label: "copy name",
+                feedback: "copied",
+                headerKey: "name",
+                isRelevant: () => true,
+                resolve: async () => "x",
+            },
+        ]);
+        expect(result).toBeUndefined();
+    });
+    it("groups key triggers by header key", () => {
+        const result = deriveYankHeaderMarkers(true, [
+            {
+                trigger: { type: "key", char: "n" },
+                label: "copy name",
+                feedback: "copied",
+                headerKey: "name",
+                isRelevant: () => true,
+                resolve: async () => "x",
+            },
+            {
+                trigger: { type: "key", char: "d" },
+                label: "copy lm",
+                feedback: "copied",
+                headerKey: "lastModified",
+                isRelevant: () => true,
+                resolve: async () => "x",
+            },
+            {
+                trigger: { type: "special", name: "return" },
+                label: "ignored",
+                feedback: "copied",
+                headerKey: "name",
+                isRelevant: () => true,
+                resolve: async () => "x",
+            },
+        ]);
+        expect(result).toEqual({
+            name: ["n"],
+            lastModified: ["d"],
+        });
+    });
+});

package/dist/src/index.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Command, Option } from "@commander-js/extra-typings";
+import { App } from "./App.js";
+import { SERVICE_REGISTRY } from "./services.js";
+import { withFullscreen } from "./utils/withFullscreen.js";
+const SERVICE_IDS = Object.keys(SERVICE_REGISTRY);
+const program = new Command()
+    .name("a9s")
+    .description("k9s-style AWS navigator")
+    .version("0.1.0")
+    .addOption(new Option("-s, --service <service>", "AWS service to browse")
+    .choices(SERVICE_IDS)
+    .default("s3"))
+    .addOption(new Option("--endpoint-url <url>", "Custom endpoint URL (e.g. http://localhost:4566 for LocalStack)").env("AWS_ENDPOINT_URL"));
+program.parse();
+// opts() return type is fully inferred from addOption() calls via extra-typings
+const options = program.opts();
+void (async () => {
+    const { instance, cleanup } = withFullscreen(_jsx(App, { initialService: options.service, endpointUrl: options.endpointUrl }));
+    process.on("SIGINT", () => {
+        cleanup();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        cleanup();
+        process.exit(0);
+    });
+    await instance.waitUntilExit();
+    cleanup();
+})();

package/dist/src/services.js

@@ -0,0 +1,12 @@
+import { createS3ServiceAdapter } from "./views/s3/adapter.js";
+import { createRoute53ServiceAdapter } from "./views/route53/adapter.js";
+import { createDynamoDBServiceAdapter } from "./views/dynamodb/adapter.js";
+import { createIamServiceAdapter } from "./views/iam/adapter.js";
+import { createSecretsManagerServiceAdapter } from "./views/secretsmanager/adapter.js";
+export const SERVICE_REGISTRY = {
+    s3: (endpointUrl, region) => createS3ServiceAdapter(endpointUrl, region),
+    route53: (_endpointUrl, _region) => createRoute53ServiceAdapter(),
+    dynamodb: (_endpointUrl, _region) => createDynamoDBServiceAdapter(),
+    iam: (_endpointUrl, _region) => createIamServiceAdapter(),
+    secretsmanager: (endpointUrl, region) => createSecretsManagerServiceAdapter(endpointUrl, region),
+};

package/dist/src/state/atoms.js

@@ -0,0 +1,27 @@
+import { atom } from "jotai";
+/** Persists across HMR / re-renders. Currently selected AWS service. */
+export const currentlySelectedServiceAtom = atom("s3");
+/** Current UI mode (navigate / search / command). */
+export const modeAtom = atom("navigate");
+/** Active filter text applied to the current view. */
+export const filterTextAtom = atom("");
+/** Text typed in command mode. */
+export const commandTextAtom = atom("");
+/** Navigation history: parallel stacks of filter texts and selected indices per level. */
+export const hierarchyStateAtom = atom({
+    filters: [""],
+    indices: [0],
+});
+/** Selected AWS region. Falls back to env vars or us-east-1. */
+export const selectedRegionAtom = atom(process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1");
+/** Selected AWS profile. "$default" means use ambient credentials. */
+export const selectedProfileAtom = atom(process.env.AWS_PROFILE ?? "$default");
+/** Derived atom: adapter session ID. Changes atomically when service/region/profile change. */
+export const adapterSessionAtom = atom((get) => {
+    const service = get(currentlySelectedServiceAtom);
+    const region = get(selectedRegionAtom);
+    const profile = get(selectedProfileAtom);
+    return `${service}:${region}:${profile}`;
+});
+/** Toggle state for revealing/hiding secret values. Persists across HMR. */
+export const revealSecretsAtom = atom(false);

package/dist/src/types.js

@@ -0,0 +1,12 @@
+/** Helper to create a text cell */
+export function textCell(displayName) {
+    return { displayName, type: "text" };
+}
+/** Helper to create a secret cell */
+export function secretCell(displayName) {
+    return { displayName, type: "secret" };
+}
+/** Helper to get cell displayName from Cell or string */
+export function getCellValue(cell) {
+    return typeof cell === "string" ? cell : cell.displayName;
+}

package/dist/src/utils/aws.js

@@ -0,0 +1,39 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/**
+ * Run an AWS CLI command asynchronously. Returns stdout or null on error/timeout.
+ */
+export async function runAwsCli(args, timeoutMs = 2000) {
+    try {
+        const { stdout } = await execFileAsync("aws", args, {
+            timeout: timeoutMs,
+            env: process.env,
+        });
+        return stdout;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Run an AWS CLI command asynchronously and parse JSON output. Throws on error.
+ */
+export async function runAwsJsonAsync(args) {
+    try {
+        const { stdout } = await execFileAsync("aws", [...args, "--output", "json"], {
+            timeout: 10_000,
+            env: process.env,
+        });
+        return JSON.parse(stdout);
+    }
+    catch (error) {
+        const message = error.message;
+        const isIamDisabled = message.includes("Service 'iam' is not enabled") ||
+            message.includes("when calling the ListRoles operation");
+        if (isIamDisabled && Boolean(process.env.AWS_ENDPOINT_URL)) {
+            throw new Error("IAM is not enabled in LocalStack. Add iam to SERVICES (for example: SERVICES=s3,iam,sts) and restart LocalStack.");
+        }
+        throw error;
+    }
+}

package/dist/src/utils/debugLogger.js

@@ -0,0 +1,34 @@
+import { appendFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const LOG_DIR = join(homedir(), ".local/share/a9s");
+const LOG_FILE = join(LOG_DIR, "debug.log");
+// Ensure log directory exists
+try {
+    mkdirSync(LOG_DIR, { recursive: true });
+}
+catch {
+    // Silently fail if we can't create directory
+}
+function timestamp() {
+    return new Date().toISOString();
+}
+export function debugLog(tag, message, data) {
+    const logEntry = data
+        ? `[${timestamp()}] ${tag} ${message} ${JSON.stringify(data)}`
+        : `[${timestamp()}] ${tag} ${message}`;
+    try {
+        appendFileSync(LOG_FILE, logEntry + "\n");
+    }
+    catch {
+        // Silently fail if we can't write to log file
+    }
+}
+export function clearDebugLog() {
+    try {
+        appendFileSync(LOG_FILE, "\n\n=== LOG CLEARED ===\n\n");
+    }
+    catch {
+        // Silently fail
+    }
+}

package/dist/src/utils/secretDisplay.js

@@ -0,0 +1,45 @@
+/**
+ * Format secret values for display:
+ * - Escape newlines as literal \n
+ * - Optionally mask with asterisks if not revealed
+ */
+export function formatSecretForDisplay(value, reveal = false) {
+    if (!value)
+        return "";
+    // Escape newlines as literal \n
+    const escaped = value.replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+    // Mask with asterisks if not revealed
+    if (!reveal) {
+        return "****";
+    }
+    return escaped;
+}
+/**
+ * Truncate secret for table display (with escaping)
+ * For hidden values: shows "****"
+ * For revealed values:
+ *   - Shows full value if fits in maxLength chars
+ *   - Shows multi-line truncation if too large (2 header lines + ... + 1 footer line)
+ */
+export function truncateSecretForTable(value, reveal = false, maxLength = 50) {
+    if (!value)
+        return "";
+    const formatted = formatSecretForDisplay(value, reveal);
+    // If hidden, always return the masked value
+    if (!reveal) {
+        return formatted; // "****"
+    }
+    // For revealed values, handle multi-line truncation
+    const lines = formatted.split("\\n"); // Split by escaped newline
+    if (lines.length > 3) {
+        // Show 2 header lines + ... + 1 footer line
+        const header = lines.slice(0, 2).join("\\n");
+        const footer = lines[lines.length - 1];
+        return `${header}\\n...\\n${footer}`;
+    }
+    // If single/few lines, apply character truncation
+    if (formatted.length > maxLength) {
+        return formatted.slice(0, maxLength) + "...";
+    }
+    return formatted;
+}

package/dist/src/utils/withFullscreen.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useEffect, useState } from "react";
+import { Box, render } from "ink";
+// Hook replacing useTerminalSize — listens for resize events
+export function useScreenSize() {
+    const [size, setSize] = useState({
+        columns: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 24,
+    });
+    useEffect(() => {
+        const handler = () => setSize({
+            columns: process.stdout.columns ?? 80,
+            rows: process.stdout.rows ?? 24,
+        });
+        process.stdout.on("resize", handler);
+        return () => {
+            process.stdout.off("resize", handler);
+        };
+    }, []);
+    return size;
+}
+// Full-terminal Box — takes exactly columns×rows
+export const FullscreenBox = forwardRef(({ children, ...props }, ref) => {
+    const { columns, rows } = useScreenSize();
+    return (_jsx(Box, { ref: ref, width: columns, height: rows, ...props, children: children }));
+});
+FullscreenBox.displayName = "FullscreenBox";
+// Wrap render() with alternate screen buffer enter/exit
+export function withFullscreen(element) {
+    process.stdout.write("\x1b[?1049h"); // enter alternate screen
+    process.stdout.write("\x1b[H"); // move cursor to top-left
+    const instance = render(element);
+    const cleanup = () => {
+        instance.unmount();
+        process.stdout.write("\x1b[?1049l"); // exit alternate screen
+    };
+    return { instance, cleanup };
+}

package/dist/src/views/dynamodb/adapter.js

@@ -0,0 +1,22 @@
+import { textCell } from "../../types.js";
+export function createDynamoDBServiceAdapter() {
+    const getColumns = () => [{ key: "name", label: "Name" }];
+    const getRows = async () => {
+        return [{ id: "stub", cells: { name: textCell("DynamoDB not yet implemented") }, meta: {} }];
+    };
+    const onSelect = async (_row) => {
+        return { action: "none" };
+    };
+    return {
+        id: "dynamodb",
+        label: "DynamoDB",
+        hudColor: { bg: "green", fg: "white" },
+        getColumns,
+        getRows,
+        onSelect,
+        canGoBack: () => false,
+        goBack: () => { },
+        getPath: () => "/",
+        getContextLabel: () => "⚡ Tables",
+    };
+}

package/dist/src/views/iam/adapter.js

@@ -0,0 +1,258 @@
+import { runAwsJsonAsync } from "../../utils/aws.js";
+import { textCell } from "../../types.js";
+import { formatDate } from "./utils.js";
+import { createIamEditCapability } from "./capabilities/editCapability.js";
+import { createIamDetailCapability } from "./capabilities/detailCapability.js";
+import { createIamYankCapability } from "./capabilities/yankCapability.js";
+function getIamMeta(row) {
+    return row.meta;
+}
+export function createIamServiceAdapter() {
+    let level = { kind: "root" };
+    let backStack = [];
+    const getLevel = () => level;
+    const setLevel = (newLevel) => {
+        level = newLevel;
+    };
+    const getBackStack = () => backStack;
+    const setBackStack = (newStack) => {
+        backStack = newStack;
+    };
+    const getColumns = () => {
+        switch (level.kind) {
+            case "root":
+            case "role-menu":
+                return [
+                    { key: "name", label: "Name" },
+                    { key: "type", label: "Type", width: 24 },
+                ];
+            case "roles":
+                return [
+                    { key: "name", label: "Role Name" },
+                    { key: "type", label: "Type", width: 14 },
+                    { key: "created", label: "Created", width: 22 },
+                ];
+            case "role-inline-policies":
+            case "role-attached-policies":
+            case "policies":
+                return [
+                    { key: "name", label: "Policy Name" },
+                    { key: "type", label: "Type", width: 24 },
+                    { key: "scope", label: "Scope", width: 12 },
+                ];
+        }
+    };
+    const getRows = async () => {
+        switch (level.kind) {
+            case "root":
+                return [
+                    {
+                        id: "roles",
+                        cells: { name: textCell("Roles"), type: textCell("IAM Role List") },
+                        meta: { type: "menu", kind: "roles" },
+                    },
+                    {
+                        id: "policies",
+                        cells: { name: textCell("Policies"), type: textCell("Managed Policy List") },
+                        meta: { type: "menu", kind: "policies" },
+                    },
+                ];
+            case "roles": {
+                const data = await runAwsJsonAsync(["iam", "list-roles"]);
+                return (data.Roles ?? []).map((role) => ({
+                    id: role.RoleName,
+                    cells: {
+                        name: textCell(role.RoleName),
+                        type: textCell("Role"),
+                        created: textCell(formatDate(role.CreateDate)),
+                    },
+                    meta: { type: "role", roleName: role.RoleName, arn: role.Arn },
+                }));
+            }
+            case "role-menu":
+                return [
+                    {
+                        id: `${level.roleName}::inline`,
+                        cells: { name: textCell("Inline Policies"), type: textCell("Role Inline Policies") },
+                        meta: {
+                            type: "menu",
+                            kind: "role-inline-policies",
+                            roleName: level.roleName,
+                        },
+                    },
+                    {
+                        id: `${level.roleName}::attached`,
+                        cells: {
+                            name: textCell("Attached Policies"),
+                            type: textCell("Role Attached Policies"),
+                        },
+                        meta: {
+                            type: "menu",
+                            kind: "role-attached-policies",
+                            roleName: level.roleName,
+                        },
+                    },
+                ];
+            case "role-inline-policies": {
+                const { roleName } = level;
+                const data = await runAwsJsonAsync([
+                    "iam",
+                    "list-role-policies",
+                    "--role-name",
+                    roleName,
+                ]);
+                return (data.PolicyNames ?? []).map((policyName) => ({
+                    id: `${roleName}::inline::${policyName}`,
+                    cells: {
+                        name: textCell(policyName),
+                        type: textCell("Inline Policy"),
+                        scope: textCell("Role"),
+                    },
+                    meta: {
+                        type: "inline-policy",
+                        roleName,
+                        policyName,
+                    },
+                }));
+            }
+            case "role-attached-policies": {
+                const { roleName } = level;
+                const data = await runAwsJsonAsync([
+                    "iam",
+                    "list-attached-role-policies",
+                    "--role-name",
+                    roleName,
+                ]);
+                return (data.AttachedPolicies ?? []).map((policy) => ({
+                    id: policy.PolicyArn,
+                    cells: {
+                        name: textCell(policy.PolicyName),
+                        type: textCell("Attached Policy"),
+                        scope: textCell("Managed"),
+                    },
+                    meta: {
+                        type: "managed-policy",
+                        policyArn: policy.PolicyArn,
+                        policyName: policy.PolicyName,
+                    },
+                }));
+            }
+            case "policies": {
+                const data = await runAwsJsonAsync([
+                    "iam",
+                    "list-policies",
+                    "--scope",
+                    "Local",
+                ]);
+                return (data.Policies ?? []).map((policy) => ({
+                    id: policy.Arn,
+                    cells: {
+                        name: textCell(policy.PolicyName),
+                        type: textCell("Managed Policy"),
+                        scope: textCell("Account"),
+                    },
+                    meta: {
+                        type: "managed-policy",
+                        policyArn: policy.Arn,
+                        policyName: policy.PolicyName,
+                    },
+                }));
+            }
+        }
+    };
+    const onSelect = async (row) => {
+        const nextBackStack = [...backStack, { level, selectedIndex: 0 }];
+        const meta = getIamMeta(row);
+        if (level.kind === "root" && meta?.type === "menu" && meta.kind === "roles") {
+            setBackStack(nextBackStack);
+            setLevel({ kind: "roles" });
+            return { action: "navigate" };
+        }
+        if (level.kind === "root" && meta?.type === "menu" && meta.kind === "policies") {
+            setBackStack(nextBackStack);
+            setLevel({ kind: "policies" });
+            return { action: "navigate" };
+        }
+        if (level.kind === "roles" && meta?.type === "role") {
+            setBackStack(nextBackStack);
+            setLevel({ kind: "role-menu", roleName: row.id });
+            return { action: "navigate" };
+        }
+        if (level.kind === "role-menu" &&
+            meta?.type === "menu" &&
+            meta.kind === "role-inline-policies") {
+            setBackStack(nextBackStack);
+            setLevel({ kind: "role-inline-policies", roleName: level.roleName });
+            return { action: "navigate" };
+        }
+        if (level.kind === "role-menu" &&
+            meta?.type === "menu" &&
+            meta.kind === "role-attached-policies") {
+            setBackStack(nextBackStack);
+            setLevel({ kind: "role-attached-policies", roleName: level.roleName });
+            return { action: "navigate" };
+        }
+        return { action: "none" };
+    };
+    const canGoBack = () => getBackStack().length > 0;
+    const goBack = () => {
+        const frame = getBackStack()[getBackStack().length - 1];
+        if (!frame)
+            return;
+        setBackStack(getBackStack().slice(0, -1));
+        setLevel(frame.level);
+    };
+    const getPath = () => {
+        switch (level.kind) {
+            case "root":
+                return "iam://";
+            case "roles":
+                return "iam://roles";
+            case "role-menu":
+                return `iam://roles/${level.roleName}`;
+            case "role-inline-policies":
+                return `iam://roles/${level.roleName}/inline-policies`;
+            case "role-attached-policies":
+                return `iam://roles/${level.roleName}/attached-policies`;
+            case "policies":
+                return "iam://policies";
+        }
+    };
+    const getContextLabel = () => {
+        switch (level.kind) {
+            case "root":
+                return "🔐 IAM Resources";
+            case "roles":
+                return "👤 IAM Roles";
+            case "role-menu":
+                return `👤 Role: ${level.roleName}`;
+            case "role-inline-policies":
+                return `📄 Inline Policies (${level.roleName})`;
+            case "role-attached-policies":
+                return `📎 Attached Policies (${level.roleName})`;
+            case "policies":
+                return "📚 Managed Policies";
+        }
+    };
+    // Compose capabilities
+    const editCapability = createIamEditCapability(getLevel);
+    const detailCapability = createIamDetailCapability(getLevel);
+    const yankCapability = createIamYankCapability();
+    return {
+        id: "iam",
+        label: "IAM",
+        hudColor: { bg: "magenta", fg: "white" },
+        getColumns,
+        getRows,
+        onSelect,
+        canGoBack,
+        goBack,
+        getPath,
+        getContextLabel,
+        capabilities: {
+            edit: editCapability,
+            detail: detailCapability,
+            yank: yankCapability,
+        },
+    };
+}