@tltdh61/dotenvrtdb 1.260331.11828 → 1.260331.11957

package/cli.js

@@ -15,6 +15,33 @@ const spawn = require("cross-spawn");
 const path = require("path");
 const fs = require("fs");
 
+function formatErrorMessage(context = "unknown", err) {
+  if (!err) return `[${context}] Unknown error`;
+  const message = err && err.message ? err.message : String(err);
+  const code = err && err.code ? ` | code=${err.code}` : "";
+  const syscall = err && err.syscall ? ` | syscall=${err.syscall}` : "";
+  const filePath = err && err.path ? ` | path=${err.path}` : "";
+  const cause =
+    err && err.cause
+      ? ` | cause=${err.cause && err.cause.message ? err.cause.message : String(err.cause)}`
+      : "";
+  return `[${context}] ${message}${code}${syscall}${filePath}${cause}`;
+}
+
+function logSyncStatus(action = "sync", { status = "unknown", file = "-", varCount = 0, message = "" } = {}) {
+  const normalizedStatus = `${status || "unknown"}`.toUpperCase();
+  const safeAction = `${action || "sync"}`.toUpperCase();
+  const detail = message ? ` | reason=${message}` : "";
+  console.log(`[${safeAction}] status=${normalizedStatus} | file=${file || "-"} | vars=${Number.isFinite(varCount) ? varCount : 0}${detail}`);
+}
+
+function ensureParentDirExists(filePath = "") {
+  const target = `${filePath || ""}`.trim();
+  if (!target) return;
+  const absPath = path.resolve(target);
+  fs.mkdirSync(path.dirname(absPath), { recursive: true });
+}
+
 const rtdbUtils = (() => {
   let rtdbUrl = ``;
 
@@ -52,6 +79,49 @@ const rtdbUtils = (() => {
     return resolved.trim();
   }
 
+  function parseFileValueDirective(value = "") {
+    if (typeof value !== "string") return null;
+    const v = value.trim();
+    if (!v) return null;
+
+    if (v.startsWith("file:raw:")) {
+      const filePath = v.slice("file:raw:".length).trim();
+      if (!filePath) return null;
+      return { type: "raw", filePath };
+    }
+    if (v.startsWith("file:base64:")) {
+      const filePath = v.slice("file:base64:".length).trim();
+      if (!filePath) return null;
+      return { type: "base64", filePath };
+    }
+    return null;
+  }
+
+  function resolveEnvFileDirectives(objVar = {}, options = {}) {
+    const baseDir = options && options.baseDir ? options.baseDir : process.cwd();
+    const next = { ...objVar };
+
+    for (const [key, val] of Object.entries(objVar || {})) {
+      const directive = parseFileValueDirective(val);
+      if (!directive) continue;
+
+      const fullPath = path.isAbsolute(directive.filePath) ? directive.filePath : path.resolve(baseDir, directive.filePath);
+      if (!fs.existsSync(fullPath)) {
+        throw new Error(`[directive] File not found for key "${key}": ${fullPath}`);
+      }
+
+      if (directive.type === "raw") {
+        next[key] = fs.readFileSync(fullPath, "utf8");
+        continue;
+      }
+      if (directive.type === "base64") {
+        next[key] = fs.readFileSync(fullPath).toString("base64");
+      }
+    }
+
+    return next;
+  }
+
   // --- pushTo ---
   const pushTo = async (objVar = {}) => {
     try {
@@ -82,7 +152,7 @@ const rtdbUtils = (() => {
       }
       return true;
     } catch (err) {
-      console.error(`[rtdb] PATCH error: ${err && err.message ? err.message : err}`);
+      console.error(formatErrorMessage("rtdb PATCH error", err));
       return false;
     }
   };
@@ -93,18 +163,21 @@ const rtdbUtils = (() => {
       const p = `${envPath || ""}`.trim();
       if (!p) {
         console.error(`[rtdb] Missing -e <path> for --push`);
-        return false;
+        return { ok: false, file: p || "-", varCount: 0 };
       }
       if (!fs.existsSync(p)) {
         console.error(`[rtdb] Env file not found: ${p}`);
-        return false;
+        return { ok: false, file: p, varCount: 0 };
       }
       const content = fs.readFileSync(p, "utf8");
       const parsed = dotenv.parse(content); // {KEY:VAL}
-      return await pushTo(parsed);
+      const resolvedVars = resolveEnvFileDirectives(parsed, { baseDir: path.dirname(path.resolve(p)) });
+      const varCount = Object.keys(resolvedVars || {}).length;
+      const ok = await pushTo(resolvedVars);
+      return { ok, file: p, varCount, reason: ok ? "" : "RTDB PATCH failed" };
     } catch (err) {
-      console.error(`[rtdb] envPathPushTo error: ${err && err.message ? err.message : err}`);
-      return false;
+      console.error(formatErrorMessage("rtdb envPathPushTo error", err));
+      return { ok: false, file: `${envPath || "-"} `.trim(), varCount: 0, reason: err && err.message ? err.message : String(err) };
     }
   };
 
@@ -125,7 +198,7 @@ const rtdbUtils = (() => {
       if (!data || typeof data !== "object" || Array.isArray(data)) return {};
       return data;
     } catch (err) {
-      console.error(`[rtdb] GET error: ${err && err.message ? err.message : err}`);
+      console.error(formatErrorMessage("rtdb GET error", err));
       return {};
     }
   };
@@ -199,7 +272,7 @@ const rtdbUtils = (() => {
       }
       return { ok: true, value: `${parsed[key] ?? ""}` };
     } catch (err) {
-      console.error(`[env] readEnvVarFromPath error: ${err && err.message ? err.message : err}`);
+      console.error(formatErrorMessage("env readEnvVarFromPath error", err));
       return { ok: false, value: "" };
     }
   }
@@ -226,7 +299,7 @@ const rtdbUtils = (() => {
       }
       return { ok: true, buffer };
     } catch (err) {
-      console.error(`[env] decodeBase64ToBuffer error: ${err && err.message ? err.message : err}`);
+      console.error(formatErrorMessage("env decodeBase64ToBuffer error", err));
       return { ok: false, buffer: Buffer.alloc(0) };
     }
   }
@@ -304,6 +377,8 @@ const rtdbUtils = (() => {
     serializeEnv,
     readEnvVarFromPath,
     decodeBase64ToBuffer,
+    parseFileValueDirective,
+    resolveEnvFileDirectives,
     ensureEnvPathProvidedAndExists,
     normalizeLegacyArgs,
     getVietnamDateTime,
@@ -334,7 +409,9 @@ function printHelp() {
       '                      also supports inline env: dotenvrtdb --shell -- FOO=bar "echo %FOO%"',
       "  --writefileraw=<path>    write raw value from --var=<name> in -e <path> env file to <path>",
       "  --writefilebase64=<path> read --var=<name> from -e <path>, decode base64, then write binary to <path>",
-      "  --var=<name>             env variable name used by --writefileraw/--writefilebase64",
+      "  --var=<name>             env variable name used by --writefileraw/--writefilebase64 (repeatable, mapped by order)",
+      "  --varraw=<name>          optional explicit variable for --writefileraw (repeatable, one-to-one with --writefileraw)",
+      "  --varbase64=<name>       optional explicit variable for --writefilebase64 (repeatable, one-to-one with --writefilebase64)",
       "  -v <name>=<value>   put variable <name> into environment using value <value>",
       "  -v <name>=<value>   multiple -v flags are allowed",
       "  -p <variable>       print value of <variable> to the console. If you specify this, you do not have to specify a `command`",
@@ -356,25 +433,26 @@ function validateCmdVariable(param) {
 }
 
 async function main() {
-  if (argv.help) {
-    printHelp();
-    process.exit();
-  }
+  try {
+    if (argv.help) {
+      printHelp();
+      process.exit();
+    }
 
-  const override = argv.o || argv.override;
+    const override = argv.o || argv.override;
 
-  // Handle quiet flag - default is true (quiet), can be disabled with --quiet=false or -q=false
-  const isQuiet = !(argv.quiet === false || argv.q === false || argv.quiet === "false" || argv.q === "false");
+    // Handle quiet flag - default is true (quiet), can be disabled with --quiet=false or -q=false
+    const isQuiet = !(argv.quiet === false || argv.q === false || argv.quiet === "false" || argv.q === "false");
 
-  if (argv.c && override) {
-    console.error("Invalid arguments. Cascading env variables conflicts with overrides.");
-    process.exit(1);
-  }
+    if (argv.c && override) {
+      console.error("Invalid arguments. Cascading env variables conflicts with overrides.");
+      process.exit(1);
+    }
 
-  // Setup RTDB URL if provided
-  if (argv.eUrl) {
-    rtdbUtils.setUrl(argv.eUrl);
-  }
+    // Setup RTDB URL if provided
+    if (argv.eUrl) {
+      rtdbUtils.setUrl(argv.eUrl);
+    }
 
   const executePush = async () => {
     /**
@@ -383,13 +461,26 @@ async function main() {
     if (!argv.push) return false;
     if (!argv.eUrl) {
       console.error(`Missing --eUrl=<url>. This is required for --push.`);
+      logSyncStatus("push", { status: "failed", file: "-", varCount: 0, message: "missing --eUrl" });
       return true; // đã "xử lý" case push nhưng lỗi => vẫn kết thúc luồng
     }
     const { ok, envPath } = rtdbUtils.ensureEnvPathProvidedAndExists();
-    if (!ok) return true;
+    if (!ok) {
+      logSyncStatus("push", { status: "failed", file: envPath || "-", varCount: 0, message: "missing/invalid -e path" });
+      return true;
+    }
 
-    const okPush = await rtdbUtils.envPathPushTo(envPath);
-    if (!okPush) process.exit(1);
+    const pushResult = await rtdbUtils.envPathPushTo(envPath);
+    if (!pushResult.ok) {
+      logSyncStatus("push", {
+        status: "failed",
+        file: pushResult.file || envPath,
+        varCount: pushResult.varCount || 0,
+        message: pushResult.reason || "unable to push env vars to RTDB",
+      });
+      process.exit(1);
+    }
+    logSyncStatus("push", { status: "success", file: pushResult.file || envPath, varCount: pushResult.varCount || 0 });
     return true;
   };
 
@@ -400,21 +491,47 @@ async function main() {
     if (!argv.pull) return false;
     if (!argv.eUrl) {
       console.error(`Missing --eUrl=<url>. This is required for --pull.`);
+      logSyncStatus("pull", { status: "failed", file: "-", varCount: 0, message: "missing --eUrl" });
       return true; // đã "xử lý" case pull nhưng lỗi => vẫn kết thúc luồng
     }
-    const { ok, envPath } = rtdbUtils.ensureEnvPathProvidedAndExists();
-    if (!ok) return true;
+    let envPath = "";
+    if (argv.e) {
+      envPath = typeof argv.e === "string" ? argv.e : argv.e[0];
+    }
+    envPath = `${envPath || ""}`.trim();
+    if (!envPath) {
+      logSyncStatus("pull", { status: "failed", file: "-", varCount: 0, message: "missing -e <path>" });
+      return true;
+    }
+    if (!fs.existsSync(envPath)) {
+      try {
+        const absPath = path.resolve(envPath);
+        fs.mkdirSync(path.dirname(absPath), { recursive: true });
+        fs.writeFileSync(absPath, "", "utf8");
+      } catch (err) {
+        logSyncStatus("pull", {
+          status: "failed",
+          file: envPath,
+          varCount: 0,
+          message: formatErrorMessage("pull create env file failed", err),
+        });
+        process.exit(1);
+      }
+    }
 
     const objVar = {
       ...rtdbUtils.getDefaultRtdbEnv(),
       ...(await rtdbUtils.pullFrom()),
     };
+    const pullVarCount = Object.keys(objVar || {}).length;
 
     try {
       const out = rtdbUtils.serializeEnv(objVar);
       fs.writeFileSync(envPath, out, "utf8");
+      logSyncStatus("pull", { status: "success", file: envPath, varCount: pullVarCount });
     } catch (err) {
       console.error(`[pull] write error: ${err && err.message ? err.message : err}`);
+      logSyncStatus("pull", { status: "failed", file: envPath, varCount: pullVarCount, message: "write file failed" });
       process.exit(1);
     }
     return true;
@@ -426,28 +543,54 @@ async function main() {
      */
     if (!argv.writefileraw) return false;
 
-    const outPath = typeof argv.writefileraw === "string" ? argv.writefileraw.trim() : "";
-    if (!outPath) {
+    const outPaths = (Array.isArray(argv.writefileraw) ? argv.writefileraw : [argv.writefileraw])
+      .map((v) => (typeof v === "string" ? v.trim() : ""))
+      .filter(Boolean);
+    if (outPaths.length === 0) {
       console.error(`Missing --writefileraw=<path>.`);
       return true;
     }
-    const varName = typeof argv.var === "string" ? argv.var.trim() : "";
-    if (!varName) {
-      console.error(`Missing --var=<name>. This is required for --writefileraw.`);
+
+    const explicitRawVars = (Array.isArray(argv.varraw || argv.varRaw) ? argv.varraw || argv.varRaw : [argv.varraw || argv.varRaw])
+      .map((v) => (typeof v === "string" ? v.trim() : ""))
+      .filter(Boolean);
+
+    const varNames = [];
+    if (explicitRawVars.length > 0) {
+      if (explicitRawVars.length !== outPaths.length) {
+        console.error(`--varraw must have the same number of entries as --writefileraw.`);
+        return true;
+      }
+      varNames.push(...explicitRawVars);
+    } else {
+      for (let i = 0; i < outPaths.length; i++) {
+        const v = varPool[varCursor++] || "";
+        varNames.push(v.trim());
+      }
+    }
+
+    if (varNames.some((v) => !v)) {
+      console.error(`Missing --var=<name>. This is required for --writefileraw (one var per output path).`);
       return true;
     }
 
     const { ok, envPath } = rtdbUtils.ensureEnvPathProvidedAndExists();
     if (!ok) return true;
 
-    const envVar = rtdbUtils.readEnvVarFromPath(envPath, varName);
-    if (!envVar.ok) process.exit(1);
+    for (let i = 0; i < outPaths.length; i++) {
+      const outPath = outPaths[i];
+      const varName = varNames[i];
 
-    try {
-      fs.writeFileSync(outPath, envVar.value, "utf8");
-    } catch (err) {
-      console.error(`[writefileraw] write error: ${err && err.message ? err.message : err}`);
-      process.exit(1);
+      const envVar = rtdbUtils.readEnvVarFromPath(envPath, varName);
+      if (!envVar.ok) process.exit(1);
+
+      try {
+        ensureParentDirExists(outPath);
+        fs.writeFileSync(outPath, envVar.value, "utf8");
+      } catch (err) {
+        console.error(`[writefileraw] write error: ${err && err.message ? err.message : err}`);
+        process.exit(1);
+      }
     }
     return true;
   };
@@ -458,74 +601,110 @@ async function main() {
      */
     if (!argv.writefilebase64) return false;
 
-    const outPath = typeof argv.writefilebase64 === "string" ? argv.writefilebase64.trim() : "";
-    if (!outPath) {
+    const outPaths = (Array.isArray(argv.writefilebase64) ? argv.writefilebase64 : [argv.writefilebase64])
+      .map((v) => (typeof v === "string" ? v.trim() : ""))
+      .filter(Boolean);
+    if (outPaths.length === 0) {
       console.error(`Missing --writefilebase64=<path>.`);
       return true;
     }
-    const varName = typeof argv.var === "string" ? argv.var.trim() : "";
-    if (!varName) {
-      console.error(`Missing --var=<name>. This is required for --writefilebase64.`);
+
+    const explicitB64Vars = (Array.isArray(argv.varbase64 || argv.varBase64) ? argv.varbase64 || argv.varBase64 : [argv.varbase64 || argv.varBase64])
+      .map((v) => (typeof v === "string" ? v.trim() : ""))
+      .filter(Boolean);
+
+    const varNames = [];
+    if (explicitB64Vars.length > 0) {
+      if (explicitB64Vars.length !== outPaths.length) {
+        console.error(`--varbase64 must have the same number of entries as --writefilebase64.`);
+        return true;
+      }
+      varNames.push(...explicitB64Vars);
+    } else {
+      for (let i = 0; i < outPaths.length; i++) {
+        const v = varPool[varCursor++] || "";
+        varNames.push(v.trim());
+      }
+    }
+
+    if (varNames.some((v) => !v)) {
+      console.error(`Missing --var=<name>. This is required for --writefilebase64 (one var per output path).`);
       return true;
     }
 
     const { ok, envPath } = rtdbUtils.ensureEnvPathProvidedAndExists();
     if (!ok) return true;
 
-    const envVar = rtdbUtils.readEnvVarFromPath(envPath, varName);
-    if (!envVar.ok) process.exit(1);
+    for (let i = 0; i < outPaths.length; i++) {
+      const outPath = outPaths[i];
+      const varName = varNames[i];
 
-    const decoded = rtdbUtils.decodeBase64ToBuffer(envVar.value);
-    if (!decoded.ok) {
-      console.error(`[writefilebase64] Invalid base64 content in variable: ${varName}`);
-      process.exit(1);
-    }
+      const envVar = rtdbUtils.readEnvVarFromPath(envPath, varName);
+      if (!envVar.ok) process.exit(1);
 
-    try {
-      fs.writeFileSync(outPath, decoded.buffer);
-    } catch (err) {
-      console.error(`[writefilebase64] write error: ${err && err.message ? err.message : err}`);
-      process.exit(1);
+      const decoded = rtdbUtils.decodeBase64ToBuffer(envVar.value);
+      if (!decoded.ok) {
+        console.error(`[writefilebase64] Invalid base64 content in variable: ${varName}`);
+        process.exit(1);
+      }
+
+      try {
+        ensureParentDirExists(outPath);
+        fs.writeFileSync(outPath, decoded.buffer);
+      } catch (err) {
+        console.error(`[writefilebase64] write error: ${err && err.message ? err.message : err}`);
+        process.exit(1);
+      }
     }
     return true;
   };
 
-  const didPush = await executePush();
-  const didPull = await executePull();
-  const didWriteFileRaw = await executeWriteFileRaw();
-  const didWriteFileBase64 = await executeWriteFileBase64();
-  if (didPush === true || didPull === true || didWriteFileRaw === true || didWriteFileBase64 === true) {
-    // Push/Pull/WriteFile là mode riêng, chạy xong thoát
-    process.exit(0);
-  }
+    const varPool = (Array.isArray(argv.var) ? argv.var : [argv.var])
+      .map((v) => (typeof v === "string" ? v.trim() : ""))
+      .filter(Boolean);
+    let varCursor = 0;
 
-  let paths = [];
-  if (argv.e) {
-    if (typeof argv.e === "string") {
-      paths.push(argv.e);
-    } else {
-      paths.push(...argv.e);
+    const didPush = await executePush();
+    if (didPush === true) {
+      // push là mode riêng
+      process.exit(0);
     }
-  } else {
-    paths.push(".env");
-  }
 
-  if (argv.c) {
-    paths = paths.reduce(
-      (accumulator, p) =>
-        accumulator.concat(typeof argv.c === "string" ? [`${p}.${argv.c}.local`, `${p}.local`, `${p}.${argv.c}`, p] : [`${p}.local`, p]),
-      [],
-    );
-  }
+    const didPull = await executePull();
+    const didWriteFileRaw = await executeWriteFileRaw();
+    const didWriteFileBase64 = await executeWriteFileBase64();
+    if (didPull === true || didWriteFileRaw === true || didWriteFileBase64 === true) {
+      // pull/writefile là mode riêng; cho phép kết hợp pull + writefile trong cùng một lệnh.
+      process.exit(0);
+    }
 
-  const variables = [];
-  if (argv.v) {
-    if (typeof argv.v === "string") {
-      variables.push(validateCmdVariable(argv.v));
+    let paths = [];
+    if (argv.e) {
+      if (typeof argv.e === "string") {
+        paths.push(argv.e);
+      } else {
+        paths.push(...argv.e);
+      }
     } else {
-      variables.push(...argv.v.map(validateCmdVariable));
+      paths.push(".env");
+    }
+
+    if (argv.c) {
+      paths = paths.reduce(
+        (accumulator, p) =>
+          accumulator.concat(typeof argv.c === "string" ? [`${p}.${argv.c}.local`, `${p}.local`, `${p}.${argv.c}`, p] : [`${p}.local`, p]),
+        [],
+      );
+    }
+
+    const variables = [];
+    if (argv.v) {
+      if (typeof argv.v === "string") {
+        variables.push(validateCmdVariable(argv.v));
+      } else {
+        variables.push(...argv.v.map(validateCmdVariable));
+      }
     }
-  }
 
   const parseUrlToArgV = async () => {
     /**
@@ -553,42 +732,52 @@ async function main() {
     }
   };
 
-  await parseUrlToArgV();
+    await parseUrlToArgV();
 
   // Merge default env với variables (variables sẽ override default)
-  const defaultEnv = rtdbUtils.getDefaultRtdbEnv() || {};
-  const parsedVariables = {
-    ...defaultEnv,
-    ...Object.fromEntries(variables),
-  };
+    const defaultEnv = rtdbUtils.getDefaultRtdbEnv() || {};
+    const parsedVariables = {
+      ...defaultEnv,
+      ...Object.fromEntries(variables),
+    };
 
-  if (argv.debug) {
-    console.log(paths);
-    console.log(parsedVariables);
-    process.exit();
-  }
+    if (argv.debug) {
+      console.log(paths);
+      console.log(parsedVariables);
+      process.exit();
+    }
 
-  paths.forEach(function (env) {
-    dotenv.config({ path: path.resolve(env), override, quiet: isQuiet });
-  });
+    paths.forEach(function (env) {
+      try {
+        dotenv.config({ path: path.resolve(env), override, quiet: isQuiet });
+      } catch (err) {
+        console.error(formatErrorMessage(`dotenv config failed for ${env}`, err));
+        process.exit(1);
+      }
+    });
 
   // Expand when all path configs are loaded
-  if (argv.expand !== false) {
-    dotenvExpand({
-      parsed: process.env,
-    });
-  }
+    if (argv.expand !== false) {
+      try {
+        dotenvExpand({
+          parsed: process.env,
+        });
+      } catch (err) {
+        console.error(formatErrorMessage("dotenv expand failed", err));
+        process.exit(1);
+      }
+    }
 
-  Object.assign(process.env, parsedVariables);
+    Object.assign(process.env, parsedVariables);
 
-  if (argv.p) {
-    let value = process.env[argv.p];
-    if (typeof value === "string") {
-      value = `${value}`;
+    if (argv.p) {
+      let value = process.env[argv.p];
+      if (typeof value === "string") {
+        value = `${value}`;
+      }
+      console.log(value != null ? value : "");
+      process.exit();
     }
-    console.log(value != null ? value : "");
-    process.exit();
-  }
 
   // cross-env-shell style: allow `KEY=VALUE` at the beginning of the command section (after `--`)
   function parseLeadingEnvAssignments(args = []) {
@@ -608,59 +797,68 @@ async function main() {
     return { env, rest: args.slice(i) };
   }
 
-  const shellOptRaw = argv.shell;
-  let shellOpt = shellOptRaw;
-  if (typeof shellOptRaw === "string") {
-    const t = shellOptRaw.trim().toLowerCase();
-    if (t === "true" || t === "1" || t === "yes") shellOpt = true;
-    else if (t === "false" || t === "0" || t === "no") shellOpt = false;
-    else shellOpt = shellOptRaw.trim();
-  }
+    const shellOptRaw = argv.shell;
+    let shellOpt = shellOptRaw;
+    if (typeof shellOptRaw === "string") {
+      const t = shellOptRaw.trim().toLowerCase();
+      if (t === "true" || t === "1" || t === "yes") shellOpt = true;
+      else if (t === "false" || t === "0" || t === "no") shellOpt = false;
+      else shellOpt = shellOptRaw.trim();
+    }
 
-  const runInShell = shellOpt === true || (typeof shellOpt === "string" && shellOpt !== "");
-  const { env: inlineEnv, rest: cmdArgs } = runInShell ? parseLeadingEnvAssignments(argv._) : { env: {}, rest: argv._ };
+    const runInShell = shellOpt === true || (typeof shellOpt === "string" && shellOpt !== "");
+    const { env: inlineEnv, rest: cmdArgs } = runInShell ? parseLeadingEnvAssignments(argv._) : { env: {}, rest: argv._ };
 
-  if (cmdArgs.length === 0) {
-    printHelp();
-    process.exit(1);
-  }
+    if (cmdArgs.length === 0) {
+      printHelp();
+      process.exit(1);
+    }
 
-  const childEnv = Object.keys(inlineEnv).length ? Object.assign({}, process.env, inlineEnv) : process.env;
+    const childEnv = Object.keys(inlineEnv).length ? Object.assign({}, process.env, inlineEnv) : process.env;
 
-  const spawnOpts = {
-    stdio: "inherit",
-    env: childEnv,
-  };
+    const spawnOpts = {
+      stdio: "inherit",
+      env: childEnv,
+    };
 
   // If --shell is provided:
   // - boolean true => use platform default shell
   // - string => pass through to node spawn `shell` option (advanced)
-  let child;
-  if (runInShell) {
-    const shellCommand = cmdArgs.length === 1 ? cmdArgs[0] : cmdArgs.join(" ");
-    const shellVal = typeof shellOpt === "string" ? shellOpt : true;
-    child = spawn(shellCommand, [], Object.assign({}, spawnOpts, { shell: shellVal }));
-  } else {
-    const command = cmdArgs[0];
-    child = spawn(command, cmdArgs.slice(1), spawnOpts);
-  }
-
-  child.on("exit", function (exitCode, signal) {
-    if (typeof exitCode === "number") {
-      process.exit(exitCode);
+    let child;
+    if (runInShell) {
+      const shellCommand = cmdArgs.length === 1 ? cmdArgs[0] : cmdArgs.join(" ");
+      const shellVal = typeof shellOpt === "string" ? shellOpt : true;
+      child = spawn(shellCommand, [], Object.assign({}, spawnOpts, { shell: shellVal }));
     } else {
-      process.kill(process.pid, signal);
+      const command = cmdArgs[0];
+      child = spawn(command, cmdArgs.slice(1), spawnOpts);
     }
-  });
 
-  for (const signal of ["SIGINT", "SIGTERM", "SIGPIPE", "SIGHUP", "SIGBREAK", "SIGWINCH", "SIGUSR1", "SIGUSR2"]) {
-    process.on(signal, function () {
-      child.kill(signal);
+    child.on("error", function (err) {
+      console.error(formatErrorMessage("spawn process error", err));
+      process.exit(1);
     });
+
+    child.on("exit", function (exitCode, signal) {
+      if (typeof exitCode === "number") {
+        process.exit(exitCode);
+      } else {
+        process.kill(process.pid, signal);
+      }
+    });
+
+    for (const signal of ["SIGINT", "SIGTERM", "SIGPIPE", "SIGHUP", "SIGBREAK", "SIGWINCH", "SIGUSR1", "SIGUSR2"]) {
+      process.on(signal, function () {
+        child.kill(signal);
+      });
+    }
+  } catch (err) {
+    console.error(formatErrorMessage("main error", err));
+    process.exit(1);
   }
 }
 
 main().catch((err) => {
-  console.error(err && err.message ? err.message : err);
+  console.error(formatErrorMessage("fatal error", err));
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tltdh61/dotenvrtdb",
-  "version": "1.260331.11828",
+  "version": "1.260331.11957",
   "description": "A CLI tool to load environment variables from .env files with remote database support",
   "main": "cli.js",
   "bin": {