@tolgamorf/env2op-cli 0.2.1 → 0.2.3

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.1",
+    version: "0.2.3",
     description: "Convert .env files to 1Password Secure Notes and generate templates for op inject/run",
     type: "module",
     main: "dist/index.js",
@@ -102,14 +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 * as p2 from "@clack/prompts";
+import { basename, dirname, join as join2 } from "node:path";
+import * as p4 from "@clack/prompts";
 
-// src/core/env-parser.ts
-import { readFile } from "node:fs/promises";
+// src/core/auth.ts
+import * as p from "@clack/prompts";
 
 // src/utils/errors.ts
 class Env2OpError extends Error {
@@ -142,117 +142,17 @@ var errors = {
   envFileEmpty: (path) => new Env2OpError(`No valid environment variables found in ${path}`, ErrorCodes.ENV_FILE_EMPTY, "Ensure the file contains KEY=value pairs"),
   opCliNotInstalled: () => new Env2OpError("1Password CLI (op) is not installed", ErrorCodes.OP_CLI_NOT_INSTALLED, "Install it from https://1password.com/downloads/command-line/"),
   opNotSignedIn: () => new Env2OpError("Not signed in to 1Password CLI", ErrorCodes.OP_NOT_SIGNED_IN, 'Run "op signin" to authenticate'),
+  opSigninFailed: () => new Env2OpError("Failed to sign in to 1Password CLI", ErrorCodes.OP_SIGNIN_FAILED, 'Try running "op signin" manually'),
   vaultNotFound: (vault) => new Env2OpError(`Vault not found: ${vault}`, ErrorCodes.VAULT_NOT_FOUND, 'Run "op vault list" to see available vaults'),
   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)
+  parseError: (line, message) => new Env2OpError(`Parse error at line ${line}: ${message}`, ErrorCodes.PARSE_ERROR),
+  templateNotFound: (path) => new Env2OpError(`Template file not found: ${path}`, ErrorCodes.TEMPLATE_NOT_FOUND, "Ensure the file exists and the path is correct"),
+  injectFailed: (message) => new Env2OpError("Failed to pull secrets from 1Password", ErrorCodes.INJECT_FAILED, message)
 };
 
-// src/core/env-parser.ts
-var HEADER_SEPARATOR = "# ===========================================================================";
-function stripHeaders(content) {
-  const lines = content.split(`
-`);
-  const result = [];
-  let inHeader = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed === HEADER_SEPARATOR) {
-      if (!inHeader) {
-        inHeader = true;
-      } else {
-        inHeader = false;
-      }
-      continue;
-    }
-    if (!inHeader) {
-      result.push(line);
-    }
-  }
-  while (result.length > 0 && result[0]?.trim() === "") {
-    result.shift();
-  }
-  return result.join(`
-`);
-}
-function parseValue(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.startsWith('"')) {
-    const endQuote = trimmed.indexOf('"', 1);
-    if (endQuote !== -1) {
-      return trimmed.slice(1, endQuote);
-    }
-  }
-  if (trimmed.startsWith("'")) {
-    const endQuote = trimmed.indexOf("'", 1);
-    if (endQuote !== -1) {
-      return trimmed.slice(1, endQuote);
-    }
-  }
-  const parts = trimmed.split(/\s+#/);
-  return (parts[0] ?? trimmed).trim();
-}
-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 content = stripHeaders(stripBom(rawContent));
-  const rawLines = content.split(`
-`);
-  const variables = [];
-  const lines = [];
-  const parseErrors = [];
-  let currentComment = "";
-  for (let i = 0;i < rawLines.length; i++) {
-    const line = rawLines[i] ?? "";
-    const trimmed = line.trim();
-    const lineNumber = i + 1;
-    if (!trimmed) {
-      lines.push({ type: "empty" });
-      currentComment = "";
-      continue;
-    }
-    if (trimmed.startsWith("#")) {
-      lines.push({ type: "comment", content: line });
-      currentComment = trimmed.slice(1).trim();
-      continue;
-    }
-    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
-    if (match?.[1]) {
-      const key = match[1];
-      const rawValue = match[2] ?? "";
-      const value = parseValue(rawValue);
-      variables.push({
-        key,
-        value,
-        comment: currentComment || undefined,
-        line: lineNumber
-      });
-      lines.push({ type: "variable", key, value });
-      currentComment = "";
-    } else if (trimmed.includes("=")) {
-      parseErrors.push(`Line ${lineNumber}: Invalid variable name`);
-    }
-  }
-  return { variables, lines, errors: parseErrors };
-}
-function validateParseResult(result, filePath) {
-  if (result.variables.length === 0) {
-    throw errors.envFileEmpty(filePath);
-  }
-}
-
 // src/utils/shell.ts
 import { spawn } from "node:child_process";
 import pc from "picocolors";
