@a9s/cli 1.0.7 → 1.0.9

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

@@ -4,6 +4,7 @@ import { formatDate } from "./utils.js";
 import { createIamEditCapability } from "./capabilities/editCapability.js";
 import { createIamDetailCapability } from "./capabilities/detailCapability.js";
 import { createIamYankCapability } from "./capabilities/yankCapability.js";
+import { SERVICE_COLORS } from "../../constants/theme.js";
 function getIamMeta(row) {
     return row.meta;
 }
@@ -241,7 +242,7 @@ export function createIamServiceAdapter() {
     return {
         id: "iam",
         label: "IAM",
-        hudColor: { bg: "magenta", fg: "white" },
+        hudColor: SERVICE_COLORS.iam,
         getColumns,
         getRows,
         onSelect,

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

@@ -1,22 +1,179 @@
 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";
+import { SERVICE_COLORS } from "../../constants/theme.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: SERVICE_COLORS.route53,
         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, {});
+}