@pagopa/dx-cli 0.24.0 → 0.25.1

package/dist/adapters/azure/locations.d.ts

@@ -3,5 +3,9 @@ export declare const locations: readonly ["italynorth", "westeurope"];
 export type AzureLocation = (typeof locations)[number];
 export declare function isAzureLocation(location: string): location is AzureLocation;
 export declare const defaultLocation: "italynorth";
-export declare const locationShort: Record<AzureLocation, string>;
+export declare const locationShort: {
+    readonly italynorth: "itn";
+    readonly westeurope: "weu";
+};
+export type LocationShortValue = (typeof locationShort)[keyof typeof locationShort];
 export declare const cloudRegions: CloudRegion[];

package/dist/adapters/azure/locations.js

@@ -19,4 +19,4 @@ export const cloudRegions = locations.map((l) => ({
     name: l,
     short: locationShort[l],
 }));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/azure-monitor/instrumentation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * OTel preload module for the dx CLI.
+ *
+ * This module is a deliberate side-effect entrypoint. It MUST be the first
+ * module loaded by the process (via a sequential dynamic import in bin/index.js)
+ * so that import-in-the-middle can register its hook before any HTTP client
+ * libraries (undici/fetch, octokit, Azure SDKs) are loaded.
+ *
+ * Initialising the Azure Monitor exporter is deferred to `enableAzureMonitor()`
+ * so the CLI can decide at runtime whether to emit telemetry (only PagoPA org
+ * members do). The import-in-the-middle hook is still registered eagerly at
+ * preload because it must run before any instrumented module is imported.
+ *
+ * Reads APPLICATIONINSIGHTS_CONNECTION_STRING from process.env because this IS
+ * the configuration boundary — no higher caller can inject config at this point
+ * in the process lifecycle.
+ */
+/**
+ * Initialises the Azure Monitor exporter and registers HTTP instrumentation.
+ *
+ * Deferred (not run at preload) so the CLI only emits telemetry once it has
+ * confirmed the user is a PagoPA org member. Idempotent: safe to call more than
+ * once. Must be called before logging is configured so the logtape OTel sink
+ * binds to the real (rather than no-op) LoggerProvider.
+ */
+export declare const enableAzureMonitor: () => void;

package/dist/adapters/azure-monitor/instrumentation.js

@@ -0,0 +1,84 @@
+/**
+ * OTel preload module for the dx CLI.
+ *
+ * This module is a deliberate side-effect entrypoint. It MUST be the first
+ * module loaded by the process (via a sequential dynamic import in bin/index.js)
+ * so that import-in-the-middle can register its hook before any HTTP client
+ * libraries (undici/fetch, octokit, Azure SDKs) are loaded.
+ *
+ * Initialising the Azure Monitor exporter is deferred to `enableAzureMonitor()`
+ * so the CLI can decide at runtime whether to emit telemetry (only PagoPA org
+ * members do). The import-in-the-middle hook is still registered eagerly at
+ * preload because it must run before any instrumented module is imported.
+ *
+ * Reads APPLICATIONINSIGHTS_CONNECTION_STRING from process.env because this IS
+ * the configuration boundary — no higher caller can inject config at this point
+ * in the process lifecycle.
+ */
+import { useAzureMonitor } from "@azure/monitor-opentelemetry";
+import { metrics, trace } from "@opentelemetry/api";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
+// import-in-the-middle and module must be the first imports so that
+// createAddHookMessageChannel / register run as early as possible.
+import { createAddHookMessageChannel } from "import-in-the-middle";
+import { register } from "module";
+import os from "node:os";
+const { registerOptions, waitForAllMessagesAcknowledged } = createAddHookMessageChannel();
+// Register the ESM module hook so that subsequent dynamic imports are
+// intercepted by OpenTelemetry's module instrumentation.
+register("import-in-the-middle/hook.mjs", import.meta.url, registerOptions);
+// Set service name before useAzureMonitor() initialises the Resource so
+// that Azure Monitor picks it up as the cloud_RoleName.
+process.env["OTEL_SERVICE_NAME"] = "cli";
+process.env["OTEL_RESOURCE_ATTRIBUTES"] = [
+    process.env["OTEL_RESOURCE_ATTRIBUTES"],
+    "service.namespace=dx",
+]
+    .filter(Boolean)
+    .join(",");
+// os.platform() returns "win32" on Windows; the OTel os.type enum uses "windows".
+const osPlatform = os.platform();
+const osType = osPlatform === "win32" ? "windows" : osPlatform;
+process.env["OTEL_RESOURCE_ATTRIBUTES"] = [
+    process.env["OTEL_RESOURCE_ATTRIBUTES"],
+    `os.type=${osType}`,
+    `os.version=${os.release()}`,
+    `os.machine=${os.machine()}`,
+]
+    .filter(Boolean)
+    .join(",");
+let azureMonitorEnabled = false;
+/**
+ * Initialises the Azure Monitor exporter and registers HTTP instrumentation.
+ *
+ * Deferred (not run at preload) so the CLI only emits telemetry once it has
+ * confirmed the user is a PagoPA org member. Idempotent: safe to call more than
+ * once. Must be called before logging is configured so the logtape OTel sink
+ * binds to the real (rather than no-op) LoggerProvider.
+ */
+export const enableAzureMonitor = () => {
+    if (azureMonitorEnabled) {
+        return;
+    }
+    azureMonitorEnabled = true;
+    useAzureMonitor({
+        azureMonitorExporterOptions: {
+            connectionString: process.env.APPLICATIONINSIGHTS_CONNECTION_STRING ||
+                "InstrumentationKey=e0ff8094-78fa-45e5-a21d-e62b453dc5d1;IngestionEndpoint=https://italynorth-0.in.applicationinsights.azure.com/;LiveEndpoint=https://italynorth.livediagnostics.monitor.azure.com/;ApplicationId=ce469d55-2ff7-4dfd-a249-cc787291e672",
+        },
+        enableLiveMetrics: true,
+    });
+    // Registered after useAzureMonitor() so the instrumentation binds to the
+    // real tracer/meter providers it installs (rather than the no-op defaults).
+    registerInstrumentations({
+        instrumentations: [new UndiciInstrumentation()],
+        meterProvider: metrics.getMeterProvider(),
+        tracerProvider: trace.getTracerProvider(),
+    });
+};
+// Block module evaluation until the hook is fully acknowledged.
+// This ensures that when bin/index.js proceeds to import the CLI entry
+// module, all transitive imports go through the registered hook.
+await waitForAllMessagesAcknowledged();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/azure-monitor/telemetry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Telemetry helpers for the dx CLI.
+ *
+ * All functions are no-ops when the OTel SDK has not been initialised (i.e.,
+ * when telemetry is disabled or the connection string is absent).
+ */
+/**
+ * Flush pending telemetry before the process exits.
+ *
+ * Uses shutdownAzureMonitor() which force-flushes AND shuts down every
+ * provider (traces, logs, metrics). Flushing only the logger provider is not
+ * enough: the root span ends right before the process exits, so without a
+ * trace flush it would never be exported and would not appear in the
+ * Application Insights timeline.
+ *
+ * Safe to call unconditionally — swallows all errors and is a no-op when the
+ * SDK was never initialised (telemetry disabled or no connection string).
+ */
+export declare const flushTelemetry: () => Promise<void>;

