Implement logic to ask for telemetry consent #5501 (#5503)

Author: ChristopherDedominici

v-next/hardhat/src/internal/cli/main.ts

@@ -38,6 +38,7 @@ import { printErrorMessages } from "./error-handler.js";
 import { getGlobalHelpString } from "./helpers/getGlobalHelpString.js";
 import { getHelpString } from "./helpers/getHelpString.js";
 import { initHardhat } from "./init/init.js";
+import { getTelemetryConsent } from "./telemetry/telemetry-consent.js";
 import { printVersionMessage } from "./version.js";
 
 export async function main(
@@ -64,6 +65,9 @@ export async function main(
       return await initHardhat();
     }
 
+    // TODO: the consent will be enabled in the other PRs related to telemetry
+    const _telemetryConsent = await getTelemetryConsent();
+
     if (builtinGlobalOptions.configPath === undefined) {
       builtinGlobalOptions.configPath = await resolveHardhatConfigPath();
     }

v-next/hardhat/src/internal/cli/prompt/prompt.ts

@@ -0,0 +1,59 @@
+/**
+ * Display a confirmation prompt to the user. The prompt will be canceled if no response is given within a specified time limit.
+ * @param name Used as the key for the answer on the returned values (answers) object.
+ * @param message The message to display when the prompt is rendered in the terminal.
+ * @param timeoutMilliseconds After how much time the prompt will be cancelled if no answer is given.
+ * @returns True or false based on the user input, or undefined if the prompt times out.
+ */
+export async function confirmationPromptWithTimeout(
+  name: string,
+  message: string,
+  timeoutMilliseconds: number = 10_000,
+): Promise<boolean | undefined> {
+  try {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- The types in the module "enquirer" are not properly defined
+    const { default: enquirer } = (await import("enquirer")) as any;
+
+    const prompt = new enquirer.prompts.Confirm(
+      createConfirmationPrompt(name, message),
+    );
+
+    // The timeout is a safety measure in case Hardhat is executed in a CI or another non-interactive environment and we do not detect it.
+    // Instead of blocking the process indefinitely, we abort the prompt after a while.
+    let timeout;
+    const timeoutPromise = new Promise((resolve) => {
+      timeout = setTimeout(resolve, timeoutMilliseconds);
+    });
+
+    const result: boolean | undefined = await Promise.race([
+      prompt.run(),
+      timeoutPromise,
+    ]);
+
+    clearTimeout(timeout);
+
+    if (result === undefined) {
+      await prompt.cancel();
+      return undefined;
+    }
+
+    return result;
+  } catch (e) {
+    if (e === "") {
+      // If the user cancels the prompt, we quit
+      return undefined;
+    }
+
+    throw e;
+  }
+}
+
+function createConfirmationPrompt(name: string, message: string) {
+  return {
+    type: "confirm",
+    name,
+    message,
+    initial: "y",
+    default: "(Y/n)",
+  };
+}

v-next/hardhat/src/internal/cli/telemetry/telemetry-consent.ts

@@ -0,0 +1,78 @@
+import path from "node:path";
+
+import { getConfigDir } from "@ignored/hardhat-vnext-core/global-dir";
+import { isCi } from "@ignored/hardhat-vnext-utils/ci";
+import {
+  exists,
+  readJsonFile,
+  writeJsonFile,
+} from "@ignored/hardhat-vnext-utils/fs";
+
+import { confirmationPromptWithTimeout } from "../prompt/prompt.js";
+
+interface TelemetryConsent {
+  consent: boolean;
+}
+
+/**
+ * Get the user's telemetry consent. If already provided, returns the answer.
+ * If not, prompts the user.
+ * Consent is only asked in interactive environments.
+ * @returns True if the user consents to telemetry, false otherwise.
+ */
+export async function getTelemetryConsent(): Promise<boolean> {
+  if (canTelemetryBeEnabled() === false) {
+    return false;
+  }
+
+  const telemetryConsentFilePath = await getTelemetryConsentFilePath();
+
+  if (await exists(telemetryConsentFilePath)) {
+    // Telemetry consent was already provided, hence return the answer
+    return (await readJsonFile<TelemetryConsent>(telemetryConsentFilePath))
+      .consent;
+  }
+
+  // Telemetry consent not provided yet, ask for it
+  return requestTelemetryConsent();
+}
+
+function canTelemetryBeEnabled(): boolean {
+  return (
+    !isCi() &&
+    process.stdout.isTTY === true &&
+    process.env.HARDHAT_DISABLE_TELEMETRY_PROMPT !== "true"
+  );
+}
+
+async function getTelemetryConsentFilePath() {
+  const configDir = await getConfigDir();
+  return path.join(configDir, "telemetry-consent.json");
+}
+
+async function requestTelemetryConsent(): Promise<boolean> {
+  const consent = await confirmTelemetryConsent();
+
+  if (consent === undefined) {
+    return false;
+  }
+
+  // Store user's consent choice
+  await writeJsonFile(await getTelemetryConsentFilePath(), { consent });
+
+  // TODO: this will be enabled in a following PR as soon as the function to send telemetry is implemented
+  // const subprocessFilePath = path.join(
+  //   path.dirname(fileURLToPath(import.meta.url)),
+  //   "report-telemetry-consent.js",
+  // );
+  // await spawnDetachedSubProcess(subprocessFilePath, [consent ? "yes" : "no"]);
+
+  return consent;
+}
+
+async function confirmTelemetryConsent(): Promise<boolean | undefined> {
+  return confirmationPromptWithTimeout(
+    "telemetryConsent",
+    "Help us improve Hardhat with anonymous crash reports & basic usage data?",
+  );
+}