@aixyz/cli 0.6.0 → 0.8.0

package/register/register.ts

@@ -0,0 +1,178 @@
+import { encodeFunctionData, formatEther, parseEventLogs, type Chain, type Log } from "viem";
+import { IdentityRegistryAbi } from "@aixyz/erc-8004";
+import { selectWalletMethod, type WalletOptions } from "./wallet";
+import { signTransaction } from "./wallet/sign";
+import { resolveUri } from "./utils";
+import {
+  resolveChainConfig,
+  selectChain,
+  resolveRegistryAddress,
+  validateBrowserRpcConflict,
+  getExplorerUrl,
+} from "./utils/chain";
+import { writeResultJson } from "./utils/result";
+import { label, truncateUri, broadcastAndConfirm, logSignResult } from "./utils/transaction";
+import chalk from "chalk";
+import boxen from "boxen";
+import type { BaseOptions } from "./index";
+
+export interface RegisterOptions extends BaseOptions {
+  uri?: string;
+  chain?: string;
+}
+
+export async function register(options: RegisterOptions): Promise<void> {
+  const chainName = options.chain ?? (await selectChain());
+  const chainConfig = resolveChainConfig(chainName);
+
+  const resolvedUri = options.uri ? resolveUri(options.uri) : undefined;
+  if (options.uri && resolvedUri !== options.uri) {
+    console.log(`Resolved ${options.uri} to data URI (${resolvedUri!.length} chars)`);
+  }
+
+  const registryAddress = resolveRegistryAddress(chainName, chainConfig.chainId, options.registry);
+
+  const data = encodeFunctionData({
+    abi: IdentityRegistryAbi,
+    functionName: "register",
+    args: resolvedUri ? [resolvedUri] : [],
+  });
+
+  const printTxDetails = (header: string) => {
+    console.log("");
+    console.log(chalk.dim(header));
+    console.log(`  ${label("To")}${registryAddress}`);
+    console.log(`  ${label("Data")}${data.slice(0, 10)}${chalk.dim("\u2026" + (data.length - 2) / 2 + " bytes")}`);
+    console.log(`  ${label("Chain")}${chainName}`);
+    console.log(`  ${label("Function")}${resolvedUri ? "register(string memory agentURI)" : "register()"}`);
+    if (resolvedUri) {
+      console.log(`  ${label("URI")}${truncateUri(resolvedUri)}`);
+    }
+    console.log("");
+  };
+
+  validateBrowserRpcConflict(options.browser, options.rpcUrl);
+
+  if (!options.broadcast) {
+    if (options.browser || options.keystore || process.env.PRIVATE_KEY) {
+      console.warn("Note: --browser/--keystore/PRIVATE_KEY ignored in dry-run mode. Pass --broadcast to use a wallet.");
+    }
+    printTxDetails("Transaction details (dry-run)");
+    console.log("Dry-run complete. To sign and broadcast, re-run with --broadcast.");
+    return;
+  }
+
+  const walletMethod = await selectWalletMethod(options);
+  validateBrowserRpcConflict(walletMethod.type === "browser" || undefined, options.rpcUrl);
+
+  printTxDetails("Signing transaction...");
+
+  const result = await signTransaction({
+    walletMethod,
+    tx: { to: registryAddress, data },
+    chain: chainConfig.chain,
+    rpcUrl: options.rpcUrl,
+    options: {
+      browser: { chainId: chainConfig.chainId, chainName, uri: resolvedUri },
+    },
+  });
+  logSignResult(walletMethod.type, result);
+
+  const { hash, receipt, timestamp } = await broadcastAndConfirm({
+    result,
+    chain: chainConfig.chain,
+    rpcUrl: options.rpcUrl,
+  });
+
+  const resultData = printResult(receipt, timestamp, chainConfig.chain, chainConfig.chainId, hash);
+
+  if (options.outDir) {
+    writeResultJson(options.outDir, "registration", resultData);
+  }
+}
+
+interface RegistrationResult {
+  agentId?: string;
+  owner?: string;
+  uri?: string;
+  chainId: number;
+  block: string;
+  timestamp: string;
+  gasPaid: string;
+  nativeCurrency: string;
+  txHash: string;
+  explorer?: string;
+  metadata?: Record<string, string>;
+}
+
+function printResult(
+  receipt: { blockNumber: bigint; gasUsed: bigint; effectiveGasPrice: bigint; logs: Log[] },
+  timestamp: bigint,
+  chain: Chain,
+  chainId: number,
+  hash: `0x${string}`,
+): RegistrationResult {
+  const events = parseEventLogs({ abi: IdentityRegistryAbi, logs: receipt.logs });
+  const registered = events.find((e) => e.eventName === "Registered");
+  const metadataEvents = events.filter((e) => e.eventName === "MetadataSet");
+
+  const lines: string[] = [];
+  const result: RegistrationResult = {
+    chainId,
+    block: receipt.blockNumber.toString(),
+    timestamp: new Date(Number(timestamp) * 1000).toUTCString(),
+    gasPaid: formatEther(receipt.gasUsed * receipt.effectiveGasPrice),
+    nativeCurrency: chain.nativeCurrency?.symbol ?? "ETH",
+    txHash: hash,
+  };
+
+  if (registered) {
+    const { agentId, agentURI, owner } = registered.args as { agentId: bigint; agentURI: string; owner: string };
+    result.agentId = agentId.toString();
+    result.owner = owner;
+    if (agentURI) result.uri = agentURI;
+
+    lines.push(`${label("Agent ID")}${chalk.bold(result.agentId)}`);
+    lines.push(`${label("Owner")}${owner}`);
+    if (agentURI) {
+      lines.push(`${label("URI")}${truncateUri(agentURI)}`);
+    }
+    lines.push(`${label("Block")}${receipt.blockNumber}`);
+  } else {
+    lines.push(`${label("Block")}${receipt.blockNumber}`);
+  }
+
+  lines.push(`${label("Timestamp")}${result.timestamp}`);
+  lines.push(`${label("Gas Paid")}${result.gasPaid} ${result.nativeCurrency}`);
+  lines.push(`${label("Tx Hash")}${hash}`);
+
+  const explorerUrl = getExplorerUrl(chain, hash);
+  if (explorerUrl) {
+    result.explorer = explorerUrl;
+    lines.push(`${label("Explorer")}${chalk.cyan(explorerUrl)}`);
+  }
+
+  if (metadataEvents.length > 0) {
+    result.metadata = {};
+    lines.push("");
+    lines.push(chalk.dim("Metadata"));
+    for (const event of metadataEvents) {
+      const { metadataKey, metadataValue } = event.args as { metadataKey: string; metadataValue: string };
+      result.metadata[metadataKey] = metadataValue;
+      lines.push(`${label(metadataKey)}${metadataValue}`);
+    }
+  }
+
+  console.log("");
+  console.log(
+    boxen(lines.join("\n"), {
+      padding: { left: 1, right: 1, top: 0, bottom: 0 },
+      borderStyle: "round",
+      borderColor: "green",
+      title: "Agent registered successfully",
+      titleAlignment: "left",
+    }),
+  );
+
+  return result;
+}

