@dotenc/cli 0.4.2 → 0.4.4

package/README.md

@@ -3,15 +3,16 @@
 [![NPM Version][npm-image]][npm-url]
 [![Github License][license-image]](LICENSE)
 [![NPM Downloads][downloads-image]][npm-url]
+[![Codecov][codecov-image]][codecov-url]
 
 🔐 Git-native encrypted environments powered by your SSH keys
 
 ## 30-Second Example
 
 ```bash
-dotenc init          # pick your SSH key, choose a name
-dotenc env edit alice    # add your personal secrets
-dotenc dev npm start # run with your encrypted env
+dotenc init            # pick your SSH key, choose a name
+dotenc env edit alice  # add your personal secrets
+dotenc dev npm start   # run with your encrypted env
 ```
 
 Encrypted `.env.alice.enc` committed.
@@ -103,7 +104,7 @@ Your SSH private keys never leave `~/.ssh/`. dotenc reads them in place - nothin
 
 After setup, your project will look like:
 
-```
+```plaintext
 .
 ├── .dotenc/
 │   ├── alice.pub
@@ -332,7 +333,7 @@ Copy the **entire** contents of the private key file and store it as a secret en
 cat ci_key
 ```
 
-```
+```plaintext
 -----BEGIN OPENSSH PRIVATE KEY-----
 b3BlbnNzaC1rZXktdjEAAAAABG5vbm...
 -----END OPENSSH PRIVATE KEY-----
@@ -478,3 +479,5 @@ It does not aim to replace centralized secret managers like Vault or Doppler —
 [license-image]: https://img.shields.io/github/license/ivanfilhoz/dotenc.svg
 [downloads-image]: https://img.shields.io/npm/dm/@dotenc/cli.svg
 [npm-url]: https://npmjs.org/package/@dotenc/cli
+[codecov-image]: https://codecov.io/gh/ivanfilhoz/dotenc/graph/badge.svg?token=U2MKXVGBA0
+[codecov-url]: https://codecov.io/gh/ivanfilhoz/dotenc

package/dist/cli.js

@@ -7,7 +7,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@dotenc/cli",
-    version: "0.4.2",
+    version: "0.4.4",
     description: "🔐 Git-native encrypted environments powered by your SSH keys",
     author: "Ivan Filho <i@ivanfilho.com>",
     license: "MIT",
@@ -579,8 +579,8 @@ var init_getPrivateKeys = __esm(() => {
 
 // src/helpers/decryptEnvironment.ts
 import chalk2 from "chalk";
-var decryptEnvironmentData = async (environment) => {
-  const { keys: availablePrivateKeys, passphraseProtectedKeys } = await getPrivateKeys();
+var defaultDecryptEnvironmentDataDeps, decryptEnvironmentData = async (environment, deps = defaultDecryptEnvironmentDataDeps) => {
+  const { keys: availablePrivateKeys, passphraseProtectedKeys } = await deps.getPrivateKeys();
   if (!availablePrivateKeys.length) {
     if (passphraseProtectedKeys.length > 0) {
       throw new Error(passphraseProtectedKeyError(passphraseProtectedKeys));
@@ -603,20 +603,20 @@ var decryptEnvironmentData = async (environment) => {
   }
   let dataKey;
   try {
-    dataKey = decryptDataKey(selectedPrivateKey, Buffer.from(grantedKey.encryptedDataKey, "base64"));
+    dataKey = deps.decryptDataKey(selectedPrivateKey, Buffer.from(grantedKey.encryptedDataKey, "base64"));
   } catch (error) {
     throw new Error("Failed to decrypt the data key.", { cause: error });
   }
-  const decryptedContent = await decryptData(dataKey, Buffer.from(environment.encryptedContent, "base64"));
+  const decryptedContent = await deps.decryptData(dataKey, Buffer.from(environment.encryptedContent, "base64"));
   return decryptedContent;
-}, decryptEnvironment = async (name) => {
-  const { keys: availablePrivateKeys } = await getPrivateKeys();
-  const environmentJson = await getEnvironmentByName(name);
+}, defaultDecryptEnvironmentDeps, decryptEnvironment = async (name, deps = defaultDecryptEnvironmentDeps) => {
+  const { keys: availablePrivateKeys } = await deps.getPrivateKeys();
+  const environmentJson = await deps.getEnvironmentByName(name);
   try {
-    return await decryptEnvironmentData(environmentJson);
+    return await decryptEnvironmentData(environmentJson, deps);
   } catch (error) {
     if (error instanceof Error && error.message === "Access denied to the environment.") {
-      console.error(`You do not have access to this environment.
+      deps.logError(`You do not have access to this environment.
 
       These are your available private keys:
 
@@ -630,7 +630,7 @@ var decryptEnvironmentData = async (environment) => {
 `);
     }
     if (error instanceof Error && error.message === "Failed to decrypt the data key.") {
-      console.error(`${chalk2.red("Error:")} failed to decrypt the data key. Please ensure you have the correct private key.`);
+      deps.logError(`${chalk2.red("Error:")} failed to decrypt the data key. Please ensure you have the correct private key.`);
     }
     throw error;
   }
