@a9s/cli 0.0.1 → 1.0.6

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

@@ -0,0 +1,93 @@
+import { getCellValue } from "../../../types.js";
+import { runAwsJsonAsync } from "../../../utils/aws.js";
+import { safeString, formatDate } from "../utils.js";
+function getIamMeta(row) {
+    return row.meta;
+}
+export function createIamDetailCapability(_getLevel) {
+    const getDetails = async (row) => {
+        const meta = getIamMeta(row);
+        if (meta?.type === "role") {
+            const roleName = meta.roleName;
+            const data = await runAwsJsonAsync([
+                "iam",
+                "get-role",
+                "--role-name",
+                roleName,
+            ]);
+            const role = data.Role;
+            return [
+                { label: "Name", value: role.RoleName },
+                { label: "Type", value: "Role" },
+                { label: "ARN", value: role.Arn },
+                { label: "Path", value: role.Path ?? "/" },
+                { label: "Created", value: formatDate(role.CreateDate) },
+                {
+                    label: "Max Session Duration",
+                    value: role.MaxSessionDuration ? `${role.MaxSessionDuration} sec` : "-",
+                },
+                { label: "Description", value: role.Description ?? "-" },
+                {
+                    label: "Last Used",
+                    value: formatDate(role.RoleLastUsed?.LastUsedDate),
+                },
+                {
+                    label: "Last Used Region",
+                    value: role.RoleLastUsed?.Region ?? "-",
+                },
+            ];
+        }
+        if (meta?.type === "inline-policy") {
+            const { roleName, policyName } = meta;
+            const data = await runAwsJsonAsync([
+                "iam",
+                "get-role-policy",
+                "--role-name",
+                roleName,
+                "--policy-name",
+                policyName,
+            ]);
+            return [
+                { label: "Name", value: policyName },
+                { label: "Type", value: "Inline Policy" },
+                { label: "Role", value: roleName },
+                {
+                    label: "Statements",
+                    value: safeString(data.PolicyDocument?.["Statement"]),
+                },
+            ];
+        }
+        if (meta?.type === "managed-policy") {
+            const { policyArn } = meta;
+            const data = await runAwsJsonAsync([
+                "iam",
+                "get-policy",
+                "--policy-arn",
+                policyArn,
+            ]);
+            const p = data.Policy;
+            return [
+                { label: "Name", value: p.PolicyName },
+                { label: "Type", value: "Managed Policy" },
+                { label: "ARN", value: p.Arn },
+                { label: "Path", value: p.Path ?? "/" },
+                { label: "Description", value: p.Description ?? "-" },
+                { label: "Default Version", value: p.DefaultVersionId ?? "-" },
+                {
+                    label: "Attachment Count",
+                    value: p.AttachmentCount !== undefined ? String(p.AttachmentCount) : "-",
+                },
+                { label: "Created", value: formatDate(p.CreateDate) },
+                { label: "Updated", value: formatDate(p.UpdateDate) },
+            ];
+        }
+        const label = getCellValue(row.cells.name) ?? row.id;
+        return [
+            { label: "Name", value: label },
+            { label: "Type", value: safeString(meta?.type ?? "Item") },
+        ];
+    };
+    return {
+        getDetails,
+    };
+}

package/dist/src/views/iam/capabilities/editCapability.js

