@tolgamorf/env2op-cli 0.1.5 → 0.2.1

package/dist/op2env-cli.js

@@ -1,140 +1,161 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
 // package.json
-var require_package = __commonJS({
-  "package.json"(exports, module) {
-    module.exports = {
-      name: "@tolgamorf/env2op-cli",
-      version: "0.1.5",
-      description: "Convert .env files to 1Password Secure Notes and generate templates for op inject/run",
-      type: "module",
-      main: "dist/index.js",
-      module: "dist/index.js",
-      types: "dist/index.d.ts",
-      exports: {
-        ".": {
-          import: "./dist/index.js",
-          types: "./dist/index.d.ts"
-        }
-      },
-      bin: {
-        env2op: "dist/cli.js",
-        op2env: "dist/op2env-cli.js"
-      },
-      files: [
-        "dist",
-        "LICENSE",
-        "README.md"
-      ],
-      scripts: {
-        dev: "bun run src/cli.ts",
-        build: "tsup",
-        test: "bun test",
-        "test:watch": "bun test --watch",
-        "test:coverage": "bun test --coverage",
-        typecheck: "tsc --noEmit",
-        lint: "bunx biome check .",
-        "lint:fix": "bunx biome check . --write",
-        format: "bunx biome format --write .",
-        "format:check": "bunx biome format .",
-        prepublishOnly: "bun run build",
-        release: "bun run scripts/release.ts"
-      },
-      keywords: [
-        "env",
-        "1password",
-        "op",
-        "cli",
-        "secrets",
-        "environment-variables",
-        "dotenv",
-        "secure-notes",
-        "bun",
-        "op-inject",
-        "op-run",
-        "template"
-      ],
-      author: {
-        name: "Tolga O.",
-        url: "https://github.com/tolgamorf"
-      },
-      license: "MIT",
-      repository: {
-        type: "git",
-        url: "git+https://github.com/tolgamorf/env2op-cli.git"
-      },
-      bugs: {
-        url: "https://github.com/tolgamorf/env2op-cli/issues"
-      },
-      homepage: "https://github.com/tolgamorf/env2op-cli#readme",
-      engines: {
-        node: ">=18.0.0"
-      },
-      dependencies: {
-        "@clack/prompts": "^0.11.0",
-        picocolors: "^1.1.1"
-      },
-      devDependencies: {
-        "@biomejs/biome": "^2.3.10",
-        "@tsconfig/bun": "^1.0.10",
-        "@types/bun": "^1.3.5",
-        tsup: "^8.5.1",
-        typescript: "^5.9.3"
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "@tolgamorf/env2op-cli",
+    version: "0.2.1",
+    description: "Convert .env files to 1Password Secure Notes and generate templates for op inject/run",
+    type: "module",
+    main: "dist/index.js",
+    module: "dist/index.js",
+    types: "dist/index.d.ts",
+    exports: {
+      ".": {
+        import: "./dist/index.js",
+        types: "./dist/index.d.ts"
       }
-    };
-  }
+    },
+    bin: {
+      env2op: "dist/cli.js",
+      op2env: "dist/op2env-cli.js"
+    },
+    files: [
+      "dist",
+      "LICENSE",
+      "README.md"
+    ],
+    scripts: {
+      dev: "bun run src/cli.ts",
+      build: "bunup",
+      test: "bun test",
+      "test:watch": "bun test --watch",
+      "test:coverage": "bun test --coverage",
+      typecheck: "tsc --noEmit",
+      lint: "bunx biome check .",
+      "lint:fix": "bunx biome check . --write",
+      format: "bunx biome format --write .",
+      "format:check": "bunx biome format .",
+      prepublishOnly: "bun run build",
+      release: "bun run scripts/release.ts"
+    },
+    keywords: [
+      "env",
+      "1password",
+      "op",
+      "cli",
+      "secrets",
+      "environment-variables",
+      "dotenv",
+      "secure-notes",
+      "bun",
+      "op-inject",
+      "op-run",
+      "template"
+    ],
+    author: {
+      name: "Tolga O.",
+      url: "https://github.com/tolgamorf"
+    },
+    license: "MIT",
+    repository: {
+      type: "git",
+      url: "git+https://github.com/tolgamorf/env2op-cli.git"
+    },
+    bugs: {
+      url: "https://github.com/tolgamorf/env2op-cli/issues"
+    },
+    homepage: "https://github.com/tolgamorf/env2op-cli#readme",
+    engines: {
+      node: ">=18.0.0"
+    },
+    dependencies: {
+      "@clack/prompts": "^0.11.0",
+      picocolors: "^1.1.1"
+    },
+    devDependencies: {
+      "@biomejs/biome": "^2.3.10",
+      "@tsconfig/bun": "^1.0.10",
+      "@types/bun": "^1.3.5",
+      bunup: "^0.16.17",
+      typescript: "^5.9.3"
+    }
+  };
 });
 
 // src/op2env-cli.ts
