@a9s/cli 1.0.6 → 1.0.8

package/dist/scripts/seed.js

@@ -93,7 +93,7 @@ async function checkLocalStack() {
         process.exit(1);
     }
 }
-async function runAws(args) {
+async function runAws(args, timeoutMs = 10000) {
     const env = {
         ...process.env,
         AWS_ACCESS_KEY_ID: "test",
@@ -102,7 +102,7 @@ async function runAws(args) {
     };
     const { stdout } = await execFileAsync("aws", ["--endpoint-url", "http://localhost:4566", ...args], {
         env,
-        timeout: 5000,
+        timeout: timeoutMs,
     });
     return stdout;
 }
@@ -195,6 +195,182 @@ async function ensureAttachedRolePolicy(roleName, policyArn) {
     await runAws(["iam", "attach-role-policy", "--role-name", roleName, "--policy-arn", policyArn]);
     console.log(`  Attached managed policy to ${roleName}`);
 }
+async function seedDynamoDB() {
+    console.log("\nSeeding DynamoDB:");
+    const tables = [
+        {
+            name: "Users",
+            pkName: "userId",
+            skName: "timestamp",
+            items: [
+                { userId: "user-001", timestamp: "2024-01-15T10:00:00Z", email: "alice@example.com", role: "admin" },
+                { userId: "user-002", timestamp: "2024-01-16T14:30:00Z", email: "bob@example.com", role: "user" },
+                { userId: "user-003", timestamp: "2024-01-17T09:45:00Z", email: "charlie@example.com", role: "user" },
+            ],
+        },
+        {
+            name: "Orders",
+            pkName: "orderId",
+            items: [
+                { orderId: "order-001", status: "completed", total: "99.99", items: "3" },
+                { orderId: "order-002", status: "pending", total: "149.50", items: "5" },
+                { orderId: "order-003", status: "shipped", total: "299.00", items: "1" },
+            ],
+        },
+    ];
+    for (const table of tables) {
+        // Try to create table
+        try {
+            const keySchema = [{ AttributeName: table.pkName, KeyType: "HASH" }];
+            const attrDefs = [{ AttributeName: table.pkName, AttributeType: "S" }];
+            if (table.skName) {
+                keySchema.push({ AttributeName: table.skName, KeyType: "RANGE" });
+                attrDefs.push({ AttributeName: table.skName, AttributeType: "S" });
+            }
+            await runAws([
+                "dynamodb",
+                "create-table",
+                "--table-name",
+                table.name,
+                "--key-schema",
+                JSON.stringify(keySchema),
+                "--attribute-definitions",
+                JSON.stringify(attrDefs),
+                "--billing-mode",
+                "PAY_PER_REQUEST",
+                "--output",
+                "json",
+            ], 15000);
+            console.log(`  Created table: ${table.name}`);
+        }
+        catch (e) {
+            const err = e;
+            if (err.message?.includes("already exists")) {
+                console.log(`  Table already exists: ${table.name}`);
+            }
+            else {
+                throw e;
+            }
+        }
+        // Add items to the table (whether newly created or existing)
+        let addedCount = 0;
+        for (const item of table.items) {
+            const itemObj = {};
+            for (const [k, v] of Object.entries(item)) {
+                itemObj[k] = { S: String(v) };
+            }
+            try {
+                await runAws([
+                    "dynamodb",
+                    "put-item",
+                    "--table-name",
+                    table.name,
+                    "--item",
+                    JSON.stringify(itemObj),
+                ], 10000);
+                addedCount++;
+            }
+            catch (e) {
+                console.log(`    Warning: could not add item: ${e.message}`);
+            }
+        }
+        console.log(`    Added ${addedCount}/${table.items.length} items`);
+    }
+}
+async function seedRoute53() {
+    console.log("\nSeeding Route53:");
+    const zones = [
+        { name: "example.com.", isPrivate: false },
+        { name: "internal.local.", isPrivate: true },
+        { name: "staging.test.", isPrivate: false },
+    ];
+    for (const zone of zones) {
+        try {
+            // First check if zone already exists
+            const listOut = await runAws([
+                "route53",
+                "list-hosted-zones",
+                "--output",
+                "json",
+            ], 10000).catch(() => "");
+            let zoneId;
+            if (listOut) {
+                try {
+                    const listParsed = JSON.parse(listOut);
+                    const existingZone = listParsed.HostedZones?.find((z) => z.Name === zone.name);
+                    if (existingZone) {
+                        zoneId = existingZone.Id;
+                        console.log(`  Hosted zone already exists: ${zone.name}`);
+                    }
+                }
+                catch (e) {
+                    // Ignore parse errors
+                    console.log(`  List zones error: ${e.message}`);
+                }
+            }
+            // If not found, create it
+            if (!zoneId) {
+                const createOut = await runAws([
+                    "route53",
+                    "create-hosted-zone",
+                    "--name",
+                    zone.name,
+                    "--caller-reference",
+                    `zone-${Date.now()}-${Math.random()}`,
+                    "--hosted-zone-config",
+                    JSON.stringify({ PrivateZone: zone.isPrivate, Comment: `Test zone for ${zone.name}` }),
+                    "--output",
+                    "json",
+                ], 10000);
+                const parsed = JSON.parse(createOut);
+                zoneId = parsed.HostedZone?.Id;
+                if (!zoneId)
+                    throw new Error(`Failed creating hosted zone ${zone.name}`);
+                console.log(`  Created hosted zone: ${zone.name} (${zoneId})`);
+            }
+            // Add some DNS records to the zone
+            const records = [
+                { name: `www.${zone.name}`, type: "A", value: "192.0.2.1" },
+                { name: `api.${zone.name}`, type: "A", value: "192.0.2.2" },
+                { name: `mail.${zone.name}`, type: "A", value: "192.0.2.3" },
+                { name: zone.name, type: "MX", value: "10 mail.example.com." },
+            ];
+            for (const record of records) {
+                try {
+                    await runAws([
+                        "route53",
+                        "change-resource-record-sets",
+                        "--hosted-zone-id",
+                        zoneId,
+                        "--change-batch",
+                        JSON.stringify({
+                            Changes: [
+                                {
+                                    Action: "UPSERT",
+                                    ResourceRecordSet: {
+                                        Name: record.name,
+                                        Type: record.type,
+                                        TTL: 300,
+                                        ResourceRecords: [{ Value: record.value }],
+                                    },
+                                },
+                            ],
+                        }),
+                    ], 10000);
+                    console.log(`    Ensured record: ${record.name} (${record.type})`);
+                }
+                catch (e) {
+                    const err = e;
+                    console.log(`    Warning adding record ${record.name}: ${err.message ?? String(e)}`);
+                }
+            }
+        }
+        catch (e) {
+            const err = e;
+            console.error(`  Error seeding zone ${zone.name}: ${err.message ?? String(e)}`);
+        }
+    }
+}
 async function seedSecretsManager() {
     console.log("\nSeeding Secrets Manager:");
     const secrets = [
@@ -299,8 +475,30 @@ async function main() {
         process.stdout.write("  Objects: ");
         await seedBucket(bucket);
     }
-    await seedIam();
-    await seedSecretsManager();
+    try {
+        await seedDynamoDB();
+    }
+    catch (e) {
+        console.error(`\nDynamoDB seeding failed: ${e.message}`);
+    }
+    try {
+        await seedRoute53();
+    }
+    catch (e) {
+        console.error(`\nRoute53 seeding failed: ${e.message}`);
+    }
+    try {
+        await seedIam();
+    }
+    catch (e) {
+        console.error(`\nIAM seeding failed: ${e.message}`);
+    }
+    try {
+        await seedSecretsManager();
+    }
+    catch (e) {
+        console.error(`\nSecrets Manager seeding failed: ${e.message}`);
+    }
     console.log("\nDone! LocalStack seeded with test data.");
     console.log("Run: pnpm dev:local");
 }

package/dist/src/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Command, Option } from "@commander-js/extra-typings";
 import { App } from "./App.js";

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/views/dynamodb/adapter.js

@@ -1,12 +1,305 @@
 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";
+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",
@@ -14,9 +307,19 @@ export function createDynamoDBServiceAdapter() {
         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,
+        },
     };
 }

