@cartesi/cli 2.0.0-alpha.1 → 2.0.0-alpha.12

package/dist/commands/deploy/build.js

@@ -1,62 +1,9 @@
-import { Flags } from "@oclif/core";
-import { execa } from "execa";
-import fs from "fs-extra";
-import path from "path";
-import { tmpNameSync } from "tmp";
-import { URL } from "url";
-import { BaseCommand } from "../../baseCommand.js";
-class DeployBuild extends BaseCommand {
-    async buildRollupsImage(platform) {
-        const buildResult = tmpNameSync();
-        const imagePath = this.getContextPath("image");
-        const binPath = path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..");
-        const dockerfile = path.join(binPath, "node", "DockerfileDeploy.txt");
-        const args = [
-            "buildx",
-            "build",
-            "-f",
-            dockerfile,
-            "--load",
-            "--iidfile",
-            buildResult,
-            imagePath,
-        ];
-        // optional platform, default to not defining, which will build for the host platform
-        if (platform) {
-            args.push("--platform", platform);
-        }
-        await execa("docker", args, { stdio: "inherit" });
-        return fs.readFileSync(buildResult, "utf8");
-    }
-    async run() {
-        const { flags } = await this.parse(DeployBuild);
-        // print machine hash
-        const templateHash = this.getMachineHash();
-        if (!templateHash) {
-            this.error(`Cartesi machine snapshot not found, run '${this.config.bin} build'`);
-        }
-        this.logPrompt({
-            title: "Cartesi machine templateHash",
-            value: templateHash,
-        });
-        this.log("Building application node Docker image...");
-        const image = await this.buildRollupsImage(flags.platform);
-        this.logPrompt({
-            title: "Application node Docker image",
-            value: image,
-        });
-        return { image };
-    }
-}
-DeployBuild.summary = "Build deployment Docker image of application.";
-DeployBuild.description = "Package the application in a Docker image ready to be deployed.";
-DeployBuild.examples = ["<%= config.bin %> <%= command.id %>"];
-DeployBuild.flags = {
-    platform: Flags.string({
-        options: ["linux/amd64", "linux/arm64"],
-        summary: "Docker image target platform",
-        description: "Select the target platform for the produced Docker image. It depends on the platform where the application node will be deployed.",
-    }),
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
+export const createBuildCommand = () => {
+    return new Command("build")
+        .description("DEPRECATED: Package the application in a Docker image ready to be deployed.")
+        .action(async () => {
+        console.warn(chalk.yellow("deploy build command is deprecated"));
+    });
 };
-DeployBuild.enableJsonFlag = true;
-export default DeployBuild;

package/dist/commands/deploy.d.ts

@@ -0,0 +1,18 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const createDeployCommand: () => Command<[], {
+    environmentName: string;
+    chainId: number;
+    rpcUrl?: string | undefined;
+    mnemonic?: string | undefined;
+    mnemonicIndex: number;
+    name?: string | undefined;
+    authorityOwner?: `0x${string}` | undefined;
+    applicationOwner?: `0x${string}` | undefined;
+    epochLength: number;
+    salt: `0x${string}`;
+    json?: true | undefined;
+    dataAvailability: "input-box" | "espresso";
+    espressoBlock: number;
+    espressoNamespace: number;
+}, {}>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,6BAA6B,CAAC;AAyQ9D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;MAuJ/B,CAAC"}

package/dist/commands/deploy.js

@@ -0,0 +1,271 @@
+import { Command, Option } from "@commander-js/extra-typings";
+import input from "@inquirer/input";
+import chalk from "chalk";
+import { execa } from "execa";
+import ora from "ora";
+import { encodeFunctionData, zeroHash } from "viem";
+import { cannon } from "viem/chains";
+import { getContextPath, getMachineHash, parseAddress, parseHash, } from "../base.js";
+import { DEFAULT_COMPOSE_ENVIRONMENT_NAME } from "../config.js";
+import { applicationFactoryAbi, applicationFactoryAddress, authorityFactoryAbi, authorityFactoryAddress, dataAvailabilityAbi, inputBoxAddress, } from "../contracts.js";
+import { addressInput } from "../prompts.js";
+import { connect } from "./send.js";
+/**
+ * Deploy authority contract (if not already deployed)
+ * @param options
+ * @returns address of the authority
+ */
+const deployAuthority = async (publicClient, walletClient, options) => {
+    const { epochLength, progress, salt } = options;
+    // deploy authority contract (if not already deployed)
+    const authorityOwner = options.authorityOwner ||
+        (await addressInput({
+            message: "Authority Owner",
+            default: walletClient.account?.address,
+        }));
+    const authorityAddress = await publicClient.readContract({
+        abi: authorityFactoryAbi,
+        address: authorityFactoryAddress,
+        functionName: "calculateAuthorityAddress",
+        args: [authorityOwner, BigInt(epochLength), salt],
+    });
+    // check if authority is already deployed
+    const authorityCode = await publicClient.getCode({
+        address: authorityAddress,
+    });
+    if (authorityCode === undefined) {
+        // deploy authority
+        const { request } = await publicClient.simulateContract({
+            abi: authorityFactoryAbi,
+            address: authorityFactoryAddress,
+            account: walletClient.account,
+            functionName: "newAuthority",
+            args: [authorityOwner, BigInt(epochLength), salt],
+        });
+        progress.start("Deploying authority...");
+        const hash = await walletClient.writeContract(request);
+        await publicClient.waitForTransactionReceipt({ hash });
+        progress.succeed(`Authority ${chalk.cyan(authorityAddress)}`);
+    }
+    return authorityAddress;
+};
+/**
+ * Deploy application contract
+ * @param options
+ * @returns address of the application
+ */
+const deployApplication = async (publicClient, walletClient, options) => {
+    const { authorityAddress, progress, salt, templateHash, dataAvailability } = options;
+    const applicationOwner = options.applicationOwner ||
+        (await addressInput({
+            message: "Application Owner",
+            default: walletClient.account?.address,
+        }));
+    const applicationAddress = await publicClient.readContract({
+        abi: applicationFactoryAbi,
+        address: applicationFactoryAddress,
+        functionName: "calculateApplicationAddress",
+        args: [
+            authorityAddress,
+            applicationOwner,
+            templateHash,
+            dataAvailability,
+            salt,
+        ],
+    });
+    // check if application is already deployed
+    const applicationCode = await publicClient.getCode({
+        address: applicationAddress,
+    });
+    if (applicationCode === undefined) {
+        // deploy application
+        const { request } = await publicClient.simulateContract({
+            abi: applicationFactoryAbi,
+            address: applicationFactoryAddress,
+            account: walletClient.account,
+            functionName: "newApplication",
+            args: [
+                authorityAddress,
+                applicationOwner,
+                templateHash,
+                dataAvailability,
+                salt,
+            ],
+        });
+        progress.start("Deploying application...");
+        const hash = await walletClient.writeContract(request);
+        await publicClient.waitForTransactionReceipt({ hash });
+        progress.succeed(`Application ${chalk.cyan(applicationAddress)}`);
+    }
+    else {
+        // abort, because application is already deployed
+        throw new Error(`Application ${chalk.cyan(templateHash)} already deployed to ${chalk.cyan(applicationAddress)}`);
+    }
+    return applicationAddress;
+};
+/**
+ * Publish machine snapshot to rollups node by copying it to the rollups node container
+ * @param options
+ * @returns path to the snapshot in the rollups node
+ */
+const publishMachine = async (options) => {
+    const { progress, environmentName, templateHash } = options;
+    const snapshotPath = getContextPath("image");
+    const containerSnapshotPath = `/var/lib/cartesi-rollups-node/snapshots/${templateHash}/`;
+    progress.start("Publishing machine snapshot...");
+    await execa("docker", [
+        "compose",
+        "--project-name",
+        environmentName,
+        "cp",
+        snapshotPath,
+        `rollups-node:${containerSnapshotPath}`,
+    ]);
+    progress.succeed(`Machine snapshot ${chalk.cyan(containerSnapshotPath)}`);
+    return containerSnapshotPath;
+};
+/**
+ * Register application in rollups node
+ * @param options
+ * @returns name of the application
+ */
+const registerApplication = async (options) => {
+    const { applicationAddress, progress, environmentName, snapshotPath, dataAvailability, } = options;
+    // use application address as the name of the deployment
+    const name = options.name ??
+        (await input({
+            message: "Application Name",
+            default: applicationAddress.toLowerCase(),
+        }));
+    // common app register args
+    const registerArgs = [
+        "--name",
+        name,
+        "--address",
+        applicationAddress,
+        "--template-path",
+        snapshotPath,
+        "--data-availability",
+        dataAvailability,
+        "--print-json",
+    ];
+    // deploy application
+    progress.start("Registering application...");
+    const { stdout } = await execa("docker", [
+        "compose",
+        "--project-name",
+        environmentName,
+        "exec",
+        "rollups-node",
+        "cartesi-rollups-cli",
+        "app",
+        "register",
+        ...registerArgs,
+    ]);
+    const registration = stdout ? JSON.parse(stdout) : undefined;
+    if (registration) {
+        if (registration.state !== "ENABLED") {
+            throw new Error(registration.reason);
+        }
+        progress.succeed(`Registration ${chalk.cyan(name)}`);
+    }
+    else {
+        throw new Error("Failed to deploy application");
+    }
+    return name;
+};
+const parseDataAvailability = (type, espressoBlock, espressoNamespace) => {
+    if (type === "espresso") {
+        return encodeFunctionData({
+            abi: dataAvailabilityAbi,
+            functionName: "InputBoxAndEspresso",
+            args: [inputBoxAddress, BigInt(espressoBlock), espressoNamespace],
+        });
+    }
+    return encodeFunctionData({
+        abi: dataAvailabilityAbi,
+        functionName: "InputBox",
+        args: [inputBoxAddress],
+    });
+};
+export const createDeployCommand = () => {
+    return new Command("deploy")
+        .description("Deploy a rollups application to a rollups node.")
+        .configureHelp({ showGlobalOptions: true })
+        .option("--environment-name <string>", "name of environment", DEFAULT_COMPOSE_ENVIRONMENT_NAME)
+        .option("--chain-id <id>", "Chain ID", Number.parseInt, 13370)
+        .option("--rpc-url <url>", "RPC URL")
+        .option("--mnemonic <phrase>", "Mnemonic passphrase")
+        .option("--mnemonic-index <index>", "Mnemonic account index", Number.parseInt, 0)
+        .option("--name <string>", "application name")
+        .option("--authority-owner <address>", "authority owner", parseAddress, undefined)
+        .option("--application-owner <address>", "application owner", parseAddress, undefined)
+        .addOption(new Option("--epoch-length <number>", "length of an epoch (in blocks)")
+        .argParser(Number)
+        .default(720))
+        .option("--salt <hash>", "salt for deployment", parseHash, zeroHash)
+        .option("--json", "output in JSON format")
+        .addOption(new Option("--data-availability <type>", "Data availability layer to use (input-box or espresso)")
+        .choices(["input-box", "espresso"])
+        .default("input-box"))
+        .addOption(new Option("--espresso-block <number>", "espresso starting block")
+        .argParser(Number)
+        .default(1))
+        .addOption(new Option("--espresso-namespace <number>", "espresso namespace Id")
+        .argParser(Number)
+        .default(1))
+        .action(async (options, command) => {
+        const { json, dataAvailability: daType, environmentName, espressoBlock, espressoNamespace, } = options;
+        // If inputbox is chosen, warn if espresso args are provided
+        if (daType === "input-box" &&
+            (espressoBlock !== undefined || espressoNamespace !== undefined)) {
+            console.warn(chalk.yellow("WARNING: --espresso-block and --espresso-namespace-id are ignored when --data-availability is input-box"));
+        }
+        const progress = ora();
+        // get cartesi machine snapshot hash, produced by 'build'
+        const templateHash = getMachineHash();
+        if (!templateHash) {
+            progress.fail(`Cartesi machine snapshot not found, run 'build'`);
+            return;
+        }
+        progress.succeed(`Cartesi machine template hash ${chalk.cyan(templateHash)}`);
+        // connect to some chain
+        const { publicClient, walletClient } = await connect(options);
+        try {
+            // parse dataAvailability
+            const dataAvailability = parseDataAvailability(daType, espressoBlock, espressoNamespace);
+            // deploy authority contract (if not already deployed)
+            const authorityAddress = await deployAuthority(publicClient, walletClient, { progress, ...options });
+            // deploy application contract
+            const applicationAddress = await deployApplication(publicClient, walletClient, {
+                authorityAddress,
+                progress,
+                templateHash,
+                ...options,
+                dataAvailability,
+            });
+            if (publicClient.chain?.id === cannon.id) {
+                // copy machine snapshot to rollups node container
+                const containerSnapshotPath = await publishMachine({
+                    progress,
+                    templateHash,
+                    environmentName,
+                });
+                const name = await registerApplication({
+                    applicationAddress,
+                    progress,
+                    snapshotPath: containerSnapshotPath,
+                    ...options,
+                    dataAvailability,
+                });
+            }
+            else {
+                const snapshotPath = getContextPath("image");
+                progress.succeed(`Done. Manually copy machine to rollups node ${chalk.cyan(snapshotPath)}`);
+            }
+        }
+        catch (e) {
+            progress.fail(e instanceof Error ? e.message : "Unknown error");
+        }
+    });
+};

package/dist/commands/doctor.d.ts

@@ -1,13 +1,3 @@
-import { BaseCommand } from "../baseCommand.js";
-export default class DoctorCommand extends BaseCommand<typeof DoctorCommand> {
-    static description: string;
-    static examples: string[];
-    private static MINIMUM_DOCKER_VERSION;
-    private static MINIMUM_DOCKER_COMPOSE_VERSION;
-    private static MINIMUM_BUILDX_VERSION;
-    private checkDocker;
-    private checkCompose;
-    private checkBuildx;
-    run(): Promise<void>;
-}
+import { Command } from "@commander-js/extra-typings";
+export declare const createDoctorCommand: () => Command<[], {}, {}>;
 //# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,WAAW,CAAC,OAAO,aAAa,CAAC;IACxE,MAAM,CAAC,WAAW,SAA2C;IAE7D,MAAM,CAAC,QAAQ,WAA2C;IAE1D,OAAO,CAAC,MAAM,CAAC,sBAAsB,CAAY;IACjD,OAAO,CAAC,MAAM,CAAC,8BAA8B,CAAY;IACzD,OAAO,CAAC,MAAM,CAAC,sBAAsB,CAAY;YAEnC,WAAW;YA+BX,YAAY;YAiCZ,WAAW;IAiDZ,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAYpC"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAyHtD,eAAO,MAAM,mBAAmB,2BAa/B,CAAC"}

package/dist/commands/doctor.js

@@ -1,106 +1,105 @@
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
 import { execa } from "execa";
+import ora from "ora";
 import semver from "semver";
-import { BaseCommand } from "../baseCommand.js";
-class DoctorCommand extends BaseCommand {
-    async checkDocker() {
-        try {
-            const { stdout: dockerVersion } = await execa("docker", [
-                "version",
-                "--format",
-                "{{json .Client.Version}}",
-            ]);
-            const v = semver.coerce(dockerVersion);
-            if (v !== null &&
-                !semver.gte(v, DoctorCommand.MINIMUM_DOCKER_VERSION)) {
-                throw new Error(`Unsupported Docker version. Minimum required version is ${DoctorCommand.MINIMUM_DOCKER_VERSION}. Installed version is ${v}.`);
-            }
+const MINIMUM_DOCKER_VERSION = "23.0.0"; // Replace with our minimum required Docker version
+const MINIMUM_DOCKER_COMPOSE_VERSION = "2.21.0"; // Replace with our minimum required Docker Compose version
+const MINIMUM_BUILDX_VERSION = "0.13.0"; // Replace with our minimum required Buildx version
+const checkDocker = async (progress) => {
+    try {
+        progress.start("Checking Docker Engine version...");
+        const { stdout: dockerVersion } = await execa("docker", [
+            "version",
+            "--format",
+            "{{json .Client.Version}}",
+        ]);
+        const v = semver.coerce(dockerVersion);
+        if (v !== null && !semver.gte(v, MINIMUM_DOCKER_VERSION)) {
+            throw new Error(`Unsupported Docker version. Minimum required version is ${MINIMUM_DOCKER_VERSION}. Installed version is ${v}.`);
         }
-        catch (e) {
-            if (e instanceof Error &&
-                e.code === "ENOENT") {
-                throw new Error("Docker not found");
-            }
-            else {
-                throw e;
-            }
+        progress.succeed(`Docker Engine ${chalk.cyan(v)}`);
+    }
+    catch (e) {
+        if (e instanceof Error &&
+            e.code === "ENOENT") {
+            throw new Error("Docker not found");
         }
-        return true;
+        throw e;
     }
-    async checkCompose() {
-        try {
-            const { stdout: dockerComposeVersion } = await execa("docker", [
-                "compose",
-                "version",
-                "--short",
-            ]);
-            const v = semver.coerce(dockerComposeVersion);
-            if (v !== null &&
-                !semver.gte(v, DoctorCommand.MINIMUM_DOCKER_COMPOSE_VERSION)) {
-                throw new Error(`Unsupported Docker Compose version. Minimum required version is ${DoctorCommand.MINIMUM_DOCKER_COMPOSE_VERSION}. Installed version is ${v}.`);
-            }
+    return true;
+};
+const checkCompose = async (progress) => {
+    try {
+        progress.start("Checking Docker Compose version...");
+        const { stdout: dockerComposeVersion } = await execa("docker", [
+            "compose",
+            "version",
+            "--short",
+        ]);
+        const v = semver.coerce(dockerComposeVersion);
+        if (v !== null && !semver.gte(v, MINIMUM_DOCKER_COMPOSE_VERSION)) {
+            throw new Error(`Unsupported Docker Compose version. Minimum required version is ${MINIMUM_DOCKER_COMPOSE_VERSION}. Installed version is ${v}.`);
         }
-        catch (e) {
-            if (e instanceof Error &&
-                e.exitCode === 125) {
-                throw new Error("Docker Compose is required but not installed or the command execution failed. Please refer to the Docker Compose documentation for installation instructions: https://docs.docker.com/compose/install/");
-            }
-            else {
-                throw e;
-            }
+        progress.succeed(`Docker Compose ${chalk.cyan(dockerComposeVersion)}`);
+    }
+    catch (e) {
+        if (e instanceof Error &&
+            e.exitCode === 125) {
+            throw new Error("Docker Compose is required but not installed or the command execution failed. Please refer to the Docker Compose documentation for installation instructions: https://docs.docker.com/compose/install/");
         }
-        return true;
+        throw e;
     }
-    async checkBuildx() {
-        try {
-            const { stdout: buildxOutput } = await execa("docker", [
-                "buildx",
-                "version",
-            ]);
-            const v = semver.coerce(buildxOutput);
-            if (v !== null &&
-                !semver.gte(v, DoctorCommand.MINIMUM_BUILDX_VERSION)) {
-                throw new Error(`Unsupported Docker Buildx version. Minimum required version is ${DoctorCommand.MINIMUM_BUILDX_VERSION}. Installed version is ${v}.`);
-            }
-            const { stdout: platformsOutput } = await execa("docker", [
-                "buildx",
-                "ls",
-                "--format",
-                "{{.Platforms}}",
-            ]);
-            const buildxPlatforms = platformsOutput
-                .split(",")
-                .map((platform) => platform.trim());
-            if (!buildxPlatforms.includes("linux/riscv64")) {
-                throw new Error("Your system does not support riscv64 architecture. Run `docker run --privileged --rm tonistiigi/binfmt:riscv` to enable riscv64 support.");
-            }
+    return true;
+};
+const checkBuildx = async (progress) => {
+    try {
+        progress.start("Checking Docker Buildx version...");
+        const { stdout: buildxOutput } = await execa("docker", [
+            "buildx",
+            "version",
+        ]);
+        const v = semver.coerce(buildxOutput);
+        if (v !== null && !semver.gte(v, MINIMUM_BUILDX_VERSION)) {
+            throw new Error(`Unsupported Docker Buildx version. Minimum required version is ${MINIMUM_BUILDX_VERSION}. Installed version is ${v}.`);
         }
-        catch (e) {
-            if (e instanceof Error &&
-                e.exitCode === 125) {
-                throw new Error("Docker Buildx is required but not installed. Please refer to the Docker Desktop documentation for installation instructions: https://docs.docker.com/desktop/");
-            }
-            else {
-                throw e;
-            }
+        progress.succeed(`Docker Buildx ${chalk.cyan(v)}`);
+        progress.start("Checking Docker RISC-V support...");
+        const { stdout: platformsOutput } = await execa("docker", [
+            "buildx",
+            "ls",
+            "--format",
+            "{{.Platforms}}",
+        ]);
+        const buildxPlatforms = platformsOutput
+            .split(",")
+            .map((platform) => platform.trim());
+        if (!buildxPlatforms.includes("linux/riscv64")) {
+            throw new Error("Your system does not support riscv64 architecture. Run `docker run --privileged --rm tonistiigi/binfmt:riscv` to enable riscv64 support.");
         }
-        return true;
+        progress.succeed(`Docker RISC-V support ${chalk.cyan("linux/riscv64")}`);
     }
-    async run() {
+    catch (e) {
+        if (e instanceof Error &&
+            e.exitCode === 125) {
+            throw new Error("Docker Buildx is required but not installed. Please refer to the Docker Desktop documentation for installation instructions: https://docs.docker.com/desktop/");
+        }
+        throw e;
+    }
+    return true;
+};
+export const createDoctorCommand = () => {
+    return new Command("doctor").action(async () => {
+        const progress = ora();
         try {
-            if (await this.checkDocker()) {
-                await this.checkCompose();
-                await this.checkBuildx();
-            }
+            await checkDocker(progress);
+            await checkCompose(progress);
+            await checkBuildx(progress);
+            progress.succeed("Your system is ready.");
         }
         catch (e) {
-            this.error(e);
+            progress.fail(e.message);
+            process.exit(1);
         }
-        this.log("Your system is ready.");
-    }
-}
-DoctorCommand.description = "Verify the minimal sytem requirements";
-DoctorCommand.examples = ["<%= config.bin %> <%= command.id %>"];
-DoctorCommand.MINIMUM_DOCKER_VERSION = "23.0.0"; // Replace with our minimum required Docker version
-DoctorCommand.MINIMUM_DOCKER_COMPOSE_VERSION = "2.21.0"; // Replace with our minimum required Docker Compose version
-DoctorCommand.MINIMUM_BUILDX_VERSION = "0.13.0"; // Replace with our minimum required Buildx version
-export default DoctorCommand;
+    });
+};

package/dist/commands/hash.d.ts

@@ -1,10 +1,5 @@
-import { BaseCommand } from "../baseCommand.js";
-export default class HashCommand extends BaseCommand<typeof HashCommand> {
-    static summary: string;
-    static description: string;
-    static enableJsonFlag: boolean;
-    run(): Promise<{
-        hash: `0x${string}`;
-    } | undefined>;
-}
+import { Command } from "@commander-js/extra-typings";
+export declare const createHashCommand: () => Command<[], {
+    json?: true | undefined;
+}, {}>;
 //# sourceMappingURL=hash.d.ts.map

package/dist/commands/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/commands/hash.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,WAAW,CAAC,OAAO,WAAW,CAAC;IACpE,MAAM,CAAC,OAAO,SAA0D;IAExE,MAAM,CAAC,WAAW,SAC2F;IAE7G,OAAc,cAAc,UAAQ;IAEvB,GAAG;;;CAgBnB"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/commands/hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAItD,eAAO,MAAM,iBAAiB;;MAsB7B,CAAC"}

package/dist/commands/hash.js

@@ -1,22 +1,22 @@
+import { Command } from "@commander-js/extra-typings";
 import chalk from "chalk";
-import { BaseCommand } from "../baseCommand.js";
-class HashCommand extends BaseCommand {
-    async run() {
-        const hash = this.getMachineHash();
+import { getMachineHash } from "../base.js";
+export const createHashCommand = () => {
+    return new Command("hash")
+        .description("Converts the binary generated by the build command to hexadecimal and prints out the result to console.")
+        .option("--json", "Format output as json.")
+        .action(async ({ json }, command) => {
+        const hash = getMachineHash();
         if (hash) {
-            if (!this.jsonEnabled()) {
-                process.stdout.write(`${chalk.green("?")} Cartesi machine templateHash ${chalk.cyan(hash)}\n`);
+            if (!json) {
+                console.log(`${chalk.green("?")} Cartesi machine templateHash ${chalk.cyan(hash)}\n`);
             }
             else {
-                return { hash };
+                process.stdout.write(JSON.stringify({ hash }));
             }
         }
         else {
-            this.error(`Cartesi machine snapshot not found, run '${this.config.bin} build'`);
+            command.error(`Cartesi machine snapshot not found, run 'build'`);
         }
-    }
-}
-HashCommand.summary = "Prints out image hash generated by the build command";
-HashCommand.description = "Converts the binary generated by the build command to hexadecimal and prints out the result to console";
-HashCommand.enableJsonFlag = true;
-export default HashCommand;
+    });
+};

package/dist/commands/logs.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const createLogsCommand: () => Command<[], {
+    environmentName: string;
+    follow?: true | undefined;
+    color: boolean;
+    since?: string | undefined;
+    tail: string;
+    until?: string | undefined;
+}, {}>;
+//# sourceMappingURL=logs.d.ts.map