@tolgamorf/env2op-cli 0.2.1 → 0.2.2

package/README.md

@@ -19,7 +19,7 @@ Or in a single command:
 brew install tolgamorf/tap/env2op-cli
 ```
 
-### Package Managers (All Operating Systems)
+### Package Managers (macOS/Linux/Windows)
 
 #### Global installation
 
@@ -97,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)
 
@@ -131,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.1",
+    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,7 +102,7 @@ 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";
@@ -788,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);
@@ -814,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);
@@ -837,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) {
@@ -890,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.
 `);
 }

package/dist/index.js

@@ -361,7 +361,7 @@ import { writeFileSync } from "node:fs";
 // package.json
 var package_default = {
   name: "@tolgamorf/env2op-cli",
-  version: "0.2.1",
+  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",

package/dist/op2env-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.2",
     description: "Convert .env files to 1Password Secure Notes and generate templates for op inject/run",
     type: "module",
     main: "dist/index.js",
@@ -102,7 +102,7 @@ var require_package = __commonJS((exports, module) => {
 });
 
 // src/op2env-cli.ts
-import pc3 from "picocolors";
+import pc5 from "picocolors";
 
 // src/commands/inject.ts
 import { existsSync, readFileSync, writeFileSync as writeFileSync2 } from "node:fs";
@@ -733,6 +733,274 @@ async function runInject(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 as existsSync2, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+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 pkg2 = require_package();
+    return pkg2.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function loadCache() {
+  try {
+    if (existsSync2(CACHE_FILE)) {
+      const content = readFileSync2(CACHE_FILE, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {}
+  return { lastCheck: 0, latestVersion: null };
+}
+function saveCache(cache) {
+  try {
+    if (!existsSync2(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    writeFileSync3(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/op2env-cli.ts
 var pkg2 = await Promise.resolve().then(() => __toESM(require_package(), 1));
 var args = process.argv.slice(2);
@@ -759,10 +1027,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: "op2env"
+  });
+  process.exit(0);
+}
 if (hasHelp || positional.length === 0) {
   showHelp();
   process.exit(0);
@@ -775,41 +1052,48 @@ await runInject({
   force: flags.has("f") || flags.has("force"),
   verbose: flags.has("verbose")
 });
+try {
+  const updateResult = await checkForUpdate();
+  if (updateResult.updateAvailable && !updateResult.isSkipped) {
+    showUpdateNotification(updateResult, "op2env");
+  }
+} catch {}
 function showHelp() {
-  const name = pc3.bold(pc3.cyan("op2env"));
-  const version = pc3.dim(`v${pkg2.version}`);
+  const name = pc5.bold(pc5.cyan("op2env"));
+  const version = pc5.dim(`v${pkg2.version}`);
   console.log(`
 ${name} ${version}
 Pull secrets from 1Password to generate .env files
 
-${pc3.bold("USAGE")}
-  ${pc3.cyan("$")} op2env ${pc3.yellow("<template_file>")} ${pc3.dim("[options]")}
+${pc5.bold("USAGE")}
+  ${pc5.cyan("$")} op2env ${pc5.yellow("<template_file>")} ${pc5.dim("[options]")}
 
-${pc3.bold("ARGUMENTS")}
-  ${pc3.yellow("template_file")}  Path to .env.tpl template file
+${pc5.bold("ARGUMENTS")}
+  ${pc5.yellow("template_file")}   Path to .env.tpl template file
 
-${pc3.bold("OPTIONS")}
-  ${pc3.cyan("-o, --output")}   Output .env path (default: template without .tpl)
-  ${pc3.cyan("-f, --force")}    Overwrite without prompting
-  ${pc3.cyan("--dry-run")}      Preview actions without executing
-  ${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 .env path (default: template without .tpl)
+  ${pc5.cyan("-f, --force")}     Overwrite without prompting
+  ${pc5.cyan("    --dry-run")}   Preview actions without executing
+  ${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 - generates .env from .env.tpl")}
-  ${pc3.cyan("$")} op2env .env.tpl
+${pc5.bold("EXAMPLES")}
+  ${pc5.dim("# Basic usage - generates .env from .env.tpl")}
+  ${pc5.cyan("$")} op2env .env.tpl
 
-  ${pc3.dim("# Custom output path")}
-  ${pc3.cyan("$")} op2env .env.tpl -o .env.local
+  ${pc5.dim("# Custom output path")}
+  ${pc5.cyan("$")} op2env .env.tpl -o .env.local
 
-  ${pc3.dim("# Preview without making changes")}
-  ${pc3.cyan("$")} op2env .env.tpl --dry-run
+  ${pc5.dim("# Preview without making changes")}
+  ${pc5.cyan("$")} op2env .env.tpl --dry-run
 
-  ${pc3.dim("# Overwrite existing .env without prompting")}
-  ${pc3.cyan("$")} op2env .env.tpl -f
+  ${pc5.dim("# Overwrite existing .env without prompting")}
+  ${pc5.cyan("$")} op2env .env.tpl -f
 
-${pc3.bold("DOCUMENTATION")}
-  ${pc3.dim("https://github.com/tolgamorf/env2op-cli")}
+${pc5.bold("DOCUMENTATION")}
+  ${pc5.dim("https://github.com/tolgamorf/env2op-cli")}
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tolgamorf/env2op-cli",
-  "version": "0.2.1",
+  "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",