package/dist/src/views/dynamodb/capabilities/detailCapability.js

@@ -0,0 +1,94 @@
+import { runAwsJsonAsync } from "../../../utils/aws.js";
+import { formatBillingMode, formatKeySchema } from "../utils.js";
+export function createDynamoDBDetailCapability(region, getLevel) {
+    const regionArgs = region ? ["--region", region] : [];
+    const getDetails = async (row) => {
+        const meta = row.meta;
+        if (!meta) {
+            return [];
+        }
+        const level = getLevel?.();
+        // Table level
+        if (level?.kind === "tables" && meta.type === "table") {
+            try {
+                const data = await runAwsJsonAsync([
+                    "dynamodb",
+                    "describe-table",
+                    "--table-name",
+                    meta.tableName,
+                    ...regionArgs,
+                ]);
+                const table = data.Table;
+                const fields = [
+                    { label: "Table Name", value: table.TableName },
+                    { label: "Table ARN", value: table.TableArn },
+                    { label: "Status", value: table.TableStatus },
+                    { label: "Billing Mode", value: formatBillingMode(table) },
+                    { label: "Item Count", value: String(table.ItemCount ?? 0) },
+                    { label: "Table Size", value: `${table.TableSizeBytes ?? 0} bytes` },
+                    { label: "Key Schema", value: formatKeySchema(table) },
+                ];
+                // Add attributes
+                if (table.AttributeDefinitions && table.AttributeDefinitions.length > 0) {
+                    const attrs = table.AttributeDefinitions.map((a) => `${a.AttributeName} (${a.AttributeType})`).join(", ");
+                    fields.push({ label: "Attributes", value: attrs });
+                }
+                fields.push({
+                    label: "GSI Count",
+                    value: String(table.GlobalSecondaryIndexes?.length ?? 0),
+                });
+                fields.push({
+                    label: "LSI Count",
+                    value: String(table.LocalSecondaryIndexes?.length ?? 0),
+                });
+                if (table.CreationDateTime) {
+                    fields.push({
+                        label: "Created",
+                        value: new Date(table.CreationDateTime).toISOString(),
+                    });
+                }
+                return fields;
+            }
+            catch {
+                return [];
+            }
+        }
+        // Item level
+        if (level?.kind === "items" && meta.type === "item") {
+            try {
+                const itemJson = meta.itemJson ? JSON.parse(meta.itemJson) : {};
+                const prettyJson = JSON.stringify(itemJson, null, 2);
+                const fields = [
+                    {
+                        label: "Item (JSON)",
+                        value: prettyJson,
+                    },
+                ];
+                if (meta.itemSize) {
+                    fields.push({
+                        label: "Size",
+                        value: `${meta.itemSize} bytes`,
+                    });
+                }
+                return fields;
+            }
+            catch {
+                return [];
+            }
+        }
+        // Item-field level
+        if (level?.kind === "item-fields" && meta.type === "item-field") {
+            const fields = [
+                { label: "Attribute", value: meta.fieldName ?? "-" },
+                { label: "Type", value: meta.fieldType ?? "-" },
+                {
+                    label: "Value",
+                    value: String(meta.fieldRawValue ?? "-"),
+                },
+            ];
+            return fields;
+        }
+        return [];
+    };
+    return { getDetails };
+}

