jwk-cli-tool 1.0.0

package/README.md

@@ -0,0 +1,76 @@
+# JWK CLI Tool
+
+Simple interactive CLI to generate:
+- PEM key pairs (`.private.pem`, `.public.pem`)
+- JWK JSON files (`.private.jwk.json`, `.public.jwk.json`)
+
+## Requirements
+
+- Node.js 18 or newer
+- npm
+
+## Install
+
+```bash
+npm install
+```
+
+## Run
+
+### Development mode
+
+```bash
+npm run dev
+```
+
+### Production mode
+
+```bash
+npm run build
+npm start
+```
+
+## How to use
+
+When the CLI starts, choose one option:
+
+1. `Generate new PEM key pair`
+2. `Generate JWK JSON files`
+3. `Exit`
+
+### 1) Generate new PEM key pair
+
+You will be asked:
+- key name
+- key type (`EC` or `RSA`)
+- algorithm (based on selected type)
+
+Files created in `keys/`:
+- `keys/<name>.private.pem`
+- `keys/<name>.public.pem`
+
+### 2) Generate JWK JSON files
+
+You will be asked:
+- PEM source:
+  - generate new PEM key pair, or
+  - use existing PEM files from `keys/`
+- `use` (`sig` or `enc`)
+- `kid` (defaults to key name)
+- algorithm only when needed (for existing RSA PEM)
+
+Files created in `outputs/`:
+- `outputs/<name>.private.jwk.json`
+- `outputs/<name>.public.jwk.json`
+
+The CLI also prints a public JWK preview in the terminal.
+
+## Supported algorithms
+
+- EC: `ES256`, `ES384`, `ES512`
+- RSA: `RS256`, `RS384`, `RS512`
+
+## Notes
+
+- `keys/` and `outputs/` are auto-created if missing.
+- If a key name already exists, CLI asks whether to overwrite.

package/dist/app.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatErrorMessage = formatErrorMessage;
+exports.runCliApp = runCliApp;
+const prompts_1 = require("@inquirer/prompts");
+const fileUtils_1 = require("./functions/fileUtils");
+const generateKey_1 = require("./prompts/generateKey");
+const generateJwk_1 = require("./prompts/generateJwk");
+function formatErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+async function promptMainMenu() {
+    const action = await (0, prompts_1.select)({
+        message: "What would you like to do?",
+        choices: [
+            { name: "1. Generate new PEM key pair", value: "generate-key" },
+            { name: "2. Generate JWK JSON files", value: "generate-jwk" },
+            { name: "3. Exit", value: "exit" }
+        ]
+    });
+    return action;
+}
+async function runCliApp() {
+    await (0, fileUtils_1.ensureProjectDirs)();
+    while (true) {
+        try {
+            const action = await promptMainMenu();
+            if (action === "exit") {
+                console.log("Goodbye.");
+                return;
+            }
+            if (action === "generate-key") {
+                await (0, generateKey_1.runGenerateKeyFlow)();
+                continue;
+            }
+            await (0, generateJwk_1.runGenerateJwkFlow)();
+        }
+        catch (error) {
+            console.error(`\nOperation failed: ${formatErrorMessage(error)}\n`);
+        }
+    }
+}

