sesterce-cli/src/cli/commands/gpu-cloud/instance/launch.ts

A powerful command-line interface tool for managing Sesterce Cloud services. Sesterce CLI provides easy access to GPU cloud instances, AI inference services, container registries, and SSH key management directly from your terminal.

import { DockerImage } from "@/modules/docker/domain/image";
import { listDockerImageTags } from "@/modules/docker/use-cases/list-docker-image-tags";
import { listDockerImages } from "@/modules/docker/use-cases/list-docker-images";
import { GpuCloudInstanceOffer } from "@/modules/gpu-cloud/domain/instance-offer";
import { GpuCloudVolume } from "@/modules/gpu-cloud/domain/volume";
import { launchInstance } from "@/modules/gpu-cloud/use-cases/launch-instance";
import { listGpuCloudOffers } from "@/modules/gpu-cloud/use-cases/list-instance-offers";
import { listGpuCloudVolumes } from "@/modules/gpu-cloud/use-cases/list-volumes";
import { SSHKey } from "@/modules/ssh-keys/domain/ssh-key";
import { listSSHKeys } from "@/modules/ssh-keys/use-cases/list-ssh-keys";
import { input, search } from "@inquirer/prompts";
import { Command } from "commander";
import { DateTime } from "luxon";

const printOffer = (
  offer: GpuCloudInstanceOffer,
  regions: {
    region: string;
    frontendName: string;
    countryCode: string | null;
  }[]
) => {
  return `${offer.gpuCount} x ${offer.gpuName} [${offer.deploymentType}] - vRAM ${offer.configuration.vRamGB}GB | vCPU ${offer.configuration.vCpu} | RAM ${offer.configuration.ramGB}GB - ${offer.cloud.name} - $${offer.hourlyPrice.toFixed(2)}/h in ${regions.map((region) => region.frontendName).join(", ")}`;
};

const printOfferShort = (offer: GpuCloudInstanceOffer) => {
  return `${offer.gpuCount} x ${offer.gpuName} [${offer.deploymentType}] - vRAM ${offer.configuration.vRamGB}GB | vCPU ${offer.configuration.vCpu} | RAM ${offer.configuration.ramGB}GB - $${offer.hourlyPrice.toFixed(2)}/h`;
};

const printVolume = (volume: GpuCloudVolume) => {
  return `${volume.name} (${volume.capacity} GB) | ${volume.availabilityZone} | ${volume.region.name} | $${volume.hourlyPrice.toFixed(2)}/hour`;
};

const printSSHKey = (sshKey: SSHKey) => {
  return `${sshKey.isDefault ? "[Default] " : ""}${sshKey.name} (${DateTime.fromISO(sshKey.createdAt).toLocaleString(DateTime.DATETIME_FULL)})`;
};

const printDockerImage = (image: DockerImage) => {
  return `${image.name} (${image.url})`;
};

