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

package/dist/commands/doctor.js

@@ -1,106 +1,111 @@
+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");
+        }
+        else {
+            throw e;
         }
-        return true;
     }
-    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/");
+        }
+        else {
+            throw e;
         }
-        return true;
     }
-    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/");
+        }
+        else {
+            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/rollups/create.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const DEFAULT_TEMPLATES_BRANCH = "prerelease/sdk-12";
+export declare const createCreateCommand: () => Command<[string], {
+    template: "cpp" | "cpp-low-level" | "go" | "javascript" | "lua" | "python" | "ruby" | "rust" | "typescript";
+    branch: string;
+}, {}>;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/rollups/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/commands/rollups/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,6BAA6B,CAAC;AAK9D,eAAO,MAAM,wBAAwB,sBAAsB,CAAC;AAc5D,eAAO,MAAM,mBAAmB;;;MA+B/B,CAAC"}

package/dist/commands/rollups/create.js

@@ -0,0 +1,36 @@
+import { Command, Option } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import ora from "ora";
+import { download } from "../../template.js";
+export const DEFAULT_TEMPLATES_BRANCH = "prerelease/sdk-12";
+const TEMPLATES = [
+    "cpp",
+    "cpp-low-level",
+    "go",
+    "javascript",
+    "lua",
+    "python",
+    "ruby",
+    "rust",
+    "typescript",
+];
+export const createCreateCommand = () => {
+    return new Command("create")
+        .argument("<name>", "application and directory name")
+        .addOption(new Option("-t, --template <template>", "template name to use")
+        .choices(TEMPLATES)
+        .makeOptionMandatory())
+        .option("-b, --branch <branch>", "cartesi/application-templates repository branch name to use", DEFAULT_TEMPLATES_BRANCH)
+        .action(async (name, { branch, template }) => {
+        const spinner = ora("Creating application...").start();
+        try {
+            const { dir } = await download("rollups", template, branch, name);
+            spinner.succeed(`Application created at ${chalk.cyan(dir)}`);
+        }
+        catch (e) {
+            spinner.fail(e instanceof Error
+                ? `Error creating application: ${chalk.red(e.message)}`
+                : String(e));
+        }
+    });
+};

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

@@ -0,0 +1,16 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const createDeployCommand: () => Command<[], {
+    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;
+}, {
+    environmentName: string;
+}>;
+//# sourceMappingURL=deploy.d.ts.map

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

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

package/dist/commands/rollups/deploy.js

@@ -0,0 +1,237 @@
+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 { 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 } = options;
+    const applicationOwner = options.applicationOwner ||
+        (await addressInput({
+            message: "Application Owner",
+            default: walletClient.account?.address,
+        }));
+    // create data availability descriptor for InputBox only
+    const dataAvailability = encodeFunctionData({
+        abi: dataAvailabilityAbi,
+        functionName: "InputBox",
+        args: [inputBoxAddress],
+    });
+    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 } = options;
+    // use template hash as the name of the deployment
+    const name = options.name ??
+        (await input({
+            message: "Application Name",
+            default: applicationAddress.toLowerCase(),
+        }));
+    // deploy application
+    progress.start("Registering application...");
+    const { stdout } = await execa("docker", [
+        "compose",
+        "--project-name",
+        environmentName,
+        "exec",
+        "rollups-node",
+        "cartesi-rollups-cli",
+        "app",
+        "register",
+        "--name",
+        name,
+        "--address",
+        applicationAddress,
+        "--template-path",
+        snapshotPath,
+        "--print-json",
+    ]);
+    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;
+};
+export const createDeployCommand = () => {
+    return new Command("deploy")
+        .description("Deploy a rollups application to a rollups node.")
+        .configureHelp({ showGlobalOptions: true })
+        .option("--chain-id <id>", "Chain ID", parseInt, 13370)
+        .option("--rpc-url <url>", "RPC URL")
+        .option("--mnemonic <phrase>", "Mnemonic passphrase")
+        .option("--mnemonic-index <index>", "Mnemonic account index", 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")
+        .action(async (options, command) => {
+        const rollupsOptions = command.optsWithGlobals();
+        const { environmentName } = rollupsOptions;
+        const { json } = options;
+        // XXX: json support is not implemented yet
+        // if case of json maybe we should not support interactive mode
+        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 {
+            // 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 });
+            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,
+                    ...rollupsOptions,
+                });
+            }
+            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/rollups/logs.d.ts

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

package/dist/commands/rollups/logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../../../src/commands/rollups/logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAItD,eAAO,MAAM,iBAAiB;;;;;;;;EAuC7B,CAAC"}

package/dist/commands/rollups/logs.js

@@ -0,0 +1,32 @@
+import { Command } from "@commander-js/extra-typings";
+import { execa } from "execa";
+export const createLogsCommand = () => {
+    return new Command("logs")
+        .description("Show logs of a local rollups node environment.")
+        .option("-f, --follow", "Follow log output")
+        .option("--no-color", "Produce monochrome output")
+        .option("--since <string>", "Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)")
+        .option("-n, --tail <string>", "Number of lines to show from the end of the logs", "all")
+        .option("--until <string>", "Show logs before a timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)")
+        .configureHelp({ showGlobalOptions: true })
+        .action(async ({ follow, color, since, tail, until }, command) => {
+        const { environmentName } = command.optsWithGlobals();
+        const logOptions = ["--no-log-prefix"];
+        if (follow)
+            logOptions.push("--follow");
+        if (color === false)
+            logOptions.push("--no-color");
+        if (since)
+            logOptions.push("--since", since);
+        if (tail)
+            logOptions.push("--tail", tail);
+        await execa("docker", [
+            "compose",
+            "--project-name",
+            environmentName,
+            "logs",
+            ...logOptions,
+            "rollups-node",
+        ], { stdio: "inherit" });
+    });
+};

package/dist/commands/rollups/start.d.ts

@@ -0,0 +1,14 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const createStartCommand: () => Command<[], {
+    blockTime: number;
+    defaultBlock: "latest" | "pending" | "safe" | "finalized";
+    cpus?: number | undefined;
+    memory?: number | undefined;
+    services: string[];
+    port: number;
+    dryRun: boolean;
+    verbose: boolean;
+}, {
+    environmentName: string;
+}>;
+//# sourceMappingURL=start.d.ts.map

package/dist/commands/rollups/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../src/commands/rollups/start.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,6BAA6B,CAAC;AA4I9D,eAAO,MAAM,kBAAkB;;;;;;;;;;;EAkK9B,CAAC"}