package/register/set-agent-uri.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, test } from "bun:test";
+import { CHAIN_ID, getIdentityRegistryAddress } from "@aixyz/erc-8004";
+import { setAgentUri, validateAgentId } from "./set-agent-uri";
+
+describe("set-agent-uri command chain configuration", () => {
+  test("sepolia chain ID is correct", () => {
+    expect(CHAIN_ID.SEPOLIA).toStrictEqual(11155111);
+  });
+
+  test("base-sepolia chain ID is correct", () => {
+    expect(CHAIN_ID.BASE_SEPOLIA).toStrictEqual(84532);
+  });
+
+  test("identity registry address is returned for sepolia", () => {
+    const address = getIdentityRegistryAddress(CHAIN_ID.SEPOLIA);
+    expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
+  });
+
+  test("identity registry address is returned for base-sepolia", () => {
+    const address = getIdentityRegistryAddress(CHAIN_ID.BASE_SEPOLIA);
+    expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
+  });
+
+  test("throws for unsupported chain ID", () => {
+    expect(() => getIdentityRegistryAddress(999999)).toThrow("Unsupported chain ID");
+  });
+});
+
+describe("validateAgentId", () => {
+  test("accepts 0", () => {
+    expect(() => validateAgentId("0")).not.toThrow();
+  });
+
+  test("accepts positive integer", () => {
+    expect(() => validateAgentId("42")).not.toThrow();
+  });
+
+  test("accepts large integer", () => {
+    expect(() => validateAgentId("999999999")).not.toThrow();
+  });
+
+  test("rejects empty string", () => {
+    expect(() => validateAgentId("")).toThrow("Invalid agent ID");
+  });
+
+  test("rejects whitespace-only string", () => {
+    expect(() => validateAgentId("  ")).toThrow("Invalid agent ID");
+  });
+
+  test("accepts leading zeros", () => {
+    expect(() => validateAgentId("007")).not.toThrow();
+  });
+
+  test("accepts single leading zero before digits", () => {
+    expect(() => validateAgentId("042")).not.toThrow();
+  });
+
+  test("rejects negative number", () => {
+    expect(() => validateAgentId("-1")).toThrow("Invalid agent ID");
+  });
+
+  test("rejects float", () => {
+    expect(() => validateAgentId("1.5")).toThrow("Invalid agent ID");
+  });
+
+  test("rejects non-numeric string", () => {
+    expect(() => validateAgentId("abc")).toThrow("Invalid agent ID");
+  });
+
+  test("rejects mixed string", () => {
+    expect(() => validateAgentId("12abc")).toThrow("Invalid agent ID");
+  });
+
+  test("rejects Infinity", () => {
+    expect(() => validateAgentId("Infinity")).toThrow("Invalid agent ID");
+  });
+
+  test("rejects NaN", () => {
+    expect(() => validateAgentId("NaN")).toThrow("Invalid agent ID");
+  });
+});
+
+describe("set-agent-uri command validation", () => {
+  test("localhost requires --registry flag", async () => {
+    await expect(
+      setAgentUri({ agentId: "1", uri: "https://example.com/agent.json", chain: "localhost" }),
+    ).rejects.toThrow("--registry is required for localhost");
+  });
+
+  test("rejects unsupported chain", async () => {
+    await expect(
+      setAgentUri({ agentId: "1", uri: "https://example.com/agent.json", chain: "fakenet" }),
+    ).rejects.toThrow("Unsupported chain: fakenet");
+  });
+
+  test("rejects invalid registry address", async () => {
+    await expect(
+      setAgentUri({
+        agentId: "1",
+        uri: "https://example.com/agent.json",
+        chain: "localhost",
+        registry: "not-an-address",
+      }),
+    ).rejects.toThrow("Invalid registry address: not-an-address");
+  });
+
+  test("rejects --browser with --rpc-url", async () => {
+    await expect(
+      setAgentUri({
+        agentId: "0",
+        uri: "https://example.com/agent.json",
+        chain: "sepolia",
+        browser: true,
+        rpcUrl: "http://localhost:8545",
+      }),
+    ).rejects.toThrow("--rpc-url cannot be used with browser wallet");
+  });
+
+  test("dry-run completes without wallet interaction when --broadcast is not set", async () => {
+    await expect(
+      setAgentUri({ agentId: "1", uri: "https://example.com/agent.json", chain: "sepolia" }),
+    ).resolves.toBeUndefined();
+  });
+
+  test("rejects invalid agent ID (negative)", async () => {
+    await expect(
+      setAgentUri({ agentId: "-1", uri: "https://example.com/agent.json", chain: "sepolia" }),
+    ).rejects.toThrow("Invalid agent ID");
+  });
+
+  test("rejects invalid agent ID (non-integer)", async () => {
+    await expect(
+      setAgentUri({ agentId: "abc", uri: "https://example.com/agent.json", chain: "sepolia" }),
+    ).rejects.toThrow("Invalid agent ID");
+  });
+
+  test("rejects invalid agent ID (float)", async () => {
+    await expect(
+      setAgentUri({ agentId: "1.5", uri: "https://example.com/agent.json", chain: "sepolia" }),
+    ).rejects.toThrow("Invalid agent ID");
+  });
+
+  test("accepts agent ID 0 as valid", async () => {
+    // Agent ID 0 passes validation — triggers a later error (browser+rpc-url conflict)
+    // proving the agent ID check did not reject it
+    await expect(
+      setAgentUri({
+        agentId: "0",
+        uri: "https://example.com/agent.json",
+        chain: "sepolia",
+        browser: true,
+        rpcUrl: "http://localhost:8545",
+      }),
+    ).rejects.toThrow("--rpc-url cannot be used with browser wallet");
+  });
+});

