@cartesi/cli 2.0.0-alpha.21 → 2.0.0-alpha.22

package/dist/config.js

@@ -1,418 +0,0 @@
-import bytes from "bytes";
-import { extname } from "node: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";
-export const DEFAULT_SDK_VERSION = "0.12.0-alpha.25";
-export const DEFAULT_SDK_IMAGE = "cartesi/sdk";
-export const PREFERRED_PORT = 6751;
-export const defaultRootDriveConfig = () => ({
-    builder: "docker",
-    buildArgs: [],
-    context: ".",
-    dockerfile: "Dockerfile", // file on current working directory
-    extraSize: 0,
-    format: DEFAULT_FORMAT,
-    tags: [],
-});
-export const defaultMachineConfig = () => ({
-    assertRollingTemplate: undefined,
-    bootargs: [],
-    entrypoint: undefined,
-    maxMCycle: undefined,
-    noRollup: undefined,
-    ramLength: DEFAULT_RAM,
-    useDockerEnv: true,
-    useDockerWorkdir: true,
-    user: undefined,
-});
-export const defaultConfig = () => ({
-    drives: { root: defaultRootDriveConfig() },
-    machine: defaultMachineConfig(),
-    sdk: `${DEFAULT_SDK_IMAGE}:${DEFAULT_SDK_VERSION}`,
-});
-const parseBoolean = (value, defaultValue) => {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    if (typeof value === "boolean") {
-        return value;
-    }
-    throw new InvalidBooleanValueError(value);
-};
-const parseOptionalBoolean = (value) => {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value === "boolean") {
-        return value;
-    }
-    throw new InvalidBooleanValueError(value);
-};
-const parseString = (value, defaultValue) => {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    if (typeof value === "string") {
-        return value;
-    }
-    throw new InvalidStringValueError(value);
-};
-const parseStringArray = (value) => {
-    if (value === undefined) {
-        return [];
-    }
-    if (typeof value === "string") {
-        return [value];
-    }
-    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);
-    }
-    if (typeof value === "string") {
-        return value;
-    }
-    throw new InvalidStringValueError(value);
-};
-const parseOptionalString = (value) => {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value === "string") {
-        return value;
-    }
-    throw new InvalidStringValueError(value);
-};
-const parseOptionalStringBoolean = (value) => {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value === "string") {
-        return value;
-    }
-    if (typeof value === "boolean") {
-        return value;
-    }
-    throw new InvalidStringValueError(value);
-};
-const parseOptionalNumber = (value) => {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value === "bigint") {
-        return value;
-    }
-    if (typeof value === "number") {
-        return BigInt(value);
-    }
-    throw new InvalidNumberValueError(value);
-};
-const parseBytes = (value, defaultValue) => {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    if (typeof value === "bigint") {
-        return Number(value);
-    }
-    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";
-    }
-    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;
-    }
-    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;
-    }
-    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.boot_args),
-        entrypoint: parseOptionalString(toml.entrypoint),
-        maxMCycle: parseOptionalNumber(toml.max_mcycle),
-        noRollup: parseBoolean(toml.no_rollup, false),
-        ramLength: parseString(toml.ram_length, DEFAULT_RAM),
-        ramImage: parseOptionalString(toml.ram_image),
-        useDockerEnv: parseBoolean(toml.use_docker_env, true),
-        useDockerWorkdir: parseBoolean(toml.use_docker_workdir, true),
-        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 { extra_size, format, mount, directory, shared, user } = drive;
-            return {
-                builder: "directory",
-                extraSize: parseBytes(extra_size, 0),
-                format: parseFormat(format),
-                mount: parseOptionalStringBoolean(mount),
-                directory: parseRequiredString(directory, "directory"),
-                shared: parseOptionalBoolean(shared),
-                user: parseOptionalString(user),
-            };
-        }
-        case "docker": {
-            const { build_args, context, dockerfile, extra_size, format, image, mount, shared, tags, target, user, } = drive;
-            return {
-                builder: "docker",
-                buildArgs: parseStringArray(build_args),
-                image: parseOptionalString(image),
-                context: parseString(context, "."),
-                dockerfile: parseString(dockerfile, "Dockerfile"),
-                extraSize: parseBytes(extra_size, 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 { extra_size, filename, format, mount, shared, user } = drive;
-            return {
-                builder: "tar",
-                extraSize: parseBytes(extra_size, 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) => {
-    let toml = {};
-    for (const s of str) {
-        toml = mergeTomlTables(toml, parseToml(s));
-    }
-    const config = {
-        drives: parseDrives(toml.drives),
-        machine: parseMachine(toml.machine),
-        sdk: parseString(toml.sdk, `${DEFAULT_SDK_IMAGE}:${DEFAULT_SDK_VERSION}`),
-    };
-    return config;
-};
-/**
- * Checks if a value is a plain object (TOML table)
- */
-function isTomlTable(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        !("toISOString" in value)); // Check for TomlDate (has toISOString method)
-}
-/**
- * Recursively merges two TOML table objects
- * Values from 'other' take precedence over 'base'
- *
- * @param base - The base TOML table
- * @param other - The TOML table to merge into base (takes precedence)
- * @returns A new merged TOML table
- */
-export function mergeTomlTables(base, other) {
-    const result = { ...base };
-    for (const [key, otherValue] of Object.entries(other)) {
-        const baseValue = result[key];
-        // If both values are tables, merge them recursively
-        if (isTomlTable(baseValue) && isTomlTable(otherValue)) {
-            result[key] = mergeTomlTables(baseValue, otherValue);
-        }
-        else {
-            // For all other cases, other value takes precedence
-            result[key] = otherValue;
-        }
-    }
-    return result;
-}
-/**
- * Merges two TOML values of any type
- *
- * @param base - The base TOML value
- * @param other - The TOML value to merge into base (takes precedence)
- * @returns The merged TOML value
- */
-export function mergeTomlValues(base, other) {
-    // If both are tables, merge recursively
-    if (isTomlTable(base) && isTomlTable(other)) {
-        return mergeTomlTables(base, other);
-    }
-    // For arrays, replaces entirely
-    return other;
-}