@@ -641,6 +641,16 @@ var init_decryptEnvironment = __esm(() => {
   init_errors();
   init_getEnvironmentByName();
   init_getPrivateKeys();
+  defaultDecryptEnvironmentDataDeps = {
+    getPrivateKeys,
+    decryptDataKey,
+    decryptData
+  };
+  defaultDecryptEnvironmentDeps = {
+    ...defaultDecryptEnvironmentDataDeps,
+    getEnvironmentByName,
+    logError: (message) => console.error(message)
+  };
 });
 
 // src/helpers/encryptDataKey.ts
@@ -1000,10 +1010,12 @@ import fs7 from "node:fs/promises";
 import os2 from "node:os";
 import path6 from "node:path";
 import { z as z2 } from "zod";
-var homeConfigSchema, configPath, setHomeConfig = async (config) => {
+var homeConfigSchema, getConfigPath = () => path6.join(os2.homedir(), ".dotenc", "config.json"), setHomeConfig = async (config) => {
   const parsedConfig = homeConfigSchema.parse(config);
+  const configPath = getConfigPath();
   await fs7.writeFile(configPath, JSON.stringify(parsedConfig, null, 2), "utf-8");
 }, getHomeConfig = async () => {
+  const configPath = getConfigPath();
   if (existsSync3(configPath)) {
     const config = JSON.parse(await fs7.readFile(configPath, "utf-8"));
     return homeConfigSchema.parse(config);
@@ -1014,7 +1026,6 @@ var init_homeConfig = __esm(() => {
   homeConfigSchema = z2.object({
     editor: z2.string().nullish()
   });
-  configPath = path6.join(os2.homedir(), ".dotenc", "config.json");
 });
 
 // src/commands/config.ts
@@ -1037,9 +1048,9 @@ var init_config = __esm(() => {
 });
 
 // src/helpers/getCurrentKeyName.ts
-var getCurrentKeyName = async () => {
-  const { keys: privateKeys } = await getPrivateKeys();
-  const publicKeys = await getPublicKeys();
+var getCurrentKeyName = async (deps = { getPrivateKeys, getPublicKeys }) => {
+  const { keys: privateKeys } = await deps.getPrivateKeys();
+  const publicKeys = await deps.getPublicKeys();
   const privateFingerprints = new Set(privateKeys.map((k) => k.fingerprint));
   const match = publicKeys.find((pub) => privateFingerprints.has(pub.fingerprint));
   return match?.name;
@@ -1077,71 +1088,85 @@ var init_parseEnv = __esm(() => {
 // src/commands/run.ts
 import { spawn } from "node:child_process";
 import chalk7 from "chalk";
-var runCommand = async (command, args, options) => {
+var defaultRunCommandDeps, runCommand = async (command, args, options, _command, deps = defaultRunCommandDeps) => {
   const environmentName = options.env || process.env.DOTENC_ENV;
   if (!environmentName) {
-    console.error(`No environment provided. Use -e or set DOTENC_ENV to the environment you want to run the command in.
+    deps.logError(`No environment provided. Use -e or set DOTENC_ENV to the environment you want to run the command in.
 To start a new environment, use "dotenc init [environment]".`);
-    process.exit(1);
+    deps.exit(1);
   }
   const environments = environmentName.split(",");
   for (const env of environments) {
-    const validation = validateEnvironmentName(env);
+    const validation = deps.validateEnvironmentName(env);
     if (!validation.valid) {
-      console.error(`${chalk7.red("Error:")} ${validation.reason}`);
-      process.exit(1);
+      deps.logError(`${chalk7.red("Error:")} ${validation.reason}`);
+      deps.exit(1);
     }
   }
   let failureCount = 0;
   const decryptedEnvs = await Promise.all(environments.map(async (environment) => {
     let content;
     try {
-      content = await decryptEnvironment(environment);
+      content = await deps.decryptEnvironment(environment);
     } catch (error) {
-      console.error(error instanceof Error ? error.message : `Unknown error occurred while decrypting the environment ${environment}.`);
+      deps.logError(error instanceof Error ? error.message : `Unknown error occurred while decrypting the environment ${environment}.`);
       failureCount++;
       return {};
     }
-    const decryptedEnv2 = parseEnv(content);
+    const decryptedEnv2 = deps.parseEnv(content);
     return decryptedEnv2;
   }));
   if (failureCount === environments.length) {
-    console.error(`${chalk7.red("Error:")} All environments failed to load.`);
-    process.exit(1);
+    deps.logError(`${chalk7.red("Error:")} All environments failed to load.`);
+    deps.exit(1);
   }
   if (failureCount > 0) {
-    console.error(`${chalk7.yellow("Warning:")} ${failureCount} of ${environments.length} environment(s) failed to load.`);
+    deps.logError(`${chalk7.yellow("Warning:")} ${failureCount} of ${environments.length} environment(s) failed to load.`);
   }
   const decryptedEnv = decryptedEnvs.reduce((acc, env) => {
     return { ...acc, ...env };
   }, {});
   const mergedEnv = { ...process.env, ...decryptedEnv };
-  const child = spawn(command, args, {
+  const child = deps.spawn(command, args, {
     env: mergedEnv,
     stdio: "inherit"
   });
   child.on("exit", (code) => {
-    process.exit(code);
+    deps.exit(code ?? 0);
   });
 };
 var init_run = __esm(() => {
   init_decryptEnvironment();
   init_parseEnv();
+  defaultRunCommandDeps = {
+    decryptEnvironment,
+    parseEnv,
+    validateEnvironmentName,
+    spawn,
+    logError: (message) => console.error(message),
+    exit: (code) => process.exit(code)
+  };
 });
 
 // src/commands/dev.ts
 import chalk8 from "chalk";
-var devCommand = async (command, args) => {
-  const keyName = await getCurrentKeyName();
+var defaultDevCommandDeps, devCommand = async (command, args, deps = defaultDevCommandDeps) => {
+  const keyName = await deps.getCurrentKeyName();
   if (!keyName) {
-    console.error(`${chalk8.red("Error:")} could not resolve your identity. Run ${chalk8.gray("dotenc init")} first.`);
-    process.exit(1);
+    deps.logError(`${chalk8.red("Error:")} could not resolve your identity. Run ${chalk8.gray("dotenc init")} first.`);
+    deps.exit(1);
   }
-  await runCommand(command, args, { env: `development,${keyName}` });
+  await deps.runCommand(command, args, { env: `development,${keyName}` });
 };
 var init_dev = __esm(() => {
   init_getCurrentKeyName();
   init_run();
+  defaultDevCommandDeps = {
+    getCurrentKeyName,
+    runCommand,
+    logError: console.error,
+    exit: process.exit
+  };
 });
 
 // src/helpers/environmentExists.ts
@@ -1167,9 +1192,9 @@ import { existsSync as existsSync5 } from "node:fs";
 import fs8 from "node:fs/promises";
 import path8 from "node:path";
 import { z as z3 } from "zod";
-var projectConfigSchema, configPath2, getProjectConfig = async () => {
-  if (existsSync5(configPath2)) {
-    const config = JSON.parse(await fs8.readFile(configPath2, "utf-8"));
+var projectConfigSchema, configPath, getProjectConfig = async () => {
+  if (existsSync5(configPath)) {
+    const config = JSON.parse(await fs8.readFile(configPath, "utf-8"));
     return projectConfigSchema.parse(config);
   }
   return {};
@@ -1178,7 +1203,7 @@ var init_projectConfig = __esm(() => {
   projectConfigSchema = z3.object({
     projectId: z3.string()
   });
-  configPath2 = path8.join(process.cwd(), "dotenc.json");
+  configPath = path8.join(process.cwd(), "dotenc.json");
 });
 
 // src/prompts/createEnvironment.ts
@@ -1282,8 +1307,15 @@ var init_createHash = () => {};
 
 // src/helpers/getDefaultEditor.ts
 import { execSync } from "node:child_process";
-var getDefaultEditor = async () => {
-  const config = await getHomeConfig();
+var commandExists = (command) => {
+  try {
+    execSync(`command -v ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}, defaultGetDefaultEditorDeps, getDefaultEditor = async (deps = defaultGetDefaultEditorDeps) => {
+  const config = await deps.getHomeConfig();
   if (config.editor) {
     return config.editor;
   }
@@ -1293,21 +1325,25 @@ var getDefaultEditor = async () => {
   if (process.env.VISUAL) {
     return process.env.VISUAL;
   }
-  const platform = process.platform;
+  const platform = deps.platform;
   if (platform === "win32") {
     return "notepad";
   }
   const editors = ["nano", "vim", "vi"];
   for (const editor of editors) {
-    try {
-      execSync(`command -v ${editor}`, { stdio: "ignore" });
+    if (deps.commandExists(editor)) {
       return editor;
-    } catch {}
+    }
   }
   throw new Error('No text editor found. Please set the EDITOR environment variable, configure an editor using "dotenc config editor <command>", or install a text editor (e.g., nano, vim, or notepad).');
 };
 var init_getDefaultEditor = __esm(() => {
   init_homeConfig();
+  defaultGetDefaultEditorDeps = {
+    getHomeConfig,
+    commandExists,
+    platform: process.platform
+  };
 });
 
 // src/commands/env/edit.ts
@@ -2056,7 +2092,7 @@ var init_program = __esm(() => {
   auth.command("revoke").argument("[environment]", "the environment to revoke access from").argument("[publicKey]", "the name of the public key to revoke access from the environment").description("revoke access from an environment").action(revokeCommand);
   auth.command("list").argument("[environment]", "the environment to list access for").description("list keys with access to an environment").action(authListCommand);
   program.command("run").argument("<command>", "the command to run").argument("[args...]", "the arguments to pass to the command").addOption(new Option("-e, --env <env1>[,env2[,...]]", "the environments to run the command in")).description("run a command in an environment").action(runCommand);
-  program.command("dev").argument("<command>", "the command to run").argument("[args...]", "the arguments to pass to the command").description("shortcut for 'run -e development,<yourname> <command>'").action(devCommand);
+  program.command("dev").argument("<command>", "the command to run").argument("[args...]", "the arguments to pass to the command").description("shortcut for 'run -e development,<yourname> <command>'").action((command, args) => devCommand(command, args));
   key = program.command("key").description("manage keys");
   key.command("add").argument("[name]", "the name of the public key in the project").addOption(new Option("--from-ssh <path>", "add a public key derived from an SSH key file")).addOption(new Option("-f, --from-file <file>", "add the key from a PEM file")).addOption(new Option("-s, --from-string <string>", "add a public key from a string")).description("add a public key to the project").action(keyAddCommand);
   key.command("list").description("list all public keys in the project").action(keyListCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotenc/cli",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "🔐 Git-native encrypted environments powered by your SSH keys",
   "author": "Ivan Filho <i@ivanfilho.com>",
   "license": "MIT",