export function createGpuCloudInstanceLaunchCommand(
  gpuCloudInstanceCommand: Command
) {
  gpuCloudInstanceCommand
    .command("launch")
    .description("Launch a GPU instance in Sesterce Cloud")
    .action(async () => {
      console.log("Loading instance offers...");
      const result = await listGpuCloudOffers.execute();
      if (result.isLeft()) {
        console.error(result.value.message);
        return;
      }

      const offers = result.value;

      const offer = await search({
        message: "Select an offer",
        source: async (input, { signal }) => {
          if (!input) {
            return offers.map(({ offer, regions }) => ({
              name: printOffer(offer, regions),
              value: { ...offer, regions },
              short: printOfferShort(offer),
            }));
          }

          return offers
            .filter(
              ({ offer }) =>
                offer.gpuName.toLowerCase().includes(input.toLowerCase()) ||
                offer.gpuCount.toString().includes(input) ||
                offer.deploymentType.toLowerCase().includes(input) ||
                offer.availability.some(({ name }) => name.includes(input))
            )
            .map(({ offer, regions }) => ({
              name: printOffer(offer, regions),
              value: { ...offer, regions },
              short: printOfferShort(offer),
            }));
        },
      });

      const selectedRegion = await search({
        message: "Select a region",
        source: async (input, { signal }) => {
          if (!input) {
            return offer.regions.map((region) => ({
              name: region.frontendName,
              value: region,
            }));
          }

          return offer.regions
            .filter((region) =>
              region.frontendName.toLowerCase().includes(input.toLowerCase())
            )
            .map((region) => ({
              name: region.frontendName,
              value: region,
            }));
        },
      });

      console.log("Loading volumes...");
      const volumesResult = await listGpuCloudVolumes.execute();
      if (volumesResult.isLeft()) {
        console.error(volumesResult.value.message);
        return;
      }

      const availableVolumes = volumesResult.value.filter(
        (volume) => volume.region.region === selectedRegion.region
      );

      const volume = await search({
        message: "Select a volume (optional)",
        source: (input, { signal }) => {
          if (availableVolumes.length === 0) {
            return [{ value: null, name: "No volumes found" }];
          }

          if (!input) {
            return availableVolumes.map((volume) => ({
              name: printVolume(volume),
              value: volume,
            }));
          }

          return availableVolumes
            .filter(
              (volume) =>
                volume.name.toLowerCase().includes(input.toLowerCase()) ||
                volume.capacity.toString().includes(input) ||
                volume.availabilityZone
                  .toLowerCase()
                  .includes(input.toLowerCase()) ||
                volume.region.name.toLowerCase().includes(input.toLowerCase())
            )
            .map((volume) => ({
              name: printVolume(volume),
              value: volume,
            }));
        },
      });

      const os = await search({
        message: "Select an OS",
        source: (input, { signal }) => {
          if (!input) {
            return offer.configuration.os.map((os) => ({
              name: os,
              value: os,
            }));
          }

          return offer.configuration.os
            .filter((os) => os.toLowerCase().includes(input.toLowerCase()))
            .map((os) => ({
              name: os,
              value: os,
            }));
        },
      });
      console.log("Loading docker images...");
      const dockerImages = await listDockerImages.execute();
      if (dockerImages.isLeft()) {
        console.error(dockerImages.value.message);
        return;
      }

      const dockerImage = await search({
        message: "Select a Docker image (optional)",
        source: (input, { signal }) => {
          if (!input) {
            return [
              { value: null, name: "None" },
              ...dockerImages.value.map((image) => ({
                name: printDockerImage(image),
                value: image,
              })),
            ];
          }

          return [
            { value: null, name: "None" },
            ...dockerImages.value
              .filter((image) =>
                image.name.toLowerCase().includes(input.toLowerCase())
              )
              .map((image) => ({
                name: printDockerImage(image),
                value: image,
              })),
          ];
        },
      });

      let dockerImageTag: string | null = null;

      if (dockerImage) {
        console.log("Loading docker image tags...");
        const dockerImageTags = await listDockerImageTags.execute({
          image: dockerImage.url,
        });
        if (dockerImageTags.isLeft()) {
          console.error(dockerImageTags.value.message);
          return;
        }

        dockerImageTag = await search({
          message: "Select a tag for the docker image",
          source: (input, { signal }) => {
            if (!input) {
              return [
                { value: dockerImage.tag, name: dockerImage.tag }, // default image tag
                ...dockerImageTags.value.map((tag) => ({
                  name: tag.name,
                  value: tag.name,
                })),
              ];
            }

            return [
              { value: dockerImage.tag, name: dockerImage.tag }, // default image tag
              ...dockerImageTags.value
                .filter((tag) =>
                  tag.name.toLowerCase().includes(input.toLowerCase())
                )
                .map((tag) => ({
                  name: tag.name,
                  value: tag.name,
                })),
            ];
          },
        });
      }

      console.log("Loading SSH keys...");
      const sshKeys = await listSSHKeys.execute();
      if (sshKeys.isLeft()) {
        console.error(sshKeys.value.message);
        return;
      }

      const sshKey = await search({
        message: "Select a SSH key",
        source: (input, { signal }) => {
          if (!input) {
            return sshKeys.value.map((sshKey) => ({
              name: printSSHKey(sshKey),
              value: sshKey,
            }));
          }

          return sshKeys.value
            .filter((sshKey) =>
              sshKey.name.toLowerCase().includes(input.toLowerCase())
            )
            .map((sshKey) => ({
              name: printSSHKey(sshKey),
              value: sshKey,
            }));
        },
      });

      const instanceName = await input({
        message: "Enter the name of the instance",
      });
      console.log("Launching instance, this may take a while...");

      const launchInstanceResult = await launchInstance.execute({
        name: instanceName,
        cloudProvider: offer.cloud._id,
        instanceId: offer.instanceId,
        volumeId: volume?._id,
        region: selectedRegion.region,
        os,
        dockerImage:
          dockerImage && dockerImageTag
            ? {
                image: dockerImage.url,
                tag: dockerImageTag,
              }
            : null,
        sshKeyId: sshKey._id,
      });

      if (launchInstanceResult.isLeft()) {
        console.error(launchInstanceResult.value.message);
        return;
      }

      console.log(
        `Instance ${launchInstanceResult.value.name} launched successfully! Instance ID: ${launchInstanceResult.value._id}`
      );
    });
}