@pagopa/dx-cli 0.23.0 → 0.23.1

package/dist/adapters/codemods/__tests__/use-pnpm.test.js

@@ -1,148 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-import YAML from "yaml";
-import { extractPackageExtensions, NPM, preparePackageJsonForPnpm, usePnpm, writePnpmWorkspaceFile, Yarn, } from "../use-pnpm.js";
-const { readFile, stdout, writeFile } = vi.hoisted(() => ({
-    readFile: vi.fn(async () => ""),
-    stdout: vi.fn(),
-    writeFile: vi.fn(),
-}));
-vi.mock("execa", () => ({
-    $: vi.fn((opts) => {
-        const hasOptions = typeof opts === "object" && Object.hasOwn(opts, "lines");
-        if (hasOptions) {
-            return () => stdout().then((output) => ({
-                stdout: output.split("\n"),
-            }));
-        }
-        return stdout().then((output) => ({
-            stdout: output,
-        }));
-    }),
-}));
-vi.mock("node:fs/promises", () => ({
-    default: {
-        appendFile: () => Promise.resolve(),
-        readFile,
-        rm: () => Promise.resolve(),
-        stat: () => Promise.resolve({
-            isFile: () => true,
-        }),
-        writeFile,
-    },
-}));
-vi.mock("../git.js", async () => ({
-    getLatestCommitShaOrRef: async () => "dummy-sha",
-}));
-describe("pm", () => {
-    test("yarn workspaces are parsed correctly", async () => {
-        const yarn = new Yarn();
-        stdout.mockResolvedValueOnce(`{"location":".","name":"io-messages"}\n{"location":"apps/citizen-func","name":"citizen-func"}`);
-        const workspaces = await yarn.listWorkspaces();
-        expect(workspaces).toEqual(["io-messages", "citizen-func"]);
-    });
-    test("npm workspaces are parsed correctly", async () => {
-        const npm = new NPM();
-        stdout.mockResolvedValueOnce(`[{ "name": "io-messages", "location": "." },{ "name": "citizen-func", "location": "apps/citizen-func" }]`);
-        const workspaces = await npm.listWorkspaces();
-        expect(workspaces).toEqual(["io-messages", "citizen-func"]);
-    });
-});
-describe("extractPackageExtensions", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    test("returns packageExtensions only if present", async () => {
-        const yarnrc = {
-            packageExtensions: {
-                "some-package@*": {
-                    peerDependencies: {
-                        react: "*",
-                    },
-                },
-            },
-        };
-        readFile.mockResolvedValueOnce(YAML.stringify(yarnrc));
-        await expect(extractPackageExtensions()).resolves.toEqual(yarnrc.packageExtensions);
-        expect(readFile).toHaveBeenCalledOnce();
-    });
-    test("returns undefined if packageExtensions is not present", async () => {
-        const yarnrc = {
-            someOtherField: {},
-        };
-        readFile.mockResolvedValueOnce(YAML.stringify(yarnrc));
-        await expect(extractPackageExtensions()).resolves.toBeUndefined();
-        expect(readFile).toHaveBeenCalledOnce();
-    });
-});
-describe("preparePackageJsonForPnpm", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    test("removes packageManager field and keeps workspaces", async () => {
-        const packageJson = {
-            name: "test-monorepo",
-            packageManager: "yarn@1.22.10",
-            version: "1.0.0",
-            workspaces: ["packages/*"],
-        };
-        readFile.mockResolvedValueOnce(JSON.stringify(packageJson, null, 2));
-        const workspaces = await preparePackageJsonForPnpm();
-        expect(workspaces).toEqual(["packages/*"]);
-        expect(readFile).toHaveBeenCalledOnce();
-        expect(writeFile).toHaveBeenCalledWith("package.json", JSON.stringify({
-            name: packageJson.name,
-            version: packageJson.version,
-        }, null, 2));
-    });
-});
-describe("writePnpmWorkspaceFile", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    test("writes pnpm-workspace.yaml with given workspaces", async () => {
-        const workspaces = ["packages/*", "apps/*"];
-        const packageExtensions = {
-            "express@*": {
-                peerDependencies: {
-                    typescript: "*",
-                },
-            },
-        };
-        await writePnpmWorkspaceFile(workspaces, packageExtensions);
-        expect(writeFile).toHaveBeenCalledWith("pnpm-workspace.yaml", expect.stringContaining(YAML.stringify({ packages: workspaces })), "utf-8");
-        expect(writeFile).toHaveBeenCalledWith("pnpm-workspace.yaml", expect.stringContaining(YAML.stringify({ packageExtensions })), "utf-8");
-    });
-});
-describe("usePnpm", () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    test("rejects if the project is already using pnpm", async () => {
-        await expect(usePnpm("pnpm", "10.20")).rejects.toThrow();
-    });
-    test.each([
-        { expected: false, version: "18.0.0" },
-        { expected: false, version: "20.10.0" },
-        { expected: false, version: "20.19.4" },
-        { expected: true, version: "22.0.0" },
-        { expected: true, version: "20.19.5" },
-    ])("rejects if Node.js version is less than required ($version)", async ({ expected, version }) => {
-        stdout.mockResolvedValue("[]");
-        readFile.mockResolvedValueOnce(JSON.stringify({ name: "test-monorepo", workspaces: [] }));
-        await expect(usePnpm("npm", version).then(() => true, () => false)).resolves.toBe(expected);
-    });
-    test("moves workspaces from package.json to pnpm-workspace.yaml", async () => {
-        const packageJson = {
-            name: "test-monorepo",
-            packageManager: "yarn@1.22.10",
-            version: "1.0.0",
-            workspaces: ["packages/*"],
-        };
-        readFile.mockResolvedValueOnce(JSON.stringify(packageJson, null, 2));
-        stdout.mockResolvedValue(`[]`); // npm list workspaces
-        await usePnpm("npm", "22.0.0");
-        expect(writeFile).toHaveBeenNthCalledWith(2, "pnpm-workspace.yaml", expect.stringContaining(YAML.stringify({
-            packages: packageJson.workspaces,
-        })), "utf-8");
-    });
-});