package/dist/src/views/dynamodb/capabilities/yankCapability.js

@@ -0,0 +1,6 @@
+import { createYankCapability } from "../../../adapters/capabilities/YankCapability.js";
+import { DynamoDBRowMetaSchema } from "../schema.js";
+import { DynamoDBYankOptions } from "./yankOptions.js";
+export function createDynamoDBYankCapability(_region, _getLevel) {
+    return createYankCapability(DynamoDBYankOptions, DynamoDBRowMetaSchema, {});
+}

package/dist/src/views/dynamodb/capabilities/yankOptions.js

@@ -0,0 +1,69 @@
+export const DynamoDBYankOptions = [
+    // Table options
+    {
+        trigger: { type: "key", char: "n" },
+        label: "Copy table name",
+        feedback: "Copied table name",
+        isRelevant: (row) => row.meta.type === "table",
+        resolve: async (row) => {
+            return row.meta.tableName ?? null;
+        },
+    },
+    {
+        trigger: { type: "key", char: "a" },
+        label: "Copy table ARN",
+        feedback: "Copied table ARN",
+        isRelevant: (row) => row.meta.type === "table",
+        resolve: async (row) => {
+            return row.meta.tableArn ?? null;
+        },
+    },
+    // Item options
+    {
+        trigger: { type: "key", char: "k" },
+        label: "Copy primary key (JSON)",
+        feedback: "Copied primary key",
+        isRelevant: (row) => row.meta.type === "item",
+        resolve: async (row) => {
+            if (!row.meta.itemPkValue && !row.meta.itemSkValue) {
+                return null;
+            }
+            const obj = {};
+            if (row.meta.itemPkValue) {
+                obj.pk = row.meta.itemPkValue;
+            }
+            if (row.meta.itemSkValue) {
+                obj.sk = row.meta.itemSkValue;
+            }
+            return JSON.stringify(obj);
+        },
+    },
+    {
+        trigger: { type: "key", char: "j" },
+        label: "Copy entire item (JSON)",
+        feedback: "Copied item",
+        isRelevant: (row) => row.meta.type === "item" && !!row.meta.itemJson,
+        resolve: async (row) => {
+            return row.meta.itemJson ?? null;
+        },
+    },
+    // Field options
+    {
+        trigger: { type: "key", char: "v" },
+        label: "Copy attribute value",
+        feedback: "Copied attribute value",
+        isRelevant: (row) => row.meta.type === "item-field",
+        resolve: async (row) => {
+            return row.meta.fieldValue ?? null;
+        },
+    },
+    {
+        trigger: { type: "key", char: "k" },
+        label: "Copy attribute name",
+        feedback: "Copied attribute name",
+        isRelevant: (row) => row.meta.type === "item-field",
+        resolve: async (row) => {
+            return row.meta.fieldName ?? null;
+        },
+    },
+];

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

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export const DynamoDBRowMetaSchema = z.object({
+    type: z.enum(["table", "item", "item-field"]),
+    tableName: z.string().optional(),
+    tableStatus: z.string().optional(),
+    tableArn: z.string().optional(),
+    billing: z.string().optional(),
+    gsiCount: z.number().optional(),
+    itemIndex: z.number().optional(),
+    itemPkValue: z.string().optional(),
+    itemSkValue: z.string().optional(),
+    itemSize: z.number().optional(),
+    itemJson: z.string().optional(),
+    fieldName: z.string().optional(),
+    fieldValue: z.string().optional(),
+    fieldType: z.string().optional(),
+    fieldRawValue: z.unknown().optional(),
+});

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

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

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