package/register/set-agent-uri.ts

@@ -0,0 +1,192 @@
+import { encodeFunctionData, formatEther, parseEventLogs, type Chain, type Log } from "viem";
+import { IdentityRegistryAbi } from "@aixyz/erc-8004";
+import { selectWalletMethod } from "./wallet";
+import { signTransaction } from "./wallet/sign";
+import { CliError, resolveUri } from "./utils";
+import {
+  resolveChainConfig,
+  selectChain,
+  resolveRegistryAddress,
+  validateBrowserRpcConflict,
+  getExplorerUrl,
+} from "./utils/chain";
+import { writeResultJson } from "./utils/result";
+import { label, truncateUri, broadcastAndConfirm, logSignResult } from "./utils/transaction";
+import { confirm, input } from "@inquirer/prompts";
+import chalk from "chalk";
+import boxen from "boxen";
+import type { BaseOptions } from "./index";
+import { promptAgentId, promptUri } from "./utils/prompt";
+
+export interface SetAgentUriOptions extends BaseOptions {
+  agentId?: string;
+  uri?: string;
+}
+
+async function confirmEmptyUri(): Promise<void> {
+  const yes = await confirm({
+    message: "URI is empty. This will clear the agent's metadata URI. Are you sure?",
+    default: false,
+  });
+  if (!yes) {
+    throw new CliError("Aborted.");
+  }
+}
+
+export function validateAgentId(agentId: string): void {
+  const n = Number(agentId);
+  if (agentId.trim() === "" || !Number.isInteger(n) || n < 0) {
+    throw new CliError(`Invalid agent ID: ${agentId}. Must be a non-negative integer.`);
+  }
+}
+
+export async function setAgentUri(options: SetAgentUriOptions): Promise<void> {
+  const chainName = options.chain ?? (await selectChain());
+  const chainConfig = resolveChainConfig(chainName);
+
+  const agentId = options.agentId ?? (await promptAgentId());
+  validateAgentId(agentId);
+
+  const uri = options.uri ?? (await promptUri());
+  if (uri === "") {
+    await confirmEmptyUri();
+  }
+  const resolvedUri = uri === "" ? "" : resolveUri(uri);
+  if (resolvedUri !== uri) {
+    console.log(`Resolved ${uri} to data URI (${resolvedUri.length} chars)`);
+  }
+
+  const registryAddress = resolveRegistryAddress(chainName, chainConfig.chainId, options.registry);
+
+  const data = encodeFunctionData({
+    abi: IdentityRegistryAbi,
+    functionName: "setAgentURI",
+    args: [BigInt(agentId), resolvedUri],
+  });
+
+  const printTxDetails = (header: string) => {
+    console.log("");
+    console.log(chalk.dim(header));
+    console.log(`  ${label("To")}${registryAddress}`);
+    console.log(`  ${label("Data")}${data.slice(0, 10)}${chalk.dim("\u2026" + (data.length - 2) / 2 + " bytes")}`);
+    console.log(`  ${label("Chain")}${chainName}`);
+    console.log(`  ${label("Function")}setAgentURI(uint256 agentId, string calldata newURI)`);
+    console.log(`  ${label("Agent ID")}${agentId}`);
+    console.log(`  ${label("URI")}${truncateUri(resolvedUri)}`);
+    console.log("");
+  };
+
+  validateBrowserRpcConflict(options.browser, options.rpcUrl);
+
+  if (!options.broadcast) {
+    if (options.browser || options.keystore || process.env.PRIVATE_KEY) {
+      console.warn("Note: --browser/--keystore/PRIVATE_KEY ignored in dry-run mode. Pass --broadcast to use a wallet.");
+    }
+    printTxDetails("Transaction details (dry-run)");
+    console.log("Dry-run complete. To sign and broadcast, re-run with --broadcast.");
+    return;
+  }
+
+  const walletMethod = await selectWalletMethod(options);
+  validateBrowserRpcConflict(walletMethod.type === "browser" || undefined, options.rpcUrl);
+
+  printTxDetails("Signing transaction...");
+
+  const result = await signTransaction({
+    walletMethod,
+    tx: { to: registryAddress, data },
+    chain: chainConfig.chain,
+    rpcUrl: options.rpcUrl,
+    options: {
+      browser: { chainId: chainConfig.chainId, chainName, uri: resolvedUri },
+    },
+  });
+  logSignResult(walletMethod.type, result);
+
+  const { hash, receipt, timestamp } = await broadcastAndConfirm({
+    result,
+    chain: chainConfig.chain,
+    rpcUrl: options.rpcUrl,
+  });
+
+  const resultData = printResult(receipt, timestamp, chainConfig.chain, chainConfig.chainId, hash);
+
+  if (options.outDir) {
+    writeResultJson(options.outDir, "set-agent-uri", resultData);
+  }
+}
+
+interface SetAgentUriResult {
+  agentId?: string;
+  newUri?: string;
+  updatedBy?: `0x${string}`;
+  chainId: number;
+  block: string;
+  timestamp: string;
+  gasPaid: string;
+  nativeCurrency: string;
+  txHash: string;
+  explorer?: string;
+}
+
+function printResult(
+  receipt: { blockNumber: bigint; gasUsed: bigint; effectiveGasPrice: bigint; logs: readonly unknown[] },
+  timestamp: bigint,
+  chain: Chain,
+  chainId: number,
+  hash: `0x${string}`,
+): SetAgentUriResult {
+  const events = parseEventLogs({ abi: IdentityRegistryAbi, logs: receipt.logs as Log[] });
+  const uriUpdated = events.find((e) => e.eventName === "URIUpdated");
+
+  const lines: string[] = [];
+  const result: SetAgentUriResult = {
+    chainId,
+    block: receipt.blockNumber.toString(),
+    timestamp: new Date(Number(timestamp) * 1000).toUTCString(),
+    gasPaid: formatEther(receipt.gasUsed * receipt.effectiveGasPrice),
+    nativeCurrency: chain.nativeCurrency?.symbol ?? "ETH",
+    txHash: hash,
+  };
+
+  if (uriUpdated) {
+    const { agentId, newURI, updatedBy } = uriUpdated.args as {
+      agentId: bigint;
+      newURI: string;
+      updatedBy: `0x${string}`;
+    };
+    result.agentId = agentId.toString();
+    result.newUri = newURI;
+    result.updatedBy = updatedBy;
+
+    lines.push(`${label("Agent ID")}${chalk.bold(result.agentId)}`);
+    lines.push(`${label("New URI")}${truncateUri(newURI)}`);
+    lines.push(`${label("Updated By")}${updatedBy}`);
+    lines.push(`${label("Block")}${receipt.blockNumber}`);
+  } else {
+    lines.push(`${label("Block")}${receipt.blockNumber}`);
+  }
+
+  lines.push(`${label("Timestamp")}${result.timestamp}`);
+  lines.push(`${label("Gas Paid")}${result.gasPaid} ${result.nativeCurrency}`);
+  lines.push(`${label("Tx Hash")}${hash}`);
+
+  const explorerUrl = getExplorerUrl(chain, hash);
+  if (explorerUrl) {
+    result.explorer = explorerUrl;
+    lines.push(`${label("Explorer")}${chalk.cyan(explorerUrl)}`);
+  }
+
+  console.log("");
+  console.log(
+    boxen(lines.join("\n"), {
+      padding: { left: 1, right: 1, top: 0, bottom: 0 },
+      borderStyle: "round",
+      borderColor: "green",
+      title: "Agent URI updated successfully",
+      titleAlignment: "left",
+    }),
+  );
+
+  return result;
+}

