@pagopa/dx-cli 0.20.1 → 0.21.0

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

@@ -15,6 +15,7 @@ import { requestAuthorizationInputSchema, } from "../../../domain/authorization.
 import { environmentShort } from "../../../domain/environment.js";
 import { isAzureLocation, locationShort } from "../../azure/locations.js";
 import { getPlopInstance, runDeploymentEnvironmentGenerator, } from "../../plop/index.js";
+import { exitWithError } from "../index.js";
 import { checkPreconditions } from "./init.js";
 /**
  * Authorize a Cloud Account (Azure Subscription, AWS Account, ...), creating a Pull Request for each account that requires authorization.
@@ -69,9 +70,11 @@ const displaySummary = (result) => {
     }
     console.log(`${step}. Visit ${chalk.underline("https://dx.pagopa.it/getting-started")} to deploy your first project\n`);
 };
-const addEnvironmentAction = (authorizationService) => checkPreconditions()
-    .andThen(() => ResultAsync.fromPromise(getPlopInstance(), () => new Error("Failed to initialize plop")))
-    .andThen((plop) => ResultAsync.fromPromise(runDeploymentEnvironmentGenerator(plop), () => new Error("Failed to run the deployment environment generator")))
+const addEnvironmentAction = (authorizationService, gitHubService) => checkPreconditions()
+    .andThen(() => ResultAsync.fromPromise(getPlopInstance(), (cause) => new Error("Failed to initialize plop", { cause })))
+    .andThen((plop) => ResultAsync.fromPromise(runDeploymentEnvironmentGenerator(plop, gitHubService), (cause) => new Error("Failed to run the deployment environment generator", {
+    cause,
+})))
     .andThen((payload) => authorizeCloudAccounts(authorizationService)(payload).map((authorizationPrs) => ({
     authorizationPrs,
 })));
@@ -81,9 +84,9 @@ export const makeAddCommand = (deps) => new Command()
     .addCommand(new Command("environment")
     .description("Add a new deployment environment")
     .action(async function () {
-    const result = await addEnvironmentAction(deps.authorizationService);
+    const result = await addEnvironmentAction(deps.authorizationService, deps.gitHubService);
     if (result.isErr()) {
-        this.error(result.error.message);
+        exitWithError(this)(result.error);
     }
     else {
         displaySummary(result.value);

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

@@ -1,5 +1,6 @@
 import { getLogger } from "@logtape/logtape";
 import { Command } from "commander";
+import { exitWithError } from "../index.js";
 export const makeCodemodCommand = ({ applyCodemodById, listCodemods, }) => new Command("codemod")
     .description("Manage and apply migration scripts to the repository")
     .addCommand(new Command("list")
@@ -7,7 +8,7 @@ export const makeCodemodCommand = ({ applyCodemodById, listCodemods, }) => new C
     .action(async function () {
     await listCodemods()
         .andTee((codemods) => console.table(codemods, ["id", "description"]))
-        .orTee((error) => this.error(error.message));
+        .orTee(exitWithError(this));
 }))
     .addCommand(new Command("apply")
     .argument("<id>", "The id of the codemod to apply")
@@ -18,5 +19,5 @@ export const makeCodemodCommand = ({ applyCodemodById, listCodemods, }) => new C
         .andTee(() => {
         logger.info("Codemod applied ✅");
     })
-        .orTee((error) => this.error(error.message));
+        .orTee(exitWithError(this));
 }));

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

@@ -115,14 +115,14 @@ const handleGeneratorError = (err) => {
     if (err instanceof Error) {
         logger.error(err.message);
     }
-    return new Error("Failed to run the generator");
+    return new Error("Failed to run the generator", { cause: err });
 };
 export const makeInitCommand = ({ gitHubService, }) => new Command()
     .name("init")
     .description("Initialize a new DX workspace")
     .action(async function () {
     await checkPreconditions()
-        .andThen(() => ResultAsync.fromPromise(getPlopInstance(), () => new Error("Failed to initialize plop")))
+        .andThen(() => ResultAsync.fromPromise(getPlopInstance(), (cause) => new Error("Failed to initialize plop", { cause })))
         .andThen((plop) => ResultAsync.fromPromise(runMonorepoGenerator(plop, gitHubService), handleGeneratorError))
         .andTee((payload) => {
         process.chdir(payload.repoName);

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

@@ -1,14 +1,15 @@
 import { azure, loadConfig } from "@pagopa/dx-savemoney";
 import { Command } from "commander";
+import { exitWithError } from "../index.js";
 export const makeSavemoneyCommand = () => new Command("savemoney")
     .description("Analyze Azure subscriptions and report unused or inefficient resources")
     .option("-c, --config <path>", "Path to YAML configuration file")
     .option("-f, --format <format>", "Report format: json, table, detailed-json, or lint (default: table)", "table")
     .option("-l, --location <string>", "Preferred Azure location for resources (overrides config file)", "italynorth")
     .option("-d, --days <number>", "Number of days for metrics analysis (overrides config file)", "30")
-    .option("-v, --verbose", "Enable verbose logging")
     .option("-t, --tags <tags...>", "Filter resources by tags (key=value key2=value2). Only resources matching ALL specified tags are analyzed.")
     .action(async function (options) {
+    const { verbose } = this.optsWithGlobals();
     try {
         // Load configuration from YAML (includes subscriptionIds, location, timespanDays, thresholds)
         const config = await loadConfig(options.config);
@@ -19,13 +20,15 @@ export const makeSavemoneyCommand = () => new Command("savemoney")
             filterTags,
             preferredLocation: options.location || config.preferredLocation,
             timespanDays: Number.parseInt(options.days, 10) || config.timespanDays,
-            verbose: options.verbose || false,
+            verbose: verbose ?? false,
         };
         // Run analysis
         await azure.analyzeAzureResources(finalConfig, options.format);
     }
     catch (error) {
-        this.error(`Analysis failed: ${error instanceof Error ? error.message : error}`);
+        exitWithError(this)(error instanceof Error
+            ? new Error(`Analysis failed: ${error.message}`, { cause: error })
+            : new Error(`Analysis failed: ${String(error)}`));
     }
 });
 /**

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

@@ -0,0 +1,10 @@
+/**
+ * Safely converts an unknown value to a human-readable error message.
+ * Preserves ExecaError.shortMessage when available and flattens AggregateError.
+ */
+export declare const toErrorMessage: (value: unknown) => string;
+/**
+ * Builds a detailed, multi-line representation of an error suitable for
+ * `--verbose` output: includes the full `cause` chain and stack traces.
+ */
+export declare const formatErrorDetailed: (value: unknown) => string;

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