package/dist/adapters/commander/__tests__/env.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/adapters/commander/__tests__/env.test.js

@@ -1,45 +0,0 @@
-import fc from "fast-check";
-/**
- * Tests for the CLI environment schema.
- * Validates that `cliEnvSchema` correctly parses `process.env`.
- */
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { z } from "zod";
-import { cliEnvSchema } from "../env.js";
-// The accepted stringbool values mirror those recognised by z.stringbool().
-const CI_TRUTHY = ["true", "1", "yes", "y", "on"];
-const CI_FALSEY = ["false", "0", "no", "n", "off"];
-const CI_ACCEPTED = [...CI_TRUTHY, ...CI_FALSEY];
-describe("cliEnvSchema", () => {
-    afterEach(() => {
-        vi.unstubAllEnvs();
-    });
-    describe("CI field", () => {
-        it("should be true for truthy string-bool values", () => {
-            fc.assert(fc.property(fc.constantFrom(...CI_TRUTHY), (value) => {
-                vi.stubEnv("CI", value);
-                const result = cliEnvSchema.safeParse(process.env);
-                expect(result.success).toBe(true);
-                expect(result.success && result.data.CI).toBe(true);
-            }));
-        });
-        it("should be false for falsey string-bool values or when unset", () => {
-            fc.assert(fc.property(fc.constantFrom(...CI_FALSEY, undefined), (value) => {
-                vi.stubEnv("CI", value);
-                const result = cliEnvSchema.safeParse(process.env);
-                expect(result.success).toBe(true);
-                expect(result.success && result.data.CI).toBe(false);
-            }));
-        });
-        it("should not parse unrecognised values", () => {
-            fc.assert(fc.property(
-            // Every string not in the accepted list
-            fc.string().filter((s) => !CI_ACCEPTED.includes(s.toLowerCase())), (value) => {
-                vi.stubEnv("CI", value);
-                const result = cliEnvSchema.safeParse(process.env);
-                expect(result.success).toBe(false);
-                expect(result.error).toBeInstanceOf(z.ZodError);
-            }));
-        });
-    });
-});

