@tolgamorf/env2op-cli 0.2.0 → 0.2.2

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.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,16 +102,15 @@ var require_package = __commonJS((exports, module) => {
 });
 
 // src/op2env-cli.ts
-import pc3 from "picocolors";
+import pc5 from "picocolors";
 
 // src/commands/inject.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync, readFileSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { basename } 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 {
@@ -134,6 +133,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"
@@ -147,6 +147,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)
 };
 
@@ -194,12 +195,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 = [];
@@ -264,33 +273,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
       });
     });
@@ -306,27 +316,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
+      });
     });
   });
 }
@@ -446,7 +465,7 @@ async function editSecureNote(options) {
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw errors.itemCreateFailed(message);
+    throw errors.itemEditFailed(message);
   }
 }
 
@@ -607,12 +626,15 @@ ${pc2.bold(pc2.underline(title))}`);
   }
 };
 
-// src/commands/inject.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/inject.ts
 function deriveOutputPath(templatePath) {
   if (templatePath.endsWith(".tpl")) {
     return templatePath.slice(0, -4);
@@ -625,7 +647,7 @@ async function runInject(options) {
   const pkg2 = await Promise.resolve().then(() => __toESM(require_package(), 1));
   logger.intro("op2env", pkg2.version, dryRun);
   try {
-    if (!existsSync2(templateFile)) {
+    if (!existsSync(templateFile)) {
       throw new Env2OpError(`Template file not found: ${templateFile}`, "TEMPLATE_NOT_FOUND", "Ensure the file exists and the path is correct");
     }
     logger.success(`Found template: ${basename(templateFile)}`);
@@ -653,7 +675,7 @@ async function runInject(options) {
       }
       authSpinner.stop("1Password CLI ready");
     }
-    const outputExists = existsSync2(outputPath);
+    const outputExists = existsSync(outputPath);
     if (dryRun) {
       if (outputExists) {
         logger.warn(`Would overwrite: ${outputPath}`);
@@ -679,7 +701,7 @@ async function runInject(options) {
       if (result.exitCode !== 0) {
         throw new Error(result.stderr);
       }
-      const rawContent = readFileSync2(outputPath, "utf-8");
+      const rawContent = readFileSync(outputPath, "utf-8");
       const envContent = stripHeaders(rawContent);
       const header = generateEnvHeader(basename(outputPath)).join(`
 `);
@@ -711,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);
@@ -737,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);
@@ -753,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.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",