@@ -0,0 +1,68 @@
+import { ExecaError } from "execa";
+/**
+ * Safely converts an unknown value to a human-readable error message.
+ * Preserves ExecaError.shortMessage when available and flattens AggregateError.
+ */
+export const toErrorMessage = (value) => {
+    if (value === null || value === undefined) {
+        return "Unknown error";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value instanceof ExecaError) {
+        return value.shortMessage || value.message || String(value);
+    }
+    if (value instanceof AggregateError) {
+        const parts = value.errors.map((inner) => toErrorMessage(inner));
+        return [value.message, ...parts].filter(Boolean).join("\n  - ");
+    }
+    if (value instanceof Error) {
+        return value.message || value.name || "Error";
+    }
+    if (typeof value === "object") {
+        const maybeMessage = value.message;
+        if (typeof maybeMessage === "string" && maybeMessage.length > 0) {
+            return maybeMessage;
+        }
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+};
+/**
+ * Builds a detailed, multi-line representation of an error suitable for
+ * `--verbose` output: includes the full `cause` chain and stack traces.
+ */
+export const formatErrorDetailed = (value) => {
+    const lines = [];
+    const seen = new Set();
+    let current = value;
+    let depth = 0;
+    while (current !== undefined && current !== null && !seen.has(current)) {
+        seen.add(current);
+        const prefix = depth === 0 ? "" : "Caused by: ";
+        if (current instanceof Error) {
+            lines.push(`${prefix}${current.name}: ${toErrorMessage(current)}`);
+            if (current.stack) {
+                // `stack` usually starts with "Name: message"; drop the first line to
+                // avoid duplication with the header we just printed.
+                const stackBody = current.stack.split("\n").slice(1).join("\n");
+                if (stackBody.trim().length > 0) {
+                    lines.push(stackBody);
+                }
+            }
+            current = current.cause;
+        }
+        else {
+            lines.push(`${prefix}${toErrorMessage(current)}`);
+            current = undefined;
+        }
+        depth += 1;
+    }
+    return lines.join("\n");
+};

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

@@ -3,5 +3,21 @@ import { Config } from "../../config.js";
 import { Dependencies } from "../../domain/dependencies.js";
 import { CodemodCommandDependencies } from "./commands/codemod.js";
 export type CliDependencies = CodemodCommandDependencies;
+export type GlobalOptions = {
+    verbose?: boolean;
+};
+/**
+ * Returns true when the global `--verbose` flag is active on the closest
+ * ancestor command that defines it (the root `dx` program in our CLI).
+ */
+export declare const isVerbose: (command: Command) => boolean;
 export declare const makeCli: (deps: Dependencies, config: Config, cliDeps: CliDependencies, version: string) => Command;
-export declare const exitWithError: (command: Command) => (error: Error) => never;
+/**
+ * Builds a failure handler that ends the command via Commander's
+ * `Command#error`, with an output tailored to the active verbosity.
+ *
+ * - In normal mode, a single meaningful line is printed.
+ * - When `--verbose` is active, the full cause chain and stack trace are
+ *   included so users can diagnose the underlying failure.
+ */
+export declare const exitWithError: (command: Command) => (error: unknown) => never;

package/dist/adapters/commander/index.js

@@ -5,9 +5,19 @@ import { makeDoctorCommand } from "./commands/doctor.js";
 import { makeInfoCommand } from "./commands/info.js";
 import { makeInitCommand } from "./commands/init.js";
 import { makeSavemoneyCommand } from "./commands/savemoney.js";
+import { formatErrorDetailed, toErrorMessage } from "./error-reporting.js";
+/**
+ * Returns true when the global `--verbose` flag is active on the closest
+ * ancestor command that defines it (the root `dx` program in our CLI).
+ */
+export const isVerbose = (command) => command.optsWithGlobals().verbose === true;
 export const makeCli = (deps, config, cliDeps, version) => {
     const program = new Command();
-    program.name("dx").description("The CLI for DX-Platform").version(version);
+    program
+        .name("dx")
+        .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);
     program.addCommand(makeDoctorCommand(deps, config));
     program.addCommand(makeCodemodCommand(cliDeps));
     program.addCommand(makeInitCommand(deps));
@@ -16,6 +26,17 @@ export const makeCli = (deps, config, cliDeps, version) => {
     program.addCommand(makeAddCommand(deps));
     return program;
 };
+/**
+ * Builds a failure handler that ends the command via Commander's
+ * `Command#error`, with an output tailored to the active verbosity.
+ *
+ * - In normal mode, a single meaningful line is printed.
+ * - When `--verbose` is active, the full cause chain and stack trace are
+ *   included so users can diagnose the underlying failure.
+ */
 export const exitWithError = (command) => (error) => {
-    command.error(error.message);
+    const message = isVerbose(command)
+        ? formatErrorDetailed(error)
+        : toErrorMessage(error);
+    command.error(message);
 };

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

@@ -1,6 +1,6 @@
 import { ResultAsync } from "neverthrow";
 import { Octokit } from "octokit";
-import { CreateBranchParams, FileContent, GetFileContentParams, GitHubService, PullRequest, Repository, UpdateFileParams } from "../../domain/github.js";
+import { CreateBranchParams, CreateOrUpdateEnvironmentSecretParams, FileContent, GetFileContentParams, GitHubService, PullRequest, Repository, UpdateFileParams } from "../../domain/github.js";
 type GitHubReleaseParam = {
     client: Octokit;
     owner: string;
@@ -10,6 +10,7 @@ export declare class OctokitGitHubService implements GitHubService {
     #private;
     constructor(octokit: Octokit);
     createBranch(params: CreateBranchParams): Promise<void>;
+    createOrUpdateEnvironmentSecret(params: CreateOrUpdateEnvironmentSecretParams): Promise<void>;
     createPullRequest(params: {
         base: string;
         body: string;

package/dist/adapters/octokit/index.js

@@ -1,4 +1,5 @@
 import { $ } from "execa";
+import sodium from "libsodium-wrappers";
 import { ResultAsync } from "neverthrow";
 import { RequestError } from "octokit";
 import semverParse from "semver/functions/parse.js";
@@ -31,6 +32,38 @@ export class OctokitGitHubService {
             });
         }
     }
+    async createOrUpdateEnvironmentSecret(params) {
+        try {
+            // GitHub requires environment secrets to be encrypted client-side with libsodium.
+            await sodium.ready;
+            // Ensure the target environment exists before resolving its public key and storing secrets.
+            await this.#octokit.request("PUT /repos/{owner}/{repo}/environments/{environment_name}", {
+                environment_name: params.environmentName,
+                owner: params.owner,
+                repo: params.repo,
+            });
+            const { data: publicKeyData } = await this.#octokit.rest.actions.getEnvironmentPublicKey({
+                environment_name: params.environmentName,
+                owner: params.owner,
+                repo: params.repo,
+            });
+            const publicKeyBytes = sodium.from_base64(publicKeyData.key, sodium.base64_variants.ORIGINAL);
+            const secretBytes = sodium.from_string(params.secretValue);
+            const encryptedBytes = sodium.crypto_box_seal(secretBytes, publicKeyBytes);
+            const encryptedValue = sodium.to_base64(encryptedBytes, sodium.base64_variants.ORIGINAL);
+            await this.#octokit.rest.actions.createOrUpdateEnvironmentSecret({
+                encrypted_value: encryptedValue,
+                environment_name: params.environmentName,
+                key_id: publicKeyData.key_id,
+                owner: params.owner,
+                repo: params.repo,
+                secret_name: params.secretName,
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to create or update secret ${params.secretName} in environment ${params.environmentName}`, { cause: error });
+        }
+    }
     async createPullRequest(params) {
         try {
             const { data } = await this.#octokit.rest.pulls.create({

package/dist/adapters/plop/__tests__/run-actions.test.d.ts

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

package/dist/adapters/plop/__tests__/run-actions.test.js

@@ -0,0 +1,68 @@
+/**
+ * Tests for the internal `runActions` helper that coordinates plop's
+ * generator execution and surfaces meaningful error messages (CES-1923).
+ */
+import { describe, expect, it } from "vitest";
+import { mock } from "vitest-mock-extended";
+import { runActions } from "../index.js";
+const makeGenerator = (result) => {
+    const generator = mock();
+    generator.runActions.mockResolvedValue(result);
+    return generator;
+};
+describe("runActions", () => {
+    it("resolves silently when there are no failures", async () => {
+        const generator = makeGenerator({ changes: [], failures: [] });
+        await expect(runActions(generator, {})).resolves.toBeUndefined();
+    });
+    it("ignores 'Aborted due to previous action failure' entries", async () => {
+        const generator = makeGenerator({
+            changes: [],
+            failures: [
+                {
+                    error: "Aborted due to previous action failure",
+                    path: "",
+                    type: "add",
+                },
+            ],
+        });
+        await expect(runActions(generator, {})).resolves.toBeUndefined();
+    });
+    it("surfaces the original failure message (no more 'undefined')", async () => {
+        const generator = makeGenerator({
+            changes: [],
+            failures: [
+                {
+                    error: "Failed to create the key vault: quota exceeded",
+                    path: "",
+                    type: "initCloudAccounts",
+                },
+            ],
+        });
+        await expect(runActions(generator, {})).rejects.toThrow(/initCloudAccounts.*Failed to create the key vault: quota exceeded/);
+    });
+    it("aggregates multiple failures into the thrown message", async () => {
+        const generator = makeGenerator({
+            changes: [],
+            failures: [
+                { error: "Missing template", path: "", type: "add" },
+                {
+                    error: "Aborted due to previous action failure",
+                    path: "",
+                    type: "modify",
+                },
+                { error: "Permission denied", path: "", type: "initCloudAccounts" },
+            ],
+        });
+        await expect(runActions(generator, {})).rejects.toThrow(/add: Missing template.*initCloudAccounts: Permission denied/s);
+    });
+    it("falls back to 'unknown error' when plop provides no error string", async () => {
+        const generator = makeGenerator({
+            changes: [],
+            failures: [
+                { error: undefined, path: "", type: "add" },
+            ],
+        });
+        await expect(runActions(generator, {})).rejects.toThrow(/unknown error/);
+    });
+});

package/dist/adapters/plop/actions/__tests__/init-cloud-accounts.test.js

@@ -1,5 +1,13 @@
 import { describe, expect, it, vi } from "vitest";
 import { initCloudAccounts } from "../init-cloud-accounts.js";
+const createMockGitHubService = () => ({
+    createBranch: vi.fn(),
+    createOrUpdateEnvironmentSecret: vi.fn().mockResolvedValue(undefined),
+    createPullRequest: vi.fn(),
+    getFileContent: vi.fn(),
+    getRepository: vi.fn(),
+    updateFile: vi.fn(),
+});
 const createMockCloudAccountService = (overrides = {}) => ({
     getTerraformBackend: vi.fn().mockResolvedValue(undefined),
     hasUserPermissionToInitialize: vi.fn().mockResolvedValue(true),
@@ -68,18 +76,24 @@ describe("initCloudAccounts", () => {
                 },
             },
         });
-        await initCloudAccounts(payload, mockService);
+        await initCloudAccounts(payload, mockService, createMockGitHubService());
         expect(initializeMock).toHaveBeenCalledTimes(2);
         expect(initializeMock).toHaveBeenCalledWith(cloudAccount1, expect.objectContaining({ name: "prod", prefix: "io" }), {
             id: "test-app-id",
             installationId: "test-installation-id",
             key: "test-private-key",
-        }, {});
+        }, {
+            owner: "pagopa",
+            repo: "dx",
+        }, expect.any(Object), {});
         expect(initializeMock).toHaveBeenCalledWith(cloudAccount2, expect.objectContaining({ name: "prod", prefix: "io" }), {
             id: "test-app-id",
             installationId: "test-installation-id",
             key: "test-private-key",
-        }, {});
+        }, {
+            owner: "pagopa",
+            repo: "dx",
+        }, expect.any(Object), {});
     });
     it("should not call initialize when cloudAccountsToInitialize is empty", async () => {
         const initializeMock = vi.fn().mockResolvedValue(undefined);
@@ -99,7 +113,7 @@ describe("initCloudAccounts", () => {
                 },
             },
         });
-        await initCloudAccounts(payload, mockService);
+        await initCloudAccounts(payload, mockService, createMockGitHubService());
         expect(initializeMock).not.toHaveBeenCalled();
     });
     it("should not call initialize when payload.init is undefined", async () => {
@@ -110,7 +124,7 @@ describe("initCloudAccounts", () => {
         const payload = createMockPayload({
             init: undefined,
         });
-        await initCloudAccounts(payload, mockService);
+        await initCloudAccounts(payload, mockService, createMockGitHubService());
         expect(initializeMock).not.toHaveBeenCalled();
     });
     it("should use prefix and environment name from payload.env", async () => {
@@ -137,11 +151,14 @@ describe("initCloudAccounts", () => {
                 },
             },
         });
-        await initCloudAccounts(payload, mockService);
+        await initCloudAccounts(payload, mockService, createMockGitHubService());
         expect(initializeMock).toHaveBeenCalledWith(cloudAccount, expect.objectContaining({ name: "uat", prefix: "pagopa" }), {
             id: "test-app-id",
             installationId: "test-installation-id",
             key: "test-private-key",
-        }, {});
+        }, {
+            owner: "pagopa",
+            repo: "dx",
+        }, expect.any(Object), {});
     });
 });

package/dist/adapters/plop/actions/init-cloud-accounts.d.ts

@@ -1,5 +1,6 @@
 import { type NodePlopAPI } from "node-plop";
 import { CloudAccountService } from "../../../domain/cloud-account.js";
+import { type GitHubService } from "../../../domain/github.js";
 import { type Payload } from "../generators/environment/prompts.js";
-export declare const initCloudAccounts: (payload: Payload, cloudAccountService: CloudAccountService) => Promise<void>;
-export default function (plop: NodePlopAPI, cloudAccountService: CloudAccountService): void;
+export declare const initCloudAccounts: (payload: Payload, cloudAccountService: CloudAccountService, gitHubService: GitHubService) => Promise<void>;
+export default function (plop: NodePlopAPI, cloudAccountService: CloudAccountService, gitHubService: GitHubService): void;

package/dist/adapters/plop/actions/init-cloud-accounts.js

@@ -1,16 +1,16 @@
 import assert from "node:assert/strict";
 import { payloadSchema, } from "../generators/environment/prompts.js";
-export const initCloudAccounts = async (payload, cloudAccountService) => {
+export const initCloudAccounts = async (payload, cloudAccountService, gitHubService) => {
     if (payload.init && payload.init.cloudAccountsToInitialize.length > 0) {
         const { runnerAppCredentials } = payload.init;
         assert.ok(runnerAppCredentials, "Runner app credentials are required");
-        await Promise.all(payload.init.cloudAccountsToInitialize.map((cloudAccount) => cloudAccountService.initialize(cloudAccount, payload.env, runnerAppCredentials, payload.tags)));
+        await Promise.all(payload.init.cloudAccountsToInitialize.map((cloudAccount) => cloudAccountService.initialize(cloudAccount, payload.env, runnerAppCredentials, payload.github, gitHubService, payload.tags)));
     }
 };
-export default function (plop, cloudAccountService) {
+export default function (plop, cloudAccountService, gitHubService) {
     plop.setActionType("initCloudAccounts", async (data) => {
         const payload = payloadSchema.parse(data);
-        await initCloudAccounts(payload, cloudAccountService);
+        await initCloudAccounts(payload, cloudAccountService, gitHubService);
         return "Cloud Accounts Initialized";
     });
 }

package/dist/adapters/plop/generators/environment/__tests__/actions.test.js

@@ -46,7 +46,12 @@ describe("actions", () => {
             payload: getPayload(false),
         },
     ])("correct order of actions", ({ payload }) => {
-        const actionsOrder = ["getTerraformBackend", "addMany", "addMany"];
+        const actionsOrder = [
+            "getTerraformBackend",
+            "addMany",
+            "addMany",
+            "addMany",
+        ];
         if (payload.init) {
             actionsOrder.unshift("initCloudAccounts", "provisionTerraformBackend");
             actionsOrder.push("addMany", "addMany");

package/dist/adapters/plop/generators/environment/actions.js

@@ -29,6 +29,17 @@ const addModule = (env, templatesPath, init = false) => {
         },
     ];
 };
+const addWorkflowModule = (templatesPath) => {
+    const cwd = process.cwd();
+    return {
+        base: path.join(templatesPath, "workflow"),
+        destination: path.join(cwd, ".github", "workflows"),
+        force: true,
+        templateFiles: path.join(templatesPath, "workflow"),
+        type: "addMany",
+        verbose: true,
+    };
+};
 export default function getActions(templatesPath) {
     return (payload) => {
         const logger = getLogger(["gen", "env"]);
@@ -39,6 +50,7 @@ export default function getActions(templatesPath) {
             {
                 type: "getTerraformBackend",
             },
+            addWorkflowModule(templatesPath),
             ...addEnvironmentModule("bootstrapper", `${github.repo}.bootstrapper.${env.name}.tfstate`),
         ];
         if (init) {

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

@@ -1,7 +1,8 @@
 import { type NodePlopAPI } from "node-plop";
 import { CloudAccountRepository, CloudAccountService } from "../../../../domain/cloud-account.js";
 import { GitHubRepo } from "../../../../domain/github-repo.js";
+import { type GitHubService } from "../../../../domain/github.js";
 import { Payload, payloadSchema } from "./prompts.js";
 export declare const PLOP_ENVIRONMENT_GENERATOR_NAME = "DX_DeploymentEnvironment";
 export { Payload, payloadSchema };
-export default function (plop: NodePlopAPI, templatesPath: string, cloudAccountRepository: CloudAccountRepository, cloudAccountService: CloudAccountService, github?: GitHubRepo): void;
+export default function (plop: NodePlopAPI, templatesPath: string, cloudAccountRepository: CloudAccountRepository, cloudAccountService: CloudAccountService, gitHubService: GitHubService, github?: GitHubRepo): void;

package/dist/adapters/plop/generators/environment/index.js

@@ -8,13 +8,13 @@ import getActions from "./actions.js";
 import getPrompts, { payloadSchema } from "./prompts.js";
 export const PLOP_ENVIRONMENT_GENERATOR_NAME = "DX_DeploymentEnvironment";
 export { payloadSchema };
-export default function (plop, templatesPath, cloudAccountRepository, cloudAccountService, github) {
+export default function (plop, templatesPath, cloudAccountRepository, cloudAccountService, gitHubService, github) {
     setEnvShortHelper(plop);
     setResourcePrefixHelper(plop);
     setEqHelper(plop);
     setGetTerraformBackend(plop, cloudAccountService);
     setProvisionTerraformBackendAction(plop, cloudAccountService);
-    setInitCloudAccountsAction(plop, cloudAccountService);
+    setInitCloudAccountsAction(plop, cloudAccountService, gitHubService);
     plop.setGenerator(PLOP_ENVIRONMENT_GENERATOR_NAME, {
         actions: getActions(templatesPath),
         description: "Generate a new deployment environment",

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

@@ -1,10 +1,12 @@
-import type { NodePlopAPI } from "plop";
+import type { NodePlopAPI, PlopGenerator } from "plop";
+import { Answers } from "inquirer";
 import { GitHubRepo } from "../../domain/github-repo.js";
 import { GitHubService } from "../../domain/github.js";
 import { Payload as EnvironmentPayload } from "../plop/generators/environment/index.js";
 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>;
 /**
  * Run the deployment environment generator
@@ -14,7 +16,7 @@ export declare const runMonorepoGenerator: (plop: NodePlopAPI, githubService: Gi
  *                 uses the explicitly passed repository. When omitted (by add command),
  *                 the generator infers it from the local git context.
  */
-export declare const runDeploymentEnvironmentGenerator: (plop: NodePlopAPI, github?: GitHubRepo) => Promise<EnvironmentPayload>;
+export declare const runDeploymentEnvironmentGenerator: (plop: NodePlopAPI, gitHubService: GitHubService, github?: GitHubRepo) => Promise<EnvironmentPayload>;
 /**
  * Configure the deployment environment generator
  *
@@ -23,4 +25,4 @@ export declare const runDeploymentEnvironmentGenerator: (plop: NodePlopAPI, gith
  *                 uses the explicitly passed repository. When omitted (by add command),
  *                 the generator infers it from the local git context.
  */
-export declare const setDeploymentEnvironmentGenerator: (plop: NodePlopAPI, github?: GitHubRepo) => void;
+export declare const setDeploymentEnvironmentGenerator: (plop: NodePlopAPI, gitHubService: GitHubService, github?: GitHubRepo) => void;