package/dist/adapters/commander/__tests__/error-reporting.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/adapters/commander/__tests__/error-reporting.test.js

@@ -1,63 +0,0 @@
-import { ExecaError } from "execa";
-import { describe, expect, it } from "vitest";
-import { formatErrorDetailed, toErrorMessage } from "../error-reporting.js";
-describe("toErrorMessage", () => {
-    it("returns the string as-is when given a string", () => {
-        expect(toErrorMessage("oops")).toBe("oops");
-    });
-    it("returns 'Unknown error' for null/undefined", () => {
-        expect(toErrorMessage(null)).toBe("Unknown error");
-        expect(toErrorMessage(undefined)).toBe("Unknown error");
-    });
-    it("returns Error.message when given a plain Error", () => {
-        expect(toErrorMessage(new Error("boom"))).toBe("boom");
-    });
-    it("prefers ExecaError.shortMessage over message", () => {
-        const execaError = Object.assign(Object.create(ExecaError.prototype), {
-            message: "long noisy message with stderr",
-            shortMessage: "Command failed: terraform init",
-        });
-        expect(toErrorMessage(execaError)).toBe("Command failed: terraform init");
-    });
-    it("flattens AggregateError into a bulleted message", () => {
-        const aggregate = new AggregateError([new Error("first"), new Error("second")], "parent");
-        expect(toErrorMessage(aggregate)).toBe("parent\n  - first\n  - second");
-    });
-    it("extracts `message` property from plain objects when present", () => {
-        expect(toErrorMessage({ message: "from object" })).toBe("from object");
-    });
-    it("falls back to JSON.stringify for objects without message", () => {
-        expect(toErrorMessage({ code: 42 })).toBe('{"code":42}');
-    });
-});
-describe("formatErrorDetailed", () => {
-    it("renders name, message and stack for a single error", () => {
-        const err = new Error("top");
-        const formatted = formatErrorDetailed(err);
-        expect(formatted).toContain("Error: top");
-        expect(formatted).toContain("at ");
-    });
-    it("walks the cause chain", () => {
-        const root = new Error("root failure");
-        const middle = new Error("middle", { cause: root });
-        const top = new Error("top", { cause: middle });
-        const formatted = formatErrorDetailed(top);
-        expect(formatted).toContain("Error: top");
-        expect(formatted).toContain("Caused by: Error: middle");
-        expect(formatted).toContain("Caused by: Error: root failure");
-    });
-    it("terminates when encountering a cycle in the cause chain", () => {
-        const a = new Error("a");
-        const b = new Error("b", { cause: a });
-        a.cause = b;
-        const formatted = formatErrorDetailed(a);
-        expect(formatted).toContain("Error: a");
-        expect(formatted).toContain("Caused by: Error: b");
-    });
-    it("handles non-Error causes gracefully", () => {
-        const err = new Error("wrapped", { cause: "raw string cause" });
-        const formatted = formatErrorDetailed(err);
-        expect(formatted).toContain("Error: wrapped");
-        expect(formatted).toContain("Caused by: raw string cause");
-    });
-});

package/dist/adapters/commander/__tests__/exit-with-error.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/adapters/commander/__tests__/exit-with-error.test.js