@@ -262,16 +162,8 @@ function quoteArg(arg) {
   }
   return arg;
 }
-async function exec(command, args = [], options = {}) {
-  const { verbose = false } = options;
-  const fullCommand = `${command} ${args.map(quoteArg).join(" ")}`;
-  if (verbose) {
-    console.log(pc.dim(`$ ${fullCommand}`));
-  }
+function collectOutput(proc, verbose) {
   return new Promise((resolve) => {
-    const proc = spawn(command, args, {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
     const stdoutChunks = [];
     const stderrChunks = [];
     proc.stdout?.on("data", (data) => {
@@ -305,48 +197,29 @@ async function exec(command, args = [], options = {}) {
     });
   });
 }
+async function exec(command, args = [], options = {}) {
+  const { verbose = false } = options;
+  const fullCommand = `${command} ${args.map(quoteArg).join(" ")}`;
+  if (verbose) {
+    console.log(pc.dim(`$ ${fullCommand}`));
+  }
+  const proc = spawn(command, args, {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return collectOutput(proc, verbose);
+}
 async function execWithStdin(command, args = [], options) {
   const { stdin: stdinContent, verbose = false } = options;
   if (verbose) {
     const fullCommand = `${command} ${args.map(quoteArg).join(" ")}`;
     console.log(pc.dim(`$ echo '...' | ${fullCommand}`));
   }
-  return new Promise((resolve) => {
-    const proc = spawn(command, args, {
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    proc.stdin?.write(stdinContent);
-    proc.stdin?.end();
-    proc.stdout?.on("data", (data) => {
-      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 = Buffer.isBuffer(data) ? data.toString() : String(data);
-      stderrChunks.push(text);
-      if (verbose)
-        process.stderr.write(text);
-    });
-    proc.on("close", (code) => {
-      resolve({
-        stdout: stdoutChunks.join(""),
-        stderr: stderrChunks.join(""),
-        exitCode: code ?? 1
-      });
-    });
-    proc.on("error", (err) => {
-      stderrChunks.push(err.message);
-      resolve({
-        stdout: stdoutChunks.join(""),
-        stderr: stderrChunks.join(""),
-        exitCode: 1
-      });
-    });
+  const proc = spawn(command, args, {
+    stdio: ["pipe", "pipe", "pipe"]
   });
+  proc.stdin?.write(stdinContent);
+  proc.stdin?.end();
+  return collectOutput(proc, verbose);
 }
 
 // src/core/onepassword.ts
@@ -468,10 +341,332 @@ async function editSecureNote(options) {
   }
 }
 
+// src/core/auth.ts
+async function ensureOpAuthenticated(options) {
+  const { verbose } = options;
+  const authSpinner = p.spinner();
+  authSpinner.start("Checking 1Password CLI...");
+  const opInstalled = await checkOpCli({ verbose });
+  if (!opInstalled) {
+    authSpinner.stop("1Password CLI not found");
+    throw errors.opCliNotInstalled();
+  }
+  let signedIn = await checkSignedIn({ verbose });
+  if (!signedIn) {
+    authSpinner.message("Signing in to 1Password...");
+    const signInSuccess = await signIn({ verbose });
+    if (!signInSuccess) {
+      authSpinner.stop();
+      throw errors.opSigninFailed();
+    }
+    signedIn = await checkSignedIn({ verbose });
+    if (!signedIn) {
+      authSpinner.stop();
+      throw errors.opNotSignedIn();
+    }
+  }
+  authSpinner.stop("1Password CLI ready");
+}
+
+// src/core/env-parser.ts
+import { readFile } from "node:fs/promises";
+
+// src/core/constants.ts
+var HEADER_SEPARATOR = `# ${"=".repeat(75)}`;
+
+// src/core/env-parser.ts
+function stripHeaders(content) {
+  const lines = content.split(`
+`);
+  const result = [];
+  let inHeader = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === HEADER_SEPARATOR) {
+      if (!inHeader) {
+        inHeader = true;
+      } else {
+        inHeader = false;
+      }
+      continue;
+    }
+    if (!inHeader) {
+      result.push(line);
+    }
+  }
+  while (result.length > 0 && result[0]?.trim() === "") {
+    result.shift();
+  }
+  return result.join(`
+`);
+}
+function parseValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith('"')) {
+    const endQuote = trimmed.indexOf('"', 1);
+    if (endQuote !== -1) {
+      return trimmed.slice(1, endQuote);
+    }
+  }
+  if (trimmed.startsWith("'")) {
+    const endQuote = trimmed.indexOf("'", 1);
+    if (endQuote !== -1) {
+      return trimmed.slice(1, endQuote);
+    }
+  }
+  const parts = trimmed.split(/\s+#/);
+  return (parts[0] ?? trimmed).trim();
+}
+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 content = stripHeaders(stripBom(rawContent));
+  const rawLines = content.split(`
+`);
+  const variables = [];
+  const lines = [];
+  const parseErrors = [];
+  let currentComment = "";
+  for (let i = 0;i < rawLines.length; i++) {
+    const line = rawLines[i] ?? "";
+    const trimmed = line.trim();
+    const lineNumber = i + 1;
+    if (!trimmed) {
+      lines.push({ type: "empty" });
+      currentComment = "";
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      lines.push({ type: "comment", content: line });
+      currentComment = trimmed.slice(1).trim();
+      continue;
+    }
+    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (match?.[1]) {
+      const key = match[1];
+      const rawValue = match[2] ?? "";
+      const value = parseValue(rawValue);
+      variables.push({
+        key,
+        value,
+        comment: currentComment || undefined,
+        line: lineNumber
+      });
+      lines.push({ type: "variable", key, value });
+      currentComment = "";
+    } else if (trimmed.includes("=")) {
+      parseErrors.push(`Line ${lineNumber}: Invalid variable name`);
+    }
+  }
+  return { variables, lines, errors: parseErrors };
+}
+function validateParseResult(result, filePath) {
+  if (result.variables.length === 0) {
+    throw errors.envFileEmpty(filePath);
+  }
+}
+
+// src/core/template-generator.ts
+import { writeFileSync as writeFileSync2 } from "node:fs";
+
+// src/lib/update.ts
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// 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
+var CACHE_DIR = join(homedir(), ".env2op");
+var CACHE_FILE = join(CACHE_DIR, "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+function getCliVersion() {
+  try {
+    const pkg = require_package();
+    return pkg.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 });
+    }
+    writeFileSync(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 p2 = parts2[i] || 0;
+    if (p1 < p2)
+      return -1;
+    if (p1 > p2)
+      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);
+}
+async function maybeShowUpdateNotification(cliName, showNotification) {
+  try {
+    const result = await checkForUpdate();
+    if (result.updateAvailable && !result.isSkipped) {
+      showNotification(result, cliName);
+    }
+  } catch {}
+}
+
 // src/core/template-generator.ts
-var import__package = __toESM(require_package(), 1);
-import { writeFileSync } from "node:fs";
-var SEPARATOR = "# ===========================================================================";
 function deriveEnvFileName(templateFileName) {
   if (templateFileName.endsWith(".tpl")) {
     return templateFileName.slice(0, -4);
@@ -487,7 +682,7 @@ function formatTimestamp() {
 function generateTemplateHeader(templateFileName) {
   const envFileName = deriveEnvFileName(templateFileName);
   return [
-    SEPARATOR,
+    HEADER_SEPARATOR,
     `#  ${templateFileName} — 1Password Secret References`,
     "#",
     "#  This template contains references to secrets stored in 1Password.",
@@ -500,27 +695,27 @@ function generateTemplateHeader(templateFileName) {
     `#    op run --env-file ${templateFileName} -- npm start`,
     "#",
     `#  Pushed: ${formatTimestamp()}`,
-    `#  Generated by env2op v${import__package.default.version}`,
+    `#  Generated by env2op v${getCliVersion()}`,
     "#  https://github.com/tolgamorf/env2op-cli",
-    SEPARATOR,
+    HEADER_SEPARATOR,
     ""
   ];
 }
 function generateEnvHeader(envFileName) {
   const templateFileName = deriveTemplateFileName(envFileName);
   return [
-    SEPARATOR,
+    HEADER_SEPARATOR,
     `#  ${envFileName} — Environment Variables`,
     "#",
     "#  WARNING: This file contains sensitive values. Do not commit to git!",
     "#",
     `#  To push updates to 1Password and generate ${templateFileName}:`,
-    `#    env2op ${envFileName} <vault> "<item_name>"`,
+    `#    env2op ${envFileName} "<vault>" "<item_name>"`,
     "#",
     `#  Pulled: ${formatTimestamp()}`,
-    `#  Generated by op2env v${import__package.default.version}`,
+    `#  Generated by op2env v${getCliVersion()}`,
     "#  https://github.com/tolgamorf/env2op-cli",
-    SEPARATOR,
+    HEADER_SEPARATOR,
     "",
     ""
   ];
@@ -548,7 +743,7 @@ function generateTemplateContent(options, templateFileName) {
 `;
 }
 function writeTemplate(content, outputPath) {
-  writeFileSync(outputPath, content, "utf-8");
+  writeFileSync2(outputPath, content, "utf-8");
 }
 function generateUsageInstructions(templatePath) {
   return ["Usage:", `  op2env ${templatePath}`, `  op run --env-file ${templatePath} -- npm start`].join(`
@@ -556,7 +751,7 @@ function generateUsageInstructions(templatePath) {
 }
 
 // src/utils/logger.ts
-import * as p from "@clack/prompts";
+import * as p2 from "@clack/prompts";
 import pc2 from "picocolors";
 var symbols = {
   success: pc2.green("✓"),
@@ -569,29 +764,29 @@ var symbols = {
 var logger = {
   intro(name, version, dryRun = false) {
     const label = dryRun ? pc2.bgYellow(pc2.black(` ${name} v${version} [DRY RUN] `)) : pc2.bgCyan(pc2.black(` ${name} v${version} `));
-    p.intro(label);
+    p2.intro(label);
   },
   section(title) {
     console.log(`
 ${pc2.bold(pc2.underline(title))}`);
   },
   success(message) {
-    p.log.success(message);
+    p2.log.success(message);
   },
   error(message) {
-    p.log.error(message);
+    p2.log.error(message);
   },
   warn(message) {
-    p.log.warn(message);
+    p2.log.warn(message);
   },
   info(message) {
-    p.log.info(message);
+    p2.log.info(message);
   },
   step(message) {
-    p.log.step(message);
+    p2.log.step(message);
   },
   message(message) {
-    p.log.message(message);
+    p2.log.message(message);
   },
   keyValue(key, value, indent = 2) {
     console.log(`${" ".repeat(indent)}${pc2.dim(key)}: ${pc2.cyan(value)}`);
@@ -606,16 +801,16 @@ ${pc2.bold(pc2.underline(title))}`);
     console.log(`${pc2.yellow("[DRY RUN]")} ${message}`);
   },
   spinner() {
-    return p.spinner();
+    return p2.spinner();
   },
   outro(message) {
-    p.outro(pc2.green(message));
+    p2.outro(pc2.green(message));
   },
   cancel(message) {
-    p.cancel(message);
+    p2.cancel(message);
   },
   note(message, title) {
-    p.note(message, title);
+    p2.note(message, title);
   },
   formatFields(fields, max = 3) {
     if (fields.length <= max) {
@@ -625,6 +820,28 @@ ${pc2.bold(pc2.underline(title))}`);
   }
 };
 
+// src/utils/error-handler.ts
+function handleCommandError(error) {
+  if (error instanceof Env2OpError) {
+    logger.error(error.message);
+    if (error.suggestion) {
+      logger.info(`Suggestion: ${error.suggestion}`);
+    }
+    process.exit(1);
+  }
+  throw error;
+}
+
+// src/utils/prompts.ts
+import * as p3 from "@clack/prompts";
+async function confirmOrExit(message) {
+  const confirmed = await p3.confirm({ message });
+  if (p3.isCancel(confirmed) || !confirmed) {
+    logger.cancel("Operation cancelled");
+    process.exit(0);
+  }
+}
+
 // src/utils/timing.ts
 import { setTimeout } from "node:timers/promises";
 var MIN_SPINNER_TIME = 500;
@@ -636,8 +853,7 @@ async function withMinTime(promise, minTime = MIN_SPINNER_TIME) {
 // 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);
+  logger.intro("env2op", getCliVersion(), dryRun);
   try {
     const parseResult = await parseEnvFile(envFile);
     validateParseResult(parseResult, envFile);
@@ -662,29 +878,8 @@ async function runConvert(options) {
       logger.keyValue("Type", secret ? "password (hidden)" : "text (visible)");
       logger.keyValue("Fields", logger.formatFields(variables.map((v) => v.key)));
     } else {
-      const authSpinner = p2.spinner();
-      authSpinner.start("Checking 1Password CLI...");
-      const opInstalled = await checkOpCli({ verbose });
-      if (!opInstalled) {
-        authSpinner.stop("1Password CLI not found");
-        throw new Env2OpError("1Password CLI (op) is not installed", "OP_CLI_NOT_INSTALLED", "Install from https://1password.com/downloads/command-line/");
-      }
-      let signedIn = await checkSignedIn({ verbose });
-      if (!signedIn) {
-        authSpinner.message("Signing in to 1Password...");
-        const signInSuccess = await signIn({ verbose });
-        if (!signInSuccess) {
-          authSpinner.stop();
-          throw new Env2OpError("Failed to sign in to 1Password CLI", "OP_SIGNIN_FAILED", 'Try running "op signin" manually');
-        }
-        signedIn = await checkSignedIn({ verbose });
-        if (!signedIn) {
-          authSpinner.stop();
-          throw new Env2OpError("Not signed in to 1Password CLI", "OP_NOT_SIGNED_IN", 'Run "op signin" to authenticate');
-        }
-      }
-      authSpinner.stop("1Password CLI ready");
-      const vaultSpinner = p2.spinner();
+      await ensureOpAuthenticated({ verbose });
+      const vaultSpinner = p4.spinner();
       vaultSpinner.start(`Checking for vault "${vault}"...`);
       const vaultFound = await withMinTime(vaultExists(vault, { verbose }));
       if (vaultFound) {
@@ -696,38 +891,32 @@ async function runConvert(options) {
           vaultSpinner.stop(`Created vault "${vault}"`);
         } else {
           vaultSpinner.stop(`Vault "${vault}" not found`);
-          const shouldCreate = await p2.confirm({
+          const shouldCreate = await p4.confirm({
             message: `Vault "${vault}" does not exist. Create it?`
           });
-          if (p2.isCancel(shouldCreate) || !shouldCreate) {
+          if (p4.isCancel(shouldCreate) || !shouldCreate) {
             logger.cancel("Operation cancelled");
             logger.info('Run "op vault list" to see available vaults');
             process.exit(0);
           }
-          const createSpinner = p2.spinner();
+          const createSpinner = p4.spinner();
           createSpinner.start(`Creating vault "${vault}"...`);
           await createVault(vault, { verbose });
           createSpinner.stop(`Created vault "${vault}"`);
         }
       }
-      const itemSpinner = p2.spinner();
+      const itemSpinner = p4.spinner();
       itemSpinner.start(`Checking for item "${itemName}"...`);
       const existingItemId = await withMinTime(itemExists(vault, itemName, { verbose }));
       if (existingItemId) {
         itemSpinner.stop(`Item "${itemName}" found`);
         if (!force) {
-          const shouldOverwrite = await p2.confirm({
-            message: `Item "${itemName}" already exists in vault "${vault}". Update it?`
-          });
-          if (p2.isCancel(shouldOverwrite) || !shouldOverwrite) {
-            logger.cancel("Operation cancelled");
-            process.exit(0);
-          }
+          await confirmOrExit(`Item "${itemName}" already exists in vault "${vault}". Update it?`);
         }
       } else {
         itemSpinner.stop(`Item "${itemName}" not found`);
       }
-      const pushSpinner = p2.spinner();
+      const pushSpinner = p4.spinner();
       pushSpinner.start("Pushing environment variables...");
       try {
         if (existingItemId) {
@@ -754,7 +943,7 @@ async function runConvert(options) {
         throw error;
       }
     }
-    const templatePath = output ?? join(dirname(envFile), `${basename(envFile)}.tpl`);
+    const templatePath = output ?? join2(dirname(envFile), `${basename(envFile)}.tpl`);
     const templateFileName = basename(templatePath);
     if (dryRun) {
       logger.warn(`Would generate template: ${templatePath}`);
@@ -777,45 +966,143 @@ async function runConvert(options) {
       logger.outro("Done! Your secrets are now in 1Password");
     }
   } catch (error) {
-    if (error instanceof Env2OpError) {
-      logger.error(error.message);
-      if (error.suggestion) {
-        logger.info(`Suggestion: ${error.suggestion}`);
-      }
-      process.exit(1);
-    }
-    throw error;
+    handleCommandError(error);
   }
 }
 
-// src/cli.ts
-var pkg2 = await Promise.resolve().then(() => __toESM(require_package(), 1));
-var args = process.argv.slice(2);
-var flags = new Set;
-var positional = [];
-var options = {};
-for (let i = 0;i < args.length; i++) {
-  const arg = args[i];
-  if (arg === "-o" || arg === "--output") {
-    const next = args[i + 1];
-    if (next && !next.startsWith("-")) {
-      options.output = next;
-      i++;
+// src/commands/update.ts
+import * as p6 from "@clack/prompts";
+import pc4 from "picocolors";
+
+// src/lib/update-prompts.ts
+import * as p5 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 p5.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 (p5.isCancel(response)) {
+    return "later";
+  }
+  return response;
+}
+function showUpdateAvailable(result) {
+  p5.log.success(`Update available: ${pc3.dim(result.currentVersion)} ${pc3.dim("→")} ${pc3.green(result.latestVersion)}`);
+}
+function showUpToDate(currentVersion) {
+  p5.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) {
+  p5.log.success(`Updated to version ${pc3.green(newVersion)}`);
+  p5.log.info("Please restart to use the new version.");
+}
+function showUpdateError(error, pm) {
+  if (error) {
+    p5.log.error(pc3.dim(error));
+  }
+  p5.log.info(`Try running manually: ${pc3.cyan(pm.updateCommand)}`);
+}
+
+// src/commands/update.ts
+async function runUpdate(options) {
+  const { force = false, cliName = "env2op" } = options;
+  p6.intro(pc4.bgCyan(pc4.black(` ${cliName} update `)));
+  const spinner5 = p6.spinner();
+  spinner5.start("Checking for updates...");
+  const result = await checkForUpdate(true);
+  spinner5.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);
+      p6.log.info(`Skipped version ${result.latestVersion}`);
+      return;
     }
-  } else if (arg.startsWith("--")) {
-    flags.add(arg.slice(2));
-  } else if (arg.startsWith("-")) {
-    for (const char of arg.slice(1)) {
-      flags.add(char);
+    if (choice === "later") {
+      p6.log.info("Update postponed");
+      return;
     }
+  }
+  const updateSpinner = p6.spinner();
+  updateSpinner.start(`Updating to ${result.latestVersion}...`);
+  const updateResult = await performUpdate(pm);
+  if (updateResult.success) {
+    updateSpinner.stop("Update completed");
+    showUpdateSuccess(result.latestVersion);
   } else {
-    positional.push(arg);
+    updateSpinner.stop("Update failed");
+    showUpdateError(updateResult.error, pm);
+    process.exit(1);
   }
 }
+
+// src/utils/args.ts
+function parseArgs(args) {
+  const flags = new Set;
+  const positional = [];
+  const options = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-o" || arg === "--output") {
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        options.output = next;
+        i++;
+      }
+    } else if (arg.startsWith("--")) {
+      flags.add(arg.slice(2));
+    } else if (arg.startsWith("-")) {
+      for (const char of arg.slice(1)) {
+        flags.add(char);
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { flags, positional, options };
+}
+
+// src/cli.ts
+var pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
+var { flags, positional, options } = parseArgs(process.argv.slice(2));
 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);
+  console.log(getCliVersion());
+  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) {
@@ -837,48 +1124,50 @@ await runConvert({
   force: flags.has("f") || flags.has("force"),
   verbose: flags.has("verbose")
 });
+await maybeShowUpdateNotification("env2op", showUpdateNotification);
 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${getCliVersion()}`);
   console.log(`
 ${name} ${version}
-${pkg2.description}
+${pkg.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) {
@@ -890,17 +1179,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.
 `);
 }