package/dist/functions/fileUtils.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDir = ensureDir;
+exports.configureStorageRoot = configureStorageRoot;
+exports.getStorageConfig = getStorageConfig;
+exports.ensureProjectDirs = ensureProjectDirs;
+exports.fileExists = fileExists;
+exports.listPemFiles = listPemFiles;
+exports.groupPemPairs = groupPemPairs;
+exports.keyFilePath = keyFilePath;
+exports.jwkFilePath = jwkFilePath;
+exports.writeJson = writeJson;
+exports.writePem = writePem;
+exports.readTextFile = readTextFile;
+exports.relativeToRoot = relativeToRoot;
+exports.resolveInKeysDir = resolveInKeysDir;
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+function buildStorageConfig(rootDir) {
+    const resolvedRoot = path_1.default.resolve(rootDir);
+    return {
+        rootDir: resolvedRoot,
+        keysDir: path_1.default.join(resolvedRoot, "keys"),
+        outputsDir: path_1.default.join(resolvedRoot, "outputs")
+    };
+}
+let storageConfig = buildStorageConfig(process.cwd());
+async function ensureDir(dirPath) {
+    await (0, promises_1.mkdir)(dirPath, { recursive: true });
+}
+function configureStorageRoot(rootDir) {
+    storageConfig = buildStorageConfig(rootDir);
+    return storageConfig;
+}
+function getStorageConfig() {
+    return storageConfig;
+}
+async function ensureProjectDirs() {
+    await Promise.all([ensureDir(storageConfig.keysDir), ensureDir(storageConfig.outputsDir)]);
+}
+async function fileExists(filePath) {
+    try {
+        await (0, promises_1.access)(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function listPemFiles() {
+    await ensureDir(storageConfig.keysDir);
+    const entries = await (0, promises_1.readdir)(storageConfig.keysDir, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".pem"))
+        .map((entry) => entry.name)
+        .sort((a, b) => a.localeCompare(b));
+}
+function groupPemPairs(files) {
+    const byName = new Map();
+    const otherPem = [];
+    for (const file of files) {
+        if (file.endsWith(".private.pem")) {
+            const name = file.slice(0, -".private.pem".length);
+            const current = byName.get(name) ?? {};
+            current.privateFile = file;
+            byName.set(name, current);
+            continue;
+        }
+        if (file.endsWith(".public.pem")) {
+            const name = file.slice(0, -".public.pem".length);
+            const current = byName.get(name) ?? {};
+            current.publicFile = file;
+            byName.set(name, current);
+            continue;
+        }
+        otherPem.push(file);
+    }
+    const pairs = [];
+    const privateOnly = [];
+    const publicOnly = [];
+    for (const [name, pair] of byName.entries()) {
+        if (pair.privateFile && pair.publicFile) {
+            pairs.push({ name, privateFile: pair.privateFile, publicFile: pair.publicFile });
+            continue;
+        }
+        if (pair.privateFile) {
+            privateOnly.push(pair.privateFile);
+        }
+        if (pair.publicFile) {
+            publicOnly.push(pair.publicFile);
+        }
+    }
+    pairs.sort((a, b) => a.name.localeCompare(b.name));
+    privateOnly.sort((a, b) => a.localeCompare(b));
+    publicOnly.sort((a, b) => a.localeCompare(b));
+    otherPem.sort((a, b) => a.localeCompare(b));
+    return { pairs, privateOnly, publicOnly, otherPem };
+}
+function keyFilePath(name, visibility) {
+    return path_1.default.join(storageConfig.keysDir, `${name}.${visibility}.pem`);
+}
+function jwkFilePath(name, visibility) {
+    return path_1.default.join(storageConfig.outputsDir, `${name}.${visibility}.jwk.json`);
+}
+async function writeJson(filePath, obj) {
+    await (0, promises_1.writeFile)(filePath, `${JSON.stringify(obj, null, 2)}\n`, "utf8");
+}
+async function writePem(filePath, pem) {
+    await (0, promises_1.writeFile)(filePath, pem, "utf8");
+}
+async function readTextFile(filePath) {
+    return (0, promises_1.readFile)(filePath, "utf8");
+}
+function relativeToRoot(filePath) {
+    return path_1.default.relative(storageConfig.rootDir, filePath);
+}
+function resolveInKeysDir(fileName) {
+    return path_1.default.join(storageConfig.keysDir, fileName);
+}

package/dist/functions/keyGen.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RSA_ALGORITHMS = exports.EC_ALGORITHMS = exports.ALL_ALGORITHMS = exports.DEFAULT_ALGORITHM = void 0;
+exports.isEcAlgorithm = isEcAlgorithm;
+exports.generatePemKeyPair = generatePemKeyPair;
+const crypto_1 = require("crypto");
+exports.DEFAULT_ALGORITHM = "ES256";
+exports.ALL_ALGORITHMS = ["ES256", "ES384", "ES512", "RS256", "RS384", "RS512"];
+exports.EC_ALGORITHMS = ["ES256", "ES384", "ES512"];
+exports.RSA_ALGORITHMS = ["RS256", "RS384", "RS512"];
+const EC_CURVE_BY_ALGORITHM = {
+    ES256: "P-256",
+    ES384: "P-384",
+    ES512: "P-521"
+};
+const RSA_SIZE_BY_ALGORITHM = {
+    RS256: 2048,
+    RS384: 3072,
+    RS512: 4096
+};
+function isEcAlgorithm(algorithm) {
+    return algorithm.startsWith("ES");
+}
+function generatePemKeyPair(algorithm) {
+    if (isEcAlgorithm(algorithm)) {
+        const { privateKey, publicKey } = (0, crypto_1.generateKeyPairSync)("ec", {
+            namedCurve: EC_CURVE_BY_ALGORITHM[algorithm]
+        });
+        return {
+            privatePem: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
+            publicPem: publicKey.export({ type: "spki", format: "pem" }).toString()
+        };
+    }
+    const { privateKey, publicKey } = (0, crypto_1.generateKeyPairSync)("rsa", {
+        modulusLength: RSA_SIZE_BY_ALGORITHM[algorithm]
+    });
+    return {
+        privatePem: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
+        publicPem: publicKey.export({ type: "spki", format: "pem" }).toString()
+    };
+}

package/dist/functions/pemToJwk.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAlgorithmFromPem = detectAlgorithmFromPem;
+exports.convertPemPairToJwks = convertPemPairToJwks;
+const crypto_1 = require("crypto");
+const EC_ALGORITHM_BY_CURVE = {
+    "P-256": "ES256",
+    "P-384": "ES384",
+    "P-521": "ES512"
+};
+function exportJwk(keyObject) {
+    return keyObject.export({ format: "jwk" });
+}
+function withMetadata(jwk, algorithm, kid, use) {
+    return {
+        ...jwk,
+        use,
+        alg: algorithm,
+        kid
+    };
+}
+function detectAlgorithmFromPem(publicPem) {
+    const publicKey = (0, crypto_1.createPublicKey)(publicPem);
+    const jwk = exportJwk(publicKey);
+    if (jwk.kty === "EC" && typeof jwk.crv === "string") {
+        return EC_ALGORITHM_BY_CURVE[jwk.crv];
+    }
+    return undefined;
+}
+function convertPemPairToJwks(privatePem, publicPem, algorithm, kid, use = "sig") {
+    const privateKey = (0, crypto_1.createPrivateKey)(privatePem);
+    const publicKey = (0, crypto_1.createPublicKey)(publicPem);
+    const privateJwk = withMetadata(exportJwk(privateKey), algorithm, kid, use);
+    const publicJwk = withMetadata(exportJwk(publicKey), algorithm, kid, use);
+    // Public JWK should never expose private parameters even if a malformed key slips in.
+    for (const privateField of ["d", "p", "q", "dp", "dq", "qi", "oth"]) {
+        delete publicJwk[privateField];
+    }
+    return { privateJwk, publicJwk };
+}

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_1 = require("./app");
+const fileUtils_1 = require("./functions/fileUtils");
+(0, fileUtils_1.configureStorageRoot)(process.cwd());
+void (0, app_1.runCliApp)().catch((error) => {
+    console.error(`Fatal error: ${(0, app_1.formatErrorMessage)(error)}`);
+    process.exit(1);
+});

package/dist/npx.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = require("@inquirer/prompts");
+const path_1 = __importDefault(require("path"));
+const app_1 = require("./app");
+const fileUtils_1 = require("./functions/fileUtils");
+async function promptForBaseFolder() {
+    const defaultBaseFolder = path_1.default.join(process.cwd(), "jwk");
+    const raw = await (0, prompts_1.input)({
+        message: "Base folder for generated files (keys/outputs will be created inside):",
+        default: defaultBaseFolder,
+        validate: (value) => (value.trim() ? true : "Base folder is required.")
+    });
+    return path_1.default.resolve(raw.trim() || defaultBaseFolder);
+}
+async function main() {
+    const baseFolder = await promptForBaseFolder();
+    const config = (0, fileUtils_1.configureStorageRoot)(baseFolder);
+    console.log(`\nSaving keys to   : ${config.keysDir}`);
+    console.log(`Saving JWK files : ${config.outputsDir}\n`);
+    await (0, app_1.runCliApp)();
+}
+void main().catch((error) => {
+    console.error(`Fatal error: ${(0, app_1.formatErrorMessage)(error)}`);
+    process.exit(1);
+});

package/dist/prompts/generateJwk.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGenerateJwkFlow = runGenerateJwkFlow;
+const prompts_1 = require("@inquirer/prompts");
+const fileUtils_1 = require("../functions/fileUtils");
+const keyGen_1 = require("../functions/keyGen");
+const pemToJwk_1 = require("../functions/pemToJwk");
+const generateKey_1 = require("./generateKey");
+function deriveNameFromPemFile(fileName) {
+    if (fileName.endsWith(".private.pem")) {
+        return fileName.slice(0, -".private.pem".length);
+    }
+    if (fileName.endsWith(".public.pem")) {
+        return fileName.slice(0, -".public.pem".length);
+    }
+    if (fileName.endsWith(".pem")) {
+        return fileName.slice(0, -".pem".length);
+    }
+    return fileName;
+}
+async function selectExistingPemFiles() {
+    const files = await (0, fileUtils_1.listPemFiles)();
+    if (files.length === 0) {
+        return null;
+    }
+    const grouped = (0, fileUtils_1.groupPemPairs)(files);
+    if (grouped.pairs.length > 0) {
+        const selectedName = await (0, prompts_1.select)({
+            message: "Select key pair from /keys:",
+            choices: grouped.pairs.map((pair) => ({
+                name: pair.name,
+                value: pair.name
+            }))
+        });
+        const selectedPair = grouped.pairs.find((pair) => pair.name === selectedName);
+        if (!selectedPair) {
+            throw new Error("Selected pair could not be resolved.");
+        }
+        return {
+            name: selectedPair.name,
+            privatePath: (0, fileUtils_1.resolveInKeysDir)(selectedPair.privateFile),
+            publicPath: (0, fileUtils_1.resolveInKeysDir)(selectedPair.publicFile)
+        };
+    }
+    const privateCandidates = [...grouped.privateOnly, ...grouped.otherPem];
+    const publicCandidates = [...grouped.publicOnly, ...grouped.otherPem];
+    if (privateCandidates.length === 0 || publicCandidates.length === 0) {
+        throw new Error("Could not find both private and public PEM files.");
+    }
+    const privateFile = await (0, prompts_1.select)({
+        message: "Select private PEM file:",
+        choices: privateCandidates.map((file) => ({ name: file, value: file }))
+    });
+    const publicFile = await (0, prompts_1.select)({
+        message: "Select public PEM file:",
+        choices: publicCandidates
+            .filter((file) => file !== privateFile)
+            .map((file) => ({ name: file, value: file }))
+    });
+    const privateName = deriveNameFromPemFile(privateFile);
+    const publicName = deriveNameFromPemFile(publicFile);
+    const defaultName = privateName || publicName || "key";
+    const nameInput = await (0, prompts_1.input)({
+        message: "Output file name prefix:",
+        default: privateName === publicName ? defaultName : `${privateName}-${publicName}`,
+        validate: (value) => (value.trim() ? true : "Name is required.")
+    });
+    return {
+        name: nameInput.trim(),
+        privatePath: (0, fileUtils_1.resolveInKeysDir)(privateFile),
+        publicPath: (0, fileUtils_1.resolveInKeysDir)(publicFile)
+    };
+}
+async function runGenerateJwkFlow() {
+    const source = await (0, prompts_1.select)({
+        message: "How do you want to provide the PEM keys?",
+        choices: [
+            {
+                name: "Generate new PEM key pair (then use it)",
+                value: "generate-new"
+            },
+            {
+                name: "Use existing PEM file from /keys folder",
+                value: "use-existing"
+            }
+        ]
+    });
+    let name;
+    let privatePem;
+    let publicPem;
+    let algorithm;
+    if (source === "generate-new") {
+        const generated = await (0, generateKey_1.runGenerateKeyFlow)();
+        name = generated.name;
+        algorithm = generated.algorithm;
+        [privatePem, publicPem] = await Promise.all([
+            (0, fileUtils_1.readTextFile)(generated.privatePath),
+            (0, fileUtils_1.readTextFile)(generated.publicPath)
+        ]);
+    }
+    else {
+        const selected = await selectExistingPemFiles();
+        if (!selected) {
+            console.log('\nNo .pem files found in /keys folder. Please generate one first.\n');
+            return;
+        }
+        name = selected.name;
+        [privatePem, publicPem] = await Promise.all([
+            (0, fileUtils_1.readTextFile)(selected.privatePath),
+            (0, fileUtils_1.readTextFile)(selected.publicPath)
+        ]);
+        algorithm = (0, pemToJwk_1.detectAlgorithmFromPem)(publicPem);
+        if (!algorithm) {
+            algorithm = await (0, generateKey_1.promptForAlgorithm)(keyGen_1.RSA_ALGORITHMS, "RS256");
+        }
+    }
+    const use = await (0, prompts_1.select)({
+        message: "Key use (use):",
+        choices: [
+            { name: "Signature (sig)", value: "sig" },
+            { name: "Encryption (enc)", value: "enc" }
+        ],
+        default: "sig"
+    });
+    const kidInput = await (0, prompts_1.input)({
+        message: "kid (leave blank to use key name):",
+        default: name
+    });
+    const kid = kidInput.trim() || name;
+    const { privateJwk, publicJwk } = (0, pemToJwk_1.convertPemPairToJwks)(privatePem, publicPem, algorithm, kid, use);
+    const privateOutputPath = (0, fileUtils_1.jwkFilePath)(name, "private");
+    const publicOutputPath = (0, fileUtils_1.jwkFilePath)(name, "public");
+    await Promise.all([
+        (0, fileUtils_1.writeJson)(privateOutputPath, privateJwk),
+        (0, fileUtils_1.writeJson)(publicOutputPath, publicJwk)
+    ]);
+    console.log("\nPublic JWK preview:");
+    console.log(JSON.stringify(publicJwk, null, 2));
+    console.log("\nGenerated JWK files.");
+    console.log(`Private JWK: ${(0, fileUtils_1.relativeToRoot)(privateOutputPath)}`);
+    console.log(`Public JWK : ${(0, fileUtils_1.relativeToRoot)(publicOutputPath)}\n`);
+}

package/dist/prompts/generateKey.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptForAlgorithm = promptForAlgorithm;
+exports.promptForKeyType = promptForKeyType;
+exports.runGenerateKeyFlow = runGenerateKeyFlow;
+const prompts_1 = require("@inquirer/prompts");
+const keyGen_1 = require("../functions/keyGen");
+const fileUtils_1 = require("../functions/fileUtils");
+const ALGORITHM_LABELS = {
+    ES256: "ES256 (EC P-256)",
+    ES384: "ES384 (EC P-384)",
+    ES512: "ES512 (EC P-521)",
+    RS256: "RS256 (RSA 2048-bit)",
+    RS384: "RS384 (RSA 3072-bit)",
+    RS512: "RS512 (RSA 4096-bit)"
+};
+const KEY_TYPE_LABELS = {
+    EC: "EC (Elliptic Curve)",
+    RSA: "RSA"
+};
+function normalizeName(value) {
+    return value.trim();
+}
+async function promptForKeyName() {
+    while (true) {
+        const rawName = await (0, prompts_1.input)({
+            message: "Key name (used as filename prefix):",
+            validate: (value) => {
+                if (!value.trim()) {
+                    return "Key name is required.";
+                }
+                if (!/^[A-Za-z0-9._-]+$/.test(value.trim())) {
+                    return "Use only letters, numbers, dot, underscore, or hyphen.";
+                }
+                return true;
+            }
+        });
+        const name = normalizeName(rawName);
+        const privatePath = (0, fileUtils_1.keyFilePath)(name, "private");
+        const publicPath = (0, fileUtils_1.keyFilePath)(name, "public");
+        const [privateExists, publicExists] = await Promise.all([
+            (0, fileUtils_1.fileExists)(privatePath),
+            (0, fileUtils_1.fileExists)(publicPath)
+        ]);
+        if (!privateExists && !publicExists) {
+            return name;
+        }
+        const overwrite = await (0, prompts_1.confirm)({
+            message: `Key files for "${name}" already exist. Overwrite them?`,
+            default: false
+        });
+        if (overwrite) {
+            return name;
+        }
+    }
+}
+async function promptForAlgorithm(allowed = keyGen_1.ALL_ALGORITHMS, defaultValue = keyGen_1.DEFAULT_ALGORITHM) {
+    const selected = await (0, prompts_1.select)({
+        message: "Algorithm:",
+        choices: allowed.map((algorithm) => ({
+            name: ALGORITHM_LABELS[algorithm],
+            value: algorithm
+        })),
+        default: defaultValue
+    });
+    return selected;
+}
+async function promptForKeyType(defaultValue = "EC") {
+    const selected = await (0, prompts_1.select)({
+        message: "Key type (kty):",
+        choices: ["EC", "RSA"].map((keyType) => ({
+            name: KEY_TYPE_LABELS[keyType],
+            value: keyType
+        })),
+        default: defaultValue
+    });
+    return selected;
+}
+async function runGenerateKeyFlow() {
+    const name = await promptForKeyName();
+    const keyType = await promptForKeyType();
+    const algorithm = keyType === "EC"
+        ? await promptForAlgorithm(keyGen_1.EC_ALGORITHMS, "ES256")
+        : await promptForAlgorithm(keyGen_1.RSA_ALGORITHMS, "RS256");
+    const { privatePem, publicPem } = (0, keyGen_1.generatePemKeyPair)(algorithm);
+    const privatePath = (0, fileUtils_1.keyFilePath)(name, "private");
+    const publicPath = (0, fileUtils_1.keyFilePath)(name, "public");
+    await Promise.all([
+        (0, fileUtils_1.writePem)(privatePath, privatePem),
+        (0, fileUtils_1.writePem)(publicPath, publicPem)
+    ]);
+    console.log(`\nGenerated PEM key pair for "${name}".`);
+    console.log(`Private key: ${(0, fileUtils_1.relativeToRoot)(privatePath)}`);
+    console.log(`Public key : ${(0, fileUtils_1.relativeToRoot)(publicPath)}\n`);
+    return {
+        name,
+        algorithm,
+        privatePath,
+        publicPath
+    };
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "jwk-cli-tool",
+  "version": "1.0.0",
+  "description": "Interactive CLI for generating PEM and JWK files",
+  "main": "dist/index.js",
+  "bin": {
+    "jwk-cli-tool": "dist/npx.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "dev": "ts-node src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "jwk",
+    "pem",
+    "crypto",
+    "typescript"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@inquirer/prompts": "^7.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.57",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "vitest": "^2.1.9"
+  }
+}