@@ -1,92 +0,0 @@
-import { Command } from "commander";
-import { describe, expect, it } from "vitest";
-import { exitWithError, isVerbose } from "../index.js";
-/**
- * Builds a parent command that exposes the global `--verbose` flag so that
- * `optsWithGlobals()` behaves the same way it does on the real CLI.
- */
-const makeProgramWith = (child, argv) => {
-    const program = new Command()
-        .name("dx")
-        .option("-v, --verbose", "verbose output", false)
-        .exitOverride()
-        .configureOutput({
-        writeErr: () => {
-            /* silence stderr in tests */
-        },
-        writeOut: () => {
-            /* silence stdout in tests */
-        },
-    });
-    child.exitOverride().configureOutput({
-        writeErr: () => {
-            /* silence */
-        },
-        writeOut: () => {
-            /* silence */
-        },
-    });
-    program.addCommand(child);
-    program.parse(argv, { from: "user" });
-    return program;
-};
-/**
- * `exitWithError` always throws (Commander's `exitOverride()` converts the
- * process.exit call into a CommanderError throw). This helper captures that
- * throw so tests can assert on the thrown payload without putting `expect`
- * inside a `catch` block (which vitest/no-conditional-expect disallows).
- */
-const captureThrown = (fn) => {
-    try {
-        fn();
-    }
-    catch (error) {
-        return error;
-    }
-    throw new Error("expected the callback to throw");
-};
-describe("isVerbose", () => {
-    it("is false when --verbose is not provided", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["run"]);
-        expect(isVerbose(cmd)).toBe(false);
-    });
-    it("is true when -v is provided at the root", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["-v", "run"]);
-        expect(isVerbose(cmd)).toBe(true);
-    });
-    it("is true when --verbose is provided at the root", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["--verbose", "run"]);
-        expect(isVerbose(cmd)).toBe(true);
-    });
-});
-describe("exitWithError", () => {
-    it("reports only the message in normal mode", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["run"]);
-        const err = new Error("outer", { cause: new Error("inner secret") });
-        expect(() => exitWithError(cmd)(err)).toThrow(/outer/);
-        const thrown = captureThrown(() => exitWithError(cmd)(err));
-        const message = String(thrown?.message ?? thrown);
-        expect(message).not.toContain("Caused by");
-        expect(message).not.toContain("inner secret");
-    });
-    it("includes the cause chain and stack trace in verbose mode", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["--verbose", "run"]);
-        const root = new Error("root cause");
-        const err = new Error("surface", { cause: root });
-        const thrown = captureThrown(() => exitWithError(cmd)(err));
-        const message = String(thrown?.message ?? thrown);
-        expect(message).toContain("Error: surface");
-        expect(message).toContain("Caused by: Error: root cause");
-        expect(message).toContain("at ");
-    });
-    it("works with non-Error values", () => {
-        const cmd = new Command("run").action(() => undefined);
-        makeProgramWith(cmd, ["run"]);
-        expect(() => exitWithError(cmd)("plain string failure")).toThrow(/plain string failure/);
-    });
-});

package/dist/adapters/commander/__tests__/global-options.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/adapters/commander/__tests__/global-options.test.js

@@ -1,33 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mock } from "vitest-mock-extended";
-import { makeCli } from "../index.js";
-const makeProgram = (argv) => {
-    const program = makeCli(mock(), mock(), mock(), "0.0.0");
-    program.exitOverride().configureOutput({
-        writeErr: () => {
-            /* silence stderr in tests */
-        },
-        writeOut: () => {
-            /* silence stdout in tests */
-        },
-    });
-    program.parseOptions(argv);
-    return program;
-};
-describe("--output option", () => {
-    it("defaults to 'text' when not provided", () => {
-        const program = makeProgram([]);
-        expect(program.opts().output).toBe("text");
-    });
-    it("accepts 'text' explicitly", () => {
-        const program = makeProgram(["--output", "text"]);
-        expect(program.opts().output).toBe("text");
-    });
-    it("accepts 'json'", () => {
-        const program = makeProgram(["--output", "json"]);
-        expect(program.opts().output).toBe("json");
-    });
-    it("rejects invalid values", () => {
-        expect(() => makeProgram(["--output", "xml"])).toThrow();
-    });
-});

package/dist/adapters/commander/__tests__/spec.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Tests for the Commander spec adapter.
- *
- * Verifies that `extractCliSpec` correctly maps Commander's internal command
- * tree to the `CliSpec` domain type, covering options, arguments, and nested
- * subcommands.
- */
-export {};

package/dist/adapters/commander/__tests__/spec.test.js

