@tolgamorf/env2op-cli 0.2.0 → 0.2.2

package/README.md

@@ -1,4 +1,4 @@
-# env2op
+# env2op & op2env
 
 Push `.env` files to 1Password and pull them back with two simple commands.
 
@@ -19,7 +19,9 @@ Or in a single command:
 brew install tolgamorf/tap/env2op-cli
 ```
 
-### npm / bun
+### Package Managers (macOS/Linux/Windows)
+
+#### Global installation
 
 ```bash
 # Using bun
@@ -28,10 +30,24 @@ bun add -g @tolgamorf/env2op-cli
 # Using npm
 npm install -g @tolgamorf/env2op-cli
 
-# Or run directly with bunx/npx
+# Using pnpm
+pnpm add -g @tolgamorf/env2op-cli
+```
+
+#### Running directly
+
+```bash
+# Using bun
 bunx @tolgamorf/env2op-cli .env Personal "MyApp"
+
+# Using npm
+npx @tolgamorf/env2op-cli .env Personal "MyApp"
+
+# Using pnpm
+pnpm dlx @tolgamorf/env2op-cli .env Personal "MyApp"
 ```
 
+
 ## Prerequisites
 
 - [1Password CLI](https://1password.com/downloads/command-line/) installed and signed in
@@ -81,8 +97,10 @@ env2op .env.production Personal "MyApp" -f
 | `-f, --force`   | Skip confirmation prompts                             |
 | `--dry-run`     | Preview actions without executing                     |
 | `--secret`      | Store all fields as 'password' type (default: 'text') |
-| `-h, --help`    | Show help                                             |
+| `--verbose`     | Show op CLI output                                    |
+| `--update`      | Check for and install updates                         |
 | `-v, --version` | Show version                                          |
+| `-h, --help`    | Show help                                             |
 
 ## op2env (Pull)
 
@@ -115,8 +133,10 @@ op2env .env.tpl -f
 | `-o, --output`  | Output .env path (default: template without `.tpl`) |
 | `-f, --force`   | Overwrite without prompting                         |
 | `--dry-run`     | Preview actions without executing                   |
-| `-h, --help`    | Show help                                           |
+| `--verbose`     | Show op CLI output                                  |
+| `--update`      | Check for and install updates                       |
 | `-v, --version` | Show version                                        |
+| `-h, --help`    | Show help                                           |
 
 ## How It Works
 

package/dist/cli.js

@@ -22,7 +22,7 @@ var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports,
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@tolgamorf/env2op-cli",
-    version: "0.2.0",
+    version: "0.2.2",
     description: "Convert .env files to 1Password Secure Notes and generate templates for op inject/run",
     type: "module",
     main: "dist/index.js",
@@ -102,15 +102,14 @@ var require_package = __commonJS((exports, module) => {
 });
 
 // src/cli.ts
-import pc3 from "picocolors";
+import pc5 from "picocolors";
 
 // src/commands/convert.ts
 import { basename, dirname, join } from "node:path";
-import { setTimeout } from "node:timers/promises";
 import * as p2 from "@clack/prompts";
 
 // src/core/env-parser.ts
-import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 
 // src/utils/errors.ts
 class Env2OpError extends Error {
@@ -133,6 +132,7 @@ var ErrorCodes = {
   VAULT_CREATE_FAILED: "VAULT_CREATE_FAILED",
   ITEM_EXISTS: "ITEM_EXISTS",
   ITEM_CREATE_FAILED: "ITEM_CREATE_FAILED",
+  ITEM_EDIT_FAILED: "ITEM_EDIT_FAILED",
   PARSE_ERROR: "PARSE_ERROR",
   TEMPLATE_NOT_FOUND: "TEMPLATE_NOT_FOUND",
   INJECT_FAILED: "INJECT_FAILED"
@@ -146,6 +146,7 @@ var errors = {
   vaultCreateFailed: (message) => new Env2OpError(`Failed to create vault: ${message}`, ErrorCodes.VAULT_CREATE_FAILED),
   itemExists: (title, vault) => new Env2OpError(`Item "${title}" already exists in vault "${vault}"`, ErrorCodes.ITEM_EXISTS, "Use default behavior (overwrites) or choose a different item name"),
   itemCreateFailed: (message) => new Env2OpError(`Failed to create 1Password item: ${message}`, ErrorCodes.ITEM_CREATE_FAILED),
+  itemEditFailed: (message) => new Env2OpError(`Failed to edit 1Password item: ${message}`, ErrorCodes.ITEM_EDIT_FAILED),
   parseError: (line, message) => new Env2OpError(`Parse error at line ${line}: ${message}`, ErrorCodes.PARSE_ERROR)
 };
 
@@ -193,12 +194,20 @@ function parseValue(raw) {
   const parts = trimmed.split(/\s+#/);
   return (parts[0] ?? trimmed).trim();
 }
-function parseEnvFile(filePath) {
-  if (!existsSync(filePath)) {
+function stripBom(content) {
+  if (content.charCodeAt(0) === 65279) {
+    return content.slice(1);
+  }
+  return content;
+}
+async function parseEnvFile(filePath) {
+  let rawContent;
+  try {
+    rawContent = await readFile(filePath, "utf-8");
+  } catch {
     throw errors.envFileNotFound(filePath);
   }
-  const rawContent = readFileSync(filePath, "utf-8");
-  const content = stripHeaders(rawContent);
+  const content = stripHeaders(stripBom(rawContent));
   const rawLines = content.split(`
 `);
   const variables = [];
@@ -263,33 +272,34 @@ async function exec(command, args = [], options = {}) {
     const proc = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
-    let stdout = "";
-    let stderr = "";
+    const stdoutChunks = [];
+    const stderrChunks = [];
     proc.stdout?.on("data", (data) => {
-      const text = data.toString();
-      stdout += text;
+      const text = Buffer.isBuffer(data) ? data.toString() : String(data);
+      stdoutChunks.push(text);
       if (verbose) {
         process.stdout.write(text);
       }
     });
     proc.stderr?.on("data", (data) => {
-      const text = data.toString();
-      stderr += text;
+      const text = Buffer.isBuffer(data) ? data.toString() : String(data);
+      stderrChunks.push(text);
       if (verbose) {
         process.stderr.write(text);
       }
     });
     proc.on("close", (code) => {
       resolve({
-        stdout,
-        stderr,
-        exitCode: code ?? 0
+        stdout: stdoutChunks.join(""),
+        stderr: stderrChunks.join(""),
+        exitCode: code ?? 1
       });
     });
-    proc.on("error", () => {
+    proc.on("error", (err) => {
+      stderrChunks.push(err.message);
       resolve({
-        stdout,
-        stderr,
+        stdout: stdoutChunks.join(""),
+        stderr: stderrChunks.join(""),
         exitCode: 1
       });
     });
@@ -305,27 +315,36 @@ async function execWithStdin(command, args = [], options) {
     const proc = spawn(command, args, {
       stdio: ["pipe", "pipe", "pipe"]
     });
-    let stdout = "";
-    let stderr = "";
+    const stdoutChunks = [];
+    const stderrChunks = [];
     proc.stdin?.write(stdinContent);
     proc.stdin?.end();
     proc.stdout?.on("data", (data) => {
-      const text = data.toString();
-      stdout += text;
+      const text = Buffer.isBuffer(data) ? data.toString() : String(data);
+      stdoutChunks.push(text);
       if (verbose)
         process.stdout.write(text);
     });
     proc.stderr?.on("data", (data) => {
-      const text = data.toString();
-      stderr += text;
+      const text = Buffer.isBuffer(data) ? data.toString() : String(data);
+      stderrChunks.push(text);
       if (verbose)
         process.stderr.write(text);
     });
     proc.on("close", (code) => {
-      resolve({ stdout, stderr, exitCode: code ?? 0 });
+      resolve({
+        stdout: stdoutChunks.join(""),
+        stderr: stderrChunks.join(""),
+        exitCode: code ?? 1
+      });
     });
-    proc.on("error", () => {
-      resolve({ stdout, stderr, exitCode: 1 });
+    proc.on("error", (err) => {
+      stderrChunks.push(err.message);
+      resolve({
+        stdout: stdoutChunks.join(""),
+        stderr: stderrChunks.join(""),
+        exitCode: 1
+      });
     });
   });
 }
@@ -445,7 +464,7 @@ async function editSecureNote(options) {
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw errors.itemCreateFailed(message);
+    throw errors.itemEditFailed(message);
   }
 }
 
@@ -606,18 +625,21 @@ ${pc2.bold(pc2.underline(title))}`);
   }
 };
 