package/dist/adapters/azure-monitor/telemetry.js

@@ -0,0 +1,28 @@
+/**
+ * Telemetry helpers for the dx CLI.
+ *
+ * All functions are no-ops when the OTel SDK has not been initialised (i.e.,
+ * when telemetry is disabled or the connection string is absent).
+ */
+/**
+ * Flush pending telemetry before the process exits.
+ *
+ * Uses shutdownAzureMonitor() which force-flushes AND shuts down every
+ * provider (traces, logs, metrics). Flushing only the logger provider is not
+ * enough: the root span ends right before the process exits, so without a
+ * trace flush it would never be exported and would not appear in the
+ * Application Insights timeline.
+ *
+ * Safe to call unconditionally — swallows all errors and is a no-op when the
+ * SDK was never initialised (telemetry disabled or no connection string).
+ */
+export const flushTelemetry = async () => {
+    try {
+        const { shutdownAzureMonitor } = await import("@azure/monitor-opentelemetry");
+        await shutdownAzureMonitor();
+    }
+    catch {
+        // Telemetry must never break the CLI.
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVsZW1ldHJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FkYXB0ZXJzL2F6dXJlLW1vbml0b3IvdGVsZW1ldHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBRUg7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsS0FBSyxJQUFtQixFQUFFO0lBQ3RELElBQUksQ0FBQztRQUNILE1BQU0sRUFBRSxvQkFBb0IsRUFBRSxHQUM1QixNQUFNLE1BQU0sQ0FBQyw4QkFBOEIsQ0FBQyxDQUFDO1FBQy9DLE1BQU0sb0JBQW9CLEVBQUUsQ0FBQztJQUMvQixDQUFDO0lBQUMsTUFBTSxDQUFDO1FBQ1Asc0NBQXNDO0lBQ3hDLENBQUM7QUFDSCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRlbGVtZXRyeSBoZWxwZXJzIGZvciB0aGUgZHggQ0xJLlxuICpcbiAqIEFsbCBmdW5jdGlvbnMgYXJlIG5vLW9wcyB3aGVuIHRoZSBPVGVsIFNESyBoYXMgbm90IGJlZW4gaW5pdGlhbGlzZWQgKGkuZS4sXG4gKiB3aGVuIHRlbGVtZXRyeSBpcyBkaXNhYmxlZCBvciB0aGUgY29ubmVjdGlvbiBzdHJpbmcgaXMgYWJzZW50KS5cbiAqL1xuXG4vKipcbiAqIEZsdXNoIHBlbmRpbmcgdGVsZW1ldHJ5IGJlZm9yZSB0aGUgcHJvY2VzcyBleGl0cy5cbiAqXG4gKiBVc2VzIHNodXRkb3duQXp1cmVNb25pdG9yKCkgd2hpY2ggZm9yY2UtZmx1c2hlcyBBTkQgc2h1dHMgZG93biBldmVyeVxuICogcHJvdmlkZXIgKHRyYWNlcywgbG9ncywgbWV0cmljcykuIEZsdXNoaW5nIG9ubHkgdGhlIGxvZ2dlciBwcm92aWRlciBpcyBub3RcbiAqIGVub3VnaDogdGhlIHJvb3Qgc3BhbiBlbmRzIHJpZ2h0IGJlZm9yZSB0aGUgcHJvY2VzcyBleGl0cywgc28gd2l0aG91dCBhXG4gKiB0cmFjZSBmbHVzaCBpdCB3b3VsZCBuZXZlciBiZSBleHBvcnRlZCBhbmQgd291bGQgbm90IGFwcGVhciBpbiB0aGVcbiAqIEFwcGxpY2F0aW9uIEluc2lnaHRzIHRpbWVsaW5lLlxuICpcbiAqIFNhZmUgdG8gY2FsbCB1bmNvbmRpdGlvbmFsbHkg4oCUIHN3YWxsb3dzIGFsbCBlcnJvcnMgYW5kIGlzIGEgbm8tb3Agd2hlbiB0aGVcbiAqIFNESyB3YXMgbmV2ZXIgaW5pdGlhbGlzZWQgKHRlbGVtZXRyeSBkaXNhYmxlZCBvciBubyBjb25uZWN0aW9uIHN0cmluZykuXG4gKi9cbmV4cG9ydCBjb25zdCBmbHVzaFRlbGVtZXRyeSA9IGFzeW5jICgpOiBQcm9taXNlPHZvaWQ+ID0+IHtcbiAgdHJ5IHtcbiAgICBjb25zdCB7IHNodXRkb3duQXp1cmVNb25pdG9yIH0gPVxuICAgICAgYXdhaXQgaW1wb3J0KFwiQGF6dXJlL21vbml0b3Itb3BlbnRlbGVtZXRyeVwiKTtcbiAgICBhd2FpdCBzaHV0ZG93bkF6dXJlTW9uaXRvcigpO1xuICB9IGNhdGNoIHtcbiAgICAvLyBUZWxlbWV0cnkgbXVzdCBuZXZlciBicmVhayB0aGUgQ0xJLlxuICB9XG59O1xuIl19

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

@@ -1,20 +1,45 @@
 /**
- * Add command - Scaffold new components into existing workspaces
+ * Add command - Scaffold new components into existing workspaces.
  *
- * This module implements the `dx add` command which allows developers to scaffold
- * new components into their existing workspace following DevEx guidelines.
- *
- * Currently supported components:
- * - environment: Add a new deployment environment to the project
+ * This module implements the `dx add` command and keeps the CLI-specific flag
+ * parsing/validation close to the Commander adapter. It turns supported flags
+ * into prefilled answers for the plop generator so the command can run with a
+ * mix of non-interactive inputs and guided prompts.
  */
 import { Command } from "commander";
 import { ResultAsync } from "neverthrow";
-import type { Payload as EnvironmentPayload } from "../../plop/generators/environment/index.js";
+import { z } from "zod/v4";
+import type { InitialAnswers as DeploymentEnvironmentInitialAnswers, Payload as EnvironmentPayload } from "../../plop/generators/environment/index.js";
 import type { CliEnv } from "../env.js";
 import { AuthorizationResult, AuthorizationService } from "../../../domain/authorization.js";
 import { GitHubAuthFactory } from "../../../domain/dependencies.js";
+declare const addEnvironmentCommandOptionsSchema: z.ZodObject<{
+    account: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    businessUnit: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    domain: z.ZodOptional<z.ZodString>;
+    installationId: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<{
+        accountId: string;
+        location: "italynorth" | "westeurope";
+    }, string>>>>;
+    managementTeam: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodEnum<{
+        dev: "dev";
+        prod: "prod";
+        uat: "uat";
+    }>>;
+    prefix: z.ZodOptional<z.ZodString>;
+    privateKeyPath: z.ZodOptional<z.ZodString>;
+    runnerAppId: z.ZodOptional<z.ZodString>;
+    yes: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AddEnvironmentCommandOptions = z.infer<typeof addEnvironmentCommandOptionsSchema>;
+export declare const parseAddEnvironmentCommandOptions: (input: unknown) => AddEnvironmentCommandOptions;
+export declare const getEnvironmentInitialAnswers: (options: AddEnvironmentCommandOptions) => Promise<DeploymentEnvironmentInitialAnswers>;
 /**
  * Authorize a Cloud Account (Azure Subscription, AWS Account, ...), creating a Pull Request for each account that requires authorization.
  */
 export declare const authorizeCloudAccounts: (authorizationService: AuthorizationService) => (envPayload: EnvironmentPayload) => ResultAsync<AuthorizationResult[], never>;
 export declare const makeAddCommand: (requireGitHubAuth: GitHubAuthFactory, env: CliEnv) => Command;
+export {};

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

@@ -1,23 +1,180 @@
 import { getLogger } from "@logtape/logtape";
 import chalk from "chalk";
 /**
- * Add command - Scaffold new components into existing workspaces
+ * Add command - Scaffold new components into existing workspaces.
  *
- * This module implements the `dx add` command which allows developers to scaffold
- * new components into their existing workspace following DevEx guidelines.
- *
- * Currently supported components:
- * - environment: Add a new deployment environment to the project
+ * This module implements the `dx add` command and keeps the CLI-specific flag
+ * parsing/validation close to the Commander adapter. It turns supported flags
+ * into prefilled answers for the plop generator so the command can run with a
+ * mix of non-interactive inputs and guided prompts.
  */
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { okAsync, ResultAsync } from "neverthrow";
+import { readFile } from "node:fs/promises";
+import { z } from "zod/v4";
 import { requestAuthorizationInputSchema, } from "../../../domain/authorization.js";
-import { environmentShort } from "../../../domain/environment.js";
-import { isAzureLocation, locationShort } from "../../azure/locations.js";
+import { environmentSchema, environmentShort, } from "../../../domain/environment.js";
+import { isAzureLocation, locationShort, } from "../../azure/locations.js";
+import { workspaceSchema } from "../../plop/generators/environment/prompts.js";
 import { collectDeploymentEnvironmentPayload, getPlopInstance, runDeploymentEnvironmentActions, } from "../../plop/index.js";
 import { asError, reportCommandError } from "../command-errors.js";
 import { createCommandPresenter, resolveOutputMode, } from "../presenters/index.js";
 import { runAddEnvironmentPreconditions } from "./init.js";
+const appendOptionValue = (value, previous = []) => [...previous, value];
+const locationOptionSchema = z
+    .string()
+    .trim()
+    .transform((value, ctx) => {
+    const [rawAccountId, ...rawLocationParts] = value.split("=");
+    const accountId = rawAccountId?.trim();
+    const location = rawLocationParts.join("=").trim();
+    if (!accountId || rawLocationParts.length === 0 || location.length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Location must use the format <subscription-id=region>.",
+        });
+        return z.NEVER;
+    }
+    if (!isAzureLocation(location)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Unsupported Azure location "${location}".`,
+        });
+        return z.NEVER;
+    }
+    return { accountId, location };
+});
+const addEnvironmentCommandOptionsSchema = z
+    .object({
+    account: z
+        .array(z.string().trim().min(1, "Cloud account id cannot be empty"))
+        .optional(),
+    businessUnit: z
+        .string()
+        .trim()
+        .min(1, "Business unit cannot be empty")
+        .optional(),
+    clientId: z.string().trim().min(1, "Client id cannot be empty").optional(),
+    domain: workspaceSchema.shape.domain.optional(),
+    installationId: z
+        .string()
+        .trim()
+        .min(1, "Installation id cannot be empty")
+        .optional(),
+    location: z.array(locationOptionSchema).optional(),
+    managementTeam: z
+        .string()
+        .trim()
+        .min(1, "Management team cannot be empty")
+        .optional(),
+    name: environmentSchema.shape.name.optional(),
+    prefix: environmentSchema.shape.prefix.optional(),
+    privateKeyPath: z
+        .string()
+        .trim()
+        .min(1, "Private key path cannot be empty")
+        .optional(),
+    runnerAppId: z
+        .string()
+        .trim()
+        .min(1, "Runner app id cannot be empty")
+        .optional(),
+    yes: z.boolean().optional(),
+})
+    .superRefine((value, ctx) => {
+    if (value.location && !value.account?.length) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Location mappings require at least one --account flag.",
+            path: ["location"],
+        });
+        return;
+    }
+    if (value.account && value.location) {
+        const selectedAccounts = new Set(value.account);
+        for (const mapping of value.location) {
+            if (!selectedAccounts.has(mapping.accountId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `Location mapping references unknown account "${mapping.accountId}".`,
+                    path: ["location"],
+                });
+            }
+        }
+    }
+});
+export const parseAddEnvironmentCommandOptions = (input) => {
+    const result = addEnvironmentCommandOptionsSchema.safeParse(input);
+    if (!result.success) {
+        throw new Error(`Invalid add environment command options:\n${z.prettifyError(result.error)}`, {
+            cause: result.error,
+        });
+    }
+    return result.data;
+};
+const buildBaseEnvironmentInitialAnswers = (options) => {
+    const env = {
+        ...(options.name && { name: options.name }),
+        ...(options.prefix && { prefix: options.prefix }),
+        ...(options.account?.length && {
+            cloudAccountIds: Array.from(new Set(options.account)),
+        }),
+        ...(options.location?.length && {
+            locations: Object.fromEntries(options.location.map(({ accountId, location }) => [
+                accountId,
+                location,
+            ])),
+        }),
+    };
+    const tags = {
+        ...(options.businessUnit && { BusinessUnit: options.businessUnit }),
+        ...(options.managementTeam && { ManagementTeam: options.managementTeam }),
+    };
+    return {
+        ...(Object.keys(env).length > 0 && { env }),
+        ...(Object.keys(tags).length > 0 && { tags }),
+        ...(options.domain && { workspace: { domain: options.domain } }),
+    };
+};
+export const getEnvironmentInitialAnswers = async (options) => {
+    const initialAnswers = buildBaseEnvironmentInitialAnswers(options);
+    const privateKey = options.privateKeyPath === undefined
+        ? undefined
+        : await readFile(options.privateKeyPath, "utf8").catch((cause) => {
+            throw new Error(`Failed to read private key file at "${options.privateKeyPath}".`, { cause });
+        });
+    // Fail fast on an empty (or whitespace-only) key file: the file contents are
+    // never trimmed, so an empty value would otherwise skip the recovery prompt
+    // and surface as an opaque schema error (or a silently invalid key) later.
+    if (privateKey !== undefined && privateKey.trim().length === 0) {
+        throw new Error(`Private key file at "${options.privateKeyPath}" is empty.`);
+    }
+    // Prefill runner-app credentials only when at least one credential flag was
+    // provided. Unspecified fields stay `undefined` on purpose so the generator
+    // prompts for the missing pieces and validates the complete set later. With
+    // no credential flag at all, leave this `undefined` to keep initialization
+    // fully interactive.
+    const runnerAppCredentials = options.runnerAppId === undefined &&
+        options.clientId === undefined &&
+        options.installationId === undefined &&
+        privateKey === undefined
+        ? undefined
+        : {
+            clientId: options.clientId,
+            id: options.runnerAppId,
+            installationId: options.installationId,
+            key: privateKey,
+        };
+    return {
+        ...initialAnswers,
+        ...((options.yes || runnerAppCredentials) && {
+            init: {
+                ...(options.yes && { confirm: true }),
+                ...(runnerAppCredentials && { runnerAppCredentials }),
+            },
+        }),
+    };
+};
 /**
  * Authorize a Cloud Account (Azure Subscription, AWS Account, ...), creating a Pull Request for each account that requires authorization.
  */
@@ -88,27 +245,52 @@ const reportSummary = (presenter, outputMode) => (result) => {
     }
 };
 const trackStep = (presenter, name, task, mapError) => ResultAsync.fromPromise(presenter.trackStep(name, task), mapError);
-const addEnvironmentAction = (authorizationService, gitHubService, presenter) => runAddEnvironmentPreconditions(presenter)
+const addEnvironmentAction = (authorizationService, gitHubService, presenter, initialAnswers = {}) => runAddEnvironmentPreconditions(presenter)
     .andThen(() => trackStep(presenter, "Initializing environment 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(collectDeploymentEnvironmentPayload(plop, gitHubService), asError("Failed to run the deployment environment generator")))
+ResultAsync.fromPromise(collectDeploymentEnvironmentPayload(plop, gitHubService, undefined, initialAnswers), asError("Failed to run the deployment environment generator")))
     .andThen(({ generator, payload }) => trackStep(presenter, "Creating environment...", () => runDeploymentEnvironmentActions(generator, payload), asError("Failed to create the deployment environment")))
     .andThen((payload) => authorizeCloudAccounts(authorizationService)(payload).map((authorizationPrs) => ({
     authorizationPrs,
+    payload,
 })));
 export const makeAddCommand = (requireGitHubAuth, env) => new Command()
     .name("add")
     .description("Add a new component to your workspace")
     .addCommand(new Command("environment")
     .description("Add a new deployment environment")
-    .action(async function () {
+    .addOption(new Option("--name <name>", "Environment name").choices([
+    "dev",
+    "uat",
+    "prod",
+]))
+    .addOption(new Option("--account <subscription-id>", "Cloud account subscription id").argParser(appendOptionValue))
+    .addOption(new Option("--location <subscription-id=region>", "Default Azure location for a selected account").argParser(appendOptionValue))
+    .addOption(new Option("--prefix <prefix>", "Environment prefix"))
+    .addOption(new Option("--domain <domain>", "Workspace domain"))
+    .addOption(new Option("--business-unit <business-unit>", "Business unit tag"))
+    .addOption(new Option("--management-team <management-team>", "Management team tag"))
+    .addOption(new Option("-y, --yes", "Confirm environment initialization without prompting"))
+    .addOption(new Option("--runner-app-id <runner-app-id>", "GitHub Runner App ID"))
+    .addOption(new Option("--client-id <client-id>", "GitHub Runner App Client ID"))
+    .addOption(new Option("--installation-id <installation-id>", "GitHub Runner App Installation ID"))
+    .addOption(new Option("--private-key-path <private-key-path>", "Path to a local GitHub Runner App private key file"))
+    .action(async function (options) {
     const { output } = this.optsWithGlobals();
     const outputMode = resolveOutputMode(env, output);
     const presenter = createCommandPresenter(outputMode);
-    await requireGitHubAuth()
-        .andThen(({ authorizationService, gitHubService }) => addEnvironmentAction(authorizationService, gitHubService, presenter))
+    await ResultAsync.fromPromise(Promise.resolve().then(() => parseAddEnvironmentCommandOptions(options)), (cause) => cause instanceof Error
+        ? cause
+        : new Error("Failed to parse add environment command options", {
+            cause,
+        }))
+        .andThen((addEnvironmentOptions) => ResultAsync.fromPromise(getEnvironmentInitialAnswers(addEnvironmentOptions), (cause) => cause instanceof Error
+        ? cause
+        : new Error("Failed to load add environment initial answers", {
+            cause,
+        })).andThen((initialAnswers) => requireGitHubAuth().andThen(({ authorizationService, gitHubService }) => addEnvironmentAction(authorizationService, gitHubService, presenter, initialAnswers))))
         .match(reportSummary(presenter, outputMode), reportCommandError(this, presenter, outputMode));
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add.js","sourceRoot":"","sources":["../../../../src/adapters/commander/commands/add.ts"],"names":[],"mappings":"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","sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport chalk from \"chalk\";\n/**\n * Add command - Scaffold new components into existing workspaces\n *\n * This module implements the `dx add` command which allows developers to scaffold\n * new components into their existing workspace following DevEx guidelines.\n *\n * Currently supported components:\n * - environment: Add a new deployment environment to the project\n */\nimport { Command } from \"commander\";\nimport { okAsync, ResultAsync } from \"neverthrow\";\n\nimport type { CommandPresenter } from \"../../../domain/command-presenter.js\";\nimport type { Payload as EnvironmentPayload } from \"../../plop/generators/environment/index.js\";\nimport type { CliEnv } from \"../env.js\";\nimport type { GlobalOptions } from \"../global-options.js\";\n\nimport {\n  AuthorizationResult,\n  AuthorizationService,\n  requestAuthorizationInputSchema,\n} from \"../../../domain/authorization.js\";\nimport { GitHubAuthFactory } from \"../../../domain/dependencies.js\";\nimport { environmentShort } from \"../../../domain/environment.js\";\nimport { type GitHubService } from \"../../../domain/github.js\";\nimport { isAzureLocation, locationShort } from \"../../azure/locations.js\";\nimport {\n  collectDeploymentEnvironmentPayload,\n  getPlopInstance,\n  runDeploymentEnvironmentActions,\n} from \"../../plop/index.js\";\nimport { asError, reportCommandError } from \"../command-errors.js\";\nimport {\n  createCommandPresenter,\n  resolveOutputMode,\n} from \"../presenters/index.js\";\nimport { runAddEnvironmentPreconditions } from \"./init.js\";\n\n/**\n * Authorize a Cloud Account (Azure Subscription, AWS Account, ...), creating a Pull Request for each account that requires authorization.\n */\nexport const authorizeCloudAccounts =\n  (authorizationService: AuthorizationService) =>\n  (\n    envPayload: EnvironmentPayload,\n  ): ResultAsync<AuthorizationResult[], never> => {\n    const accountsToInitialize =\n      envPayload.init?.cloudAccountsToInitialize ?? [];\n\n    if (accountsToInitialize.length === 0) {\n      return okAsync([]);\n    }\n\n    const logger = getLogger([\"dx-cli\", \"add-environment\"]);\n    const { name, prefix } = envPayload.env;\n    const envShort = environmentShort[name];\n\n    const requestAll = async (): Promise<AuthorizationResult[]> => {\n      const results: AuthorizationResult[] = [];\n\n      for (const account of accountsToInitialize) {\n        if (!isAzureLocation(account.defaultLocation)) {\n          logger.warn(\n            \"Skipping authorization for {account}: unsupported location\",\n            { account: account.displayName },\n          );\n          continue;\n        }\n\n        const locShort = locationShort[account.defaultLocation];\n        const input = requestAuthorizationInputSchema.safeParse({\n          bootstrapIdentityId: `${prefix}-${envShort}-${locShort}-bootstrap-id-01`,\n          envShort,\n          prefix,\n          repoName: envPayload.github.repo,\n          repoOwner: envPayload.github.owner,\n          subscriptionName: account.displayName,\n        });\n\n        if (!input.success) {\n          logger.warn(\"Skipping authorization for {account}: invalid input\", {\n            account: account.displayName,\n          });\n          continue;\n        }\n\n        const result = await authorizationService.requestAuthorization(\n          input.data,\n        );\n\n        result.match(\n          (authResult) => results.push(authResult),\n          (error) =>\n            logger.warn(\"Authorization request failed for {account}: {error}\", {\n              account: account.displayName,\n              error: error.message,\n            }),\n        );\n      }\n\n      return results;\n    };\n\n    return ResultAsync.fromPromise(requestAll(), () => []).orElse(() =>\n      okAsync([]),\n    );\n  };\n\ntype AddResult = {\n  authorizationPrs: AuthorizationResult[];\n};\n\nconst displaySummary = (result: AddResult) => {\n  const { authorizationPrs } = result;\n  console.log(chalk.green.bold(\"\\nCloud environment created successfully!\"));\n\n  let step = 1;\n  console.log(chalk.green.bold(\"\\nNext Steps:\"));\n  const prsWithUrl = authorizationPrs.filter(\n    (pr): pr is AuthorizationResult & { url: string } => pr.url != null,\n  );\n  if (prsWithUrl.length > 0) {\n    console.log(`${step++}. Review the Azure authorization Pull Request(s):`);\n    for (const authPr of prsWithUrl) {\n      console.log(`   - ${chalk.underline(authPr.url)}`);\n    }\n  }\n  console.log(\n    `${step}. Visit ${chalk.underline(\"https://dx.pagopa.it/getting-started\")} to deploy your first project\\n`,\n  );\n};\n\n/**\n * Routes the successful outcome through the presenter: JSON mode emits the\n * structured envelope while text mode renders the human-readable summary.\n */\nconst reportSummary =\n  (presenter: CommandPresenter, outputMode: \"json\" | \"text\") =>\n  (result: AddResult): void => {\n    if (outputMode === \"json\") {\n      presenter.reportResult(result);\n    } else {\n      displaySummary(result);\n    }\n  };\n\nconst trackStep = <T, E>(\n  presenter: CommandPresenter,\n  name: string,\n  task: () => Promise<T>,\n  mapError: (cause: unknown) => E,\n): ResultAsync<T, E> =>\n  ResultAsync.fromPromise(presenter.trackStep(name, task), mapError);\n\nconst addEnvironmentAction = (\n  authorizationService: AuthorizationService,\n  gitHubService: GitHubService,\n  presenter: CommandPresenter,\n): ResultAsync<AddResult, Error> =>\n  runAddEnvironmentPreconditions(presenter)\n    .andThen(() =>\n      trackStep(\n        presenter,\n        \"Initializing environment generator...\",\n        getPlopInstance,\n        asError(\"Failed to initialize plop\"),\n      ),\n    )\n    .andThen((plop) =>\n      // The prompt phase must run outside trackStep: in text mode trackStep\n      // renders a spinner that occupies the TTY and hides the prompts.\n      ResultAsync.fromPromise(\n        collectDeploymentEnvironmentPayload(plop, gitHubService),\n        asError(\"Failed to run the deployment environment generator\"),\n      ),\n    )\n    .andThen(({ generator, payload }) =>\n      trackStep(\n        presenter,\n        \"Creating environment...\",\n        () => runDeploymentEnvironmentActions(generator, payload),\n        asError(\"Failed to create the deployment environment\"),\n      ),\n    )\n    .andThen((payload) =>\n      authorizeCloudAccounts(authorizationService)(payload).map(\n        (authorizationPrs) => ({\n          authorizationPrs,\n        }),\n      ),\n    );\n\nexport const makeAddCommand = (\n  requireGitHubAuth: GitHubAuthFactory,\n  env: CliEnv,\n): Command =>\n  new Command()\n    .name(\"add\")\n    .description(\"Add a new component to your workspace\")\n    .addCommand(\n      new Command(\"environment\")\n        .description(\"Add a new deployment environment\")\n        .action(async function () {\n          const { output } = this.optsWithGlobals<GlobalOptions>();\n          const outputMode = resolveOutputMode(env, output);\n          const presenter = createCommandPresenter(outputMode);\n\n          await requireGitHubAuth()\n            .andThen(({ authorizationService, gitHubService }) =>\n              addEnvironmentAction(\n                authorizationService,\n                gitHubService,\n                presenter,\n              ),\n            )\n            .match(\n              reportSummary(presenter, outputMode),\n              reportCommandError(this, presenter, outputMode),\n            );\n        }),\n    );\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add.js","sourceRoot":"","sources":["../../../../src/adapters/commander/commands/add.ts"],"names":[],"mappings":"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","sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport chalk from \"chalk\";\n/**\n * Add command - Scaffold new components into existing workspaces.\n *\n * This module implements the `dx add` command and keeps the CLI-specific flag\n * parsing/validation close to the Commander adapter. It turns supported flags\n * into prefilled answers for the plop generator so the command can run with a\n * mix of non-interactive inputs and guided prompts.\n */\nimport { Command, Option } from \"commander\";\nimport { okAsync, ResultAsync } from \"neverthrow\";\nimport { readFile } from \"node:fs/promises\";\nimport { z } from \"zod/v4\";\n\nimport type { CommandPresenter } from \"../../../domain/command-presenter.js\";\nimport type {\n  InitialAnswers as DeploymentEnvironmentInitialAnswers,\n  Payload as EnvironmentPayload,\n} from \"../../plop/generators/environment/index.js\";\nimport type { CliEnv } from \"../env.js\";\nimport type { GlobalOptions } from \"../global-options.js\";\n\nimport {\n  AuthorizationResult,\n  AuthorizationService,\n  requestAuthorizationInputSchema,\n} from \"../../../domain/authorization.js\";\nimport { GitHubAuthFactory } from \"../../../domain/dependencies.js\";\nimport {\n  environmentSchema,\n  environmentShort,\n} from \"../../../domain/environment.js\";\nimport { type GitHubService } from \"../../../domain/github.js\";\nimport {\n  type AzureLocation,\n  isAzureLocation,\n  locationShort,\n} from \"../../azure/locations.js\";\nimport { workspaceSchema } from \"../../plop/generators/environment/prompts.js\";\nimport {\n  collectDeploymentEnvironmentPayload,\n  getPlopInstance,\n  runDeploymentEnvironmentActions,\n} from \"../../plop/index.js\";\nimport { asError, reportCommandError } from \"../command-errors.js\";\nimport {\n  createCommandPresenter,\n  resolveOutputMode,\n} from \"../presenters/index.js\";\nimport { runAddEnvironmentPreconditions } from \"./init.js\";\n\nconst appendOptionValue = (\n  value: string,\n  previous: string[] = [],\n): string[] => [...previous, value];\n\nconst locationOptionSchema = z\n  .string()\n  .trim()\n  .transform((value, ctx) => {\n    const [rawAccountId, ...rawLocationParts] = value.split(\"=\");\n    const accountId = rawAccountId?.trim();\n    const location = rawLocationParts.join(\"=\").trim();\n\n    if (!accountId || rawLocationParts.length === 0 || location.length === 0) {\n      ctx.addIssue({\n        code: z.ZodIssueCode.custom,\n        message: \"Location must use the format <subscription-id=region>.\",\n      });\n      return z.NEVER;\n    }\n\n    if (!isAzureLocation(location)) {\n      ctx.addIssue({\n        code: z.ZodIssueCode.custom,\n        message: `Unsupported Azure location \"${location}\".`,\n      });\n      return z.NEVER;\n    }\n\n    return { accountId, location };\n  });\n\nconst addEnvironmentCommandOptionsSchema = z\n  .object({\n    account: z\n      .array(z.string().trim().min(1, \"Cloud account id cannot be empty\"))\n      .optional(),\n    businessUnit: z\n      .string()\n      .trim()\n      .min(1, \"Business unit cannot be empty\")\n      .optional(),\n    clientId: z.string().trim().min(1, \"Client id cannot be empty\").optional(),\n    domain: workspaceSchema.shape.domain.optional(),\n    installationId: z\n      .string()\n      .trim()\n      .min(1, \"Installation id cannot be empty\")\n      .optional(),\n    location: z.array(locationOptionSchema).optional(),\n    managementTeam: z\n      .string()\n      .trim()\n      .min(1, \"Management team cannot be empty\")\n      .optional(),\n    name: environmentSchema.shape.name.optional(),\n    prefix: environmentSchema.shape.prefix.optional(),\n    privateKeyPath: z\n      .string()\n      .trim()\n      .min(1, \"Private key path cannot be empty\")\n      .optional(),\n    runnerAppId: z\n      .string()\n      .trim()\n      .min(1, \"Runner app id cannot be empty\")\n      .optional(),\n    yes: z.boolean().optional(),\n  })\n  .superRefine((value, ctx) => {\n    if (value.location && !value.account?.length) {\n      ctx.addIssue({\n        code: z.ZodIssueCode.custom,\n        message: \"Location mappings require at least one --account flag.\",\n        path: [\"location\"],\n      });\n      return;\n    }\n\n    if (value.account && value.location) {\n      const selectedAccounts = new Set(value.account);\n      for (const mapping of value.location) {\n        if (!selectedAccounts.has(mapping.accountId)) {\n          ctx.addIssue({\n            code: z.ZodIssueCode.custom,\n            message: `Location mapping references unknown account \"${mapping.accountId}\".`,\n            path: [\"location\"],\n          });\n        }\n      }\n    }\n  });\n\nexport type AddEnvironmentCommandOptions = z.infer<\n  typeof addEnvironmentCommandOptionsSchema\n>;\n\nexport const parseAddEnvironmentCommandOptions = (\n  input: unknown,\n): AddEnvironmentCommandOptions => {\n  const result = addEnvironmentCommandOptionsSchema.safeParse(input);\n  if (!result.success) {\n    throw new Error(\n      `Invalid add environment command options:\\n${z.prettifyError(result.error)}`,\n      {\n        cause: result.error,\n      },\n    );\n  }\n\n  return result.data;\n};\n\nconst buildBaseEnvironmentInitialAnswers = (\n  options: AddEnvironmentCommandOptions,\n): DeploymentEnvironmentInitialAnswers => {\n  const env = {\n    ...(options.name && { name: options.name }),\n    ...(options.prefix && { prefix: options.prefix }),\n    ...(options.account?.length && {\n      cloudAccountIds: Array.from(new Set(options.account)),\n    }),\n    ...(options.location?.length && {\n      locations: Object.fromEntries(\n        options.location.map(({ accountId, location }) => [\n          accountId,\n          location as AzureLocation,\n        ]),\n      ),\n    }),\n  };\n\n  const tags = {\n    ...(options.businessUnit && { BusinessUnit: options.businessUnit }),\n    ...(options.managementTeam && { ManagementTeam: options.managementTeam }),\n  };\n\n  return {\n    ...(Object.keys(env).length > 0 && { env }),\n    ...(Object.keys(tags).length > 0 && { tags }),\n    ...(options.domain && { workspace: { domain: options.domain } }),\n  };\n};\n\nexport const getEnvironmentInitialAnswers = async (\n  options: AddEnvironmentCommandOptions,\n): Promise<DeploymentEnvironmentInitialAnswers> => {\n  const initialAnswers = buildBaseEnvironmentInitialAnswers(options);\n  const privateKey =\n    options.privateKeyPath === undefined\n      ? undefined\n      : await readFile(options.privateKeyPath, \"utf8\").catch((cause) => {\n          throw new Error(\n            `Failed to read private key file at \"${options.privateKeyPath}\".`,\n            { cause },\n          );\n        });\n\n  // Fail fast on an empty (or whitespace-only) key file: the file contents are\n  // never trimmed, so an empty value would otherwise skip the recovery prompt\n  // and surface as an opaque schema error (or a silently invalid key) later.\n  if (privateKey !== undefined && privateKey.trim().length === 0) {\n    throw new Error(\n      `Private key file at \"${options.privateKeyPath}\" is empty.`,\n    );\n  }\n\n  // Prefill runner-app credentials only when at least one credential flag was\n  // provided. Unspecified fields stay `undefined` on purpose so the generator\n  // prompts for the missing pieces and validates the complete set later. With\n  // no credential flag at all, leave this `undefined` to keep initialization\n  // fully interactive.\n  const runnerAppCredentials =\n    options.runnerAppId === undefined &&\n    options.clientId === undefined &&\n    options.installationId === undefined &&\n    privateKey === undefined\n      ? undefined\n      : {\n          clientId: options.clientId,\n          id: options.runnerAppId,\n          installationId: options.installationId,\n          key: privateKey,\n        };\n\n  return {\n    ...initialAnswers,\n    ...((options.yes || runnerAppCredentials) && {\n      init: {\n        ...(options.yes && { confirm: true }),\n        ...(runnerAppCredentials && { runnerAppCredentials }),\n      },\n    }),\n  };\n};\n\n/**\n * Authorize a Cloud Account (Azure Subscription, AWS Account, ...), creating a Pull Request for each account that requires authorization.\n */\nexport const authorizeCloudAccounts =\n  (authorizationService: AuthorizationService) =>\n  (\n    envPayload: EnvironmentPayload,\n  ): ResultAsync<AuthorizationResult[], never> => {\n    const accountsToInitialize =\n      envPayload.init?.cloudAccountsToInitialize ?? [];\n\n    if (accountsToInitialize.length === 0) {\n      return okAsync([]);\n    }\n\n    const logger = getLogger([\"dx-cli\", \"add-environment\"]);\n    const { name, prefix } = envPayload.env;\n    const envShort = environmentShort[name];\n\n    const requestAll = async (): Promise<AuthorizationResult[]> => {\n      const results: AuthorizationResult[] = [];\n\n      for (const account of accountsToInitialize) {\n        if (!isAzureLocation(account.defaultLocation)) {\n          logger.warn(\n            \"Skipping authorization for {account}: unsupported location\",\n            { account: account.displayName },\n          );\n          continue;\n        }\n\n        const locShort = locationShort[account.defaultLocation];\n        const input = requestAuthorizationInputSchema.safeParse({\n          bootstrapIdentityId: `${prefix}-${envShort}-${locShort}-bootstrap-id-01`,\n          envShort,\n          prefix,\n          repoName: envPayload.github.repo,\n          repoOwner: envPayload.github.owner,\n          subscriptionName: account.displayName,\n        });\n\n        if (!input.success) {\n          logger.warn(\"Skipping authorization for {account}: invalid input\", {\n            account: account.displayName,\n          });\n          continue;\n        }\n\n        const result = await authorizationService.requestAuthorization(\n          input.data,\n        );\n\n        result.match(\n          (authResult) => results.push(authResult),\n          (error) =>\n            logger.warn(\"Authorization request failed for {account}: {error}\", {\n              account: account.displayName,\n              error: error.message,\n            }),\n        );\n      }\n\n      return results;\n    };\n\n    return ResultAsync.fromPromise(requestAll(), () => []).orElse(() =>\n      okAsync([]),\n    );\n  };\n\ntype AddResult = {\n  authorizationPrs: AuthorizationResult[];\n  payload: EnvironmentPayload;\n};\n\nconst displaySummary = (result: AddResult) => {\n  const { authorizationPrs } = result;\n  console.log(chalk.green.bold(\"\\nCloud environment created successfully!\"));\n\n  let step = 1;\n  console.log(chalk.green.bold(\"\\nNext Steps:\"));\n  const prsWithUrl = authorizationPrs.filter(\n    (pr): pr is AuthorizationResult & { url: string } => pr.url != null,\n  );\n  if (prsWithUrl.length > 0) {\n    console.log(`${step++}. Review the Azure authorization Pull Request(s):`);\n    for (const authPr of prsWithUrl) {\n      console.log(`   - ${chalk.underline(authPr.url)}`);\n    }\n  }\n  console.log(\n    `${step}. Visit ${chalk.underline(\"https://dx.pagopa.it/getting-started\")} to deploy your first project\\n`,\n  );\n};\n\n/**\n * Routes the successful outcome through the presenter: JSON mode emits the\n * structured envelope while text mode renders the human-readable summary.\n */\nconst reportSummary =\n  (presenter: CommandPresenter, outputMode: \"json\" | \"text\") =>\n  (result: AddResult): void => {\n    if (outputMode === \"json\") {\n      presenter.reportResult(result);\n    } else {\n      displaySummary(result);\n    }\n  };\n\nconst trackStep = <T, E>(\n  presenter: CommandPresenter,\n  name: string,\n  task: () => Promise<T>,\n  mapError: (cause: unknown) => E,\n): ResultAsync<T, E> =>\n  ResultAsync.fromPromise(presenter.trackStep(name, task), mapError);\n\nconst addEnvironmentAction = (\n  authorizationService: AuthorizationService,\n  gitHubService: GitHubService,\n  presenter: CommandPresenter,\n  initialAnswers: DeploymentEnvironmentInitialAnswers = {},\n): ResultAsync<AddResult, Error> =>\n  runAddEnvironmentPreconditions(presenter)\n    .andThen(() =>\n      trackStep(\n        presenter,\n        \"Initializing environment generator...\",\n        getPlopInstance,\n        asError(\"Failed to initialize plop\"),\n      ),\n    )\n    .andThen((plop) =>\n      // The prompt phase must run outside trackStep: in text mode trackStep\n      // renders a spinner that occupies the TTY and hides the prompts.\n      ResultAsync.fromPromise(\n        collectDeploymentEnvironmentPayload(\n          plop,\n          gitHubService,\n          undefined,\n          initialAnswers,\n        ),\n        asError(\"Failed to run the deployment environment generator\"),\n      ),\n    )\n    .andThen(({ generator, payload }) =>\n      trackStep(\n        presenter,\n        \"Creating environment...\",\n        () => runDeploymentEnvironmentActions(generator, payload),\n        asError(\"Failed to create the deployment environment\"),\n      ),\n    )\n    .andThen((payload) =>\n      authorizeCloudAccounts(authorizationService)(payload).map(\n        (authorizationPrs) => ({\n          authorizationPrs,\n          payload,\n        }),\n      ),\n    );\n\nexport const makeAddCommand = (\n  requireGitHubAuth: GitHubAuthFactory,\n  env: CliEnv,\n): Command =>\n  new Command()\n    .name(\"add\")\n    .description(\"Add a new component to your workspace\")\n    .addCommand(\n      new Command(\"environment\")\n        .description(\"Add a new deployment environment\")\n        .addOption(\n          new Option(\"--name <name>\", \"Environment name\").choices([\n            \"dev\",\n            \"uat\",\n            \"prod\",\n          ]),\n        )\n        .addOption(\n          new Option(\n            \"--account <subscription-id>\",\n            \"Cloud account subscription id\",\n          ).argParser(appendOptionValue),\n        )\n        .addOption(\n          new Option(\n            \"--location <subscription-id=region>\",\n            \"Default Azure location for a selected account\",\n          ).argParser(appendOptionValue),\n        )\n        .addOption(new Option(\"--prefix <prefix>\", \"Environment prefix\"))\n        .addOption(new Option(\"--domain <domain>\", \"Workspace domain\"))\n        .addOption(\n          new Option(\"--business-unit <business-unit>\", \"Business unit tag\"),\n        )\n        .addOption(\n          new Option(\n            \"--management-team <management-team>\",\n            \"Management team tag\",\n          ),\n        )\n        .addOption(\n          new Option(\n            \"-y, --yes\",\n            \"Confirm environment initialization without prompting\",\n          ),\n        )\n        .addOption(\n          new Option(\"--runner-app-id <runner-app-id>\", \"GitHub Runner App ID\"),\n        )\n        .addOption(\n          new Option(\"--client-id <client-id>\", \"GitHub Runner App Client ID\"),\n        )\n        .addOption(\n          new Option(\n            \"--installation-id <installation-id>\",\n            \"GitHub Runner App Installation ID\",\n          ),\n        )\n        .addOption(\n          new Option(\n            \"--private-key-path <private-key-path>\",\n            \"Path to a local GitHub Runner App private key file\",\n          ),\n        )\n        .action(async function (options: unknown) {\n          const { output } = this.optsWithGlobals<GlobalOptions>();\n          const outputMode = resolveOutputMode(env, output);\n          const presenter = createCommandPresenter(outputMode);\n\n          await ResultAsync.fromPromise(\n            Promise.resolve().then(() =>\n              parseAddEnvironmentCommandOptions(options),\n            ),\n            (cause) =>\n              cause instanceof Error\n                ? cause\n                : new Error(\"Failed to parse add environment command options\", {\n                    cause,\n                  }),\n          )\n            .andThen((addEnvironmentOptions) =>\n              ResultAsync.fromPromise(\n                getEnvironmentInitialAnswers(addEnvironmentOptions),\n                (cause) =>\n                  cause instanceof Error\n                    ? cause\n                    : new Error(\n                        \"Failed to load add environment initial answers\",\n                        {\n                          cause,\n                        },\n                      ),\n              ).andThen((initialAnswers) =>\n                requireGitHubAuth().andThen(\n                  ({ authorizationService, gitHubService }) =>\n                    addEnvironmentAction(\n                      authorizationService,\n                      gitHubService,\n                      presenter,\n                      initialAnswers,\n                    ),\n                ),\n              ),\n            )\n            .match(\n              reportSummary(presenter, outputMode),\n              reportCommandError(this, presenter, outputMode),\n            );\n        }),\n    );\n"]}