package/register/utils/chain.ts

@@ -0,0 +1,57 @@
+import { isAddress, type Chain } from "viem";
+import { mainnet, sepolia, baseSepolia, foundry } from "viem/chains";
+import { CHAIN_ID, getIdentityRegistryAddress } from "@aixyz/erc-8004";
+import { select } from "@inquirer/prompts";
+import { CliError } from "../utils";
+
+export interface ChainConfig {
+  chain: Chain;
+  chainId: number;
+}
+
+export const CHAINS: Record<string, ChainConfig> = {
+  mainnet: { chain: mainnet, chainId: CHAIN_ID.MAINNET },
+  sepolia: { chain: sepolia, chainId: CHAIN_ID.SEPOLIA },
+  "base-sepolia": { chain: baseSepolia, chainId: CHAIN_ID.BASE_SEPOLIA },
+  localhost: { chain: foundry, chainId: 31337 },
+};
+
+export function resolveChainConfig(chainName: string): ChainConfig {
+  const config = CHAINS[chainName];
+  if (!config) {
+    throw new CliError(`Unsupported chain: ${chainName}. Supported chains: ${Object.keys(CHAINS).join(", ")}`);
+  }
+  return config;
+}
+
+export async function selectChain(): Promise<string> {
+  return select({
+    message: "Select target chain:",
+    choices: Object.keys(CHAINS).map((name) => ({ name, value: name })),
+  });
+}
+
+export function resolveRegistryAddress(chainName: string, chainId: number, registry?: string): `0x${string}` {
+  if (registry) {
+    if (!isAddress(registry)) {
+      throw new CliError(`Invalid registry address: ${registry}`);
+    }
+    return registry as `0x${string}`;
+  }
+  if (chainName === "localhost") {
+    throw new CliError("--registry is required for localhost (no default contract deployment)");
+  }
+  return getIdentityRegistryAddress(chainId) as `0x${string}`;
+}
+
+export function validateBrowserRpcConflict(browser: boolean | undefined, rpcUrl: string | undefined): void {
+  if (browser && rpcUrl) {
+    throw new CliError("--rpc-url cannot be used with browser wallet. The browser wallet uses its own RPC endpoint.");
+  }
+}
+
+export function getExplorerUrl(chain: Chain, txHash: string): string | null {
+  const explorer = chain.blockExplorers?.default;
+  if (!explorer) return null;
+  return `${explorer.url}/tx/${txHash}`;
+}

