@cartesi/cli 1.4.0 → 2.0.0-alpha.0

package/dist/commands/shell.d.ts

@@ -6,9 +6,10 @@ export default class Shell extends BaseCommand<typeof Shell> {
         image: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        command: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        config: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         "run-as-root": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
-    private startShell;
     run(): Promise<void>;
 }
 //# sourceMappingURL=shell.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../src/commands/shell.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,WAAW,CAAC,OAAO,KAAK,CAAC;IACxD,MAAM,CAAC,WAAW,SAAqD;IAEvE,MAAM,CAAC,QAAQ,WAA2C;IAE1D,MAAM,CAAC,IAAI;;MAKT;IAEF,MAAM,CAAC,KAAK;;MAKV;YAEY,UAAU;IAsCX,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAcpC"}
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../src/commands/shell.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIhD,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,WAAW,CAAC,OAAO,KAAK,CAAC;IACxD,MAAM,CAAC,WAAW,SAAqD;IAEvE,MAAM,CAAC,QAAQ,WAA2C;IAE1D,MAAM,CAAC,IAAI;;MAKT;IAEF,MAAM,CAAC,KAAK;;;;MAgBV;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA2CpC"}

package/dist/commands/shell.js

@@ -1,51 +1,40 @@
 import { Args, Flags } from "@oclif/core";
-import { execa } from "execa";
 import fs from "fs-extra";
-import { lookpath } from "lookpath";
 import path from "path";
 import { BaseCommand } from "../baseCommand.js";
+import { bootMachine } from "../machine.js";
 class Shell extends BaseCommand {
-    async startShell(ext2Path, runAsRoot) {
-        const containerDir = "/mnt";
-        const bind = `${path.resolve(path.dirname(ext2Path))}:${containerDir}`;
-        const ext2 = path.join(containerDir, path.basename(ext2Path));
-        const ramSize = "128Mi";
-        const driveLabel = "root";
-        const sdkImage = "cartesi/sdk:0.10.0"; // XXX: how to resolve sdk version?
-        const args = [
-            "run",
-            "--interactive",
-            "--tty",
-            "--volume",
-            bind,
-            sdkImage,
-            "cartesi-machine",
-            `--ram-length=${ramSize}`,
-            "--append-bootargs=no4lvl",
-            `--flash-drive=label:${driveLabel},filename:${ext2}`,
-        ];
-        if (runAsRoot) {
-            args.push("--append-init=USER=root");
-        }
-        if (!(await lookpath("stty"))) {
-            args.push("-i");
-        }
-        else {
-            args.push("-it");
-        }
-        await execa("docker", [...args, "--", "/bin/bash"], {
-            stdio: "inherit",
-        });
-    }
     async run() {
         const { flags } = await this.parse(Shell);
-        // use pre-existing image or build dapp image
-        const ext2Path = this.getContextPath("image.ext2");
-        if (!fs.existsSync(ext2Path)) {
-            throw new Error(`machine not built, run '${this.config.bin} build'`);
+        // get application configuration from 'cartesi.toml'
+        const config = this.getApplicationConfig(flags.config);
+        // destination directory for image and intermediate files
+        const destination = path.resolve(this.getContextPath());
+        // check if all drives are built
+        for (const [name, drive] of Object.entries(config.drives)) {
+            const filename = `${name}.${drive.format}`;
+            const pathname = this.getContextPath(filename);
+            if (!fs.existsSync(pathname)) {
+                throw new Error(`drive '${name}' not built, run '${this.config.bin} build'`);
+            }
         }
-        // execute the machine and save snapshot
-        await this.startShell(ext2Path, flags["run-as-root"]);
+        // create shell entrypoint
+        const info = {
+            cmd: [],
+            entrypoint: [this.flags.command],
+            env: [],
+            workdir: "/",
+        };
+        // start with interactive mode on
+        config.machine.interactive = true;
+        // interactive mode can't have final hash
+        config.machine.finalHash = false;
+        // do not store machine in interactive mode
+        config.machine.store = undefined;
+        // run as root if flag is set
+        config.machine.user = flags["run-as-root"] ? "root" : undefined;
+        // boot machine
+        await bootMachine(config, info, destination);
     }
 }
 Shell.description = "Start a shell in cartesi machine of application";
@@ -57,9 +46,20 @@ Shell.args = {
     }),
 };
 Shell.flags = {
+    command: Flags.string({
+        default: "/bin/sh",
+        description: "shell command to run",
+        summary: "shell to run",
+    }),
+    config: Flags.file({
+        char: "c",
+        default: "cartesi.toml",
+        summary: "path to the configuration file",
+    }),
     "run-as-root": Flags.boolean({
-        description: "run as root user",
         default: false,
+        description: "run as root user",
+        summary: "run the cartesi machine as the root user",
     }),
 };
 export default Shell;