-// src/commands/convert.ts
+// src/utils/timing.ts
+import { setTimeout } from "node:timers/promises";
 var MIN_SPINNER_TIME = 500;
 async function withMinTime(promise, minTime = MIN_SPINNER_TIME) {
   const [result] = await Promise.all([promise, setTimeout(minTime)]);
   return result;
 }
+
+// src/commands/convert.ts
 async function runConvert(options) {
   const { envFile, vault, itemName, output, dryRun, secret, force, verbose } = options;
   const pkg2 = await Promise.resolve().then(() => __toESM(require_package(), 1));
   logger.intro("env2op", pkg2.version, dryRun);
   try {
-    const parseResult = parseEnvFile(envFile);
+    const parseResult = await parseEnvFile(envFile);
     validateParseResult(parseResult, envFile);
     const { variables, lines } = parseResult;
     const varCount = variables.length;
@@ -728,7 +750,7 @@ async function runConvert(options) {
         }
         pushSpinner.stop(existingItemId ? `Updated "${itemResult.title}" in vault "${itemResult.vault}"` : `Created "${itemResult.title}" in vault "${itemResult.vault}"`);
       } catch (error) {
-        pushSpinner.stop(existingItemId ? "Failed to update Secure Note" : "Failed to create Secure Note");
+        pushSpinner.stop();
         throw error;
       }
     }