-import pc2 from "picocolors";
+import pc3 from "picocolors";
 
 // src/commands/inject.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename } from "path";
+import { existsSync, readFileSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename } from "node:path";
 import * as p2 from "@clack/prompts";
 
 // src/core/env-parser.ts
-import { existsSync, readFileSync } from "fs";
+import { readFile } from "node:fs/promises";
 
 // src/utils/errors.ts
-var Env2OpError = class extends Error {
+class Env2OpError extends Error {
+  code;
+  suggestion;
   constructor(message, code, suggestion) {
     super(message);
     this.code = code;
     this.suggestion = suggestion;
     this.name = "Env2OpError";
   }
+}
+var ErrorCodes = {
+  ENV_FILE_NOT_FOUND: "ENV_FILE_NOT_FOUND",
+  ENV_FILE_EMPTY: "ENV_FILE_EMPTY",
+  OP_CLI_NOT_INSTALLED: "OP_CLI_NOT_INSTALLED",
+  OP_NOT_SIGNED_IN: "OP_NOT_SIGNED_IN",
+  OP_SIGNIN_FAILED: "OP_SIGNIN_FAILED",
+  VAULT_NOT_FOUND: "VAULT_NOT_FOUND",
+  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"
+};
+var errors = {
+  envFileNotFound: (path) => new Env2OpError(`File not found: ${path}`, ErrorCodes.ENV_FILE_NOT_FOUND, "Check that the file path is correct"),
+  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'),
+  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)
 };
 
 // src/core/env-parser.ts
 var HEADER_SEPARATOR = "# ===========================================================================";
 function stripHeaders(content) {
-  const lines = content.split("\n");
+  const lines = content.split(`
+`);
   const result = [];
   let inHeader = false;
   for (const line of lines) {
@@ -154,69 +175,343 @@ function stripHeaders(content) {
   while (result.length > 0 && result[0]?.trim() === "") {
     result.shift();
   }
-  return result.join("\n");
+  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 "child_process";
-async function exec(command, args2 = []) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(command, args2, {
-      shell: false,
-      stdio: ["pipe", "pipe", "pipe"]
+import { spawn } from "node:child_process";
+import pc from "picocolors";
+function quoteArg(arg) {
+  if (/[ [\]'"\\=]/.test(arg)) {
+    return `'${arg.replace(/'/g, "'\\''")}'`;
+  }
+  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}`));
+  }
+  return new Promise((resolve) => {
+    const proc = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    let stdout = "";
-    let stderr = "";
+    const stdoutChunks = [];
+    const stderrChunks = [];
     proc.stdout?.on("data", (data) => {
-      stdout += data.toString();
+      const text = Buffer.isBuffer(data) ? data.toString() : String(data);
+      stdoutChunks.push(text);
+      if (verbose) {
+        process.stdout.write(text);
+      }
     });
     proc.stderr?.on("data", (data) => {
-      stderr += data.toString();
+      const text = Buffer.isBuffer(data) ? data.toString() : String(data);
+      stderrChunks.push(text);
+      if (verbose) {
+        process.stderr.write(text);
+      }
     });
-    proc.on("error", (error) => {
-      reject(error);
+    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
+      });
+    });
+  });
+}
+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,
-        stderr,
-        exitCode: code ?? 0
+        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
       });
     });
   });
 }
-async function execQuiet(command, args2 = []) {
+
+// src/core/onepassword.ts
+async function checkOpCli(options = {}) {
+  const result = await exec("op", ["--version"], options);
+  return result.exitCode === 0;
+}
+async function checkSignedIn(options = {}) {
+  const result = await exec("op", ["whoami", "--format", "json"], options);
+  return result.exitCode === 0;
+}
+async function signIn(options = {}) {
+  const result = await exec("op", ["signin"], options);
+  return result.exitCode === 0;
+}
+async function itemExists(vault, title, options = {}) {
+  const result = await exec("op", ["item", "list", "--vault", vault, "--format", "json"], options);
+  if (result.exitCode !== 0) {
+    return null;
+  }
+  try {
+    const items = JSON.parse(result.stdout);
+    const item = items.find((item2) => item2.title === title);
+    return item?.id ?? null;
+  } catch {
+    return null;
+  }
+}
+async function vaultExists(vault, options = {}) {
+  const result = await exec("op", ["vault", "list", "--format", "json"], options);
+  if (result.exitCode !== 0) {
+    return false;
+  }
   try {
-    const result = await exec(command, args2);
-    return result.exitCode === 0;
+    const vaults = JSON.parse(result.stdout);
+    return vaults.some((v) => v.name === vault);
   } catch {
     return false;
   }
 }
-
-// src/core/onepassword.ts
-async function checkOpCli() {
-  return execQuiet("op", ["--version"]);
+async function createVault(name, options = {}) {
+  try {
+    await exec("op", ["vault", "create", name], options);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw errors.vaultCreateFailed(message);
+  }
 }
-async function checkSignedIn() {
-  return execQuiet("op", ["account", "get"]);
+function buildItemTemplate(title, vault, fields, secret) {
+  const fieldType = secret ? "CONCEALED" : "STRING";
+  return {
+    title,
+    vault: { name: vault },
+    category: "SECURE_NOTE",
+    fields: fields.map(({ key, value }) => ({
+      type: fieldType,
+      label: key,
+      value
+    }))
+  };
+}
+async function createSecureNote(options) {
+  const { vault, title, fields, secret, verbose } = options;
+  const template = buildItemTemplate(title, vault, fields, secret);
+  const json = JSON.stringify(template);
+  try {
+    const result = await execWithStdin("op", ["item", "create", "--format", "json"], { stdin: json, verbose });
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr || "Failed to create item");
+    }
+    const item = JSON.parse(result.stdout);
+    const fieldIds = {};
+    for (const field of item.fields ?? []) {
+      if (field.label && field.id) {
+        fieldIds[field.label] = field.id;
+      }
+    }
+    return {
+      id: item.id,
+      title: item.title,
+      vault: item.vault?.name ?? vault,
+      vaultId: item.vault?.id ?? "",
+      fieldIds
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw errors.itemCreateFailed(message);
+  }
+}
+async function editSecureNote(options) {
+  const { vault, title, fields, secret, verbose, itemId } = options;
+  const template = buildItemTemplate(title, vault, fields, secret);
+  const json = JSON.stringify(template);
+  try {
+    const result = await execWithStdin("op", ["item", "edit", itemId, "--format", "json"], {
+      stdin: json,
+      verbose
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr || "Failed to edit item");
+    }
+    const item = JSON.parse(result.stdout);
+    const fieldIds = {};
+    for (const field of item.fields ?? []) {
+      if (field.label && field.id) {
+        fieldIds[field.label] = field.id;
+      }
+    }
+    return {
+      id: item.id,
+      title: item.title,
+      vault: item.vault?.name ?? vault,
+      vaultId: item.vault?.id ?? "",
+      fieldIds
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw errors.itemEditFailed(message);
+  }
 }
 
 // src/core/template-generator.ts
-var import_package = __toESM(require_package(), 1);
-import { writeFileSync } from "fs";
+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);
+  }
+  return templateFileName;
+}
 function deriveTemplateFileName(envFileName) {
   return `${envFileName}.tpl`;
 }
 function formatTimestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, " UTC");
+  return new Date().toISOString().replace("T", " ").replace(/\.\d{3}Z$/, " UTC");
+}
+function generateTemplateHeader(templateFileName) {
+  const envFileName = deriveEnvFileName(templateFileName);
+  return [
+    SEPARATOR,
+    `#  ${templateFileName} — 1Password Secret References`,
+    "#",
+    "#  This template contains references to secrets stored in 1Password.",
+    "#  The actual values are not stored here — only secret references.",
+    "#",
+    `#  To generate ${envFileName} with real values:`,
+    `#    op2env ${templateFileName}`,
+    "#",
+    "#  To run a command with secrets injected:",
+    `#    op run --env-file ${templateFileName} -- npm start`,
+    "#",
+    `#  Pushed: ${formatTimestamp()}`,
+    `#  Generated by env2op v${import__package.default.version}`,
+    "#  https://github.com/tolgamorf/env2op-cli",
+    SEPARATOR,
+    ""
+  ];
 }
 function generateEnvHeader(envFileName) {
   const templateFileName = deriveTemplateFileName(envFileName);
   return [
     SEPARATOR,
-    `#  ${envFileName} \u2014 Environment Variables`,
+    `#  ${envFileName} — Environment Variables`,
     "#",
     "#  WARNING: This file contains sensitive values. Do not commit to git!",
     "#",
@@ -224,127 +519,105 @@ function generateEnvHeader(envFileName) {
     `#    env2op ${envFileName} <vault> "<item_name>"`,
     "#",
     `#  Pulled: ${formatTimestamp()}`,
-    `#  Generated by op2env v${import_package.default.version}`,
+    `#  Generated by op2env v${import__package.default.version}`,
     "#  https://github.com/tolgamorf/env2op-cli",
     SEPARATOR,
     "",
     ""
   ];
 }
+function generateTemplateContent(options, templateFileName) {
+  const { vaultId, itemId, lines: envLines, fieldIds } = options;
+  const outputLines = generateTemplateHeader(templateFileName);
+  for (const line of envLines) {
+    switch (line.type) {
+      case "empty":
+        outputLines.push("");
+        break;
+      case "comment":
+        outputLines.push(line.content);
+        break;
+      case "variable": {
+        const fieldId = fieldIds[line.key] ?? line.key;
+        outputLines.push(`${line.key}=op://${vaultId}/${itemId}/${fieldId}`);
+        break;
+      }
+    }
+  }
+  return `${outputLines.join(`
+`)}
+`;
+}
+function writeTemplate(content, outputPath) {
+  writeFileSync(outputPath, content, "utf-8");
+}
+function generateUsageInstructions(templatePath) {
+  return ["Usage:", `  op2env ${templatePath}`, `  op run --env-file ${templatePath} -- npm start`].join(`
+`);
+}
 
 // src/utils/logger.ts
 import * as p from "@clack/prompts";
-import pc from "picocolors";
+import pc2 from "picocolors";
 var symbols = {
-  success: pc.green("\u2713"),
-  error: pc.red("\u2717"),
-  warning: pc.yellow("\u26A0"),
-  info: pc.blue("\u2139"),
-  arrow: pc.cyan("\u2192"),
-  bullet: pc.dim("\u2022")
+  success: pc2.green("✓"),
+  error: pc2.red("✗"),
+  warning: pc2.yellow("⚠"),
+  info: pc2.blue("ℹ"),
+  arrow: pc2.cyan("→"),
+  bullet: pc2.dim("•")
 };
 var logger = {
-  /**
-   * Display CLI intro banner
-   */
   intro(name, version, dryRun = false) {
-    const label = dryRun ? pc.bgYellow(pc.black(` ${name} v${version} [DRY RUN] `)) : pc.bgCyan(pc.black(` ${name} v${version} `));
+    const label = dryRun ? pc2.bgYellow(pc2.black(` ${name} v${version} [DRY RUN] `)) : pc2.bgCyan(pc2.black(` ${name} v${version} `));
     p.intro(label);
   },
-  /**
-   * Display section header
-   */
   section(title) {
     console.log(`
-${pc.bold(pc.underline(title))}`);
+${pc2.bold(pc2.underline(title))}`);
   },
-  /**
-   * Success message
-   */
   success(message) {
     p.log.success(message);
   },
-  /**
-   * Error message
-   */
   error(message) {
     p.log.error(message);
   },
-  /**
-   * Warning message
-   */
   warn(message) {
     p.log.warn(message);
   },
-  /**
-   * Info message
-   */
   info(message) {
     p.log.info(message);
   },
-  /**
-   * Step in a process
-   */
   step(message) {
     p.log.step(message);
   },
-  /**
-   * Message (neutral)
-   */
   message(message) {
     p.log.message(message);
   },
-  /**
-   * Display key-value pair
-   */
   keyValue(key, value, indent = 2) {
-    console.log(`${" ".repeat(indent)}${pc.dim(key)}: ${pc.cyan(value)}`);
+    console.log(`${" ".repeat(indent)}${pc2.dim(key)}: ${pc2.cyan(value)}`);
   },
-  /**
-   * Display list item
-   */
   listItem(item, indent = 2) {
     console.log(`${" ".repeat(indent)}${symbols.bullet} ${item}`);
   },
-  /**
-   * Display arrow item
-   */
   arrowItem(item, indent = 2) {
     console.log(`${" ".repeat(indent)}${symbols.arrow} ${item}`);
   },
-  /**
-   * Display dry run indicator
-   */
   dryRun(message) {
-    console.log(`${pc.yellow("[DRY RUN]")} ${message}`);
+    console.log(`${pc2.yellow("[DRY RUN]")} ${message}`);
   },
-  /**
-   * Create a spinner for async operations
-   */
   spinner() {
     return p.spinner();
   },
-  /**
-   * Display outro message
-   */
   outro(message) {
-    p.outro(pc.green(message));
+    p.outro(pc2.green(message));
   },
-  /**
-   * Display cancellation message
-   */
   cancel(message) {
     p.cancel(message);
   },
-  /**
-   * Display a note block
-   */
   note(message, title) {
     p.note(message, title);
   },
-  /**
-   * Format a field list for display
-   */
   formatFields(fields, max = 3) {
     if (fields.length <= max) {
       return fields.join(", ");
@@ -353,6 +626,14 @@ ${pc.bold(pc.underline(title))}`);
   }
 };
 
+// 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")) {
@@ -360,39 +641,41 @@ function deriveOutputPath(templatePath) {
   }
   return `${templatePath}.env`;
 }
-async function runInject(options2) {
-  const { templateFile: templateFile2, output, dryRun, force } = options2;
-  const outputPath = output ?? deriveOutputPath(templateFile2);
-  const pkg3 = await Promise.resolve().then(() => __toESM(require_package(), 1));
-  logger.intro("op2env", pkg3.version, dryRun);
+async function runInject(options) {
+  const { templateFile, output, dryRun, force, verbose } = options;
+  const outputPath = output ?? deriveOutputPath(templateFile);
+  const pkg2 = await Promise.resolve().then(() => __toESM(require_package(), 1));
+  logger.intro("op2env", pkg2.version, dryRun);
   try {
-    if (!existsSync2(templateFile2)) {
-      throw new Env2OpError(
-        `Template file not found: ${templateFile2}`,
-        "TEMPLATE_NOT_FOUND",
-        "Ensure the file exists and the path is correct"
-      );
+    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(templateFile2)}`);
+    logger.success(`Found template: ${basename(templateFile)}`);
     if (!dryRun) {
-      const opInstalled = await checkOpCli();
+      const authSpinner = p2.spinner();
+      authSpinner.start("Checking 1Password CLI...");
+      const opInstalled = await checkOpCli({ verbose });
       if (!opInstalled) {
-        throw new Env2OpError(
-          "1Password CLI (op) is not installed",
-          "OP_CLI_NOT_INSTALLED",
-          "Install from https://1password.com/downloads/command-line/"
-        );
+        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/");
       }
-      const signedIn = await checkSignedIn();
+      let signedIn = await checkSignedIn({ verbose });
       if (!signedIn) {
-        throw new Env2OpError(
-          "Not signed in to 1Password CLI",
-          "OP_NOT_SIGNED_IN",
-          'Run "op signin" to authenticate'
-        );
+        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 outputExists = existsSync2(outputPath);
+    const outputExists = existsSync(outputPath);
     if (dryRun) {
       if (outputExists) {
         logger.warn(`Would overwrite: ${outputPath}`);
@@ -411,23 +694,31 @@ async function runInject(options2) {
         process.exit(0);
       }
     }
-    const spinner2 = logger.spinner();
-    spinner2.start("Injecting secrets from 1Password...");
+    const spinner3 = verbose ? null : logger.spinner();
+    spinner3?.start("Pulling secrets from 1Password...");
     try {
-      const result = await exec("op", ["inject", "-i", templateFile2, "-o", outputPath, "-f"]);
+      const result = await withMinTime(exec("op", ["inject", "-i", templateFile, "-o", outputPath, "-f"], { verbose }));
       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("\n");
+      const header = generateEnvHeader(basename(outputPath)).join(`
+`);
       writeFileSync2(outputPath, header + envContent, "utf-8");
-      spinner2.stop(`Generated: ${outputPath}`);
+      const varCount = envContent.split(`
+`).filter((line) => line.trim() && !line.trim().startsWith("#")).length;
+      const stopMessage = `Generated ${basename(outputPath)} — ${varCount} variable${varCount === 1 ? "" : "s"}`;
+      if (spinner3) {
+        spinner3.stop(stopMessage);
+      } else {
+        logger.success(stopMessage);
+      }
     } catch (error) {
-      spinner2.stop("Failed to inject secrets");
+      spinner3?.stop("Failed to pull secrets");
       const stderr = error?.stderr;
       const message = stderr || (error instanceof Error ? error.message : String(error));
-      throw new Env2OpError("Failed to inject secrets from 1Password", "INJECT_FAILED", message);
+      throw new Env2OpError("Failed to pull secrets from 1Password", "INJECT_FAILED", message);
     }
     logger.outro("Done! Your .env file is ready");
   } catch (error) {
@@ -445,10 +736,10 @@ async function runInject(options2) {
 // src/op2env-cli.ts
 var pkg2 = await Promise.resolve().then(() => __toESM(require_package(), 1));
 var args = process.argv.slice(2);
-var flags = /* @__PURE__ */ new Set();
+var flags = new Set;
 var positional = [];
 var options = {};
-for (let i = 0; i < args.length; i++) {
+for (let i = 0;i < args.length; i++) {
   const arg = args[i];
   if (arg === "-o" || arg === "--output") {
     const next = args[i + 1];
@@ -481,42 +772,44 @@ await runInject({
   templateFile,
   output: options.output,
   dryRun: flags.has("dry-run"),
-  force: flags.has("f") || flags.has("force")
+  force: flags.has("f") || flags.has("force"),
+  verbose: flags.has("verbose")
 });
 function showHelp() {
-  const name = pc2.bold(pc2.cyan("op2env"));
-  const version = pc2.dim(`v${pkg2.version}`);
+  const name = pc3.bold(pc3.cyan("op2env"));
+  const version = pc3.dim(`v${pkg2.version}`);
   console.log(`
 ${name} ${version}
 Pull secrets from 1Password to generate .env files
 
-${pc2.bold("USAGE")}
-  ${pc2.cyan("$")} op2env ${pc2.yellow("<template_file>")} ${pc2.dim("[options]")}
+${pc3.bold("USAGE")}
+  ${pc3.cyan("$")} op2env ${pc3.yellow("<template_file>")} ${pc3.dim("[options]")}
 
-${pc2.bold("ARGUMENTS")}
-  ${pc2.yellow("template_file")}  Path to .env.tpl template file
+${pc3.bold("ARGUMENTS")}
+  ${pc3.yellow("template_file")}  Path to .env.tpl template file
 
-${pc2.bold("OPTIONS")}
-  ${pc2.cyan("-o, --output")}   Output .env path (default: template without .tpl)
-  ${pc2.cyan("-f, --force")}    Overwrite without prompting
-  ${pc2.cyan("--dry-run")}      Preview actions without executing
-  ${pc2.cyan("-h, --help")}     Show this help message
-  ${pc2.cyan("-v, --version")}  Show version
+${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
 
-${pc2.bold("EXAMPLES")}
-  ${pc2.dim("# Basic usage - generates .env from .env.tpl")}
-  ${pc2.cyan("$")} op2env .env.tpl
+${pc3.bold("EXAMPLES")}
+  ${pc3.dim("# Basic usage - generates .env from .env.tpl")}
+  ${pc3.cyan("$")} op2env .env.tpl
 
-  ${pc2.dim("# Custom output path")}
-  ${pc2.cyan("$")} op2env .env.tpl -o .env.local
+  ${pc3.dim("# Custom output path")}
+  ${pc3.cyan("$")} op2env .env.tpl -o .env.local
 
-  ${pc2.dim("# Preview without making changes")}
-  ${pc2.cyan("$")} op2env .env.tpl --dry-run
+  ${pc3.dim("# Preview without making changes")}
+  ${pc3.cyan("$")} op2env .env.tpl --dry-run
 
-  ${pc2.dim("# Overwrite existing .env without prompting")}
-  ${pc2.cyan("$")} op2env .env.tpl -f
+  ${pc3.dim("# Overwrite existing .env without prompting")}
+  ${pc3.cyan("$")} op2env .env.tpl -f
 
-${pc2.bold("DOCUMENTATION")}
-  ${pc2.dim("https://github.com/tolgamorf/env2op-cli")}
+${pc3.bold("DOCUMENTATION")}
+  ${pc3.dim("https://github.com/tolgamorf/env2op-cli")}
 `);
 }