@@ -1,264 +0,0 @@
-/**
- * Tests for the Commander spec adapter.
- *
- * Verifies that `extractCliSpec` correctly maps Commander's internal command
- * tree to the `CliSpec` domain type, covering options, arguments, and nested
- * subcommands.
- */
-import { Argument, Command, Option } from "commander";
-import { describe, expect, it } from "vitest";
-import { extractCliSpec } from "../spec.js";
-const buildRoot = () => new Command("dx")
-    .description("The CLI for DX-Platform")
-    .version("1.2.3")
-    .addOption(new Option("-v, --verbose", "Enable verbose output").default(false))
-    .addOption(new Option("--output <mode>", "Output mode")
-    .choices(["text", "json"])
-    .default("text"));
-const registerRootMetadataAndGlobalOptionTests = () => {
-    describe("root metadata and global options", () => {
-        it("maps the root command name, description and version", () => {
-            const root = buildRoot();
-            const spec = extractCliSpec(root, "1.2.3");
-            expect(spec).toMatchObject({
-                description: "The CLI for DX-Platform",
-                name: "dx",
-                specVersion: "1",
-                version: "1.2.3",
-            });
-        });
-        it("maps global options from the root command", () => {
-            const root = buildRoot();
-            const spec = extractCliSpec(root, "1.2.3");
-            expect(spec.globalOptions.find((o) => o.long === "--verbose")).toStrictEqual({
-                choices: [],
-                defaultValue: false,
-                description: "Enable verbose output",
-                flags: "-v, --verbose",
-                long: "--verbose",
-                optional: false,
-                required: false,
-                short: "-v",
-            });
-            expect(spec.globalOptions.find((o) => o.long === "--output")).toStrictEqual({
-                choices: ["text", "json"],
-                defaultValue: "text",
-                description: "Output mode",
-                flags: "--output <mode>",
-                long: "--output",
-                optional: false,
-                required: true,
-                short: undefined,
-            });
-        });
-        it("excludes help and version options from globalOptions", () => {
-            const root = buildRoot();
-            const spec = extractCliSpec(root, "1.2.3");
-            const flags = spec.globalOptions.map((o) => o.long);
-            expect(flags).not.toContain("--help");
-            expect(flags).not.toContain("--version");
-        });
-    });
-};
-const registerCommandListTests = () => {
-    describe("command lists", () => {
-        it("maps a flat subcommand with options and no arguments", () => {
-            const root = buildRoot();
-            root.addCommand(new Command("doctor")
-                .description("Run health checks")
-                .addOption(new Option("--fix", "Auto-fix issues").default(false)));
-            const spec = extractCliSpec(root, "1.2.3");
-            expect(spec.commands).toStrictEqual([
-                {
-                    arguments: [],
-                    commands: [],
-                    description: "Run health checks",
-                    name: "doctor",
-                    options: [
-                        {
-                            choices: [],
-                            defaultValue: false,
-                            description: "Auto-fix issues",
-                            flags: "--fix",
-                            long: "--fix",
-                            optional: false,
-                            required: false,
-                            short: undefined,
-                        },
-                    ],
-                },
-            ]);
-        });
-        it("maps a subcommand argument (required)", () => {
-            const root = buildRoot();
-            root.addCommand(new Command("apply")
-                .description("Apply something")
-                .addArgument(new Argument("<id>", "The id of the item to apply")));
-            const spec = extractCliSpec(root, "1.2.3");
-            expect(spec.commands).toStrictEqual([
-                {
-                    arguments: [
-                        {
-                            choices: [],
-                            defaultValue: undefined,
-                            description: "The id of the item to apply",
-                            name: "id",
-                            required: true,
-                            variadic: false,
-                        },
-                    ],
-                    commands: [],
-                    description: "Apply something",
-                    name: "apply",
-                    options: [],
-                },
-            ]);
-        });
-        it("maps a variadic optional argument", () => {
-            const root = buildRoot();
-            root.addCommand(new Command("run")
-                .description("Run scripts")
-                .addArgument(new Argument("[scripts...]", "Scripts to run")));
-            const spec = extractCliSpec(root, "1.2.3");
-            expect(spec.commands).toStrictEqual([
-                {
-                    arguments: [
-                        {
-                            choices: [],
-                            defaultValue: undefined,
-                            description: "Scripts to run",
-                            name: "scripts",
-                            required: false,
-                            variadic: true,
-                        },
-                    ],
-                    commands: [],
-                    description: "Run scripts",
-                    name: "run",
-                    options: [],
-                },
-            ]);
-        });
-        it("includes commands registered with { hidden: true }", () => {
-            const root = buildRoot();
-            const visible = new Command("visible").description("Visible");
-            const hidden = new Command("internal").description("Internal");
-            root.addCommand(visible);
-            root.addCommand(hidden, { hidden: true });
-            const spec = extractCliSpec(root, "1.2.3");
-            expect(spec.commands).toStrictEqual([
-                {
-                    arguments: [],
-                    commands: [],
-                    description: "Visible",
-                    name: "visible",
-                    options: [],
-                },
-                {
-                    arguments: [],
-                    commands: [],
-                    description: "Internal",
-                    name: "internal",
-                    options: [],
-                },
-            ]);
-        });
-        it("excludes the spec command from the extracted command list", () => {
-            const root = buildRoot();
-            root.addCommand(new Command("doctor").description("Run health checks"));
-            root.addCommand(new Command("spec").description("Print the CLI spec"));
-            const spec = extractCliSpec(root, "1.2.3");
-            expect(spec.commands).toStrictEqual([
-                {
-                    arguments: [],
-                    commands: [],
-                    description: "Run health checks",
-                    name: "doctor",
-                    options: [],
-                },
-            ]);
-        });
-        it("returns empty commands array when root has no subcommands", () => {
-            const root = buildRoot();
-            const spec = extractCliSpec(root, "1.2.3");
-            expect(spec.commands).toEqual([]);
-        });
-        it("maps an argument with choices", () => {
-            const root = buildRoot();
-            root.addCommand(new Command("format")
-                .description("Format output")
-                .addArgument(new Argument("<style>", "Output style").choices(["json", "table"])));
-            const spec = extractCliSpec(root, "1.2.3");
-            expect(spec.commands).toStrictEqual([
-                {
-                    arguments: [
-                        {
-                            choices: ["json", "table"],
-                            defaultValue: undefined,
-                            description: "Output style",
-                            name: "style",
-                            required: true,
-                            variadic: false,
-                        },
-                    ],
-                    commands: [],
-                    description: "Format output",
-                    name: "format",
-                    options: [],
-                },
-            ]);
-        });
-    });
-};
-const registerNestedCommandTests = () => {
-    describe("nested commands", () => {
-        it("recursively maps nested subcommands", () => {
-            const root = buildRoot();
-            const codemod = new Command("codemod").description("Manage codemods");
-            codemod.addCommand(new Command("list").description("List available codemods"));
-            codemod.addCommand(new Command("apply")
-                .description("Apply a codemod")
-                .addArgument(new Argument("<id>", "Codemod id")));
-            root.addCommand(codemod);
-            const spec = extractCliSpec(root, "1.2.3");
-            expect(spec.commands).toStrictEqual([
-                {
-                    arguments: [],
-                    commands: [
-                        {
-                            arguments: [],
-                            commands: [],
-                            description: "List available codemods",
-                            name: "list",
-                            options: [],
-                        },
-                        {
-                            arguments: [
-                                {
-                                    choices: [],
-                                    defaultValue: undefined,
-                                    description: "Codemod id",
-                                    name: "id",
-                                    required: true,
-                                    variadic: false,
-                                },
-                            ],
-                            commands: [],
-                            description: "Apply a codemod",
-                            name: "apply",
-                            options: [],
-                        },
-                    ],
-                    description: "Manage codemods",
-                    name: "codemod",
-                    options: [],
-                },
-            ]);
-        });
-    });
-};
-describe("extractCliSpec", () => {
-    registerRootMetadataAndGlobalOptionTests();
-    registerCommandListTests();
-    registerNestedCommandTests();
-});

package/dist/adapters/commander/commands/__tests__/add.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Tests for authorizeCloudAccounts in the init command.
- */
-export {};