@@ -766,6 +788,274 @@ async function runConvert(options) {
   }
 }
 
+// src/commands/update.ts
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
+
+// src/lib/package-manager.ts
+var UPDATE_COMMANDS = {
+  homebrew: "brew upgrade tolgamorf/tap/env2op-cli",
+  npm: "npm update -g @tolgamorf/env2op-cli",
+  bun: "bun update -g @tolgamorf/env2op-cli",
+  pnpm: "pnpm update -g @tolgamorf/env2op-cli",
+  unknown: "npm update -g @tolgamorf/env2op-cli"
+};
+var DISPLAY_NAMES = {
+  homebrew: "Homebrew",
+  npm: "npm",
+  bun: "Bun",
+  pnpm: "pnpm",
+  unknown: "npm (default)"
+};
+function detectFromPath() {
+  const binPath = process.argv[1] ?? "";
+  if (binPath.includes("/Cellar/") || binPath.includes("/homebrew/") || binPath.includes("/opt/homebrew/") || binPath.includes("/home/linuxbrew/")) {
+    return "homebrew";
+  }
+  if (binPath.includes("/.bun/")) {
+    return "bun";
+  }
+  if (binPath.includes("/pnpm/") || binPath.includes("/.pnpm/")) {
+    return "pnpm";
+  }
+  if (binPath.includes("/node_modules/")) {
+    return "npm";
+  }
+  return null;
+}
+async function detectFromCommands() {
+  const brewResult = await exec("brew", ["list", "env2op-cli"], { verbose: false });
+  if (brewResult.exitCode === 0) {
+    return "homebrew";
+  }
+  return "npm";
+}
+async function detectPackageManager() {
+  const fromPath = detectFromPath();
+  if (fromPath) {
+    return {
+      type: fromPath,
+      updateCommand: UPDATE_COMMANDS[fromPath],
+      displayName: DISPLAY_NAMES[fromPath]
+    };
+  }
+  const fromCommands = await detectFromCommands();
+  return {
+    type: fromCommands,
+    updateCommand: UPDATE_COMMANDS[fromCommands],
+    displayName: DISPLAY_NAMES[fromCommands]
+  };
+}
+
+// src/lib/update.ts
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+var CACHE_DIR = join2(homedir(), ".env2op");
+var CACHE_FILE = join2(CACHE_DIR, "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+function getCliVersion() {
+  try {
+    const pkg2 = require_package();
+    return pkg2.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function loadCache() {
+  try {
+    if (existsSync(CACHE_FILE)) {
+      const content = readFileSync(CACHE_FILE, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {}
+  return { lastCheck: 0, latestVersion: null };
+}
+function saveCache(cache) {
+  try {
+    if (!existsSync(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    writeFileSync2(CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {}
+}
+function shouldCheckForUpdate(cache) {
+  const now = Date.now();
+  return now - cache.lastCheck > CHECK_INTERVAL_MS;
+}
+async function fetchLatestVersion() {
+  try {
+    const response = await fetch("https://registry.npmjs.org/@tolgamorf/env2op-cli/latest");
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    const p1 = parts1[i] || 0;
+    const p22 = parts2[i] || 0;
+    if (p1 < p22)
+      return -1;
+    if (p1 > p22)
+      return 1;
+  }
+  return 0;
+}
+async function checkForUpdate(forceCheck = false) {
+  const currentVersion = getCliVersion();
+  const cache = loadCache();
+  if (!forceCheck && !shouldCheckForUpdate(cache) && cache.latestVersion) {
+    const updateAvailable2 = compareVersions(currentVersion, cache.latestVersion) < 0;
+    const isSkipped2 = cache.skipVersion === cache.latestVersion;
+    return {
+      currentVersion,
+      latestVersion: cache.latestVersion,
+      updateAvailable: updateAvailable2,
+      isSkipped: isSkipped2,
+      fromCache: true
+    };
+  }
+  const latestVersion = await fetchLatestVersion();
+  saveCache({
+    ...cache,
+    lastCheck: Date.now(),
+    latestVersion
+  });
+  if (!latestVersion) {
+    return {
+      currentVersion,
+      latestVersion: null,
+      updateAvailable: false,
+      isSkipped: false,
+      fromCache: false
+    };
+  }
+  const updateAvailable = compareVersions(currentVersion, latestVersion) < 0;
+  const isSkipped = cache.skipVersion === latestVersion;
+  return {
+    currentVersion,
+    latestVersion,
+    updateAvailable,
+    isSkipped,
+    fromCache: false
+  };
+}
+async function performUpdate(pm) {
+  const packageManager = pm ?? await detectPackageManager();
+  try {
+    const [command, ...args] = packageManager.updateCommand.split(" ");
+    const result = await exec(command, args, { verbose: false });
+    if (result.exitCode !== 0) {
+      return {
+        success: false,
+        error: result.stderr || `Command exited with code ${result.exitCode}`
+      };
+    }
+    return { success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: message };
+  }
+}
+function skipVersion(version) {
+  const cache = loadCache();
+  cache.skipVersion = version;
+  saveCache(cache);
+}
+
+// src/lib/update-prompts.ts
+import * as p3 from "@clack/prompts";
+import pc3 from "picocolors";
+var S_BAR_START = "┌";
+var S_BAR_END = "└";
+function showUpdateNotification(result, cliName = "env2op") {
+  console.log();
+  console.log(`${pc3.gray(S_BAR_START)}${pc3.gray("─")} ${pc3.yellow("Update available:")} ${pc3.dim(result.currentVersion)} ${pc3.dim("→")} ${pc3.green(result.latestVersion)}`);
+  console.log(`${pc3.gray(S_BAR_END)}${pc3.gray("─")} Run ${pc3.cyan(`'${cliName} update'`)} to update`);
+}
+async function askToUpdate(result) {
+  const response = await p3.select({
+    message: "Would you like to update?",
+    options: [
+      { value: "update", label: "Update now", hint: "Download and install the latest version" },
+      { value: "later", label: "Remind me later", hint: "Ask again next time" },
+      { value: "skip", label: "Skip this version", hint: `Don't ask about ${result.latestVersion} again` }
+    ]
+  });
+  if (p3.isCancel(response)) {
+    return "later";
+  }
+  return response;
+}
+function showUpdateAvailable(result) {
+  p3.log.success(`Update available: ${pc3.dim(result.currentVersion)} ${pc3.dim("→")} ${pc3.green(result.latestVersion)}`);
+}
+function showUpToDate(currentVersion) {
+  p3.log.success(`You're on the latest version ${pc3.green(`(${currentVersion})`)}`);
+}
+function showPackageManagerInfo(pm) {
+  console.log();
+  console.log(`  ${pc3.dim("Detected:")} ${pm.displayName} installation`);
+  console.log(`  ${pc3.dim("Command:")}  ${pc3.cyan(pm.updateCommand)}`);
+  console.log();
+}
+function showUpdateSuccess(newVersion) {
+  p3.log.success(`Updated to version ${pc3.green(newVersion)}`);
+  p3.log.info("Please restart to use the new version.");
+}
+function showUpdateError(error, pm) {
+  if (error) {
+    p3.log.error(pc3.dim(error));
+  }
+  p3.log.info(`Try running manually: ${pc3.cyan(pm.updateCommand)}`);
+}
+
+// src/commands/update.ts
+async function runUpdate(options) {
+  const { force = false, cliName = "env2op" } = options;
+  p4.intro(pc4.bgCyan(pc4.black(` ${cliName} update `)));
+  const spinner4 = p4.spinner();
+  spinner4.start("Checking for updates...");
+  const result = await checkForUpdate(true);
+  spinner4.stop("Checked for updates");
+  if (!result.updateAvailable || !result.latestVersion) {
+    showUpToDate(result.currentVersion);
+    return;
+  }
+  showUpdateAvailable(result);
+  const pm = await detectPackageManager();
+  showPackageManagerInfo(pm);
+  if (!force) {
+    const choice = await askToUpdate(result);
+    if (choice === "skip") {
+      skipVersion(result.latestVersion);
+      p4.log.info(`Skipped version ${result.latestVersion}`);
+      return;
+    }
+    if (choice === "later") {
+      p4.log.info("Update postponed");
+      return;
+    }
+  }
+  const updateSpinner = p4.spinner();
+  updateSpinner.start(`Updating to ${result.latestVersion}...`);
+  const updateResult = await performUpdate(pm);
+  if (updateResult.success) {
+    updateSpinner.stop("Update completed");
+    showUpdateSuccess(result.latestVersion);
+  } else {
+    updateSpinner.stop("Update failed");
+    showUpdateError(updateResult.error, pm);
+    process.exit(1);
+  }
+}
+
 // src/cli.ts
 var pkg2 = await Promise.resolve().then(() => __toESM(require_package(), 1));
 var args = process.argv.slice(2);
@@ -792,10 +1082,19 @@ for (let i = 0;i < args.length; i++) {
 }
 var hasHelp = flags.has("h") || flags.has("help");
 var hasVersion = flags.has("v") || flags.has("version");
+var hasUpdate = flags.has("update");
 if (hasVersion) {
   console.log(pkg2.version);
   process.exit(0);
 }
+if (hasUpdate) {
+  await runUpdate({
+    force: flags.has("f") || flags.has("force"),
+    verbose: flags.has("verbose"),
+    cliName: "env2op"
+  });
+  process.exit(0);
+}
 if (hasHelp || positional.length === 0) {
   showHelp();
   process.exit(0);
@@ -815,48 +1114,55 @@ await runConvert({
   force: flags.has("f") || flags.has("force"),
   verbose: flags.has("verbose")
 });
+try {
+  const updateResult = await checkForUpdate();
+  if (updateResult.updateAvailable && !updateResult.isSkipped) {
+    showUpdateNotification(updateResult, "env2op");
+  }
+} catch {}
 function showHelp() {
-  const name = pc3.bold(pc3.cyan("env2op"));
-  const version = pc3.dim(`v${pkg2.version}`);
+  const name = pc5.bold(pc5.cyan("env2op"));
+  const version = pc5.dim(`v${pkg2.version}`);
   console.log(`
 ${name} ${version}
 ${pkg2.description}
 
-${pc3.bold("USAGE")}
-  ${pc3.cyan("$")} env2op ${pc3.yellow("<env_file>")} ${pc3.yellow("<vault>")} ${pc3.yellow("<item_name>")} ${pc3.dim("[options]")}
+${pc5.bold("USAGE")}
+  ${pc5.cyan("$")} env2op ${pc5.yellow("<env_file>")} ${pc5.yellow("<vault>")} ${pc5.yellow("<item_name>")} ${pc5.dim("[options]")}
 
-${pc3.bold("ARGUMENTS")}
-  ${pc3.yellow("env_file")}     Path to .env file
-  ${pc3.yellow("vault")}        1Password vault name
-  ${pc3.yellow("item_name")}    Name for the Secure Note in 1Password
+${pc5.bold("ARGUMENTS")}
+  ${pc5.yellow("env_file")}        Path to .env file
+  ${pc5.yellow("vault")}           1Password vault name
+  ${pc5.yellow("item_name")}       Name for the Secure Note in 1Password
 
-${pc3.bold("OPTIONS")}
-  ${pc3.cyan("-o, --output")}   Output template path (default: <env_file>.tpl)
-  ${pc3.cyan("-f, --force")}    Skip confirmation prompts
-  ${pc3.cyan("--dry-run")}      Preview actions without executing
-  ${pc3.cyan("--secret")}       Store all fields as password type (hidden)
-  ${pc3.cyan("--verbose")}      Show op CLI output
-  ${pc3.cyan("-h, --help")}     Show this help message
-  ${pc3.cyan("-v, --version")}  Show version
+${pc5.bold("OPTIONS")}
+  ${pc5.cyan("-o, --output")}    Output template path (default: <env_file>.tpl)
+  ${pc5.cyan("-f, --force")}     Skip confirmation prompts
+  ${pc5.cyan("    --dry-run")}   Preview actions without executing
+  ${pc5.cyan("    --secret")}    Store all fields as password type (hidden)
+  ${pc5.cyan("    --verbose")}   Show op CLI output
+  ${pc5.cyan("    --update")}    Check for and install updates
+  ${pc5.cyan("-v, --version")}   Show version
+  ${pc5.cyan("-h, --help")}      Show this help message
 
-${pc3.bold("EXAMPLES")}
-  ${pc3.dim("# Basic usage")}
-  ${pc3.cyan("$")} env2op .env.production Personal "MyApp - Production"
+${pc5.bold("EXAMPLES")}
+  ${pc5.dim("# Basic usage")}
+  ${pc5.cyan("$")} env2op .env.production Personal "MyApp - Production"
 
-  ${pc3.dim("# Custom output path")}
-  ${pc3.cyan("$")} env2op .env Personal "MyApp" -o secrets.tpl
+  ${pc5.dim("# Custom output path")}
+  ${pc5.cyan("$")} env2op .env Personal "MyApp" -o secrets.tpl
 
-  ${pc3.dim("# Preview without making changes")}
-  ${pc3.cyan("$")} env2op .env Personal "MyApp" --dry-run
+  ${pc5.dim("# Preview without making changes")}
+  ${pc5.cyan("$")} env2op .env Personal "MyApp" --dry-run
 
-  ${pc3.dim("# Store as hidden password fields")}
-  ${pc3.cyan("$")} env2op .env Personal "MyApp" --secret
+  ${pc5.dim("# Store as hidden password fields")}
+  ${pc5.cyan("$")} env2op .env Personal "MyApp" --secret
 
-  ${pc3.dim("# Skip confirmation prompts (for CI/scripts)")}
-  ${pc3.cyan("$")} env2op .env Personal "MyApp" -f
+  ${pc5.dim("# Skip confirmation prompts (for CI/scripts)")}
+  ${pc5.cyan("$")} env2op .env Personal "MyApp" -f
 
-${pc3.bold("DOCUMENTATION")}
-  ${pc3.dim("https://github.com/tolgamorf/env2op-cli")}
+${pc5.bold("DOCUMENTATION")}
+  ${pc5.dim("https://github.com/tolgamorf/env2op-cli")}
 `);
 }
 function showMissingArgsError(provided) {
@@ -868,17 +1174,17 @@ function showMissingArgsError(provided) {
   if (provided.length < 3)
     missing.push("item_name");
   console.log(`
-${pc3.red(pc3.bold("Error:"))} Missing required arguments
+${pc5.red(pc5.bold("Error:"))} Missing required arguments
 
-${pc3.bold("Usage:")} env2op ${pc3.yellow("<env_file>")} ${pc3.yellow("<vault>")} ${pc3.yellow("<item_name>")} ${pc3.dim("[options]")}
+${pc5.bold("Usage:")} env2op ${pc5.yellow("<env_file>")} ${pc5.yellow("<vault>")} ${pc5.yellow("<item_name>")} ${pc5.dim("[options]")}
 
-${pc3.bold("Missing:")}
-${missing.map((arg) => `  ${pc3.red("•")} ${pc3.yellow(arg)}`).join(`
+${pc5.bold("Missing:")}
+${missing.map((arg) => `  ${pc5.red("•")} ${pc5.yellow(arg)}`).join(`
 `)}
 
-${pc3.bold("Example:")}
-  ${pc3.cyan("$")} env2op .env.production Personal "MyApp - Production"
+${pc5.bold("Example:")}
+  ${pc5.cyan("$")} env2op .env.production Personal "MyApp - Production"
 
-Run ${pc3.cyan("env2op --help")} for more information.
+Run ${pc5.cyan("env2op --help")} for more information.
 `);
 }