@@ -0,0 +1,175 @@
+/**
+ * Unwrap a DynamoDB AttributeValue to its native JS value.
+ * E.g., { S: "hello" } → "hello", { N: "42" } → "42", { BOOL: true } → true
+ */
+export function unwrapDynamoValue(attr) {
+    const key = Object.keys(attr)[0];
+    const value = attr[key];
+    switch (key) {
+        case "S":
+            return value;
+        case "N":
+            return value;
+        case "B":
+            return value;
+        case "SS":
+            return value;
+        case "NS":
+            return value;
+        case "BS":
+            return value;
+        case "M": {
+            const mapVal = value;
+            const obj = {};
+            for (const [k, v] of Object.entries(mapVal)) {
+                obj[k] = unwrapDynamoValue(v);
+            }
+            return obj;
+        }
+        case "L": {
+            const listVal = value;
+            return listVal.map((v) => unwrapDynamoValue(v));
+        }
+        case "NULL":
+            return null;
+        case "BOOL":
+            return value;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Get the DynamoDB type descriptor for an attribute value.
+ * Returns the single-letter type: S, N, B, SS, NS, BS, M, L, NULL, BOOL
+ */
+export function getDynamoType(attr) {
+    const key = Object.keys(attr)[0];
+    return key || "?";
+}
+/**
+ * Format a DynamoDB value for display.
+ * - For simple types (S, N, B, BOOL, NULL), return the value
+ * - For collections (SS, NS, BS), return comma-separated or wrapped in []
+ * - For maps/lists, return pretty JSON
+ * - For large values (>3 lines), truncate to 2 header + ... + 1 footer
+ * - For single/few line values, truncate at 50 chars with "..." suffix
+ */
+export function formatDynamoValue(attr) {
+    const type = getDynamoType(attr);
+    const raw = unwrapDynamoValue(attr);
+    const key = Object.keys(attr)[0];
+    const value = attr[key];
+    if (type === "NULL")
+        return "null";
+    if (type === "BOOL")
+        return String(value);
+    if (type === "N")
+        return String(value);
+    if (type === "S") {
+        const str = String(value);
+        // Escape newlines for display
+        const escaped = str.replace(/\n/g, "\\n");
+        if (escaped.length > 50)
+            return escaped.slice(0, 47) + "...";
+        return escaped;
+    }
+    if (type === "B")
+        return `<binary: ${value?.length ?? 0} bytes>`;
+    if (type === "SS") {
+        return (value ?? []).join(", ");
+    }
+    if (type === "NS") {
+        return (value ?? []).join(", ");
+    }
+    if (type === "BS") {
+        return `<${(value ?? []).length} binary values>`;
+    }
+    if (type === "M") {
+        const json = JSON.stringify(raw, null, 2);
+        return truncateLargeValue(json);
+    }
+    if (type === "L") {
+        const json = JSON.stringify(raw, null, 2);
+        return truncateLargeValue(json);
+    }
+    return String(raw);
+}
+function truncateLargeValue(str) {
+    const lines = str.split("\n");
+    if (lines.length > 3) {
+        return `${lines[0]}\n${lines[1]}\n...\n${lines[lines.length - 1]}`;
+    }
+    // Single or few lines
+    const compact = str.replace(/\n/g, " ");
+    if (compact.length > 50)
+        return compact.slice(0, 47) + "...";
+    return compact;
+}
+/**
+ * Format billing mode: "On-Demand" or "Provisioned (R:X W:Y)"
+ */
+export function formatBillingMode(table) {
+    const billing = table.BillingModeSummary?.BillingMode;
+    if (billing === "PAY_PER_REQUEST") {
+        return "On-Demand";
+    }
+    const r = table.ProvisionedThroughput?.ReadCapacityUnits ?? 0;
+    const w = table.ProvisionedThroughput?.WriteCapacityUnits ?? 0;
+    return `Provisioned (R:${r} W:${w})`;
+}
+/**
+ * Format key schema: "PK: userId, SK: timestamp" or just "PK: id"
+ */
+export function formatKeySchema(table) {
+    const keys = table.KeySchema ?? [];
+    const hash = keys.find((k) => k.KeyType === "HASH");
+    const range = keys.find((k) => k.KeyType === "RANGE");
+    let result = "";
+    if (hash)
+        result += `PK: ${hash.AttributeName}`;
+    if (range)
+        result += (result ? ", " : "") + `SK: ${range.AttributeName}`;
+    return result || "-";
+}
+/**
+ * Extract primary key value from an item.
+ * Returns a JSON string like '{"userId": "abc123"}' or '{"id": "x", "sk": "y"}'
+ */
+export function extractPrimaryKeyJson(item, table) {
+    const keys = table.KeySchema ?? [];
+    const pkObj = {};
+    for (const key of keys) {
+        const attrName = key.AttributeName;
+        const attr = item[attrName];
+        if (attr) {
+            pkObj[attrName] = unwrapDynamoValue(attr);
+        }
+    }
+    return JSON.stringify(pkObj);
+}
+/**
+ * Get the sort key value from an item for display.
+ * Returns unwrapped value or undefined.
+ */
+export function extractSkValue(item, table) {
+    const rangeKey = table.KeySchema?.find((k) => k.KeyType === "RANGE");
+    if (!rangeKey)
+        return undefined;
+    const attr = item[rangeKey.AttributeName];
+    if (!attr)
+        return undefined;
+    return String(unwrapDynamoValue(attr));
+}
+/**
+ * Get the partition key value from an item for display.
+ * Returns unwrapped value or undefined.
+ */
+export function extractPkValue(item, table) {
+    const hashKey = table.KeySchema?.find((k) => k.KeyType === "HASH");
+    if (!hashKey)
+        return undefined;
+    const attr = item[hashKey.AttributeName];
+    if (!attr)
+        return undefined;
+    return String(unwrapDynamoValue(attr));
+}

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

@@ -1,22 +1,178 @@
 import { textCell } from "../../types.js";
-export function createRoute53ServiceAdapter() {
-    const getColumns = () => [{ key: "name", label: "Name" }];
+import { runAwsJsonAsync } from "../../utils/aws.js";
+import { atom } from "jotai";
+import { getDefaultStore } from "jotai";
+import { createRoute53DetailCapability } from "./capabilities/detailCapability.js";
+import { createRoute53YankCapability } from "./capabilities/yankCapability.js";
+export const route53LevelAtom = atom({ kind: "zones" });
+export const route53BackStackAtom = atom([]);
+export function createRoute53ServiceAdapter(endpointUrl, region) {
+    const store = getDefaultStore();
+    const regionArgs = region ? ["--region", region] : [];
+    const getLevel = () => store.get(route53LevelAtom);
+    const setLevel = (level) => store.set(route53LevelAtom, level);
+    const getBackStack = () => store.get(route53BackStackAtom);
+    const setBackStack = (stack) => store.set(route53BackStackAtom, stack);
+    const getColumns = () => {
+        const level = getLevel();
+        if (level.kind === "zones") {
+            return [
+                { key: "name", label: "Name" },
+                { key: "zoneId", label: "Zone ID" },
+                { key: "recordCount", label: "Records" },
+                { key: "type", label: "Type", width: 10 },
+            ];
+        }
+        // records level
+        return [
+            { key: "name", label: "Name" },
+            { key: "type", label: "Type", width: 10 },
+            { key: "ttl", label: "TTL", width: 10 },
+            { key: "values", label: "Value(s)", width: 50 },
+        ];
+    };
     const getRows = async () => {
-        return [{ id: "stub", cells: { name: textCell("Route53 not yet implemented") }, meta: {} }];
+        const level = getLevel();
+        if (level.kind === "zones") {
+            const data = await runAwsJsonAsync([
+                "route53",
+                "list-hosted-zones",
+                ...regionArgs,
+            ]);
+            return (data.HostedZones ?? []).map((zone) => {
+                const isPrivate = zone.Config?.PrivateZone ?? zone.HostedZoneConfig?.PrivateZone ?? false;
+                const shortZoneId = zone.Id.replace(/^\/hostedzone\//, "");
+                return {
+                    id: zone.Id,
+                    cells: {
+                        name: textCell(zone.Name),
+                        zoneId: textCell(shortZoneId),
+                        recordCount: textCell(String(zone.ResourceRecordSetCount ?? 0)),
+                        type: textCell(isPrivate ? "Private" : "Public"),
+                    },
+                    meta: {
+                        type: "zone",
+                        zoneId: shortZoneId,
+                        zoneName: zone.Name,
+                        isPrivate,
+                    },
+                };
+            });
+        }
+        // records level
+        const { zoneId, zoneName } = level;
+        try {
+            const fullZoneId = zoneId.startsWith("/hostedzone/") ? zoneId : `/hostedzone/${zoneId}`;
+            const data = await runAwsJsonAsync([
+                "route53",
+                "list-resource-record-sets",
+                "--hosted-zone-id",
+                fullZoneId,
+                ...regionArgs,
+            ]);
+            return (data.ResourceRecordSets ?? []).map((record) => {
+                const values = [];
+                let valuesDisplay = "";
+                if (record.AliasTarget) {
+                    valuesDisplay = `ALIAS → ${record.AliasTarget.DNSName}`;
+                }
+                else if (record.ResourceRecords && record.ResourceRecords.length > 0) {
+                    record.ResourceRecords.forEach((r) => values.push(r.Value));
+                    if (values.length <= 3) {
+                        valuesDisplay = values.join(", ");
+                    }
+                    else {
+                        valuesDisplay = `<${values.length} values>`;
+                    }
+                }
+                return {
+                    id: `${record.Name}-${record.Type}`,
+                    cells: {
+                        name: textCell(record.Name),
+                        type: textCell(record.Type),
+                        ttl: textCell(record.AliasTarget ? "-" : String(record.TTL ?? "-")),
+                        values: textCell(valuesDisplay),
+                    },
+                    meta: {
+                        type: "record",
+                        zoneId,
+                        zoneName,
+                        recordName: record.Name,
+                        recordType: record.Type,
+                        recordTtl: record.TTL,
+                        recordValues: values,
+                        recordAliasTarget: record.AliasTarget,
+                    },
+                };
+            });
+        }
+        catch {
+            return [];
+        }
     };
-    const onSelect = async (_row) => {
+    const onSelect = async (row) => {
+        const level = getLevel();
+        const backStack = getBackStack();
+        const meta = row.meta;
+        if (level.kind === "zones") {
+            if (!meta || meta.type !== "zone") {
+                return { action: "none" };
+            }
+            const newStack = [...backStack, { level: level, selectedIndex: 0 }];
+            setBackStack(newStack);
+            setLevel({
+                kind: "records",
+                zoneId: meta.zoneId,
+                zoneName: meta.zoneName,
+            });
+            return { action: "navigate" };
+        }
+        // records 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 === "zones")
+            return "route53://";
+        return `route53://${level.zoneName}`;
+    };
+    const getContextLabel = () => {
+        const level = getLevel();
+        if (level.kind === "zones")
+            return "🌐 Hosted Zones";
+        return `🌐 ${level.zoneName}`;
+    };
+    // Compose capabilities
+    const detailCapability = createRoute53DetailCapability(region, getLevel);
+    const yankCapability = createRoute53YankCapability(region, getLevel);
     return {
         id: "route53",
         label: "Route53",
-        hudColor: { bg: "blue", fg: "white" },
+        hudColor: { bg: "cyan", fg: "black" },
         getColumns,
         getRows,
         onSelect,
-        canGoBack: () => false,
-        goBack: () => { },
-        getPath: () => "/",
-        getContextLabel: () => "🌐 DNS Records",
+        canGoBack,
+        goBack,
+        getPath,
+        getContextLabel,
+        reset() {
+            setLevel({ kind: "zones" });
+            setBackStack([]);
+        },
+        capabilities: {
+            detail: detailCapability,
+            yank: yankCapability,
+        },
     };
 }

package/dist/src/views/route53/capabilities/detailCapability.js

@@ -0,0 +1,63 @@
+import { runAwsJsonAsync } from "../../../utils/aws.js";
+export function createRoute53DetailCapability(region, getLevel) {
+    const regionArgs = region ? ["--region", region] : [];
+    const getDetails = async (row) => {
+        const meta = row.meta;
+        if (!meta) {
+            return [];
+        }
+        const level = getLevel?.();
+        // Zone level
+        if (level?.kind === "zones" && meta.type === "zone") {
+            const fullZoneId = meta.zoneId.startsWith("/hostedzone/")
+                ? meta.zoneId
+                : `/hostedzone/${meta.zoneId}`;
+            const data = await runAwsJsonAsync([
+                "route53",
+                "get-hosted-zone",
+                "--id",
+                fullZoneId,
+                ...regionArgs,
+            ]);
+            const fields = [
+                { label: "Zone Name", value: data.Name ?? "-" },
+                { label: "Zone ID (Full)", value: data.Id ?? "-" },
+                { label: "Zone ID (Short)", value: meta.zoneId },
+                { label: "Record Count", value: String(data.ResourceRecordSetCount ?? 0) },
+                {
+                    label: "Type",
+                    value: meta.isPrivate ? "Private" : "Public",
+                },
+                { label: "Caller Reference", value: data.CallerReference ?? "-" },
+            ];
+            return fields;
+        }
+        // Record level
+        if (level?.kind === "records" && meta.type === "record") {
+            const fields = [
+                { label: "Record Name", value: meta.recordName ?? "-" },
+                { label: "Record Type", value: meta.recordType ?? "-" },
+                { label: "TTL", value: meta.recordAliasTarget ? "(Alias - no TTL)" : String(meta.recordTtl ?? "-") },
+            ];
+            if (meta.recordValues && meta.recordValues.length > 0) {
+                fields.push({
+                    label: "Values",
+                    value: meta.recordValues.join("\n"),
+                });
+            }
+            if (meta.recordAliasTarget) {
+                fields.push({
+                    label: "Alias Target",
+                    value: meta.recordAliasTarget.DNSName,
+                });
+                fields.push({
+                    label: "Hosted Zone ID",
+                    value: meta.recordAliasTarget.HostedZoneId,
+                });
+            }
+            return fields;
+        }
+        return [];
+    };
+    return { getDetails };
+}

package/dist/src/views/route53/capabilities/yankCapability.js

@@ -0,0 +1,6 @@
+import { createYankCapability } from "../../../adapters/capabilities/YankCapability.js";
+import { Route53RowMetaSchema } from "../schema.js";
+import { Route53YankOptions } from "./yankOptions.js";
+export function createRoute53YankCapability(_region, _getLevel) {
+    return createYankCapability(Route53YankOptions, Route53RowMetaSchema, {});
+}

package/dist/src/views/route53/capabilities/yankOptions.js

@@ -0,0 +1,58 @@
+export const Route53YankOptions = [
+    // Zone options
+    {
+        trigger: { type: "key", char: "n" },
+        label: "Copy zone name",
+        feedback: "Copied zone name",
+        isRelevant: (row) => row.meta.type === "zone",
+        resolve: async (row) => {
+            return row.meta.zoneName ?? null;
+        },
+    },
+    {
+        trigger: { type: "key", char: "i" },
+        label: "Copy zone ID",
+        feedback: "Copied zone ID",
+        isRelevant: (row) => row.meta.type === "zone",
+        resolve: async (row) => {
+            return row.meta.zoneId ?? null;
+        },
+    },
+    // Record options
+    {
+        trigger: { type: "key", char: "n" },
+        label: "Copy record name",
+        feedback: "Copied record name",
+        isRelevant: (row) => row.meta.type === "record",
+        resolve: async (row) => {
+            return row.meta.recordName ?? null;
+        },
+    },
+    {
+        trigger: { type: "key", char: "v" },
+        label: "Copy first value",
+        feedback: "Copied first value",
+        isRelevant: (row) => {
+            return row.meta.type === "record" && (row.meta.recordValues?.length ?? 0) > 0;
+        },
+        resolve: async (row) => {
+            return row.meta.recordValues?.[0] ?? null;
+        },
+    },
+    {
+        trigger: { type: "key", char: "b" },
+        label: "Copy in BIND format",
+        feedback: "Copied BIND format",
+        isRelevant: (row) => row.meta.type === "record",
+        resolve: async (row) => {
+            const name = row.meta.recordName ?? "";
+            const type = row.meta.recordType ?? "";
+            const ttl = row.meta.recordTtl ?? 3600;
+            const value = row.meta.recordValues?.[0] ?? "";
+            if (row.meta.recordAliasTarget) {
+                return `${name} ALIAS ${row.meta.recordAliasTarget.DNSName}`;
+            }
+            return `${name} ${ttl} IN ${type} ${value}`;
+        },
+    },
+];

package/dist/src/views/route53/schema.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export const Route53RowMetaSchema = z.object({
+    type: z.enum(["zone", "record"]),
+    zoneId: z.string().optional(),
+    zoneName: z.string().optional(),
+    isPrivate: z.boolean().optional(),
+    recordName: z.string().optional(),
+    recordType: z.string().optional(),
+    recordTtl: z.number().optional(),
+    recordValues: z.array(z.string()).optional(),
+    recordAliasTarget: z
+        .object({
+        HostedZoneId: z.string(),
+        DNSName: z.string(),
+        EvaluateTargetHealth: z.boolean(),
+    })
+        .optional(),
+});

package/dist/src/views/route53/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a9s/cli",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "k9s-style TUI navigator for AWS services",
   "keywords": [
     "aws",
@@ -35,7 +35,7 @@
     "localstack:setup": "pnpm localstack:up && sleep 3 && pnpm localstack:seed",
     "dev:local": "AWS_ENDPOINT_URL=http://localhost:4566 AWS_REGION=us-east-1 AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test tsx --watch src/index.tsx",
     "dev": "tsx --watch src/index.tsx",
-    "build": "tsc",
+    "build": "tsc && node scripts/add-shebang.js",
     "lint": "oxlint",
     "format": "oxfmt --write",
     "test": "vitest run",