@a9s/cli 1.0.7 → 1.0.9

package/dist/src/features/AppMainView.integration.test.js

@@ -33,6 +33,7 @@ function createPickerManager(active) {
         region: mkEntry("region"),
         profile: mkEntry("profile"),
         resource: mkEntry("resource"),
+        theme: mkEntry("theme"),
         activePicker: active,
         openPicker: (_id) => { },
         closeActivePicker: noop,

package/dist/src/features/AppMainView.js

@@ -13,7 +13,9 @@ import { debugLog } from "../utils/debugLogger.js";
 import { revealSecretsAtom } from "../state/atoms.js";
 import { truncateSecretForTable } from "../utils/secretDisplay.js";
 import { getCellValue } from "../types.js";
+import { useTheme } from "../contexts/ThemeContext.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 THEME = useTheme();
     const revealSecrets = useAtomValue(revealSecretsAtom);
     // Format secret values for display ONLY - original rows (via filteredRows) stay unchanged for editing
     const displayRows = useMemo(() => {
@@ -65,7 +67,7 @@ export function AppMainView({ helpPanel, helpTabs, pickers, error, describeState
         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 }) }));
+        return (_jsx(Box, { width: "100%", borderStyle: "round", borderColor: THEME.panel.helpPanelBorderText, 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;
@@ -73,17 +75,17 @@ export function AppMainView({ helpPanel, helpTabs, pickers, error, describeState
         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 }) }));