@@ -0,0 +1,59 @@
+import { runAwsJsonAsync } from "../../../utils/aws.js";
+import { writeTempJsonFile } from "../utils.js";
+function getIamMeta(row) {
+    return row.meta;
+}
+export function createIamEditCapability(_getLevel) {
+    const onEdit = async (row) => {
+        const meta = getIamMeta(row);
+        if (meta?.type === "role") {
+            const roleName = meta.roleName;
+            const roleData = await runAwsJsonAsync([
+                "iam",
+                "get-role",
+                "--role-name",
+                roleName,
+            ]);
+            const trust = roleData.Role.AssumeRolePolicyDocument ?? {};
+            const filePath = await writeTempJsonFile(`${roleName}-trust-policy`, trust);
+            return { action: "edit", filePath, metadata: {} };
+        }
+        if (meta?.type === "inline-policy") {
+            const { roleName, policyName } = meta;
+            const data = await runAwsJsonAsync([
+                "iam",
+                "get-role-policy",
+                "--role-name",
+                roleName,
+                "--policy-name",
+                policyName,
+            ]);
+            const filePath = await writeTempJsonFile(`${roleName}-${policyName}-inline-policy`, data.PolicyDocument ?? {});
+            return { action: "edit", filePath, metadata: {} };
+        }
+        if (meta?.type === "managed-policy") {
+            const { policyArn, policyName } = meta;
+            const policyMeta = await runAwsJsonAsync([
+                "iam",
+                "get-policy",
+                "--policy-arn",
+                policyArn,
+            ]);
+            const versionId = policyMeta.Policy.DefaultVersionId;
+            if (!versionId)
+                return { action: "none" };
+            const policyVersion = await runAwsJsonAsync(["iam", "get-policy-version", "--policy-arn", policyArn, "--version-id", versionId]);
+            const filePath = await writeTempJsonFile(`${policyName || "policy"}-${versionId}`, policyVersion.PolicyVersion?.Document ?? {});
+            return { action: "edit", filePath, metadata: {} };
+        }
+        return { action: "none" };
+    };
+    const uploadFile = async (_filePath, _metadata) => {
+        // IAM doesn't support file upload for now
+        throw new Error("Upload not supported for IAM");
+    };
+    return {
+        onEdit,
+        uploadFile,
+    };
+}

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

@@ -0,0 +1,6 @@
+import { createYankCapability } from "../../../adapters/capabilities/YankCapability.js";
+import { IamRowMetaSchema } from "../schema.js";
+import { iamYankOptions } from "./yankOptions.js";
+export function createIamYankCapability() {
+    return createYankCapability(iamYankOptions, IamRowMetaSchema, {});
+}

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

@@ -0,0 +1,15 @@
+export const iamYankOptions = [
+    {
+        trigger: { type: "key", char: "a" },
+        label: "copy arn",
+        feedback: "Copied ARN",
+        isRelevant: (row) => row.meta.type === "role" || row.meta.type === "managed-policy",
+        resolve: async (row) => {
+            if (row.meta.type === "role")
+                return row.meta.arn;
+            if (row.meta.type === "managed-policy")
+                return row.meta.policyArn;
+            return null;
+        },
+    },
+];

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

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const IamRowMetaSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("menu"), kind: z.string(), roleName: z.string().optional() }),
+    z.object({ type: z.literal("role"), roleName: z.string(), arn: z.string() }),
+    z.object({ type: z.literal("inline-policy"), roleName: z.string(), policyName: z.string() }),
+    z.object({ type: z.literal("managed-policy"), policyArn: z.string(), policyName: z.string() }),
+]);

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

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

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

@@ -0,0 +1,21 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdtemp, writeFile } from "node:fs/promises";
+export function safeString(value) {
+    if (value === null || value === undefined)
+        return "-";
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value);
+}
+export function formatDate(value) {
+    if (!value)
+        return "-";
+    return value.replace("T", " ").replace("Z", "");
+}
+export async function writeTempJsonFile(prefix, payload) {
+    const dir = await mkdtemp(join(tmpdir(), "a9s-iam-"));
+    const filePath = join(dir, `${prefix}.json`);
+    await writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    return filePath;
+}

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

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

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