package/dist/config.d.ts

@@ -0,0 +1,102 @@
+import { TomlPrimitive } from "smol-toml";
+/**
+ * Typed Errors
+ */
+export declare class InvalidBuilderError extends Error {
+    constructor(builder: TomlPrimitive);
+}
+export declare class InvalidDriveFormatError extends Error {
+    constructor(format: TomlPrimitive);
+}
+export declare class InvalidEmptyDriveFormatError extends Error {
+    constructor(format: TomlPrimitive);
+}
+export declare class InvalidStringValueError extends Error {
+    constructor(value: TomlPrimitive);
+}
+export declare class InvalidBooleanValueError extends Error {
+    constructor(value: TomlPrimitive);
+}
+export declare class InvalidNumberValueError extends Error {
+    constructor(value: TomlPrimitive);
+}
+export declare class InvalidBytesValueError extends Error {
+    constructor(value: TomlPrimitive);
+}
+export declare class RequiredFieldError extends Error {
+    constructor(key: TomlPrimitive);
+}
+export declare class InvalidStringArrayError extends Error {
+    constructor();
+}
+type DriveFormat = "ext2" | "sqfs";
+export type ImageInfo = {
+    cmd: string[];
+    entrypoint: string[];
+    env: string[];
+    workdir: string;
+};
+export type DriveResult = ImageInfo | undefined | void;
+export type DirectoryDriveConfig = {
+    builder: "directory";
+    extraSize: number;
+    format: DriveFormat;
+    directory: string;
+};
+export type DockerDriveConfig = {
+    builder: "docker";
+    context: string;
+    dockerfile: string;
+    extraSize: number;
+    format: DriveFormat;
+    image?: string;
+    tags: string[];
+    target?: string;
+};
+export type EmptyDriveConfig = {
+    builder: "empty";
+    format: "ext2" | "raw";
+    size: number;
+};
+export type ExistingDriveConfig = {
+    builder: "none";
+    filename: string;
+    format: DriveFormat;
+};
+export type TarDriveConfig = {
+    builder: "tar";
+    filename: string;
+    format: DriveFormat;
+    extraSize: number;
+};
+export type DriveConfig = (DirectoryDriveConfig | DockerDriveConfig | EmptyDriveConfig | ExistingDriveConfig | TarDriveConfig) & {
+    mount?: string | boolean;
+    shared?: boolean;
+    user?: string;
+};
+export type MachineConfig = {
+    assertRollingTemplate?: boolean;
+    bootargs: string[];
+    entrypoint?: string;
+    finalHash: boolean;
+    interactive?: boolean;
+    maxMCycle?: bigint;
+    noRollup?: boolean;
+    ramLength: string;
+    ramImage: string;
+    store?: string;
+    user?: string;
+};
+export type Config = {
+    drives: Record<string, DriveConfig>;
+    machine: MachineConfig;
+    sdk: string;
+};
+export declare const defaultRootDriveConfig: () => DriveConfig;
+export declare const defaultRamImage: () => string;
+export declare const defaultMachineConfig: () => MachineConfig;
+export declare const defaultConfig: () => Config;
+export declare const getDriveFormat: (filename: string) => DriveFormat;
+export declare const parse: (str: string) => Config;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}

package/dist/config.js