+        return (_jsx(Box, { width: "100%", borderStyle: "round", borderColor: THEME.panel.yankPanelBorderText, 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"] }) })] }));
+        return (_jsxs(Box, { width: "100%", borderStyle: "round", borderColor: THEME.upload.uploadBorderText, flexDirection: "column", children: [_jsxs(Box, { paddingX: 1, paddingY: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: THEME.upload.uploadTitleText, children: "\u26A0 Overwrite Secret on AWS?" }), _jsx(Text, { color: THEME.upload.uploadSubtitleText, children: "This will update the secret permanently." })] }), _jsx(Box, { paddingX: 1, paddingY: 1, borderTop: true, borderColor: THEME.upload.uploadDiffDividerText, children: uploadPreview ? (_jsx(DiffViewer, { oldValue: uploadPreview.old, newValue: uploadPreview.new, scrollOffset: panelScrollOffset, visibleLines: diffVisibleLines })) : (_jsx(Text, { color: THEME.upload.uploadLoadingText, children: "Loading preview..." })) }), _jsx(Box, { paddingX: 1, paddingY: 1, borderTop: true, borderColor: THEME.upload.uploadConfirmPromptText, children: _jsxs(Text, { children: ["Press", " ", _jsx(Text, { bold: true, color: THEME.upload.uploadConfirmKeyText, children: "y" }), " ", "to confirm or", " ", _jsx(Text, { bold: true, color: THEME.upload.uploadCancelKeyText, 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 }) }));
+        return (_jsx(Box, { width: "100%", borderStyle: "round", borderColor: THEME.panel.detailPanelBorderText, 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?.() ?? "" }));

package/dist/src/hooks/useCommandRouter.js

@@ -8,6 +8,8 @@ export function parseCommand(input) {
         return { type: "openRegions" };
     if (command === "resources")
         return { type: "openResources" };
+    if (command === "theme")
+        return { type: "openThemePicker" };
     const regionMatch = command.match(/^(region|use-region)\s+([a-z0-9-]+)$/i);
     if (regionMatch?.[2]) {
         return { type: "setRegion", region: regionMatch[2].toLowerCase() };
@@ -37,6 +39,9 @@ export function useCommandRouter(args) {
             case "openResources":
                 args.openResourcePicker();
                 return;
+            case "openThemePicker":
+                args.openThemePicker();
+                return;
             case "setRegion":
                 args.setSelectedRegion(parsed.region);
                 return;

package/dist/src/hooks/usePickerManager.js

@@ -3,10 +3,12 @@ import { textCell } from "../types.js";
 import { usePickerState } from "./usePickerState.js";
 import { usePickerTable } from "./usePickerTable.js";
 import { SERVICE_REGISTRY } from "../services.js";
+import { THEMES, THEME_LABELS } from "../constants/theme.js";
 export function usePickerManager({ tableHeight, availableRegions, availableProfiles, }) {
     const region = usePickerState();
     const profile = usePickerState();
     const resource = usePickerState();
+    const theme = usePickerState();
     const regionRows = useMemo(() => availableRegions.map((r) => ({
         id: r.name,
         cells: { region: textCell(r.name), description: textCell(r.description) },
@@ -25,6 +27,14 @@ export function usePickerManager({ tableHeight, availableRegions, availableProfi
         },
         meta: {},
     })), []);
+    const themeRows = useMemo(() => Object.keys(THEMES).map((themeName) => ({
+        id: themeName,
+        cells: {
+            theme: textCell(THEME_LABELS[themeName]),
+            id: textCell(themeName),
+        },
+        meta: {},
+    })), []);
     const regionTable = usePickerTable({
         rows: regionRows,
         filterText: region.filter,
@@ -40,6 +50,11 @@ export function usePickerManager({ tableHeight, availableRegions, availableProfi
         filterText: resource.filter,
         maxHeight: tableHeight,
     });
+    const themeTable = usePickerTable({
+        rows: themeRows,
+        filterText: theme.filter,
+        maxHeight: tableHeight,
+    });
     const regionColumns = [
         { key: "region", label: "Region" },
         { key: "description", label: "Description" },
@@ -52,6 +67,10 @@ export function usePickerManager({ tableHeight, availableRegions, availableProfi
         { key: "resource", label: "Resource" },
         { key: "description", label: "Description" },
     ];
+    const themeColumns = [
+        { key: "theme", label: "Theme" },
+        { key: "id", label: "ID" },
+    ];
     const regionEntry = {
         id: "region",
         columns: regionColumns,
@@ -73,13 +92,22 @@ export function usePickerManager({ tableHeight, availableRegions, availableProfi
         ...resource,
         ...resourceTable,
     };
+    const themeEntry = {
+        id: "theme",
+        columns: themeColumns,
+        contextLabel: "Select Theme",
+        ...theme,
+        ...themeTable,
+    };
     const activePicker = regionEntry.open
         ? regionEntry
         : profileEntry.open
             ? profileEntry
             : resourceEntry.open
                 ? resourceEntry
-                : null;
+                : themeEntry.open
+                    ? themeEntry
+                    : null;
     const getEntry = (id) => {
         switch (id) {
             case "region":
@@ -88,6 +116,8 @@ export function usePickerManager({ tableHeight, availableRegions, availableProfi
                 return profileEntry;
             case "resource":
                 return resourceEntry;
+            case "theme":
+                return themeEntry;
         }
     };
     const openPicker = (id) => {
@@ -114,6 +144,9 @@ export function usePickerManager({ tableHeight, availableRegions, availableProfi
             case "profile":
                 handlers.onSelectProfile(activePicker.selectedRow.id);
                 break;
+            case "theme":
+                handlers.onSelectTheme(activePicker.selectedRow.id);
+                break;
         }
         activePicker.closePicker();
     };
@@ -121,6 +154,7 @@ export function usePickerManager({ tableHeight, availableRegions, availableProfi
         region: regionEntry,
         profile: profileEntry,
         resource: resourceEntry,
+        theme: themeEntry,
         activePicker,
         openPicker,
         closeActivePicker,

package/dist/src/index.js

@@ -4,6 +4,7 @@ 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";
+import { ThemeProvider } from "./contexts/ThemeContext.js";
 const SERVICE_IDS = Object.keys(SERVICE_REGISTRY);
 const program = new Command()
     .name("a9s")
@@ -17,7 +18,7 @@ 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 }));
+    const { instance, cleanup } = withFullscreen(_jsx(ThemeProvider, { children: _jsx(App, { initialService: options.service, endpointUrl: options.endpointUrl }) }));
     process.on("SIGINT", () => {
         cleanup();
         process.exit(0);

package/dist/src/services.js

@@ -5,8 +5,8 @@ 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(),
+    route53: (_endpointUrl, region) => createRoute53ServiceAdapter(undefined, region),
+    dynamodb: (_endpointUrl, region) => createDynamoDBServiceAdapter(undefined, region),
     iam: (_endpointUrl, _region) => createIamServiceAdapter(),
     secretsmanager: (endpointUrl, region) => createSecretsManagerServiceAdapter(endpointUrl, region),
 };

package/dist/src/state/atoms.js

@@ -1,4 +1,5 @@
 import { atom } from "jotai";
+import { loadConfig } from "../utils/config.js";
 /** Persists across HMR / re-renders. Currently selected AWS service. */
 export const currentlySelectedServiceAtom = atom("s3");
 /** Current UI mode (navigate / search / command). */
@@ -25,3 +26,5 @@ export const adapterSessionAtom = atom((get) => {
 });
 /** Toggle state for revealing/hiding secret values. Persists across HMR. */
 export const revealSecretsAtom = atom(false);
+/** Active UI theme name — initialized from ~/.config/a9s/config.json on startup. */
+export const themeNameAtom = atom(loadConfig().theme ?? "monokai");

package/dist/src/utils/config.js

@@ -0,0 +1,36 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import * as YAML from "yaml";
+import { z } from "zod";
+import { THEMES } from "../constants/theme.js";
+const CONFIG_DIR = path.join(os.homedir(), ".config", "a9s");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.yaml");
+const THEME_NAMES = Object.keys(THEMES);
+const A9sConfigSchema = z.object({
+    theme: z.enum(THEME_NAMES).optional(),
+});
+export function loadConfig() {
+    try {
+        const raw = YAML.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+        return A9sConfigSchema.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(update) {
+    try {
+        let existing = {};
+        try {
+            const raw = YAML.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+            existing = A9sConfigSchema.parse(raw);
+        }
+        catch { }
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(CONFIG_PATH, YAML.stringify({ ...existing, ...update }));
+    }
+    catch {
+        // Best-effort — silently ignore write failures
+    }
+}

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

@@ -1,22 +1,326 @@
 import { textCell } from "../../types.js";
-export function createDynamoDBServiceAdapter() {
-    const getColumns = () => [{ key: "name", label: "Name" }];
+import { runAwsJsonAsync } from "../../utils/aws.js";
+import { atom } from "jotai";
+import { getDefaultStore } from "jotai";
+import { unwrapDynamoValue, formatBillingMode, formatDynamoValue, getDynamoType, extractPkValue, extractSkValue, } from "./utils.js";
+import { createDynamoDBDetailCapability } from "./capabilities/detailCapability.js";
+import { createDynamoDBYankCapability } from "./capabilities/yankCapability.js";
+import { SERVICE_COLORS } from "../../constants/theme.js";
+export const dynamoDBLevelAtom = atom({ kind: "tables" });
+export const dynamoDBBackStackAtom = atom([]);
+// Cache for table descriptions to avoid repeated AWS calls
+const tableDescriptionCache = new Map();
+// Cache for scanned items
+const itemsCache = new Map();
+export function createDynamoDBServiceAdapter(endpointUrl, region) {
+    const store = getDefaultStore();
+    const regionArgs = region ? ["--region", region] : [];
+    const getLevel = () => store.get(dynamoDBLevelAtom);
+    const setLevel = (level) => store.set(dynamoDBLevelAtom, level);
+    const getBackStack = () => store.get(dynamoDBBackStackAtom);
+    const setBackStack = (stack) => store.set(dynamoDBBackStackAtom, stack);
+    const getTableDescription = async (tableName) => {
+        const cached = tableDescriptionCache.get(tableName);
+        if (cached)
+            return cached;
+        try {
+            const data = await runAwsJsonAsync([
+                "dynamodb",
+                "describe-table",
+                "--table-name",
+                tableName,
+                ...regionArgs,
+            ]);
+            const table = data.Table;
+            tableDescriptionCache.set(tableName, table);
+            return table;
+        }
+        catch {
+            return null;
+        }
+    };
+    const getColumns = () => {
+        const level = getLevel();
+        if (level.kind === "tables") {
+            return [
+                { key: "name", label: "Name" },
+                { key: "status", label: "Status", width: 12 },
+                { key: "items", label: "Items", width: 10 },
+                { key: "billing", label: "Billing", width: 25 },
+                { key: "gsis", label: "GSIs", width: 6 },
+            ];
+        }
+        if (level.kind === "items") {
+            const table = tableDescriptionCache.get(level.tableName);
+            if (!table) {
+                // Fallback: return standard columns that will always be populated
+                return [
+                    { key: "#", label: "#", width: 4 },
+                    { key: "pk", label: "PK", width: 20 },
+                    { key: "sk", label: "SK", width: 20 },
+                    { key: "size", label: "Size", width: 10 },
+                ];
+            }
+            const keys = table.KeySchema ?? [];
+            const hashKey = keys.find((k) => k.KeyType === "HASH");
+            const rangeKey = keys.find((k) => k.KeyType === "RANGE");
+            const cols = [{ key: "#", label: "#", width: 4 }];
+            if (hashKey) {
+                cols.push({ key: "pk", label: hashKey.AttributeName, width: 20 });
+            }
+            if (rangeKey) {
+                cols.push({ key: "sk", label: rangeKey.AttributeName, width: 20 });
+            }
+            cols.push({ key: "size", label: "Size", width: 10 });
+            return cols;
+        }
+        // item-fields level
+        return [
+            { key: "attribute", label: "Attribute" },
+            { key: "value", label: "Value", width: 50 },
+            { key: "type", label: "Type", width: 8 },
+        ];
+    };
     const getRows = async () => {
-        return [{ id: "stub", cells: { name: textCell("DynamoDB not yet implemented") }, meta: {} }];
+        const level = getLevel();
+        if (level.kind === "tables") {
+            try {
+                const listData = await runAwsJsonAsync([
+                    "dynamodb",
+                    "list-tables",
+                    ...regionArgs,
+                ]);
+                const tableNames = listData.TableNames ?? [];
+                // Describe all tables in parallel
+                const tables = await Promise.all(tableNames.map((name) => getTableDescription(name)));
+                return tables
+                    .filter((t) => t !== null)
+                    .map((table) => {
+                    const statusColor = table.TableStatus === "ACTIVE"
+                        ? "green"
+                        : table.TableStatus === "CREATING" || table.TableStatus === "UPDATING"
+                            ? "yellow"
+                            : "red";
+                    return {
+                        id: table.TableArn,
+                        cells: {
+                            name: textCell(table.TableName),
+                            status: textCell(table.TableStatus),
+                            items: textCell(String(table.ItemCount ?? 0)),
+                            billing: textCell(formatBillingMode(table)),
+                            gsis: textCell(String(table.GlobalSecondaryIndexes?.length ?? 0)),
+                        },
+                        meta: {
+                            type: "table",
+                            tableName: table.TableName,
+                            tableStatus: table.TableStatus,
+                            tableArn: table.TableArn,
+                            billing: formatBillingMode(table),
+                            gsiCount: table.GlobalSecondaryIndexes?.length ?? 0,
+                        },
+                    };
+                });
+            }
+            catch {
+                return [];
+            }
+        }
+        if (level.kind === "items") {
+            const { tableName } = level;
+            try {
+                // Check cache
+                const cached = itemsCache.get(tableName);
+                if (cached) {
+                    const table = cached.table;
+                    const items = cached.items;
+                    return items.map((item, index) => {
+                        const pkValue = extractPkValue(item, table);
+                        const skValue = extractSkValue(item, table);
+                        const itemSize = JSON.stringify(item).length;
+                        const cells = {
+                            name: textCell(`Item ${index + 1}`),
+                            "#": textCell(String(index + 1)),
+                            pk: textCell(pkValue ?? "-"),
+                            sk: textCell(skValue ?? "-"),
+                            size: textCell(`${itemSize}B`),
+                        };
+                        return {
+                            id: `${tableName}-${index}`,
+                            cells,
+                            meta: {
+                                type: "item",
+                                tableName,
+                                itemIndex: index,
+                                itemPkValue: pkValue ?? undefined,
+                                itemSkValue: skValue ?? undefined,
+                                itemSize,
+                                itemJson: JSON.stringify(item),
+                            },
+                        };
+                    });
+                }
+                // Fetch table description to get key schema
+                const table = await getTableDescription(tableName);
+                if (!table)
+                    return [];
+                // Scan items
+                const scanData = await runAwsJsonAsync([
+                    "dynamodb",
+                    "scan",
+                    "--table-name",
+                    tableName,
+                    "--limit",
+                    "50",
+                    ...regionArgs,
+                ]);
+                const items = scanData.Items ?? [];
+                itemsCache.set(tableName, { items, table });
+                return items.map((item, index) => {
+                    const pkValue = extractPkValue(item, table);
+                    const skValue = extractSkValue(item, table);
+                    const itemSize = JSON.stringify(item).length;
+                    const cells = {
+                        name: textCell(`Item ${index + 1}`),
+                        "#": textCell(String(index + 1)),
+                        pk: textCell(pkValue ?? "-"),
+                        sk: textCell(skValue ?? "-"),
+                        size: textCell(`${itemSize}B`),
+                    };
+                    return {
+                        id: `${tableName}-${index}`,
+                        cells,
+                        meta: {
+                            type: "item",
+                            tableName,
+                            itemIndex: index,
+                            itemPkValue: pkValue ?? undefined,
+                            itemSkValue: skValue ?? undefined,
+                            itemSize,
+                            itemJson: JSON.stringify(item),
+                        },
+                    };
+                });
+            }
+            catch {
+                return [];
+            }
+        }
+        // item-fields level
+        if (level.kind === "item-fields") {
+            const { tableName, itemIndex } = level;
+            const cached = itemsCache.get(tableName);
+            if (!cached)
+                return [];
+            const item = cached.items[itemIndex];
+            if (!item)
+                return [];
+            return Object.entries(item).map(([attrName, attrValue]) => {
+                const displayValue = formatDynamoValue(attrValue);
+                const type = getDynamoType(attrValue);
+                return {
+                    id: attrName,
+                    cells: {
+                        attribute: textCell(attrName),
+                        value: textCell(displayValue),
+                        type: textCell(type),
+                    },
+                    meta: {
+                        type: "item-field",
+                        tableName,
+                        itemIndex,
+                        fieldName: attrName,
+                        fieldValue: displayValue,
+                        fieldType: type,
+                        fieldRawValue: unwrapDynamoValue(attrValue),
+                    },
+                };
+            });
+        }
+        return [];
     };
-    const onSelect = async (_row) => {
+    const onSelect = async (row) => {
+        const level = getLevel();
+        const backStack = getBackStack();
+        const meta = row.meta;
+        if (level.kind === "tables") {
+            if (!meta || meta.type !== "table") {
+                return { action: "none" };
+            }
+            // Clear items cache when switching tables
+            itemsCache.clear();
+            const newStack = [...backStack, { level: level, selectedIndex: 0 }];
+            setBackStack(newStack);
+            setLevel({
+                kind: "items",
+                tableName: meta.tableName,
+            });
+            return { action: "navigate" };
+        }
+        if (level.kind === "items") {
+            if (!meta || meta.type !== "item") {
+                return { action: "none" };
+            }
+            const newStack = [...backStack, { level: level, selectedIndex: 0 }];
+            setBackStack(newStack);
+            setLevel({
+                kind: "item-fields",
+                tableName: meta.tableName,
+                itemIndex: meta.itemIndex,
+            });
+            return { action: "navigate" };
+        }
+        // item-fields level: leaf, no drill-down
         return { action: "none" };
     };
+    const canGoBack = () => getBackStack().length > 0;
+    const goBack = () => {
+        const backStack = getBackStack();
+        if (backStack.length > 0) {
+            const newStack = backStack.slice(0, -1);
+            const frame = backStack[backStack.length - 1];
+            setBackStack(newStack);
+            setLevel(frame.level);
+        }
+    };
+    const getPath = () => {
+        const level = getLevel();
+        if (level.kind === "tables")
+            return "dynamodb://";
+        if (level.kind === "items")
+            return `dynamodb://${level.tableName}`;
+        return `dynamodb://${level.tableName}/items`;
+    };
+    const getContextLabel = () => {
+        const level = getLevel();
+        if (level.kind === "tables")
+            return "⚡ Tables";
+        if (level.kind === "items")
+            return `⚡ ${level.tableName}`;
+        return `⚡ ${level.tableName}/items`;
+    };
+    // Compose capabilities
+    const detailCapability = createDynamoDBDetailCapability(region, getLevel);
+    const yankCapability = createDynamoDBYankCapability(region, getLevel);
     return {
         id: "dynamodb",
         label: "DynamoDB",
-        hudColor: { bg: "green", fg: "white" },
+        hudColor: SERVICE_COLORS.dynamodb,
         getColumns,
         getRows,
         onSelect,
-        canGoBack: () => false,
-        goBack: () => { },
-        getPath: () => "/",
-        getContextLabel: () => "⚡ Tables",
+        canGoBack,
+        goBack,
+        getPath,
+        getContextLabel,
+        reset() {
+            setLevel({ kind: "tables" });
+            setBackStack([]);
+            tableDescriptionCache.clear();
+            itemsCache.clear();
+        },
+        capabilities: {
+            detail: detailCapability,
+            yank: yankCapability,
+        },
     };
 }