@chengyixu/envshow 1.0.0

package/envshow.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+
+const { env, stdout, exit, stderr } = process;
+
+const HELP = `envshow — pretty-print environment variables
+
+Usage:
+  envshow [options]
+  echo "KEY=val" | envshow --stdin    Merge stdin .env lines into output
+
+Options:
+  --filter, -f <pattern>   Only show keys matching pattern (case-insensitive substring)
+  --mask, -m               Mask values: show first 4 + last 4 characters
+  --json, -j               Output as JSON
+  --keys, -k               Show only keys, no values
+  --no-sort, --sort -s     Sort alphabetically by key (default: --sort)
+  --stdin, -i              Read KEY=value lines from stdin and merge into env
+  --prefix, -p <prefix>    Only show keys starting with this prefix
+  --help, -h               Show this help
+  --version, -v            Show version
+
+Examples:
+  envshow                          All env vars, sorted
+  envshow -f NODE                  Only keys containing "NODE"
+  envshow -p AWS_                  Only keys starting with "AWS_"
+  envshow -mj                      Masked values as JSON
+  envshow -k -f PATH               Just keys matching PATH (handy for checking)
+  cat .env | envshow --stdin       Merge .env file into current env and display
+  envshow --stdin < .env           Same as above
+  envshow -f proxy -m              Find proxy settings with masked values
+`;
+
+const VERSION = '1.0.0';
+
+function parseArgs(argv) {
+  const flags = {
+    filter: null,
+    mask: false,
+    json: false,
+    keysOnly: false,
+    sort: true,
+    stdin: false,
+    prefix: null,
+    help: false,
+    version: false,
+  };
+
+  // Expand combined short flags: -mj -> -m -j
+  const expanded = [];
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.length > 2 && arg.startsWith('-') && !arg.startsWith('--') && arg[1] !== 'f' && arg[1] !== 'p') {
+      // Split -mj into -m -j (but not -f or -p since they take values)
+      for (let j = 1; j < arg.length; j++) {
+        expanded.push('-' + arg[j]);
+      }
+    } else {
+      expanded.push(arg);
+    }
+  }
+
+  for (let i = 0; i < expanded.length; i++) {
+    const arg = expanded[i];
+    switch (arg) {
+      case '--filter': case '-f':
+        flags.filter = expanded[++i];
+        if (!flags.filter || flags.filter.startsWith('-')) { stderr.write('envshow: --filter requires a pattern\n'); exit(1); }
+        break;
+      case '--mask': case '-m':
+        flags.mask = true;
+        break;
+      case '--json': case '-j':
+        flags.json = true;
+        break;
+      case '--keys': case '-k':
+        flags.keysOnly = true;
+        break;
+      case '--sort': case '-s':
+        flags.sort = true;
+        break;
+      case '--no-sort':
+        flags.sort = false;
+        break;
+      case '--stdin': case '-i':
+        flags.stdin = true;
+        break;
+      case '--prefix': case '-p':
+        flags.prefix = expanded[++i];
+        if (!flags.prefix || flags.prefix.startsWith('-')) { stderr.write('envshow: --prefix requires a value\n'); exit(1); }
+        break;
+      case '--help': case '-h':
+        flags.help = true;
+        break;
+      case '--version': case '-v':
+        flags.version = true;
+        break;
+      default:
+        if (arg.startsWith('-')) {
+          stderr.write(`envshow: unknown option '${arg}'\n`);
+          exit(1);
+        }
+    }
+  }
+
+  return flags;
+}
+
+function maskValue(val) {
+  if (val.length <= 8) return '*'.repeat(val.length);
+  return val.slice(0, 4) + '*'.repeat(Math.max(val.length - 8, 1)) + val.slice(-4);
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    // If nothing comes in after 100ms, resolve
+    setTimeout(() => resolve(data), 100);
+  });
+}
+
+function parseEnvLines(input) {
+  const result = {};
+  for (const line of input.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let val = trimmed.slice(eqIdx + 1).trim();
+    // Strip surrounding quotes
+    if ((val.startsWith('"') && val.endsWith('"')) ||
+        (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    if (key) result[key] = val;
+  }
+  return result;
+}
+
+async function main() {
+  const flags = parseArgs(process.argv);
+
+  if (flags.help) {
+    stdout.write(HELP);
+    exit(0);
+  }
+
+  if (flags.version) {
+    stdout.write(`envshow v${VERSION}\n`);
+    exit(0);
+  }
+
+  let entries = Object.entries(env);
+
+  // Merge stdin if requested
+  if (flags.stdin) {
+    const stdinData = await readStdin();
+    if (stdinData) {
+      const parsed = parseEnvLines(stdinData);
+      const merged = { ...env, ...parsed };
+      entries = Object.entries(merged);
+    }
+  }
+
+  // Filter by prefix
+  if (flags.prefix) {
+    const pfx = flags.prefix.toUpperCase();
+    entries = entries.filter(([k]) => k.toUpperCase().startsWith(pfx));
+  }
+
+  // Filter by substring
+  if (flags.filter) {
+    const f = flags.filter.toUpperCase();
+    entries = entries.filter(([k]) => k.toUpperCase().includes(f));
+  }
+
+  // Sort
+  if (flags.sort) {
+    entries.sort(([a], [b]) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
+  }
+
+  // JSON output
+  if (flags.json) {
+    const obj = {};
+    for (const [k, v] of entries) {
+      obj[k] = flags.keysOnly ? '' : (flags.mask ? maskValue(v) : v);
+    }
+    stdout.write(JSON.stringify(obj, null, 2) + '\n');
+    return;
+  }
+
+  // Find max key length for alignment
+  const maxKeyLen = entries.length > 0
+    ? Math.max(...entries.map(([k]) => k.length))
+    : 0;
+
+  // Terminal color support (basic check)
+  const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+
+  const CYAN = useColor ? '\x1b[36m' : '';
+  const YELLOW = useColor ? '\x1b[33m' : '';
+  const DIM = useColor ? '\x1b[2m' : '';
+  const RESET = useColor ? '\x1b[0m' : '';
+
+  for (const [key, val] of entries) {
+    if (flags.keysOnly) {
+      stdout.write(`${CYAN}${key}${RESET}\n`);
+    } else {
+      const displayVal = flags.mask ? maskValue(val) : val;
+      const valColor = flags.mask ? YELLOW : '';
+      const pad = ' '.repeat(Math.max(maxKeyLen - key.length, 0));
+      stdout.write(`${CYAN}${key}${RESET}${pad} ${DIM}=${RESET} ${valColor}${displayVal}${RESET}\n`);
+    }
+  }
+}
+
+main().catch((err) => {
+  stderr.write(`envshow: ${err.message}\n`);
+  exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@chengyixu/envshow",
+  "version": "1.0.0",
+  "description": "Pretty-print environment variables with sorting, filtering, masking, and JSON output. Zero dependencies.",
+  "main": "envshow.js",
+  "bin": {
+    "envshow": "envshow.js"
+  },
+  "files": [
+    "envshow.js"
+  ],
+  "keywords": [
+    "env",
+    "environment",
+    "variables",
+    "pretty-print",
+    "cli",
+    "dotenv",
+    "debug",
+    "devtools"
+  ],
+  "author": "chengyixu",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chengyixu/envshow.git"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}