@@ -0,0 +1,378 @@
+import bytes from "bytes";
+import os from "os";
+import { extname } from "path";
+import { parse as parseToml } from "smol-toml";
+/**
+ * Typed Errors
+ */
+export class InvalidBuilderError extends Error {
+    constructor(builder) {
+        super(`Invalid builder: ${builder}`);
+        this.name = "InvalidBuilder";
+    }
+}
+export class InvalidDriveFormatError extends Error {
+    constructor(format) {
+        super(`Invalid drive format: ${format}`);
+        this.name = "InvalidDriveFormatError";
+    }
+}
+export class InvalidEmptyDriveFormatError extends Error {
+    constructor(format) {
+        super(`Invalid empty drive format: ${format}`);
+        this.name = "InvalidEmptyDriveFormatError";
+    }
+}
+export class InvalidStringValueError extends Error {
+    constructor(value) {
+        super(`Invalid string value: ${value}`);
+        this.name = "InvalidStringValueError";
+    }
+}
+export class InvalidBooleanValueError extends Error {
+    constructor(value) {
+        super(`Invalid boolean value: ${value}`);
+        this.name = "InvalidBooleanValueError";
+    }
+}
+export class InvalidNumberValueError extends Error {
+    constructor(value) {
+        super(`Invalid number value: ${value}`);
+        this.name = "InvalidNumberValueError";
+    }
+}
+export class InvalidBytesValueError extends Error {
+    constructor(value) {
+        super(`Invalid bytes value: ${value}`);
+        this.name = "InvalidBytesValueError";
+    }
+}
+export class RequiredFieldError extends Error {
+    constructor(key) {
+        super(`Missing required field: ${key}`);
+        this.name = "RequiredFieldError";
+    }
+}
+export class InvalidStringArrayError extends Error {
+    constructor() {
+        super(`Invalid string array`);
+        this.name = "InvalidStringArrayError";
+    }
+}
+/**
+ * Configuration for drives of a Cartesi Machine. A drive may already exist or be built by a builder
+ */
+const DEFAULT_FORMAT = "ext2";
+const DEFAULT_RAM = "128Mi";
+const DEFAULT_RAM_IMAGE_DOCKER = "/usr/share/cartesi-machine/images/linux.bin";
+const DEFAULT_RAM_IMAGE_LINUX = "/usr/share/cartesi-machine/images/linux.bin";
+const DEFAULT_RAM_IMAGE_MAC = "/opt/homebrew/share/cartesi-machine/images/linux.bin";
+const DEFAULT_SDK = "cartesi/sdk:0.12.0-alpha.0";
+export const defaultRootDriveConfig = () => ({
+    builder: "docker",
+    context: ".",
+    dockerfile: "Dockerfile", // file on current working directory
+    extraSize: 0,
+    format: DEFAULT_FORMAT,
+    tags: [],
+});
+export const defaultRamImage = () => {
+    switch (os.platform()) {
+        case "darwin":
+            return DEFAULT_RAM_IMAGE_MAC;
+        default:
+            return DEFAULT_RAM_IMAGE_LINUX;
+    }
+};
+export const defaultMachineConfig = () => ({
+    assertRollingTemplate: undefined,
+    bootargs: [],
+    entrypoint: undefined,
+    finalHash: true,
+    interactive: undefined,
+    maxMCycle: undefined,
+    noRollup: undefined,
+    ramLength: DEFAULT_RAM,
+    ramImage: defaultRamImage(),
+    store: "image",
+    user: undefined,
+});
+export const defaultConfig = () => ({
+    drives: { root: defaultRootDriveConfig() },
+    machine: defaultMachineConfig(),
+    sdk: DEFAULT_SDK,
+});
+const parseBoolean = (value, defaultValue) => {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    else if (typeof value === "boolean") {
+        return value;
+    }
+    throw new InvalidBooleanValueError(value);
+};
+const parseOptionalBoolean = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if (typeof value === "boolean") {
+        return value;
+    }
+    throw new InvalidBooleanValueError(value);
+};
+const parseString = (value, defaultValue) => {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    else if (typeof value === "string") {
+        return value;
+    }
+    throw new InvalidStringValueError(value);
+};
+const parseStringArray = (value) => {
+    if (value === undefined) {
+        return [];
+    }
+    else if (typeof value === "string") {
+        return [value];
+    }
+    else if (typeof value === "object" && Array.isArray(value)) {
+        return value.map((v) => {
+            if (typeof v === "string") {
+                return v;
+            }
+            throw new InvalidStringValueError(v);
+        });
+    }
+    throw new InvalidStringArrayError();
+};
+const parseRequiredString = (value, key) => {
+    if (value === undefined) {
+        throw new RequiredFieldError(key);
+    }
+    else if (typeof value === "string") {
+        return value;
+    }
+    throw new InvalidStringValueError(value);
+};
+const parseOptionalString = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if (typeof value === "string") {
+        return value;
+    }
+    throw new InvalidStringValueError(value);
+};
+const parseOptionalStringBoolean = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if (typeof value === "string") {
+        return value;
+    }
+    else if (typeof value === "boolean") {
+        return value;
+    }
+    throw new InvalidStringValueError(value);
+};
+const parseOptionalNumber = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if (typeof value === "bigint") {
+        return value;
+    }
+    else if (typeof value === "number") {
+        return BigInt(value);
+    }
+    throw new InvalidNumberValueError(value);
+};
+const parseBytes = (value, defaultValue) => {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    else if (typeof value === "bigint") {
+        return Number(value);
+    }
+    else if (typeof value === "number" || typeof value === "string") {
+        const output = bytes.parse(value);
+        if (output !== null) {
+            return output;
+        }
+    }
+    throw new InvalidBytesValueError(value);
+};
+const parseBuilder = (value) => {
+    if (value === undefined) {
+        return "docker";
+    }
+    else if (typeof value === "string") {
+        switch (value) {
+            case "directory":
+                return "directory";
+            case "docker":
+                return "docker";
+            case "empty":
+                return "empty";
+            case "none":
+                return "none";
+            case "tar":
+                return "tar";
+        }
+    }
+    throw new InvalidBuilderError(value);
+};
+const parseFormat = (value) => {
+    if (value === undefined) {
+        return DEFAULT_FORMAT;
+    }
+    else if (typeof value === "string") {
+        switch (value) {
+            case "ext2":
+                return "ext2";
+            case "sqfs":
+                return "sqfs";
+        }
+    }
+    throw new InvalidDriveFormatError(value);
+};
+const parseEmptyFormat = (value) => {
+    if (value === undefined) {
+        return DEFAULT_FORMAT;
+    }
+    else if (typeof value === "string") {
+        switch (value) {
+            case "ext2":
+                return "ext2";
+            case "raw":
+                return "raw";
+        }
+    }
+    throw new InvalidEmptyDriveFormatError(value);
+};
+const parseMachine = (value) => {
+    if (value === undefined) {
+        // default machine
+        return defaultMachineConfig();
+    }
+    if (typeof value !== "object") {
+        throw new Error(`Invalid machine configuration: ${value}`);
+    }
+    const toml = value;
+    return {
+        assertRollingTemplate: parseOptionalBoolean(toml["assert-rolling-template"]),
+        bootargs: parseStringArray(toml.bootargs),
+        finalHash: parseBoolean(toml["final-hash"], true),
+        interactive: undefined,
+        maxMCycle: parseOptionalNumber(toml["max-mcycle"]),
+        noRollup: parseBoolean(toml["no-rollup"], false),
+        ramLength: parseString(toml["ram-length"], DEFAULT_RAM),
+        ramImage: parseString(toml["ram-image"], defaultRamImage()),
+        store: "image",
+        user: parseOptionalString(toml.user),
+    };
+};
+export const getDriveFormat = (filename) => {
+    const extension = extname(filename);
+    switch (extension) {
+        case ".ext2":
+            return "ext2";
+        case ".sqfs":
+            return "sqfs";
+        default:
+            throw new InvalidDriveFormatError(extension);
+    }
+};
+const parseDrive = (drive) => {
+    const builder = parseBuilder(drive.builder);
+    switch (builder) {
+        case "directory": {
+            const { extraSize, format, mount, directory, shared, user } = drive;
+            return {
+                builder: "directory",
+                extraSize: parseBytes(extraSize, 0),
+                format: parseFormat(format),
+                mount: parseOptionalStringBoolean(mount),
+                directory: parseRequiredString(directory, "directory"),
+                shared: parseOptionalBoolean(shared),
+                user: parseOptionalString(user),
+            };
+        }
+        case "docker": {
+            const { context, dockerfile, extraSize, format, image, mount, shared, tags, target, user, } = drive;
+            return {
+                builder: "docker",
+                image: parseOptionalString(image),
+                context: parseString(context, "."),
+                dockerfile: parseString(dockerfile, "Dockerfile"),
+                extraSize: parseBytes(extraSize, 0),
+                format: parseFormat(format),
+                mount: parseOptionalStringBoolean(mount),
+                shared: parseOptionalBoolean(shared),
+                user: parseOptionalString(user),
+                tags: parseStringArray(tags),
+                target: parseOptionalString(target),
+            };
+        }
+        case "empty": {
+            const { format, mount, size, shared, user } = drive;
+            return {
+                builder: "empty",
+                format: parseEmptyFormat(format),
+                mount: parseOptionalStringBoolean(mount),
+                shared: parseOptionalBoolean(shared),
+                size: parseBytes(size, 0),
+                user: parseOptionalString(user),
+            };
+        }
+        case "tar": {
+            const { extraSize, filename, format, mount, shared, user } = drive;
+            return {
+                builder: "tar",
+                extraSize: parseBytes(extraSize, 0),
+                filename: parseRequiredString(filename, "filename"),
+                format: parseFormat(format),
+                mount: parseOptionalStringBoolean(mount),
+                shared: parseOptionalBoolean(shared),
+                user: parseOptionalString(user),
+            };
+        }
+        case "none": {
+            const { shared, mount, user } = drive;
+            const filename = parseRequiredString(drive.filename, "filename");
+            const format = getDriveFormat(filename);
+            return {
+                builder: "none",
+                filename,
+                format,
+                mount: parseOptionalStringBoolean(mount),
+                shared: parseOptionalBoolean(shared),
+                user: parseOptionalString(user),
+            };
+        }
+    }
+};
+const parseDrives = (config) => {
+    // load drives from configuration
+    const drives = Object.entries(config ?? {}).reduce((acc, [name, drive]) => {
+        acc[name] = parseDrive(drive);
+        return acc;
+    }, {});
+    // check if there is a root drive
+    const hasRoot = drives.root !== undefined;
+    if (!hasRoot) {
+        // there is no root drive, add a default one
+        drives.root = defaultRootDriveConfig();
+    }
+    return drives;
+};
+export const parse = (str) => {
+    const toml = parseToml(str);
+    const config = {
+        drives: parseDrives(toml.drives),
+        machine: parseMachine(toml.machine),
+        sdk: parseString(toml.sdk, DEFAULT_SDK),
+    };
+    return config;
+};