@@ -0,0 +1,154 @@
+import { textCell } from "../../types.js";
+import { createS3Client } from "./client.js";
+import { fetchBuckets, fetchObjects, downloadObject } from "./fetcher.js";
+import { atom } from "jotai";
+import { getDefaultStore } from "jotai";
+import { formatSize } from "./utils.js";
+import { createS3EditCapability } from "./capabilities/editCapability.js";
+import { createS3DetailCapability } from "./capabilities/detailCapability.js";
+import { createS3YankCapability } from "./capabilities/yankCapability.js";
+import { createS3ActionCapability } from "./capabilities/actionCapability.js";
+export const s3LevelAtom = atom({ kind: "buckets" });
+export const s3BackStackAtom = atom([]);
+export function createS3ServiceAdapter(endpointUrl, region) {
+    const store = getDefaultStore();
+    const client = createS3Client(endpointUrl, region);
+    // Getters and setters for level/backStack from atoms
+    const getLevel = () => store.get(s3LevelAtom);
+    const setLevel = (level) => store.set(s3LevelAtom, level);
+    const getBackStack = () => store.get(s3BackStackAtom);
+    const setBackStack = (stack) => store.set(s3BackStackAtom, stack);
+    const getColumns = () => {
+        const level = getLevel();
+        if (level.kind === "buckets") {
+            return [
+                { key: "name", label: "Name" },
+                { key: "type", label: "Type", width: 10 },
+                { key: "creationDate", label: "Creation Date", width: 22 },
+            ];
+        }
+        return [
+            { key: "name", label: "Name" },
+            { key: "type", label: "Type", width: 10 },
+            { key: "size", label: "Size", width: 12 },
+            { key: "lastModified", label: "Last Modified", width: 22 },
+        ];
+    };
+    const getRows = async () => {
+        const level = getLevel();
+        if (level.kind === "buckets") {
+            const buckets = await fetchBuckets(client);
+            return buckets.map((b) => ({
+                id: b.name,
+                cells: {
+                    name: textCell(b.name),
+                    type: textCell("Bucket"),
+                    creationDate: textCell(b.creationDate ? b.creationDate.toISOString().replace("T", " ").slice(0, 19) : "-"),
+                },
+                meta: { type: "bucket" },
+            }));
+        }
+        const { bucket, prefix } = level;
+        const objects = await fetchObjects(client, bucket, prefix);
+        return objects.map((obj) => {
+            const displayKey = obj.key.slice(prefix.length);
+            return {
+                id: obj.key,
+                cells: {
+                    name: textCell(displayKey),
+                    type: textCell(obj.isFolder ? "Folder" : "File"),
+                    size: textCell(obj.isFolder ? "" : formatSize(obj.size)),
+                    lastModified: textCell(obj.lastModified ? obj.lastModified.toISOString().replace("T", " ").slice(0, 19) : ""),
+                },
+                meta: { type: obj.isFolder ? "folder" : "object", key: obj.key },
+            };
+        });
+    };
+    const onSelect = async (row) => {
+        const level = getLevel();
+        const backStack = getBackStack();
+        if (level.kind === "buckets") {
+            const newStack = [...backStack, { level: level, selectedIndex: 0 }];
+            setBackStack(newStack);
+            setLevel({ kind: "objects", bucket: row.id, prefix: "" });
+            return { action: "navigate" };
+        }
+        const type = row.meta?.type;
+        if (type === "folder") {
+            const newStack = [...backStack, { level: level, selectedIndex: 0 }];
+            setBackStack(newStack);
+            setLevel({
+                kind: "objects",
+                bucket: level.bucket,
+                prefix: row.meta?.key,
+            });
+            return { action: "navigate" };
+        }
+        if (type === "object") {
+            const filePath = await downloadObject(client, level.bucket, row.meta?.key);
+            return {
+                action: "edit",
+                filePath,
+                metadata: {
+                    bucket: level.bucket,
+                    key: row.meta?.key,
+                },
+            };
+        }
+        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 === "buckets")
+            return "s3://";
+        const { bucket, prefix } = level;
+        return `s3://${bucket}/${prefix}`;
+    };
+    const getContextLabel = () => {
+        const level = getLevel();
+        if (level.kind === "buckets")
+            return "🪣 Buckets";
+        const prefix = level.prefix ? ` › ${level.prefix}` : "";
+        return `📦 ${level.bucket}${prefix}`;
+    };
+    // Compose capabilities
+    const detailCapability = createS3DetailCapability(client, getLevel);
+    const editCapability = createS3EditCapability(client, getLevel);
+    const yankCapability = createS3YankCapability({
+        getLevel,
+        getDetails: detailCapability.getDetails,
+    });
+    const actionCapability = createS3ActionCapability(client, getLevel, getBackStack, setBackStack, setLevel);
+    return {
+        id: "s3",
+        label: "S3",
+        hudColor: { bg: "red", fg: "white" },
+        getColumns,
+        getRows,
+        onSelect,
+        canGoBack,
+        goBack,
+        getPath,
+        getContextLabel,
+        reset() {
+            setLevel({ kind: "buckets" });
+            setBackStack([]);
+        },
+        capabilities: {
+            edit: editCapability,
+            detail: detailCapability,
+            yank: yankCapability,
+            actions: actionCapability,
+        },
+    };
+}

