@pagopa/dx-cli 0.23.0 → 0.23.2

package/dist/adapters/commander/commands/init.js

@@ -9,14 +9,17 @@ import { oraPromise } from "ora";
 import { z } from "zod";
 import { Repository, } from "../../../domain/github.js";
 import { tf$ } from "../../execa/terraform.js";
-import { getPlopInstance, runMonorepoGenerator } from "../../plop/index.js";
+import { collectMonorepoPayload, getPlopInstance, runMonorepoActions, } from "../../plop/index.js";
 import { exitWithError } from "../index.js";
+import { createCommandPresenter } from "../presenters/index.js";
 const isGitHubRepoCreationSkipped = (input) => "gitHubRepoCreationSkipped" in input;
-const withSpinner = (text, successText, failText, promise) => ResultAsync.fromPromise(oraPromise(promise, {
+const withSpinner = (text, successText, failText, task) => ResultAsync.fromPromise(oraPromise(task(), {
     failText,
     successText,
     text,
 }), (cause) => new Error(failText, { cause }));
+const asError = (message) => (cause) => new Error(message, { cause });
+const trackStep = (presenter, name, task, mapError) => ResultAsync.fromPromise(presenter.trackStep(name, task), mapError);
 const displaySummary = (input) => {
     const docsUrl = "https://dx.pagopa.it/getting-started";
     if (isGitHubRepoCreationSkipped(input)) {
@@ -52,8 +55,12 @@ const displaySummary = (input) => {
         console.log(`Please, manually create a Pull Request in the GitHub repository to review the scaffolded code.\n`);
     }
 };
-const checkTerraformCliIsInstalled = () => withSpinner("Checking Terraform installation...", "Terraform is installed!", "Please install terraform CLI before running this command. If you use tfenv, run: tfenv install latest && tfenv use latest", tf$ `terraform -version`);
-const checkCorepackIsInstalled = () => withSpinner("Checking Corepack installation...", "Corepack is installed!", "Please install Corepack before running this command.", tf$ `corepack -v`);
+const checkTerraformCli = () => tf$ `terraform -version`;
+const checkTerraformCliIsInstalled = () => withSpinner("Checking Terraform installation...", "Terraform is installed!", "Please install terraform CLI before running this command. If you use tfenv, run: tfenv install latest && tfenv use latest", checkTerraformCli);
+const trackTerraformCliIsInstalled = (presenter) => trackStep(presenter, "Checking Terraform installation...", checkTerraformCli, asError("Please install terraform CLI before running this command. If you use tfenv, run: tfenv install latest && tfenv use latest"));
+const checkCorepack = () => tf$ `corepack -v`;
+const checkCorepackIsInstalled = () => withSpinner("Checking Corepack installation...", "Corepack is installed!", "Please install Corepack before running this command.", checkCorepack);
+const trackCorepackIsInstalled = (presenter) => trackStep(presenter, "Checking Corepack installation...", checkCorepack, asError("Please install Corepack before running this command."));
 const azureAccountSchema = z.object({
     user: z.object({
         name: z.string().min(1),
@@ -68,13 +75,14 @@ const ensureAzLogin = async () => {
     const { user } = azureAccountSchema.parse(parsed);
     return user.name;
 };
-const checkAzLogin = () => withSpinner("Check Azure login status...", (userName) => `You are logged in to Azure (${userName})`, "Please log in to Azure CLI using `az login` before running this command.", ensureAzLogin());
+const checkAzLogin = () => withSpinner("Check Azure login status...", (userName) => `You are logged in to Azure (${userName})`, "Please log in to Azure CLI using `az login` before running this command.", ensureAzLogin);
+const runInitPreconditions = (presenter) => trackTerraformCliIsInstalled(presenter).andThen(() => trackCorepackIsInstalled(presenter));
 // TODO(CES-1810): Make these checks concurrent to speed up the preconditions check phase
 export const checkInitPreconditions = () => checkTerraformCliIsInstalled().andThen(() => checkCorepackIsInstalled());
 export const checkAddEnvironmentPreconditions = () => checkTerraformCliIsInstalled()
     .andThen(() => checkAzLogin())
     .andThen(() => checkCorepackIsInstalled());
-const createRemoteRepository = ({ repoName, repoOwner, }) => {
+const createRemoteRepositoryWithPresenter = (presenter) => ({ repoName, repoOwner, }) => {
     const logger = getLogger(["dx-cli", "init"]);
     const repo$ = tf$({ cwd: path.resolve("infra", "repository") });
     const applyTerraform = async () => {
@@ -89,9 +97,9 @@ const createRemoteRepository = ({ repoName, repoOwner, }) => {
             throw error;
         }
     };
-    return withSpinner("Creating GitHub repository...", "GitHub repository created successfully!", "Failed to create GitHub repository.", applyTerraform()).map(() => new Repository(repoName, repoOwner));
+    return trackStep(presenter, "Creating GitHub repository...", applyTerraform, asError("Failed to create GitHub repository.")).map(() => new Repository(repoName, repoOwner));
 };
-const initializeGitRepository = (repository) => {
+const initializeGitRepositoryWithPresenter = (presenter) => (repository) => {
     const branchName = "features/scaffold-workspace";
     const git$ = $({
         shell: true,
@@ -109,24 +117,24 @@ const initializeGitRepository = (repository) => {
         await git$ `git commit --no-gpg-sign -m "Scaffold workspace"`;
         await git$ `git push -u origin ${branchName}`;
     };
-    return withSpinner("Pushing code to GitHub...", "Code pushed to GitHub successfully!", "Failed to push code to GitHub.", pushToOrigin()).map(() => ({ branchName, repository }));
+    return trackStep(presenter, "Pushing code to GitHub...", pushToOrigin, asError("Failed to push code to GitHub.")).map(() => ({ branchName, repository }));
 };
-const handleNewGitHubRepository = (githubService) => (payload) => createRemoteRepository(payload)
-    .andThen(initializeGitRepository)
-    .andThen((localWorkspace) => createPullRequest(githubService)(localWorkspace).map((pr) => ({
-    pr,
-    repository: localWorkspace.repository,
-})));
-const createPullRequest = (githubService) => ({ branchName, repository, }) => withSpinner("Creating Pull Request...", "Pull Request created successfully!", "Failed to create Pull Request.", githubService.createPullRequest({
+const createPullRequestWithPresenter = ({ gitHubService, presenter }) => ({ branchName, repository, }) => trackStep(presenter, "Creating Pull Request...", () => gitHubService.createPullRequest({
     base: "main",
     body: "This PR contains the scaffolded monorepo structure.",
     head: branchName,
     owner: repository.owner,
     repo: repository.name,
     title: "Scaffold repository",
-}))
+}), asError("Failed to create Pull Request."))
     // If PR creation fails, don't block the workflow
     .orElse(() => okAsync(undefined));
+const handleNewGitHubRepositoryWithPresenter = (context) => (payload) => createRemoteRepositoryWithPresenter(context.presenter)(payload)
+    .andThen(initializeGitRepositoryWithPresenter(context.presenter))
+    .andThen((localWorkspace) => createPullRequestWithPresenter(context)(localWorkspace).map((pr) => ({
+    pr,
+    repository: localWorkspace.repository,
+})));
 const handleGeneratorError = (err) => {
     const logger = getLogger(["dx-cli", "init"]);
     if (err instanceof Error) {
@@ -142,19 +150,46 @@ export const confirmGitHubRepoCreation = (payload) => ResultAsync.fromPromise(in
     type: "confirm",
 })
     .then(({ confirm }) => confirm), (cause) => new Error("Failed to read GitHub publish confirmation", { cause }));
+const runInitAction = ({ gitHubService, presenter, }) => trackStep(presenter, "Initializing workspace generator...", getPlopInstance, asError("Failed to initialize plop"))
+    .andThen((plop) => 
+// The prompt phase must run outside trackStep: in text mode trackStep
+// renders a spinner that occupies the TTY and hides the prompts.
+ResultAsync.fromPromise(collectMonorepoPayload(plop, gitHubService), handleGeneratorError))
+    .andThen(({ generator, payload }) => trackStep(presenter, "Scaffolding workspace...", () => runMonorepoActions(generator, payload), handleGeneratorError))
+    .andTee((payload) => {
+    process.chdir(payload.repoName);
+})
+    .andThen((payload) => confirmGitHubRepoCreation(payload).andThen((confirmed) => confirmed
+    ? handleNewGitHubRepositoryWithPresenter({
+        gitHubService,
+        presenter,
+    })(payload)
+    : okAsync({ gitHubRepoCreationSkipped: true, payload })));
+const reportSummary = (presenter, outputMode) => (result) => {
+    if (outputMode === "json") {
+        presenter.reportResult(result);
+    }
+    else {
+        displaySummary(result);
+    }
+};
+const reportCommandError = (command, presenter, outputMode) => (error) => {
+    if (outputMode === "json") {
+        presenter.reportError(error);
+        process.exitCode = 1;
+    }
+    else {
+        exitWithError(command)(error);
+    }
+};
 export const makeInitCommand = (requireGitHubAuth) => new Command()
     .name("init")
     .description("Initialize a new DX workspace")
     .action(async function () {
-    await checkInitPreconditions()
+    const { output } = this.optsWithGlobals();
+    const presenter = createCommandPresenter(output);
+    await runInitPreconditions(presenter)
         .andThen(() => requireGitHubAuth())
-        .andThen((auth) => ResultAsync.fromPromise(getPlopInstance(), (cause) => new Error("Failed to initialize plop", { cause }))
-        .andThen((plop) => ResultAsync.fromPromise(runMonorepoGenerator(plop, auth.gitHubService), handleGeneratorError))
-        .andTee((payload) => {
-        process.chdir(payload.repoName);
-    })
-        .andThen((payload) => confirmGitHubRepoCreation(payload).andThen((confirmed) => confirmed
-        ? handleNewGitHubRepository(auth.gitHubService)(payload)
-        : okAsync({ gitHubRepoCreationSkipped: true, payload }))))
-        .match(displaySummary, exitWithError(this));
+        .andThen((auth) => runInitAction({ gitHubService: auth.gitHubService, presenter }))
+        .match(reportSummary(presenter, output), reportCommandError(this, presenter, output));
 });

package/dist/adapters/commander/index.js

@@ -20,7 +20,7 @@ export const makeCli = (deps, config, cliDeps, version) => {
         .description("The CLI for DX-Platform")
         .version(version)
         .option("-v, --verbose", "Enable verbose output: debug-level logs and full error chain (with stack traces) when a command fails", false)
-        .addOption(new Option("--output <mode>", "Output mode: 'text' (human-readable, default) or 'json' (structured JSON envelope on stdout, NDJSON progress events on stderr)")
+        .addOption(new Option("--output <mode>", "Output mode: text (default, human-readable) or json (structured events to stdout for agents)")
         .choices(["text", "json"])
         .default("text"));
     program.addCommand(makeDoctorCommand(deps, config));

package/dist/adapters/plop/index.d.ts

@@ -7,7 +7,25 @@ import { Payload as MonorepoPayload } from "../plop/generators/monorepo/index.js
 export declare const setMonorepoGenerator: (plop: NodePlopAPI) => void;
 export declare const getPlopInstance: () => Promise<NodePlopAPI>;
 export declare const runActions: (generator: PlopGenerator, payload: Answers) => Promise<void>;
-export declare const runMonorepoGenerator: (plop: NodePlopAPI, githubService: GitHubService) => Promise<MonorepoPayload>;
+/**
+ * Collect the monorepo payload by running the generator's interactive prompts.
+ *
+ * This phase MUST run outside any spinner: a spinner (e.g. ora) occupies the
+ * TTY and prevents the inquirer prompts from being rendered. Callers should
+ * track only the subsequent {@link runMonorepoActions} phase, which is
+ * non-interactive.
+ */
+export declare const collectMonorepoPayload: (plop: NodePlopAPI, githubService: GitHubService) => Promise<{
+    generator: PlopGenerator;
+    payload: MonorepoPayload;
+}>;
+/**
+ * Execute the monorepo generator actions for an already-collected payload.
+ *
+ * This phase is non-interactive, so callers are free to wrap it in a spinner
+ * or other progress indicator.
+ */
+export declare const runMonorepoActions: (generator: PlopGenerator, payload: MonorepoPayload) => Promise<MonorepoPayload>;
 /**
  * Run the deployment environment generator
  *

package/dist/adapters/plop/index.js

@@ -48,17 +48,30 @@ export const runActions = async (generator, payload) => {
         throw new Error(`One or more actions failed during generation (${summary}).`);
     }
 };
-export const runMonorepoGenerator = async (plop, githubService) => {
+/**
+ * Collect the monorepo payload by running the generator's interactive prompts.
+ *
+ * This phase MUST run outside any spinner: a spinner (e.g. ora) occupies the
+ * TTY and prevents the inquirer prompts from being rendered. Callers should
+ * track only the subsequent {@link runMonorepoActions} phase, which is
+ * non-interactive.
+ */
+export const collectMonorepoPayload = async (plop, githubService) => {
     setMonorepoGenerator(plop);
     const generator = plop.getGenerator(PLOP_MONOREPO_GENERATOR_NAME);
     const answers = await generator.runPrompts();
     const payload = monorepoPayloadSchema.parse(answers);
     await validatePayload(payload, githubService);
-    await oraPromise(runActions(generator, payload), {
-        failText: "Failed to create workspace files.",
-        successText: "Workspace files created successfully!",
-        text: "Creating workspace files...",
-    });
+    return { generator, payload };
+};
+/**
+ * Execute the monorepo generator actions for an already-collected payload.
+ *
+ * This phase is non-interactive, so callers are free to wrap it in a spinner
+ * or other progress indicator.
+ */
+export const runMonorepoActions = async (generator, payload) => {
+    await runActions(generator, payload);
     return payload;
 };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/dx-cli",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "type": "module",
   "description": "A CLI useful to manage DX tools.",
   "repository": {
@@ -48,7 +48,7 @@
     "semver": "^7.7.4",
     "yaml": "^2.8.4",
     "zod": "^4.4.2",
-    "@pagopa/dx-savemoney": "^0.3.0"
+    "@pagopa/dx-savemoney": "^0.3.1"
   },
   "devDependencies": {
     "@tsconfig/node24": "24.0.4",
@@ -56,15 +56,15 @@
     "@types/libsodium-wrappers": "^0.8.2",
     "@types/node": "^22.19.17",
     "@types/semver": "^7.7.1",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/coverage-v8": "^4.1.8",
     "eslint": "^10.3.0",
     "fast-check": "^4.8.0",
     "memfs": "^4.57.2",
     "plop": "^4.0.5",
     "prettier": "3.8.3",
     "typescript": "~5.9.3",
-    "vitest": "^3.2.4",
-    "vitest-mock-extended": "^3.1.1",
+    "vitest": "^4.1.8",
+    "vitest-mock-extended": "^4.0.0",
     "@pagopa/eslint-config": "^6.0.4"
   },
   "engines": {

package/templates/monorepo/nx.json

@@ -68,7 +68,6 @@
         },
         "build": {
           "targetName": "build",
-          "configName": "tsconfig.json",
           "buildDepsName": "build-deps",
           "watchDepsName": "watch-deps"
         }

package/dist/adapters/azure/__tests__/cloud-account-repository.test.d.ts

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

package/dist/adapters/azure/__tests__/cloud-account-repository.test.js

@@ -1,95 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { AzureSubscriptionRepository } from "../cloud-account-repository.js";
-const createMockSubscription = (overrides = {}) => ({
-    displayName: "Test Subscription",
-    state: "Enabled",
-    subscriptionId: "00000000-0000-0000-0000-000000000001",
-    ...overrides,
-});
-const createMockSubscriptionClient = (subscriptions) => {
-    const listIterator = async function* () {
-        for (const sub of subscriptions) {
-            yield sub;
-        }
-    };
-    return {
-        subscriptions: {
-            list: listIterator,
-        },
-    };
-};
-vi.mock("@azure/arm-resources-subscriptions", () => ({
-    SubscriptionClient: vi.fn(),
-}));
-vi.mock("@azure/identity", () => ({
-    DefaultAzureCredential: vi.fn(),
-}));
-import { SubscriptionClient } from "@azure/arm-resources-subscriptions";
-import { DefaultAzureCredential } from "@azure/identity";
-const MockedSubscriptionClient = SubscriptionClient;
-describe("AzureSubscriptionRepository", () => {
-    it("should return a list of enabled subscriptions", async () => {
-        const subscriptions = [
-            createMockSubscription({
-                displayName: "Sub 1",
-                subscriptionId: "sub-1",
-            }),
-            createMockSubscription({
-                displayName: "Sub 2",
-                subscriptionId: "sub-2",
-            }),
-        ];
-        MockedSubscriptionClient.mockImplementation(() => createMockSubscriptionClient(subscriptions));
-        const repository = new AzureSubscriptionRepository(new DefaultAzureCredential());
-        const result = await repository.list();
-        expect(result).toHaveLength(2);
-        expect(result[0]).toMatchObject({
-            displayName: "Sub 1",
-            id: "sub-1",
-        });
-        expect(result[1]).toMatchObject({
-            displayName: "Sub 2",
-            id: "sub-2",
-        });
-    });
-    it("should filter out disabled subscriptions", async () => {
-        const subscriptions = [
-            createMockSubscription({
-                displayName: "Enabled Sub",
-                state: "Enabled",
-                subscriptionId: "enabled-sub",
-            }),
-            createMockSubscription({
-                displayName: "Disabled Sub",
-                state: "Disabled",
-                subscriptionId: "disabled-sub",
-            }),
-        ];
-        MockedSubscriptionClient.mockImplementation(() => createMockSubscriptionClient(subscriptions));
-        const repository = new AzureSubscriptionRepository(new DefaultAzureCredential());
-        const result = await repository.list();
-        expect(result).toHaveLength(1);
-        expect(result[0]).toMatchObject({
-            displayName: "Enabled Sub",
-            id: "enabled-sub",
-        });
-    });
-    it("should return an empty array when no subscriptions exist", async () => {
-        MockedSubscriptionClient.mockImplementation(() => createMockSubscriptionClient([]));
-        const repository = new AzureSubscriptionRepository(new DefaultAzureCredential());
-        const result = await repository.list();
-        expect(result).toEqual([]);
-    });
-    it("should filter out subscriptions with other states", async () => {
-        const subscriptions = [
-            createMockSubscription({ state: "Enabled" }),
-            createMockSubscription({ state: "Warned" }),
-            createMockSubscription({ state: "PastDue" }),
-            createMockSubscription({ state: "Deleted" }),
-        ];
-        MockedSubscriptionClient.mockImplementation(() => createMockSubscriptionClient(subscriptions));
-        const repository = new AzureSubscriptionRepository(new DefaultAzureCredential());
-        const result = await repository.list();
-        expect(result).toHaveLength(1);
-    });
-});

package/dist/adapters/azure/__tests__/cloud-account-service.test.d.ts

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