package/register/utils/prompt.ts

@@ -0,0 +1,18 @@
+import { input } from "@inquirer/prompts";
+
+export async function promptAgentId(): Promise<string> {
+  return input({
+    message: "Agent ID (token ID) to update:",
+    validate: (value) => {
+      const n = Number(value);
+      if (value.trim() === "" || !Number.isInteger(n) || n < 0) return "Must be a non-negative integer";
+      return true;
+    },
+  });
+}
+
+export async function promptUri(): Promise<string> {
+  return input({
+    message: "New agent metadata URI or path to .json file (leave empty to clear):",
+  });
+}

package/register/utils/result.ts

@@ -0,0 +1,14 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+
+export function writeResultJson(outDir: string, filenamePrefix: string, result: { chainId: number }): void {
+  if (!existsSync(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+  }
+
+  const filename = `${filenamePrefix}-${result.chainId}-${Date.now()}.json`;
+  const filePath = join(outDir, filename);
+  writeFileSync(filePath, JSON.stringify(result, null, 2) + "\n");
+  console.log(`\n${chalk.green("✓")} Result written to ${chalk.bold(filePath)}`);
+}

package/register/utils/spinner.ts

@@ -0,0 +1,39 @@
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const INTERVAL = 80;
+
+export interface Spinner {
+  pause(): void;
+  stop(finalMessage?: string): void;
+}
+
+export function startSpinner(message: string): Spinner {
+  if (!process.stderr.isTTY) {
+    process.stderr.write(`${message}\n`);
+    return { pause() {}, stop() {} };
+  }
+
+  let i = 0;
+  let timer: ReturnType<typeof setInterval> | null = setInterval(() => {
+    process.stderr.write(`\r${FRAMES[i++ % FRAMES.length]} ${message}`);
+  }, INTERVAL);
+
+  return {
+    pause() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+        process.stderr.write(`\r\x1b[2K`);
+      }
+    },
+    stop(finalMessage?: string) {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      process.stderr.write(`\r\x1b[2K`);
+      if (finalMessage) {
+        process.stderr.write(`${finalMessage}\n`);
+      }
+    },
+  };
+}