package/dist/src/views/s3/capabilities/actionCapability.js

@@ -0,0 +1,172 @@
+import { downloadObjectToPath } from "../fetcher.js";
+import { toParentPrefix } from "../utils.js";
+function toErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+function hasCode(error, code) {
+    return Boolean(typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === code);
+}
+export function createS3ActionCapability(client, getLevel, getBackStack, setBackStack, setLevel) {
+    const getKeybindings = () => [
+        {
+            trigger: { type: "key", char: "f" },
+            actionId: "fetch",
+            label: "Fetch / download selected file",
+            shortLabel: "download",
+            scope: "navigate",
+            adapterId: "s3",
+        },
+        {
+            trigger: { type: "chord", keys: ["g", "p"] },
+            actionId: "jump-to-path",
+            label: "Go to path jump prompt",
+            shortLabel: "jump path",
+            scope: "navigate",
+            adapterId: "s3",
+        },
+    ];
+    const executeAction = async (actionId, context) => {
+        const level = getLevel();
+        if (actionId === "fetch") {
+            // Start fetch flow: prompt for path
+            if (!context.row)
+                return { type: "error", message: "No row selected" };
+            if (level.kind !== "objects") {
+                return { type: "error", message: "Fetch is only available in object view" };
+            }
+            const type = context.row.meta?.type;
+            if (type !== "object") {
+                return { type: "error", message: "Fetch is only available for objects" };
+            }
+            return {
+                type: "prompt",
+                label: "Fetch to:",
+                defaultValue: "",
+                nextActionId: "fetch:submit",
+            };
+        }
+        if (actionId === "fetch:submit") {
+            // User entered a path; try to download
+            if (!context.row || !context.data?.path) {
+                return { type: "error", message: "Invalid path" };
+            }
+            if (level.kind !== "objects") {
+                return { type: "error", message: "Fetch is only available in object view" };
+            }
+            const destinationPath = context.data.path;
+            try {
+                const finalPath = await downloadObjectToPath(client, level.bucket, context.row.meta?.key, destinationPath, false);
+                return {
+                    type: "feedback",
+                    message: `Downloaded to ${finalPath}`,
+                };
+            }
+            catch (err) {
+                // Check for file exists error
+                if (hasCode(err, "EEXIST")) {
+                    return {
+                        type: "confirm",
+                        message: `File exists. Overwrite ${destinationPath}?`,
+                        nextActionId: "fetch:overwrite",
+                        data: { path: destinationPath },
+                    };
+                }
+                return {
+                    type: "error",
+                    message: `Fetch failed: ${toErrorMessage(err)}`,
+                };
+            }
+        }
+        if (actionId === "fetch:overwrite") {
+            // User confirmed overwrite
+            if (!context.row || !context.data?.path) {
+                return { type: "error", message: "Invalid path" };
+            }
+            if (level.kind !== "objects") {
+                return { type: "error", message: "Fetch is only available in object view" };
+            }
+            const destinationPath = context.data.path;
+            try {
+                const finalPath = await downloadObjectToPath(client, level.bucket, context.row.meta?.key, destinationPath, true);
+                return {
+                    type: "feedback",
+                    message: `Downloaded to ${finalPath}`,
+                };
+            }
+            catch (err) {
+                return {
+                    type: "error",
+                    message: `Fetch failed: ${toErrorMessage(err)}`,
+                };
+            }
+        }
+        if (actionId === "jump-to-path") {
+            // Start jump flow: prompt for target
+            return {
+                type: "prompt",
+                label: "Jump to (s3://bucket/key or /key):",
+                defaultValue: "",
+                nextActionId: "jump-to-path:submit",
+            };
+        }
+        if (actionId === "jump-to-path:submit") {
+            // User entered a jump target
+            if (!context.data?.path) {
+                return { type: "error", message: "Invalid jump target" };
+            }
+            const raw = context.data.path.trim();
+            if (!raw)
+                return { type: "error", message: "Jump target is empty" };
+            const current = level;
+            let nextBucket = "";
+            let nextPrefix = "";
+            if (raw.startsWith("s3://")) {
+                const withoutScheme = raw.slice("s3://".length);
+                const slashIdx = withoutScheme.indexOf("/");
+                if (slashIdx === -1) {
+                    nextBucket = withoutScheme;
+                    nextPrefix = "";
+                }
+                else {
+                    nextBucket = withoutScheme.slice(0, slashIdx);
+                    const keySpec = withoutScheme.slice(slashIdx + 1);
+                    nextPrefix = toParentPrefix(keySpec);
+                }
+                if (!nextBucket)
+                    return { type: "error", message: "Invalid S3 URI: missing bucket" };
+            }
+            else {
+                if (level.kind !== "objects") {
+                    return {
+                        type: "error",
+                        message: 'From bucket list, jump must use "s3://bucket/..."',
+                    };
+                }
+                nextBucket = level.bucket;
+                const localSpec = raw.startsWith("/") ? raw.slice(1) : raw;
+                nextPrefix = toParentPrefix(localSpec);
+            }
+            const backStack = getBackStack();
+            // Actually perform the navigation by updating the level
+            setBackStack([...backStack, { level: current, selectedIndex: 0 }]);
+            setLevel({ kind: "objects", bucket: nextBucket, prefix: nextPrefix });
+            return {
+                type: "multi",
+                effects: [
+                    { type: "refresh" },
+                    { type: "feedback", message: `Jumped to s3://${nextBucket}/${nextPrefix}` },
+                ],
+            };
+        }
+        return { type: "error", message: `Unknown action: ${actionId}` };
+    };
+    return {
+        getKeybindings,
+        executeAction,
+    };
+}

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

