feat(cli): improve startup feedback

tuler · tuler · commit 8e4d09c5eba6 · 2025-03-14T00:14:53.000-04:00
diff --git a/apps/cli/package.json b/apps/cli/package.json
@@ -30,9 +30,11 @@
         "execa": "^9.5.2",
         "fs-extra": "^11.3.0",
         "giget": "^2.0.0",
+        "listr2": "^8.2.5",
         "lookpath": "^1.2.3",
         "open": "^10.1.0",
         "ora": "^8.2.0",
+        "p-retry": "^6.2.1",
         "progress-stream": "^2.0.0",
         "semver": "^7.7.1",
         "smol-toml": "^1.3.1",
diff --git a/apps/cli/src/base.ts b/apps/cli/src/base.ts
@@ -92,22 +92,39 @@ export const logPrompt = ({
     console.log(`${chalk.green("?")} ${title} ${chalk.cyan(value)}`);
 };
 
-export const getServiceState = async (
-    projectName: string,
-    serviceName: string,
-): Promise<string | undefined> => {
+const getServiceInfo = async (options: {
+    projectName: string;
+    service: string;
+}): Promise<PsResponse | undefined> => {
+    const { projectName, service } = options;
+
     // get service information
     const { stdout } = await execa("docker", [
         "compose",
         "--project-name",
         projectName,
         "ps",
-        serviceName,
+        service,
         "--format",
         "json",
     ]);
-    const ps = stdout ? (JSON.parse(stdout) as PsResponse) : undefined;
-    return ps?.State;
+    return stdout ? (JSON.parse(stdout) as PsResponse) : undefined;
+};
+
+export const getServiceState = async (options: {
+    projectName: string;
+    service: string;
+}): Promise<string | undefined> => {
+    const info = await getServiceInfo(options);
+    return info?.State;
+};
+
+export const getServiceHealth = async (options: {
+    projectName: string;
+    service: string;
+}): Promise<string | undefined> => {
+    const info = await getServiceInfo(options);
+    return info?.Health;
 };
 
 export const parseAddress = (
diff --git a/apps/cli/src/commands/rollups/start.ts b/apps/cli/src/commands/rollups/start.ts
@@ -1,20 +1,133 @@
 import { Command, Option } from "@commander-js/extra-typings";
 import chalk from "chalk";
 import { execa } from "execa";
+import { Listr, ListrTask } from "listr2";
+import pRetry from "p-retry";
 import path from "path";
+import { getServiceHealth } from "../../base.js";
 import { RollupsCommandOpts } from "../rollups.js";
 
 const commaSeparatedList = (value: string, _previous: string[]) =>
     value.split(",");
 
-const availableServices = [
-    "bundler",
-    "explorer",
-    "graphql",
-    // "otterscan",
-    "paymaster",
+type Service = {
+    name: string; // name of the service
+    file: string; // docker compose file name
+    healthySemaphore?: string; // service to check if the service is healthy
+    healthyTitle?: string | ((port: number) => string); // title of the service when it is healthy
+    waitTitle?: string; // title of the service when it is starting
+    errorTitle?: string; // title of the service when it is not healthy
+};
+
+const host = "http://127.0.0.1";
+
+// services configuration
+const standardServices: Service[] = [
+    {
+        name: "anvil",
+        file: "docker-compose-anvil.yaml",
+        healthySemaphore: "anvil",
+        healthyTitle: `Service ${chalk.cyan("anvil")} ready at ${chalk.cyan(`${host}:8545`)}`,
+        waitTitle: `Starting ${chalk.cyan("anvil")}...`,
+        errorTitle: `Service ${chalk.red("anvil")} failed`,
+    },
+    {
+        name: "proxy",
+        file: "docker-compose-proxy.yaml",
+    },
+    {
+        name: "database",
+        file: "docker-compose-database.yaml",
+    },
+    {
+        name: "rollups-node",
+        file: "docker-compose-node.yaml",
+        healthySemaphore: "proxy",
+        healthyTitle: (port) =>
+            `Service ${chalk.cyan("rollups-node")} ready at ${chalk.cyan(`${host}:${port}/inspect/<address>`)}`,
+        waitTitle: `Starting ${chalk.cyan("rollups-node")}...`,
+        errorTitle: `Service ${chalk.red("rollups-node")} failed`,
+    },
 ];
 
+const availableServices: Service[] = [
+    {
+        name: "bundler",
+        file: "docker-compose-bundler.yaml",
+        healthySemaphore: "proxy",
+        healthyTitle: (port) =>
+            `Service ${chalk.cyan("bundler")} ready at ${chalk.cyan(`${host}:${port}/bundler/rpc`)}`,
+        waitTitle: `Starting ${chalk.cyan("bundler")}...`,
+        errorTitle: `Service ${chalk.red("bundler")} failed`,
+    },
+    {
+        name: "espresso",
+        file: "docker-compose-espresso.yaml",
+        healthySemaphore: "proxy",
+        healthyTitle: (port) =>
+            `Service ${chalk.cyan("espresso")} ready at ${chalk.cyan(`${host}:${port}/espresso`)}`,
+        waitTitle: `Starting ${chalk.cyan("espresso")}...`,
+        errorTitle: `Service ${chalk.red("espresso")} failed`,
+    },
+    {
+        name: "explorer",
+        file: "docker-compose-explorer.yaml",
+        healthySemaphore: "proxy",
+        healthyTitle: (port) =>
+            `Service ${chalk.cyan("explorer")} ready at ${chalk.cyan(`${host}:${port}/explorer`)}`,
+        waitTitle: `Starting ${chalk.cyan("explorer")}...`,
+        errorTitle: `Service ${chalk.red("explorer")} failed`,
+    },
+    {
+        name: "graphql",
+        file: "docker-compose-graphql.yaml",
+        healthySemaphore: "proxy",
+        healthyTitle: (port) =>
+            `Service ${chalk.cyan("graphql")} ready at ${chalk.cyan(`${host}:${port}/graphql`)}`,
+        waitTitle: `Starting ${chalk.cyan("graphql")}...`,
+        errorTitle: `Service ${chalk.red("graphql")} failed`,
+    },
+    {
+        name: "paymaster",
+        file: "docker-compose-paymaster.yaml",
+        healthySemaphore: "proxy",
+        healthyTitle: (port) =>
+            `Service ${chalk.cyan("paymaster")} ready at ${chalk.cyan(`${host}:${port}/paymaster`)}`,
+        waitTitle: `Starting ${chalk.cyan("paymaster")}...`,
+        errorTitle: `Service ${chalk.red("paymaster")} failed`,
+    },
+];
+
+const serviceMonitorTask = (options: {
+    errorTitle?: string;
+    healthyTitle?: string;
+    projectName: string;
+    service: string;
+    waitTitle?: string;
+}): ListrTask => {
+    const { errorTitle, healthyTitle, service, waitTitle } = options;
+
+    return {
+        task: async (_ctx, task) => {
+            await pRetry(
+                async () => {
+                    const health = await getServiceHealth(options);
+                    if (health !== "healthy") {
+                        throw new Error(
+                            errorTitle ??
+                                `Service ${chalk.cyan(service)} is not healthy`,
+                        );
+                    }
+                },
+                { retries: 100, minTimeout: 500, factor: 1.1 },
+            );
+            task.title =
+                healthyTitle ?? `Service ${chalk.cyan(service)} is ready`;
+        },
+        title: waitTitle ?? `Starting ${chalk.cyan(service)}...`,
+    };
+};
+
 export const createStartCommand = () => {
     return new Command<[], {}, RollupsCommandOpts>("start")
         .description("Start a local rollups node environment.")
@@ -54,7 +167,6 @@ export const createStartCommand = () => {
             [],
         )
         .option("-p, --port <number>", "port to listen on", parseInt, 8080)
-        .option("-d, --detach", "run in detached mode", false)
         .option("--dry-run", "show the docker compose configuration", false)
         .option("-v, --verbose", "verbose output", false)
         .action(async (options, command) => {
@@ -63,7 +175,6 @@ export const createStartCommand = () => {
                 blockTime,
                 cpus,
                 defaultBlock,
-                detach,
                 dryRun,
                 memory,
                 port,
@@ -77,24 +188,18 @@ export const createStartCommand = () => {
             );
 
             // setup the environment variable used in docker compose
-            const listenPort = port;
             const env: NodeJS.ProcessEnv = {
                 ANVIL_VERBOSITY: verbose ? "--steps-tracing" : "--silent",
                 BLOCK_TIME: blockTime.toString(),
                 CARTESI_BLOCKCHAIN_DEFAULT_BLOCK: defaultBlock,
                 CARTESI_LOG_LEVEL: verbose ? "info" : "error",
                 CARTESI_BIN_PATH: binPath,
-                CARTESI_LISTEN_PORT: listenPort.toString(),
+                CARTESI_LISTEN_PORT: port.toString(),
                 CARTESI_ROLLUPS_NODE_CPUS: cpus?.toString(),
                 CARTESI_ROLLUPS_NODE_MEMORY: memory?.toString(),
             };
 
-            const composeFiles = [
-                "docker-compose-anvil.yaml",
-                "docker-compose-proxy.yaml",
-                "docker-compose-database.yaml",
-                "docker-compose-node.yaml",
-            ];
+            const composeFiles = standardServices.map(({ file }) => file);
 
             // cpu and memory limits, mostly for testing and debuggingpurposes
             if (cpus) {
@@ -104,21 +209,16 @@ export const createStartCommand = () => {
                 composeFiles.push("docker-compose-node-memory.yaml");
             }
 
+            // select subset of optional services
             const optionalServices =
                 services.length === 1 && services[0] === "all"
                     ? availableServices
-                    : services;
-
-            // validate services and add to compose files
-            for (const service of optionalServices) {
-                if (!availableServices.includes(service)) {
-                    throw new Error(
-                        `Service ${chalk.cyan(service)} not available`,
-                    );
-                } else {
-                    composeFiles.push(`docker-compose-${service}.yaml`);
-                }
-            }
+                    : availableServices.filter(({ name }) =>
+                          services.includes(name),
+                      );
+
+            // add to compose files list
+            composeFiles.push(...optionalServices.map(({ file }) => file));
 
             // create the "--file <file>" list
             const files = composeFiles
@@ -128,63 +228,48 @@ export const createStartCommand = () => {
                 ])
                 .flat();
 
-            const compose_args = [
+            const composeArgs = [
                 "compose",
                 ...files,
                 "--project-name",
                 projectName,
             ];
 
-            const up_args = [];
+            // run in detached mode (background)
+            const upArgs = ["--detach"];
 
-            if (detach) {
-                // run in detached mode (background)
-                // will need to check logs using docker
-                up_args.push("--detach");
+            if (dryRun) {
+                // show the docker compose configuration
+                await execa("docker", [...composeArgs, "config"], {
+                    env,
+                    stdio: "inherit",
+                });
             } else {
-                if (!verbose) {
-                    // attach only to rollups-node and prompt
-                    compose_args.push("--progress", "quiet");
-                    up_args.push("--attach", "rollups-node");
-                }
-            }
-
-            // XXX: need this handler, so SIGINT can still call the finally block below
-            process.on("SIGINT", () => {});
-
-            try {
-                if (dryRun) {
-                    // show the docker compose configuration
-                    await execa("docker", [...compose_args, "config"], {
-                        env,
-                        stdio: "inherit",
-                    });
-                    return;
-                }
-
                 // run compose environment
-                await execa("docker", [...compose_args, "up", ...up_args], {
+                const up = execa("docker", [...composeArgs, "up", ...upArgs], {
                     env,
-                    stdio: "inherit",
                 });
-            } catch (e: unknown) {
-                // 130 is a graceful shutdown, so we can swallow it
-                if ((e as any).exitCode !== 130) {
-                    throw e;
-                }
-            } finally {
-                // if it's detached, exit silently, because it's running in the background
-                if (!detach) {
-                    // shut it down, including volumes
-                    await execa(
-                        "docker",
-                        [...compose_args, "down", "--volumes"],
-                        {
-                            env,
-                            stdio: "inherit",
-                        },
-                    );
-                }
+
+                // create tasks to monitor services startup
+                const monitorTasks = [...standardServices, ...optionalServices]
+                    .filter(({ healthySemaphore }) => !!healthySemaphore) // only services with a healthy semaphore
+                    .map((service) => {
+                        const healthyTitle =
+                            typeof service.healthyTitle === "function"
+                                ? service.healthyTitle(port)
+                                : service.healthyTitle;
+                        return serviceMonitorTask({
+                            projectName,
+                            service: service.healthySemaphore!,
+                            errorTitle: service.errorTitle,
+                            waitTitle: service.waitTitle,
+                            healthyTitle,
+                        });
+                    });
+
+                const tasks = new Listr(monitorTasks, { concurrent: true });
+                await tasks.run();
+                await up;
             }
         });
 };
diff --git a/apps/cli/src/commands/rollups/status.ts b/apps/cli/src/commands/rollups/status.ts
@@ -12,7 +12,10 @@ export const createStatusCommand = () => {
         .option("--json", "output in JSON format")
         .action(async ({ json }, command) => {
             const { projectName } = command.optsWithGlobals();
-            const status = await getServiceState(projectName, "rollups-node");
+            const status = await getServiceState({
+                projectName,
+                service: "rollups-node",
+            });
             const deployments = await getDeployments({ projectName });
 
             if (json) {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
