dotenvx-ui 0.1.0

package/dist/cli.js

@@ -0,0 +1,1295 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import { render } from "ink";
+
+// src/core/scanner.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join, relative, basename, dirname } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".next",
+  ".turbo",
+  "build",
+  ".cache"
+]);
+function detectRoot(cwd) {
+  let dir = cwd;
+  while (true) {
+    try {
+      statSync(join(dir, ".git"));
+      return dir;
+    } catch {
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return cwd;
+}
+function scanForEnvFiles(root) {
+  const results = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry)) continue;
+      const full = join(dir, entry);
+      try {
+        const stat = statSync(full);
+        if (stat.isDirectory()) {
+          walk(full);
+        } else if (isEnvFile(entry)) {
+          results.push(full);
+        }
+      } catch {
+      }
+    }
+  }
+  walk(root);
+  return results;
+}
+function isEnvFile(name) {
+  if (name === ".env.keys") return false;
+  return name === ".env" || name.startsWith(".env.");
+}
+function parseEnvironmentFromFilename(filename) {
+  const name = basename(filename);
+  if (name === ".env") return "default";
+  const suffix = name.slice(".env.".length);
+  return suffix || "default";
+}
+function scan(cwd) {
+  const root = detectRoot(cwd);
+  const paths = scanForEnvFiles(root);
+  return paths.map((filePath) => {
+    const rel = relative(root, filePath);
+    const pkg = relative(root, dirname(filePath)) || ".";
+    const environment = parseEnvironmentFromFilename(basename(filePath));
+    let content = "";
+    try {
+      content = readFileSync(filePath, "utf8");
+    } catch {
+    }
+    const hasPublicKey = content.includes("DOTENV_PUBLIC_KEY=");
+    const encrypted = /encrypted:/.test(content);
+    return {
+      path: filePath,
+      relativePath: rel,
+      package: pkg,
+      environment,
+      encrypted,
+      hasPublicKey,
+      keys: []
+    };
+  });
+}
+
+// src/tui/App.tsx
+import { useState as useState3 } from "react";
+import { Box as Box7, Text as Text7, useApp, useInput as useInput6, useStdin as useStdin6 } from "ink";
+import clipboard from "clipboardy";
+
+// src/tui/FileList.tsx
+import { Box, Text, useInput, useStdin } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function FileList({ files, selectedIndex, focused, onSelect }) {
+  const { isRawModeSupported } = useStdin();
+  useInput((_, key) => {
+    if (!focused) return;
+    if (key.upArrow) onSelect(Math.max(0, selectedIndex - 1));
+    if (key.downArrow) onSelect(Math.min(files.length - 1, selectedIndex + 1));
+  }, { isActive: isRawModeSupported });
+  const byPkg = Map.groupBy(files, (f) => f.package);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: 24, borderStyle: "single", borderRight: true, borderTop: false, borderBottom: false, borderLeft: false, children: Array.from(byPkg.entries()).map(([pkg, pkgFiles]) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, dimColor: true, children: [
+      " ",
+      pkg
+    ] }),
+    pkgFiles.map((f) => {
+      const idx = files.indexOf(f);
+      const selected = idx === selectedIndex;
+      return /* @__PURE__ */ jsx(Box, { paddingLeft: 2, children: /* @__PURE__ */ jsxs(
+        Text,
+        {
+          backgroundColor: selected && focused ? "blue" : void 0,
+          color: selected && focused ? "white" : selected ? "cyan" : void 0,
+          children: [
+            f.encrypted ? "\u{1F512} " : "   ",
+            f.environment
+          ]
+        }
+      ) }, f.path);
+    })
+  ] }, pkg)) });
+}
+
+// src/tui/KeyTable.tsx
+import { Box as Box2, Text as Text2, useInput as useInput2, useStdin as useStdin2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var SECRET_PATTERN = /secret|password|token|key|private|api_?key/i;
+function maskValue(k, revealed) {
+  if (revealed.has(k.key)) return revealed.get(k.key);
+  if (k.encrypted) return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+  if (SECRET_PATTERN.test(k.key)) return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+  return k.value.length > 48 ? k.value.slice(0, 48) + "\u2026" : k.value;
+}
+function KeyTable({ file, keys, selectedIndex, focused, revealed, onSelect }) {
+  const { isRawModeSupported } = useStdin2();
+  useInput2((_, key) => {
+    if (!focused) return;
+    if (key.upArrow) onSelect(Math.max(0, selectedIndex - 1));
+    if (key.downArrow) onSelect(Math.min(keys.length - 1, selectedIndex + 1));
+  }, { isActive: isRawModeSupported });
+  const encBadge = file.encrypted ? /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: " encrypted" }) : /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " plain" });
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs2(Box2, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: file.relativePath }),
+      encBadge,
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "  ",
+        keys.length,
+        " key",
+        keys.length === 1 ? "" : "s"
+      ] })
+    ] }),
+    keys.length === 0 ? /* @__PURE__ */ jsx2(Box2, { paddingX: 2, marginTop: 1, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "No keys found. Press ",
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: "a" }),
+      " to add one."
+    ] }) }) : keys.map((k, idx) => {
+      const selected = idx === selectedIndex;
+      const value = maskValue(k, revealed);
+      const lockIcon = k.encrypted && !revealed.has(k.key) ? " \u{1F512}" : "";
+      return /* @__PURE__ */ jsx2(Box2, { paddingX: 1, children: /* @__PURE__ */ jsxs2(
+        Text2,
+        {
+          backgroundColor: selected && focused ? "blue" : void 0,
+          color: selected && focused ? "white" : selected ? "cyan" : void 0,
+          children: [
+            k.key.padEnd(24),
+            /* @__PURE__ */ jsx2(Text2, { dimColor: !selected, children: value }),
+            lockIcon
+          ]
+        }
+      ) }, k.key);
+    })
+  ] });
+}
+
+// src/tui/StatusBar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var FILE_HINTS = "\u2191\u2193 navigate  tab switch panel  ? help  q quit";
+var KEY_HINTS = "\u2191\u2193 navigate  tab switch  enter edit  y copy  r reveal  a add  D del  d diff  ? help  q quit";
+function StatusBar({ message, focus }) {
+  return /* @__PURE__ */ jsx3(Box3, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, paddingX: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: message ?? (focus === "files" ? FILE_HINTS : KEY_HINTS) }) });
+}
+
+// src/tui/DiffView.tsx
+import { useState } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput3, useStdin as useStdin3 } from "ink";
+
+// src/core/parser/io.ts
+import { readFileSync as readFileSync2, writeFileSync, renameSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { randomBytes } from "crypto";
+
+// src/core/parser/values.ts
+function isEncryptedValue(value) {
+  return value.startsWith("encrypted:");
+}
+function parseValue(rawValue, allLines, nextLineIdx) {
+  const trimmed = rawValue.trim();
+  if (trimmed.startsWith('"')) {
+    const inner = trimmed.slice(1);
+    const closeIdx = findClosingQuote(inner);
+    if (closeIdx !== -1) {
+      return { value: unescape(inner.slice(0, closeIdx)), extraLines: [] };
+    }
+    const valueLines = [inner];
+    let idx = nextLineIdx;
+    while (idx < allLines.length) {
+      const continuation = allLines[idx];
+      const close = findClosingQuote(continuation);
+      if (close !== -1) {
+        valueLines.push(continuation.slice(0, close));
+        return {
+          value: valueLines.join("\n"),
+          extraLines: allLines.slice(nextLineIdx, idx + 1)
+        };
+      }
+      valueLines.push(continuation);
+      idx++;
+    }
+    return { value: valueLines.join("\n"), extraLines: allLines.slice(nextLineIdx, idx) };
+  }
+  if (trimmed.startsWith("'")) {
+    const inner = trimmed.slice(1);
+    const closeIdx = inner.indexOf("'");
+    return {
+      value: closeIdx !== -1 ? inner.slice(0, closeIdx) : inner,
+      extraLines: []
+    };
+  }
+  const commentIdx = trimmed.indexOf(" #");
+  const bare = commentIdx !== -1 ? trimmed.slice(0, commentIdx) : trimmed;
+  return { value: bare, extraLines: [] };
+}
+function serializeKeyValue(key, value) {
+  if (value.includes("\n")) {
+    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/\r/g, "\\r");
+    return `${key}="${escaped}"`;
+  }
+  if (value === "" || /[\s#"'`]/.test(value)) {
+    return `${key}="${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return `${key}=${value}`;
+}
+function findClosingQuote(s) {
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (s[i] === '"') return i;
+  }
+  return -1;
+}
+function unescape(s) {
+  return s.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r").replace(/\\\\/g, "\\").replace(/\\"/g, '"');
+}
+
+// src/core/parser/io.ts
+function readEnvFile(filePath) {
+  const content = readFileSync2(filePath, "utf8");
+  return parse(content).filter((e) => e.type === "key").map((e) => ({
+    key: e.key,
+    value: e.value,
+    encrypted: isEncryptedValue(e.value),
+    comment: extractLeadingComment(e.lines)
+  }));
+}
+function writeEnvFile(filePath, keys) {
+  const content = readFileSync2(filePath, "utf8");
+  const entries = parse(content);
+  const updates = new Map(keys.map((k) => [k.key, k]));
+  const outLines = [];
+  const written = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.type === "raw") {
+      outLines.push(entry.text);
+      continue;
+    }
+    const update = updates.get(entry.key);
+    if (!update) continue;
+    written.add(entry.key);
+    const leadingComments = getLeadingCommentLines(entry.lines);
+    outLines.push(...leadingComments);
+    if (update.value === entry.value) {
+      const keyLines = entry.lines.filter((l) => !l.trimStart().startsWith("#"));
+      outLines.push(...keyLines);
+    } else {
+      outLines.push(serializeKeyValue(entry.key, update.value));
+    }
+  }
+  for (const k of keys) {
+    if (!written.has(k.key)) {
+      if (k.comment) outLines.push(`# ${k.comment}`);
+      outLines.push(serializeKeyValue(k.key, k.value));
+    }
+  }
+  const output = outLines.join("\n") + (content.endsWith("\n") ? "\n" : "");
+  atomicWrite(filePath, output);
+}
+function addKey(filePath, key, value) {
+  const keys = readEnvFile(filePath);
+  if (keys.some((k) => k.key === key)) {
+    throw new Error(`Key "${key}" already exists in ${filePath}`);
+  }
+  keys.push({ key, value, encrypted: isEncryptedValue(value) });
+  writeEnvFile(filePath, keys);
+}
+function updateKey(filePath, key, value) {
+  const keys = readEnvFile(filePath);
+  const idx = keys.findIndex((k) => k.key === key);
+  if (idx === -1) throw new Error(`Key "${key}" not found in ${filePath}`);
+  keys[idx] = { ...keys[idx], key, value, encrypted: isEncryptedValue(value) };
+  writeEnvFile(filePath, keys);
+}
+function removeKey(filePath, key) {
+  const keys = readEnvFile(filePath).filter((k) => k.key !== key);
+  writeEnvFile(filePath, keys);
+}
+function parse(content) {
+  const entries = [];
+  const lines = content.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  let i = 0;
+  let pendingComments = [];
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      for (const c of pendingComments) entries.push({ type: "raw", text: c });
+      pendingComments = [];
+      entries.push({ type: "raw", text: line });
+      i++;
+      continue;
+    }
+    if (line.trimStart().startsWith("#")) {
+      pendingComments.push(line);
+      i++;
+      continue;
+    }
+    const eqIdx = line.indexOf("=");
+    if (eqIdx === -1) {
+      for (const c of pendingComments) entries.push({ type: "raw", text: c });
+      pendingComments = [];
+      entries.push({ type: "raw", text: line });
+      i++;
+      continue;
+    }
+    const key = line.slice(0, eqIdx).trim();
+    const rawValue = line.slice(eqIdx + 1);
+    const { value, extraLines } = parseValue(rawValue, lines, i + 1);
+    entries.push({ type: "key", key, value, lines: [...pendingComments, line, ...extraLines] });
+    pendingComments = [];
+    i += 1 + extraLines.length;
+  }
+  for (const c of pendingComments) entries.push({ type: "raw", text: c });
+  return entries;
+}
+function getLeadingCommentLines(lines) {
+  const result = [];
+  for (const l of lines) {
+    if (l.trimStart().startsWith("#")) result.push(l);
+    else break;
+  }
+  return result;
+}
+function extractLeadingComment(lines) {
+  const comments = getLeadingCommentLines(lines).map(
+    (l) => l.trimStart().slice(1).trim()
+  );
+  return comments.length > 0 ? comments.join("\n") : void 0;
+}
+function atomicWrite(filePath, content) {
+  const tmp = join2(
+    dirname2(filePath),
+    `.dotenvx-ui-tmp-${randomBytes(6).toString("hex")}`
+  );
+  try {
+    writeFileSync(tmp, content, { encoding: "utf8", flag: "wx" });
+    renameSync(tmp, filePath);
+  } catch (err) {
+    try {
+      writeFileSync(tmp, "");
+    } catch {
+    }
+    throw new Error(`Failed to write ${filePath}: ${err.message}`);
+  }
+}
+
+// src/core/dotenvx.ts
+import { createRequire } from "module";
+import { existsSync, readFileSync as readFileSync3 } from "fs";
+import { join as join3, dirname as dirname3 } from "path";
+var dotenvx = createRequire(import.meta.url)("@dotenvx/dotenvx");
+function decryptValue(encryptedValue, envFilePath) {
+  if (!isEncryptedValue(encryptedValue)) return encryptedValue;
+  const keyName = findKeyForValue(encryptedValue, envFilePath);
+  if (!keyName) return null;
+  const keysFile = findKeysFile(envFilePath);
+  try {
+    const result = dotenvx.get(keyName, {
+      path: envFilePath,
+      ...keysFile ? { envKeysFile: keysFile } : {},
+      logLevel: "error"
+    });
+    return result ?? null;
+  } catch {
+    return null;
+  }
+}
+var DOTENVX_INTERNAL_KEYS = /* @__PURE__ */ new Set(["DOTENV_PUBLIC_KEY", "DOTENV_PRIVATE_KEY"]);
+function encryptFile(envFilePath) {
+  const keys = readEnvFile(envFilePath);
+  for (const k of keys) {
+    if (!isEncryptedValue(k.value) && !DOTENVX_INTERNAL_KEYS.has(k.key)) {
+      dotenvx.set(k.key, k.value, {
+        path: envFilePath,
+        encrypt: true,
+        logLevel: "error"
+      });
+    }
+  }
+}
+function encryptKey(envFilePath, keyName, plainValue) {
+  dotenvx.set(keyName, plainValue, {
+    path: envFilePath,
+    encrypt: true,
+    logLevel: "error"
+  });
+}
+function decryptFile(envFilePath) {
+  const keys = readEnvFile(envFilePath);
+  for (const k of keys) {
+    if (isEncryptedValue(k.value)) {
+      const plain = decryptValue(k.value, envFilePath);
+      if (plain !== null) updateKey(envFilePath, k.key, plain);
+    }
+  }
+}
+function findKeysFile(envFilePath) {
+  let dir = dirname3(envFilePath);
+  while (true) {
+    const candidate = join3(dir, ".env.keys");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function findKeyForValue(encryptedValue, envFilePath) {
+  let raw;
+  try {
+    raw = readFileSync3(envFilePath, "utf8");
+  } catch {
+    return null;
+  }
+  for (const line of raw.split("\n")) {
+    const eqIdx = line.indexOf("=");
+    if (eqIdx === -1) continue;
+    const lineValue = line.slice(eqIdx + 1).trim();
+    if (lineValue === encryptedValue) return line.slice(0, eqIdx).trim();
+  }
+  return null;
+}
+
+// src/tui/DiffView.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var COL_VAL = 26;
+function buildDisplayMap(keys, filePath) {
+  const out = /* @__PURE__ */ new Map();
+  for (const k of keys) {
+    if (k.encrypted) {
+      const plain = decryptValue(k.value, filePath);
+      out.set(k.key, plain !== null ? plain : "\u{1F512}");
+    } else {
+      out.set(k.key, k.value);
+    }
+  }
+  return out;
+}
+function buildRows(leftMap, rightMap) {
+  const allKeys = Array.from(/* @__PURE__ */ new Set([...leftMap.keys(), ...rightMap.keys()]));
+  return allKeys.map((key) => {
+    const l = leftMap.get(key) ?? null;
+    const r = rightMap.get(key) ?? null;
+    let status;
+    if (l === null) status = "right-only";
+    else if (r === null) status = "left-only";
+    else if (l === r) status = "same";
+    else status = "diff";
+    return {
+      key,
+      leftDisplay: l !== null ? trunc(l, COL_VAL) : "",
+      rightDisplay: r !== null ? trunc(r, COL_VAL) : "",
+      status
+    };
+  });
+}
+function trunc(s, max) {
+  const first = s.split("\n")[0];
+  return first.length > max ? first.slice(0, max - 1) + "\u2026" : first;
+}
+function safeRead(file) {
+  try {
+    return readEnvFile(file.path);
+  } catch {
+    return [];
+  }
+}
+function DiffView({ left, files, onClose }) {
+  const { isRawModeSupported } = useStdin3();
+  const others = files.filter((f) => f.path !== left.path);
+  const [pickerIndex, setPickerIndex] = useState(0);
+  const rightFile = others[pickerIndex] ?? null;
+  const leftKeys = safeRead(left);
+  const rightKeys = rightFile ? safeRead(rightFile) : [];
+  const leftMap = buildDisplayMap(leftKeys, left.path);
+  const rightMap = rightFile ? buildDisplayMap(rightKeys, rightFile.path) : /* @__PURE__ */ new Map();
+  const rows = rightFile ? buildRows(leftMap, rightMap) : [];
+  useInput3((input, key) => {
+    if (key.escape || input === "q") {
+      onClose();
+      return;
+    }
+    if (key.upArrow) setPickerIndex((i) => Math.max(0, i - 1));
+    if (key.downArrow) setPickerIndex((i) => Math.min(others.length - 1, i + 1));
+  }, { isActive: isRawModeSupported });
+  const leftName = trunc(left.relativePath, COL_VAL);
+  const rightName = rightFile ? trunc(rightFile.relativePath, COL_VAL) : "\u2014";
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Box4, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "dotenvx-ui  " }),
+      /* @__PURE__ */ jsxs3(Text4, { dimColor: true, children: [
+        "diff  ",
+        left.relativePath,
+        "  \u2194  ",
+        rightFile?.relativePath ?? "\u2014"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3(
+      Box4,
+      {
+        flexDirection: "column",
+        paddingX: 1,
+        borderStyle: "single",
+        borderBottom: true,
+        borderTop: false,
+        borderLeft: false,
+        borderRight: false,
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, dimColor: true, children: "compare with" }),
+          others.map((f, i) => {
+            const selected = i === pickerIndex;
+            return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs3(
+              Text4,
+              {
+                backgroundColor: selected ? "blue" : void 0,
+                color: selected ? "white" : void 0,
+                children: [
+                  selected ? "\u25B6 " : "  ",
+                  f.relativePath
+                ]
+              }
+            ) }, f.path);
+          }),
+          others.length === 0 && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  no other files" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", flexGrow: 1, paddingX: 1, children: [
+      /* @__PURE__ */ jsxs3(Box4, { borderStyle: "single", borderBottom: true, borderTop: false, borderLeft: false, borderRight: false, children: [
+        /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "KEY".padEnd(22) }),
+        /* @__PURE__ */ jsxs3(Text4, { bold: true, children: [
+          "  ",
+          leftName.padEnd(COL_VAL + 2)
+        ] }),
+        /* @__PURE__ */ jsx4(Text4, { bold: true, children: rightName })
+      ] }),
+      rows.map((row) => /* @__PURE__ */ jsx4(DiffRow, { row }, row.key)),
+      rows.length === 0 && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Select a file to compare." }) })
+    ] }),
+    /* @__PURE__ */ jsxs3(Box4, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, paddingX: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2191\u2193 pick file  esc close    " }),
+      /* @__PURE__ */ jsx4(Text4, { color: "green", children: "\u25CF same" })
+    ] })
+  ] });
+}
+function DiffRow({ row }) {
+  const { key, leftDisplay, rightDisplay, status } = row;
+  const color = status === "same" ? "green" : void 0;
+  return /* @__PURE__ */ jsxs3(Box4, { children: [
+    /* @__PURE__ */ jsx4(Text4, { color, children: key.padEnd(22) }),
+    /* @__PURE__ */ jsxs3(Text4, { color, children: [
+      "  ",
+      (leftDisplay || "\u2014").padEnd(COL_VAL + 2)
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { color, children: rightDisplay || "\u2014" })
+  ] });
+}
+
+// src/tui/HelpOverlay.tsx
+import { Box as Box5, Text as Text5, useInput as useInput4, useStdin as useStdin4 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var SECTIONS = [
+  {
+    title: "Navigation",
+    rows: [
+      ["\u2191 \u2193", "Move up / down"],
+      ["Tab", "Switch between file list and key table"],
+      ["q / Esc", "Quit"]
+    ]
+  },
+  {
+    title: "Key actions",
+    rows: [
+      ["Enter", "Edit selected key"],
+      ["a", "Add new key"],
+      ["D", "Delete selected key (confirmation required)"],
+      ["y", "Copy value to clipboard"],
+      ["r", "Reveal / hide selected key value"],
+      ["R", "Reveal / hide all key values"]
+    ]
+  },
+  {
+    title: "File actions",
+    rows: [
+      ["e", "Encrypt / decrypt entire file"],
+      ["d", "Open diff view"]
+    ]
+  },
+  {
+    title: "Diff view",
+    rows: [
+      ["\u2191 \u2193", "Pick file to compare"],
+      ["Esc / q", "Close diff view"]
+    ]
+  }
+];
+var KEY_WIDTH = 10;
+function HelpOverlay({ onClose }) {
+  const { isRawModeSupported } = useStdin4();
+  useInput4((input, key) => {
+    if (input === "?" || input === "q" || key.escape) onClose();
+  }, { isActive: isRawModeSupported });
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsxs4(Box5, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: "dotenvx-ui  " }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "keyboard shortcuts" })
+    ] }),
+    SECTIONS.map((section) => /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: section.title }),
+      section.rows.map(([key, desc]) => /* @__PURE__ */ jsxs4(Box5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: key.padEnd(KEY_WIDTH) }),
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: desc })
+      ] }, key))
+    ] }, section.title)),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "? / q / esc  close help" }) })
+  ] });
+}
+
+// src/tui/InlineForm.tsx
+import { useState as useState2 } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput5, useStdin as useStdin5 } from "ink";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function InlineForm({ label, initialValue = "", onSubmit, onCancel }) {
+  const { isRawModeSupported } = useStdin5();
+  const [value, setValue] = useState2(initialValue);
+  const [cursor, setCursor] = useState2(initialValue.length);
+  useInput5((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      onSubmit(value);
+      return;
+    }
+    if (key.leftArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setCursor((c) => Math.min(value.length, c + 1));
+      return;
+    }
+    if (key.ctrl && input === "a" || key.home) {
+      setCursor(0);
+      return;
+    }
+    if (key.ctrl && input === "e" || key.end) {
+      setCursor(value.length);
+      return;
+    }
+    if (key.ctrl && input === "k") {
+      setValue((v) => v.slice(0, cursor));
+      return;
+    }
+    if (key.ctrl && input === "u") {
+      setValue((v) => v.slice(cursor));
+      setCursor(0);
+      return;
+    }
+    if (key.backspace) {
+      if (cursor === 0) return;
+      setValue((v) => v.slice(0, cursor - 1) + v.slice(cursor));
+      setCursor((c) => c - 1);
+      return;
+    }
+    if (key.delete) {
+      setValue((v) => v.slice(0, cursor) + v.slice(cursor + 1));
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      setValue((v) => v.slice(0, cursor) + input + v.slice(cursor));
+      setCursor((c) => c + input.length);
+    }
+  }, { isActive: isRawModeSupported });
+  const before = value.slice(0, cursor);
+  const at = value[cursor] ?? " ";
+  const after = value.slice(cursor + 1);
+  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, paddingX: 1, paddingTop: 0, children: /* @__PURE__ */ jsxs5(Box6, { children: [
+    /* @__PURE__ */ jsxs5(Text6, { bold: true, color: "cyan", children: [
+      label,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx6(Text6, { children: before }),
+    /* @__PURE__ */ jsx6(Text6, { inverse: true, children: at }),
+    /* @__PURE__ */ jsx6(Text6, { children: after }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "   \u21B5 confirm  esc cancel" })
+  ] }) });
+}
+
+// src/tui/App.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function App({ files }) {
+  const { exit } = useApp();
+  const { isRawModeSupported } = useStdin6();
+  const [fileIndex, setFileIndex] = useState3(0);
+  const [keyIndex, setKeyIndex] = useState3(0);
+  const [focus, setFocus] = useState3("files");
+  const [revealed, setRevealed] = useState3(/* @__PURE__ */ new Map());
+  const [mode, setMode] = useState3({ type: "normal" });
+  const [statusMsg, setStatusMsg] = useState3();
+  const [keys, setKeys] = useState3(() => loadKeys(files[0]));
+  const selectedFile = files[fileIndex];
+  function loadKeys(file) {
+    try {
+      return readEnvFile(file.path);
+    } catch {
+      return [];
+    }
+  }
+  function refreshKeys() {
+    setKeys(loadKeys(selectedFile));
+  }
+  function selectFile(idx) {
+    setFileIndex(idx);
+    setKeyIndex(0);
+    setRevealed(/* @__PURE__ */ new Map());
+    setKeys(loadKeys(files[idx]));
+  }
+  function flash(msg, ms = 1500) {
+    setStatusMsg(msg);
+    setTimeout(() => setStatusMsg(void 0), ms);
+  }
+  useInput6((input, key) => {
+    if (mode.type !== "normal") return;
+    if (input === "q" || key.escape) {
+      exit();
+      return;
+    }
+    if (input === "?") {
+      setMode({ type: "help" });
+      return;
+    }
+    if (key.tab) {
+      setFocus((f) => f === "files" ? "keys" : "files");
+      return;
+    }
+    if (focus !== "keys") return;
+    const k = keys[keyIndex];
+    if (input === "r") {
+      if (!k) return;
+      if (revealed.has(k.key)) {
+        setRevealed((prev) => {
+          const next = new Map(prev);
+          next.delete(k.key);
+          return next;
+        });
+        return;
+      }
+      if (k.encrypted) {
+        const plain = decryptValue(k.value, selectedFile.path);
+        if (plain === null) {
+          flash("\u{1F512} Private key not found in environment");
+          return;
+        }
+        setRevealed((prev) => new Map(prev).set(k.key, plain));
+      } else {
+        setRevealed((prev) => new Map(prev).set(k.key, k.value));
+      }
+      return;
+    }
+    if (input === "R") {
+      if (revealed.size > 0) {
+        setRevealed(/* @__PURE__ */ new Map());
+        return;
+      }
+      const next = /* @__PURE__ */ new Map();
+      for (const entry of keys) {
+        if (entry.encrypted) {
+          const plain = decryptValue(entry.value, selectedFile.path);
+          if (plain === null) {
+            flash("\u{1F512} Private key not found \u2014 cannot reveal all");
+            return;
+          }
+          next.set(entry.key, plain);
+        } else {
+          next.set(entry.key, entry.value);
+        }
+      }
+      setRevealed(next);
+      return;
+    }
+    if (input === "y") {
+      if (!k) return;
+      const value = k.encrypted ? decryptValue(k.value, selectedFile.path) : k.value;
+      if (value === null) {
+        flash("\u{1F512} Private key not found \u2014 cannot copy");
+        return;
+      }
+      clipboard.writeSync(value);
+      flash(`Copied ${k.key}`);
+      return;
+    }
+    if (key.return) {
+      if (!k) return;
+      if (k.encrypted) {
+        const plain = decryptValue(k.value, selectedFile.path);
+        if (plain === null) {
+          flash("\u{1F512} Private key not found \u2014 cannot edit");
+          return;
+        }
+        setMode({ type: "edit", key: { ...k, value: plain } });
+      } else {
+        setMode({ type: "edit", key: k });
+      }
+      return;
+    }
+    if (input === "a") {
+      setMode({ type: "add-key" });
+      return;
+    }
+    if (input === "D") {
+      if (!k) return;
+      setMode({ type: "confirm-delete", key: k });
+      return;
+    }
+    if (input === "d") {
+      setMode({ type: "diff" });
+      return;
+    }
+    if (input === "e") {
+      setMode({ type: "confirm-encrypt" });
+      return;
+    }
+  }, { isActive: isRawModeSupported && mode.type === "normal" });
+  if (mode.type === "edit") {
+    const editing = mode.key;
+    return /* @__PURE__ */ jsx7(
+      Layout,
+      {
+        files,
+        fileIndex,
+        keys,
+        keyIndex,
+        focus,
+        revealed,
+        onSelectFile: selectFile,
+        onSelectKey: setKeyIndex,
+        statusMsg,
+        focus2: focus,
+        extra: /* @__PURE__ */ jsx7(
+          InlineForm,
+          {
+            label: `Edit ${editing.key}`,
+            initialValue: editing.value,
+            onSubmit: (val) => {
+              if (editing.encrypted) {
+                encryptKey(selectedFile.path, editing.key, val);
+              } else {
+                updateKey(selectedFile.path, editing.key, val);
+              }
+              setRevealed((prev) => {
+                const next = new Map(prev);
+                next.delete(editing.key);
+                return next;
+              });
+              refreshKeys();
+              setMode({ type: "normal" });
+              flash(`Saved ${editing.key}`);
+            },
+            onCancel: () => setMode({ type: "normal" })
+          }
+        )
+      }
+    );
+  }
+  if (mode.type === "add-key") {
+    return /* @__PURE__ */ jsx7(
+      Layout,
+      {
+        files,
+        fileIndex,
+        keys,
+        keyIndex,
+        focus,
+        revealed,
+        onSelectFile: selectFile,
+        onSelectKey: setKeyIndex,
+        statusMsg,
+        focus2: focus,
+        extra: /* @__PURE__ */ jsx7(
+          InlineForm,
+          {
+            label: "New key name",
+            onSubmit: (keyName) => {
+              if (!keyName.trim()) {
+                setMode({ type: "normal" });
+                return;
+              }
+              setMode({ type: "add-value", keyName: keyName.trim() });
+            },
+            onCancel: () => setMode({ type: "normal" })
+          },
+          "add-key"
+        )
+      }
+    );
+  }
+  if (mode.type === "add-value") {
+    const { keyName } = mode;
+    return /* @__PURE__ */ jsx7(
+      Layout,
+      {
+        files,
+        fileIndex,
+        keys,
+        keyIndex,
+        focus,
+        revealed,
+        onSelectFile: selectFile,
+        onSelectKey: setKeyIndex,
+        statusMsg,
+        focus2: focus,
+        extra: /* @__PURE__ */ jsx7(
+          InlineForm,
+          {
+            label: `Value for ${keyName}`,
+            onSubmit: (val) => {
+              if (selectedFile.encrypted) {
+                setMode({ type: "confirm-add-encrypt", keyName, value: val });
+              } else {
+                addKey(selectedFile.path, keyName, val);
+                refreshKeys();
+                setKeyIndex(keys.length);
+                setMode({ type: "normal" });
+                flash(`Added ${keyName}`);
+              }
+            },
+            onCancel: () => setMode({ type: "normal" })
+          },
+          "add-value"
+        )
+      }
+    );
+  }
+  if (mode.type === "confirm-add-encrypt") {
+    const { keyName, value: newVal } = mode;
+    const commit = (encrypt) => {
+      addKey(selectedFile.path, keyName, newVal);
+      if (encrypt) encryptKey(selectedFile.path, keyName, newVal);
+      refreshKeys();
+      setKeyIndex(keys.length);
+      setMode({ type: "normal" });
+      flash(`Added ${keyName}${encrypt ? " (encrypted)" : ""}`);
+    };
+    return /* @__PURE__ */ jsx7(
+      Layout,
+      {
+        files,
+        fileIndex,
+        keys,
+        keyIndex,
+        focus,
+        revealed,
+        onSelectFile: selectFile,
+        onSelectKey: setKeyIndex,
+        statusMsg,
+        focus2: focus,
+        extra: /* @__PURE__ */ jsx7(ConfirmAddEncrypt, { keyName, onEncrypt: () => commit(true), onPlain: () => commit(false), onCancel: () => setMode({ type: "normal" }) })
+      }
+    );
+  }
+  if (mode.type === "confirm-delete") {
+    const { key: k } = mode;
+    return /* @__PURE__ */ jsx7(
+      Layout,
+      {
+        files,
+        fileIndex,
+        keys,
+        keyIndex,
+        focus,
+        revealed,
+        onSelectFile: selectFile,
+        onSelectKey: setKeyIndex,
+        statusMsg,
+        focus2: focus,
+        extra: /* @__PURE__ */ jsx7(
+          ConfirmDelete,
+          {
+            keyName: k.key,
+            onConfirm: () => {
+              removeKey(selectedFile.path, k.key);
+              refreshKeys();
+              setKeyIndex(Math.max(0, keyIndex - 1));
+              setMode({ type: "normal" });
+              flash(`Deleted ${k.key}`);
+            },
+            onCancel: () => setMode({ type: "normal" })
+          }
+        )
+      }
+    );
+  }
+  if (mode.type === "confirm-encrypt") {
+    const isEncrypted = selectedFile.encrypted;
+    return /* @__PURE__ */ jsx7(
+      Layout,
+      {
+        files,
+        fileIndex,
+        keys,
+        keyIndex,
+        focus,
+        revealed,
+        onSelectFile: selectFile,
+        onSelectKey: setKeyIndex,
+        statusMsg,
+        focus2: focus,
+        extra: /* @__PURE__ */ jsx7(
+          ConfirmEncrypt,
+          {
+            decrypt: isEncrypted,
+            fileName: selectedFile.relativePath,
+            onConfirm: () => {
+              try {
+                if (isEncrypted) {
+                  decryptFile(selectedFile.path);
+                  flash(`Decrypted ${selectedFile.relativePath}`);
+                } else {
+                  encryptFile(selectedFile.path);
+                  flash(`Encrypted ${selectedFile.relativePath}`);
+                }
+              } catch (err) {
+                flash(`Error: ${err instanceof Error ? err.message : String(err)}`);
+              }
+              refreshKeys();
+              setRevealed(/* @__PURE__ */ new Map());
+              setMode({ type: "normal" });
+            },
+            onCancel: () => setMode({ type: "normal" })
+          }
+        )
+      }
+    );
+  }
+  if (mode.type === "help") {
+    return /* @__PURE__ */ jsx7(HelpOverlay, { onClose: () => setMode({ type: "normal" }) });
+  }
+  if (mode.type === "diff") {
+    return /* @__PURE__ */ jsx7(
+      DiffView,
+      {
+        left: selectedFile,
+        files,
+        onClose: () => setMode({ type: "normal" })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx7(
+    Layout,
+    {
+      files,
+      fileIndex,
+      keys,
+      keyIndex,
+      focus,
+      revealed,
+      onSelectFile: selectFile,
+      onSelectKey: setKeyIndex,
+      statusMsg,
+      focus2: focus
+    }
+  );
+}
+function Layout({
+  files,
+  fileIndex,
+  keys,
+  keyIndex,
+  focus,
+  revealed,
+  onSelectFile,
+  onSelectKey,
+  statusMsg,
+  extra
+}) {
+  const selectedFile = files[fileIndex];
+  const encCount = files.filter((f) => f.encrypted).length;
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsxs6(Box7, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: "dotenvx-ui" }),
+      /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+        "  ",
+        selectedFile.relativePath,
+        "  \xB7  ",
+        files.length,
+        " files  \xB7  ",
+        encCount,
+        " enc"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs6(Box7, { flexGrow: 1, children: [
+      /* @__PURE__ */ jsx7(FileList, { files, selectedIndex: fileIndex, focused: focus === "files", onSelect: onSelectFile }),
+      /* @__PURE__ */ jsx7(
+        KeyTable,
+        {
+          file: selectedFile,
+          keys,
+          selectedIndex: keyIndex,
+          focused: focus === "keys",
+          revealed,
+          onSelect: onSelectKey
+        }
+      )
+    ] }),
+    extra,
+    /* @__PURE__ */ jsx7(StatusBar, { focus, message: statusMsg })
+  ] });
+}
+function ConfirmDelete({ keyName, onConfirm, onCancel }) {
+  const { isRawModeSupported } = useStdin6();
+  useInput6((input) => {
+    if (input === "y" || input === "Y") onConfirm();
+    else onCancel();
+  }, { isActive: isRawModeSupported });
+  return /* @__PURE__ */ jsxs6(Box7, { paddingX: 1, children: [
+    /* @__PURE__ */ jsxs6(Text7, { color: "red", children: [
+      "Delete ",
+      /* @__PURE__ */ jsx7(Text7, { bold: true, children: keyName }),
+      "? "
+    ] }),
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "y confirm  any other key cancel" })
+  ] });
+}
+function ConfirmEncrypt({ decrypt, fileName, onConfirm, onCancel }) {
+  const { isRawModeSupported } = useStdin6();
+  useInput6((input) => {
+    if (input === "y" || input === "Y") onConfirm();
+    else onCancel();
+  }, { isActive: isRawModeSupported });
+  const action = decrypt ? "Decrypt" : "Encrypt";
+  const color = decrypt ? "yellow" : "green";
+  return /* @__PURE__ */ jsxs6(Box7, { paddingX: 1, children: [
+    /* @__PURE__ */ jsxs6(Text7, { color, children: [
+      action,
+      " ",
+      /* @__PURE__ */ jsx7(Text7, { bold: true, children: fileName }),
+      "? "
+    ] }),
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "y confirm  any other key cancel" })
+  ] });
+}
+function ConfirmAddEncrypt({ keyName, onEncrypt, onPlain, onCancel }) {
+  const { isRawModeSupported } = useStdin6();
+  useInput6((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (input === "y" || input === "Y") {
+      onEncrypt();
+      return;
+    }
+    if (input === "n" || input === "N" || key.return) {
+      onPlain();
+      return;
+    }
+  }, { isActive: isRawModeSupported });
+  return /* @__PURE__ */ jsxs6(Box7, { paddingX: 1, children: [
+    /* @__PURE__ */ jsxs6(Text7, { children: [
+      "Encrypt ",
+      /* @__PURE__ */ jsx7(Text7, { bold: true, children: keyName }),
+      "? "
+    ] }),
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "y encrypt  n plain  esc cancel" })
+  ] });
+}
+
+// src/tui/ErrorBoundary.tsx
+import React4 from "react";
+import { Box as Box8, Text as Text8 } from "ink";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+var ErrorBoundary = class extends React4.Component {
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  render() {
+    if (this.state.error) {
+      return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { bold: true, color: "red", children: "dotenvx-ui crashed" }),
+        /* @__PURE__ */ jsx8(Text8, { children: this.state.error.message }),
+        /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Please report this at https://github.com/alxbrla/dotenvx-ui/issues" }) })
+      ] });
+    }
+    return this.props.children;
+  }
+};
+
+// src/cli.tsx
+import { createRequire as createRequire2 } from "module";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var { version } = createRequire2(import.meta.url)("../package.json");
+var HELP = `
+dotenvx-ui \u2014 terminal and web UI for dotenvx environment files
+
+Usage:
+  dotenvx-ui         Launch TUI
+  dotenvx-ui ui      Launch web UI in browser
+
+Options:
+  -v, --version      Print version
+  -h, --help         Show this help
+`;
+var commands = {
+  "--version": () => {
+    console.log(version);
+    process.exit(0);
+  },
+  "-v": () => {
+    console.log(version);
+    process.exit(0);
+  },
+  "--help": () => {
+    console.log(HELP);
+    process.exit(0);
+  },
+  "-h": () => {
+    console.log(HELP);
+    process.exit(0);
+  },
+  "ui": runWebUI
+};
+var [, , command] = process.argv;
+if (command !== void 0 && !(command in commands)) {
+  console.error(`Unknown command: ${command}
+Run dotenvx-ui --help for usage.`);
+  process.exit(1);
+}
+commands[command ?? ""]?.() ?? runTUI();
+function runTUI() {
+  const files = scan(process.cwd());
+  if (files.length === 0) {
+    console.error("No .env files found in this directory.");
+    process.exit(1);
+  }
+  render(/* @__PURE__ */ jsx9(ErrorBoundary, { children: /* @__PURE__ */ jsx9(App, { files }) }));
+}
+function runWebUI() {
+  console.log("Web UI \u2014 coming soon");
+  process.exit(0);
+}