@@ -0,0 +1,115 @@
+import { GetBucketAclCommand, GetBucketEncryptionCommand, GetBucketLocationCommand, GetBucketTaggingCommand, GetBucketVersioningCommand, ListObjectsV2Command, } from "@aws-sdk/client-s3";
+import { formatSize } from "../utils.js";
+import { headObject } from "../fetcher.js";
+export function createS3DetailCapability(client, getLevel) {
+    const getDetails = async (row) => {
+        const cells = row.cells;
+        const type = row.meta?.type;
+        if (type === "bucket") {
+            const bucket = cells.name.displayName ?? row.id;
+            const fields = [
+                { label: "Name", value: cells.name.displayName ?? "-" },
+                { label: "Type", value: "Bucket" },
+                { label: "Created", value: cells.creationDate.displayName ?? "-" },
+            ];
+            const [locationResult, versioningResult, encryptionResult, taggingResult, aclResult, sampleObjectsResult,] = await Promise.allSettled([
+                client.send(new GetBucketLocationCommand({ Bucket: bucket })),
+                client.send(new GetBucketVersioningCommand({ Bucket: bucket })),
+                client.send(new GetBucketEncryptionCommand({ Bucket: bucket })),
+                client.send(new GetBucketTaggingCommand({ Bucket: bucket })),
+                client.send(new GetBucketAclCommand({ Bucket: bucket })),
+                client.send(new ListObjectsV2Command({
+                    Bucket: bucket,
+                    MaxKeys: 1000,
+                })),
+            ]);
+            if (locationResult.status === "fulfilled") {
+                const raw = locationResult.value.LocationConstraint;
+                const region = raw ?? "us-east-1";
+                fields.push({ label: "Region", value: region });
+            }
+            if (versioningResult.status === "fulfilled") {
+                fields.push({
+                    label: "Versioning",
+                    value: versioningResult.value.Status ?? "Disabled",
+                });
+            }
+            if (encryptionResult.status === "fulfilled") {
+                const rule = encryptionResult.value.ServerSideEncryptionConfiguration?.Rules?.[0];
+                const algorithm = rule?.ApplyServerSideEncryptionByDefault?.SSEAlgorithm;
+                fields.push({
+                    label: "Default Encryption",
+                    value: algorithm ?? "Enabled (custom)",
+                });
+            }
+            else {
+                fields.push({ label: "Default Encryption", value: "Not configured" });
+            }
+            if (taggingResult.status === "fulfilled") {
+                const tags = taggingResult.value.TagSet ?? [];
+                fields.push({ label: "Tags", value: String(tags.length) });
+                for (const tag of tags.slice(0, 5)) {
+                    fields.push({
+                        label: `tag:${tag.Key ?? "-"}`,
+                        value: tag.Value ?? "-",
+                    });
+                }
+                if (tags.length > 5) {
+                    fields.push({
+                        label: "tag:...",
+                        value: `+${tags.length - 5} more`,
+                    });
+                }
+            }
+            if (aclResult.status === "fulfilled") {
+                const grants = aclResult.value.Grants ?? [];
+                fields.push({ label: "ACL Grants", value: String(grants.length) });
+            }
+            if (sampleObjectsResult.status === "fulfilled") {
+                const objects = sampleObjectsResult.value.Contents ?? [];
+                const objectCount = objects.length;
+                const totalBytes = objects.reduce((sum, obj) => sum + (obj.Size ?? 0), 0);
+                fields.push({ label: "Objects (sample)", value: String(objectCount) });
+                fields.push({ label: "Size (sample)", value: formatSize(totalBytes) });
+                if (sampleObjectsResult.value.IsTruncated) {
+                    fields.push({ label: "Sample Note", value: "First 1000 objects only" });
+                }
+            }
+            return fields;
+        }
+        if (type === "folder") {
+            return [
+                { label: "Name", value: row.cells.name.displayName ?? "-" },
+                { label: "Type", value: "Folder" },
+                { label: "Key", value: row.meta?.key ?? "-" },
+            ];
+        }
+        const level = getLevel();
+        if (level.kind !== "objects")
+            return [];
+        const key = row.meta?.key;
+        const meta = await headObject(client, level.bucket, key);
+        const fields = [
+            { label: "Name", value: row.cells.name.displayName ?? "-" },
+            { label: "Key", value: key },
+            { label: "Size", value: row.cells.size.displayName ?? "-" },
+            { label: "Content-Type", value: meta.contentType ?? "-" },
+            { label: "ETag", value: meta.etag ?? "-" },
+            { label: "Last Modified", value: meta.lastModified ?? "-" },
+            { label: "Storage Class", value: meta.storageClass ?? "-" },
+        ];
+        if (meta.versionId)
+            fields.push({ label: "Version ID", value: meta.versionId });
+        if (meta.serverSideEncryption)
+            fields.push({ label: "SSE", value: meta.serverSideEncryption });
+        for (const [k, v] of Object.entries(meta)) {
+            if (k.startsWith("meta:") && v) {
+                fields.push({ label: k.slice(5), value: v });
+            }
+        }
+        return fields;
+    };
+    return {
+        getDetails,
+    };
+}