fix(account): catch inquirer force-close instead of guarding on isTTY

The first cut guarded promptPassword with !process.stdin.isTTY, which was too
blunt: it rejected PIPED stdin outright. But piped stdin is exactly how the e2e
harness (and real automation) supply the keystore password — so `genlayer
deploy` and every keystore-unlock path started failing with 'Maximum password
attempts exceeded' in CI (isTTY is false for a pipe, so the guard threw before
inquirer could read the piped password).

Instead, let inquirer run and catch its ExitPromptError ('User force closed the
prompt') — which only fires on an ACTUAL force-close (no TTY AND no piped
input). Rewrite that into the actionable, flag-naming message. Piped stdin now
reaches inquirer normally; the clear error still appears when there is genuinely
no input.

Verified against a keystore: piped source-password exports OK; empty stdin
yields 'No interactive terminal available for a password prompt. Pass
--source-password ...'. 774/774 unit tests.

Author: MuncleUscles

src/lib/actions/BaseAction.ts

@@ -450,35 +450,47 @@ export class BaseAction extends ConfigFileManager {
   }
 
   /**
-   * Fail with an actionable message instead of letting inquirer throw a cryptic
-   * `ExitPromptError: User force closed the prompt` when there is no interactive
-   * terminal (piped stdin, CI, automation). Without this, a missing flag reads
-   * like the user hit Ctrl-C. `hint` names the flag(s) that make the command
-   * non-interactive so the fix is obvious.
+   * inquirer throws an `ExitPromptError` ("User force closed the prompt") when a
+   * prompt can't be satisfied — no TTY and no piped stdin. That message reads
+   * exactly like the user hit Ctrl-C when in fact a required flag is missing.
+   * Rewrite it into an actionable error naming the flag(s) that make the command
+   * non-interactive. Crucially this only fires on an ACTUAL force-close: piped
+   * stdin (how the e2e harness and automation supply the password) still feeds
+   * inquirer normally, so we must NOT pre-empt with an `isTTY` guard.
    */
-  protected assertInteractive(hint?: string): void {
-    if (process.stdin.isTTY) return;
-    const guidance = hint ?? "Provide the required value via the corresponding command flag to run non-interactively.";
-    throw new Error(`No interactive terminal available for a prompt. ${guidance}`);
+  private isExitPromptError(error: unknown): boolean {
+    if (!error) return false;
+    const name = (error as {name?: string}).name;
+    const message = error instanceof Error ? error.message : String(error);
+    return name === "ExitPromptError" || /force closed the prompt/i.test(message);
   }
 
   protected async promptPassword(message: string, nonInteractiveHint?: string): Promise<string> {
-    this.assertInteractive(nonInteractiveHint);
-    const answer = await inquirer.prompt([
-      {
-        type: "password",
-        name: "password",
-        message: chalk.yellow(message),
-        mask: "*",
-        validate: (input: string) => {
-          if (!input) {
-            return "Password cannot be empty";
-          }
-          return true;
+    try {
+      const answer = await inquirer.prompt([
+        {
+          type: "password",
+          name: "password",
+          message: chalk.yellow(message),
+          mask: "*",
+          validate: (input: string) => {
+            if (!input) {
+              return "Password cannot be empty";
+            }
+            return true;
+          },
         },
-      },
-    ]);
-    return answer.password;
+      ]);
+      return answer.password;
+    } catch (error) {
+      if (this.isExitPromptError(error)) {
+        const guidance =
+          nonInteractiveHint ??
+          "Provide the required value via the corresponding command flag to run non-interactively.";
+        throw new Error(`No interactive terminal available for a password prompt. ${guidance}`);
+      }
+      throw error;
+    }
   }
 
   protected async confirmPrompt(message: string): Promise<void> {

tests/libs/baseAction.test.ts

@@ -27,7 +27,6 @@ describe("BaseAction", () => {
   let consoleSpy: any;
   let consoleErrorSpy: any;
   let processExitSpy: any;
-  const originalIsTTY = process.stdin.isTTY;
 
   // Standard web3 keystore format
   const mockKeystoreData = {
@@ -51,10 +50,6 @@ describe("BaseAction", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    // Prompts require an interactive terminal; simulate one so the
-    // interactive-path assertions exercise inquirer (vitest's stdin is not a
-    // TTY, which would otherwise trip the non-interactive guard).
-    (process.stdin as {isTTY?: boolean}).isTTY = true;
     consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
     consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
     processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
@@ -109,7 +104,6 @@ describe("BaseAction", () => {
 
   afterEach(() => {
     vi.restoreAllMocks();
-    (process.stdin as {isTTY?: boolean}).isTTY = originalIsTTY;
   });
 
   test("should start the spinner with a message", () => {
@@ -261,23 +255,36 @@ describe("BaseAction", () => {
     }]);
   });
 
-  test("should throw an actionable error (not prompt) when no interactive terminal is available", async () => {
-    (process.stdin as {isTTY?: boolean}).isTTY = false;
+  test("rewrites inquirer's force-close (no TTY, no piped input) into an actionable error", async () => {
+    // inquirer throws ExitPromptError when a prompt can't be satisfied; that
+    // reads like Ctrl-C when a flag is actually missing. We rewrite it, naming
+    // the flag. (We do NOT pre-empt with an isTTY guard — piped stdin must still
+    // reach inquirer; see the deploy path in the e2e harness.)
+    const exitErr = Object.assign(new Error("User force closed the prompt with 0 null"), {
+      name: "ExitPromptError",
+    });
+    vi.mocked(inquirer.prompt).mockRejectedValue(exitErr);
 
     await expect(
       baseAction["promptPassword"]("Enter password:", "Pass --source-password to run non-interactively."),
     ).rejects.toThrow(/No interactive terminal available.*--source-password/s);
-    // Must fail fast, before inquirer force-closes with a misleading ExitPromptError.
-    expect(inquirer.prompt).not.toHaveBeenCalled();
+    expect(inquirer.prompt).toHaveBeenCalled(); // inquirer IS invoked; we only rewrite its force-close
   });
 
-  test("should surface the generic non-interactive hint when no flag hint is given", async () => {
-    (process.stdin as {isTTY?: boolean}).isTTY = false;
+  test("surfaces the generic hint when no flag hint is given", async () => {
+    const exitErr = Object.assign(new Error("User force closed the prompt with 0 null"), {
+      name: "ExitPromptError",
+    });
+    vi.mocked(inquirer.prompt).mockRejectedValue(exitErr);
 
     await expect(baseAction["promptPassword"]("Enter password:")).rejects.toThrow(
       /No interactive terminal available.*corresponding command flag/s,
     );
-    expect(inquirer.prompt).not.toHaveBeenCalled();
+  });
+
+  test("passes through a non-force-close prompt error unchanged", async () => {
+    vi.mocked(inquirer.prompt).mockRejectedValue(new Error("some other inquirer failure"));
+    await expect(baseAction["promptPassword"]("Enter password:")).rejects.toThrow(/some other inquirer failure/);
   });
 
   test("should validate password input is not empty", async () => {