feat(cli): deprecate deploy and deploy build commands

Author: tuler

.changeset/eighty-clowns-buy.md

@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": major
+---
+
+DEPRECATED: cartesi deploy build

.changeset/upset-news-ask.md

@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": major
+---
+
+DEPRECATED: cartesi deploy

apps/cli/src/commands/deploy.ts

@@ -1,97 +1,19 @@
-import { Command, Option } from "@commander-js/extra-typings";
-import confirm from "@inquirer/confirm";
-import select from "@inquirer/select";
+import { Command } from "@commander-js/extra-typings";
 import chalk from "chalk";
-import open, { apps } from "open";
-import { getMachineHash, logPrompt } from "../base.js";
 import { createBuildCommand } from "./deploy/build.js";
 
 export const createDeployCommand = () => {
     const command = new Command("deploy")
         .description(
-            "Package and deploy the application to a supported live network.",
+            "DEPRECATED: Package and deploy the application to a supported live network.",
         )
-        .addOption(
-            new Option("--hosting <hosting>", "hosting type").choices([
-                "self-hosted",
-                "third-party",
-            ]),
-        )
-        .addOption(
-            new Option(
-                "--webapp <webapp>",
-                "webapp address",
-            ).makeOptionMandatory(),
-        )
-        .action(async (options, command) => {
-            // print machine hash
-            const templateHash = getMachineHash();
-            if (!templateHash) {
-                command.error(
-                    `Cartesi machine snapshot not found, run 'build'`,
-                );
-                return;
-            }
-            logPrompt({
-                title: "Cartesi machine templateHash",
-                value: templateHash,
-            });
-
-            // ask for deployment type
-            const hosting =
-                options.hosting ||
-                (await select<"self-hosted" | "third-party">({
-                    message: "Select hosting type",
-                    choices: [
-                        {
-                            name: "Self-hosting",
-                            description: `Select this option if you want to run the node for your application.
-You will need the following infrastructure:
-
-- a cloud server for the application node
-- a postgres database
-- a web3 node provider
-- a funded wallet
-`,
-                            value: "self-hosted",
-                        },
-                        {
-                            name: "Use third-party provider",
-                            description:
-                                "Select this option to use a third-party service provider to run a node for your application.",
-                            value: "third-party",
-                            disabled: "(coming soon)",
-                        },
-                    ],
-                }));
-
-            let queryString = "";
-            switch (hosting) {
-                case "self-hosted": {
-                    // build docker image
-                    // Execute the build subcommand
-                    command.commands
-                        .find((cmd) => cmd.name() === "build")
-                        ?.parseAsync(command.args);
-
-                    queryString = `?templateHash=${templateHash}`;
-                    break;
-                }
-                case "third-party": {
-                    command.error(
-                        "Third-party provider deployment not supported yet",
-                    );
-                }
-            }
-
-            // prompt user to open webapp for onchain deployment
-            const deployUrl = `${options.webapp}${queryString}`;
-            if (await confirm({ message: `Open ${chalk.cyan(deployUrl)}?` })) {
-                open(deployUrl, { app: { name: apps.chrome } });
-            }
-
-            return;
+        .action(async () => {
+            console.warn(
+                chalk.yellow(
+                    "deploy command is deprecated, use 'rollups deploy' instead",
+                ),
+            );
         });
-    command.addCommand(createBuildCommand());
+    command.addCommand(createBuildCommand(), { hidden: true });
     return command;
 };

apps/cli/src/commands/deploy/build.ts

@@ -1,79 +1,12 @@
-import { Command, Option } from "@commander-js/extra-typings";
-import { execa } from "execa";
-import fs from "fs-extra";
-import path from "path";
-import { tmpNameSync } from "tmp";
-import { getContextPath, getMachineHash, logPrompt } from "../../base.js";
-
-const buildRollupsImage = async (platform?: string) => {
-    const buildResult = tmpNameSync();
-    const imagePath = getContextPath("image");
-    const binPath = path.join(
-        path.dirname(new URL(import.meta.url).pathname),
-        "..",
-        "..",
-    );
-    const dockerfile = path.join(
-        binPath,
-        "compose",
-        "rollups",
-        "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");
-};
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
 
 export const createBuildCommand = () => {
     return new Command("build")
         .description(
-            "Package the application in a Docker image ready to be deployed.",
+            "DEPRECATED: Package the application in a Docker image ready to be deployed.",
         )
-        .addOption(
-            new Option(
-                "--platform <platform>",
-                "Docker image target platform",
-            ).choices(["linux/amd64", "linux/arm64"]),
-        )
-        .option("--json", "Format output as json.")
-        .action(async ({ platform, json }, command) => {
-            // print machine hash
-            const templateHash = getMachineHash();
-            if (!templateHash) {
-                command.error(
-                    `Cartesi machine snapshot not found, run 'build'`,
-                );
-                return;
-            }
-            logPrompt({
-                title: "Cartesi machine templateHash",
-                value: templateHash,
-            });
-            console.log("Building application node Docker image...");
-
-            const image = await buildRollupsImage(platform);
-            logPrompt({
-                title: "Application node Docker image",
-                value: image,
-            });
-
-            if (json) {
-                process.stdout.write(JSON.stringify({ image }));
-            }
+        .action(async () => {
+            console.warn(chalk.yellow("deploy build command is deprecated"));
         });
 };

apps/cli/src/compose/rollups/DockerfileDeploy.txt

@@ -36,7 +36,7 @@ const program = new Command()
     .addCommand(createBuildCommand())
     .addCommand(createCleanCommand())
     .addCommand(createCreateCommand())
-    .addCommand(createDeployCommand())
+    .addCommand(createDeployCommand(), { hidden: true })
     .addCommand(createDoctorCommand())
     .addCommand(createHashCommand())
     .addCommand(createRollupsCommand())