@pagopa/dx-cli 0.24.0 → 0.25.0

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"]}

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

@@ -9,6 +9,7 @@
  */
 import chalk from "chalk";
 import { Command } from "commander";
+import process from "node:process";
 import { runDoctor } from "../../../domain/doctor.js";
 import { createCommandPresenter, resolveOutputMode, } from "../presenters/index.js";
 const formatCheck = (check) => check.isValid
@@ -28,6 +29,8 @@ export const makeDoctorCommand = (dependencies, config, env) => new Command()
     const presenter = createCommandPresenter(outputMode);
     const result = await runDoctor(dependencies, config);
     reportDoctorResult(presenter, outputMode)(result);
+    // Use process.exitCode instead of process.exit() so that the finally
+    // block in runCli() can flush telemetry before the process terminates.
     process.exitCode = result.hasErrors ? 1 : 0;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FkYXB0ZXJzL2NvbW1hbmRlci9jb21tYW5kcy9kb2N0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFDSCxPQUFPLEtBQUssTUFBTSxPQUFPLENBQUM7QUFDMUIsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUNwQyxPQUFPLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFVbkMsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ3RELE9BQU8sRUFDTCxzQkFBc0IsRUFDdEIsaUJBQWlCLEdBQ2xCLE1BQU0sd0JBQXdCLENBQUM7QUFFaEMsTUFBTSxXQUFXLEdBQUcsQ0FBQyxLQUFzQixFQUFVLEVBQUUsQ0FDckQsS0FBSyxDQUFDLE9BQU87SUFDWCxDQUFDLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxLQUFLLEtBQUssQ0FBQyxjQUFjLEVBQUUsQ0FBQztJQUMxQyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxLQUFLLEtBQUssQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUFDO0FBRTNDLE1BQU0sa0JBQWtCLEdBQ3RCLENBQUMsU0FBMkIsRUFBRSxVQUEyQixFQUFFLEVBQUUsQ0FDN0QsQ0FBQyxNQUFvQixFQUFRLEVBQUU7SUFDN0IsU0FBUyxDQUFDLFlBQVksQ0FDcEIsVUFBVSxLQUFLLE1BQU07UUFDbkIsQ0FBQyxDQUFDLE1BQU07UUFDUixDQUFDLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUM5QyxDQUFDO0FBQ0osQ0FBQyxDQUFDO0FBRUosTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsQ0FDL0IsWUFBMEIsRUFDMUIsTUFBYyxFQUNkLEdBQVcsRUFDRixFQUFFLENBQ1gsSUFBSSxPQUFPLEVBQUU7S0FDVixJQUFJLENBQUMsUUFBUSxDQUFDO0tBQ2QsV0FBVyxDQUNWLCtEQUErRCxDQUNoRTtLQUNBLE1BQU0sQ0FBQyxLQUFLO0lBQ1gsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLElBQUksQ0FBQyxlQUFlLEVBQWlCLENBQUM7SUFDekQsTUFBTSxVQUFVLEdBQUcsaUJBQWlCLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ2xELE1BQU0sU0FBUyxHQUFHLHNCQUFzQixDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBRXJELE1BQU0sTUFBTSxHQUFHLE1BQU0sU0FBUyxDQUFDLFlBQVksRUFBRSxNQUFNLENBQUMsQ0FBQztJQUVyRCxrQkFBa0IsQ0FBQyxTQUFTLEVBQUUsVUFBVSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUM7SUFFbEQscUVBQXFFO0lBQ3JFLHVFQUF1RTtJQUN2RSxPQUFPLENBQUMsUUFBUSxHQUFHLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQzlDLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBgZG9jdG9yYCBDb21tYW5kZXIgY29tbWFuZC5cbiAqXG4gKiBWZXJpZmllcyB0aGUgcmVwb3NpdG9yeSBzZXR1cCBhbmQgcm91dGVzIHRoZSBvdXRjb21lIHRocm91Z2ggdGhlIHNoYXJlZFxuICogQ29tbWFuZFByZXNlbnRlciBwb3J0LiBKU09OIG1vZGUgZW1pdHMgdGhlIHN0cnVjdHVyZWQgcmVzdWx0OyB0ZXh0IG1vZGUgZW1pdHNcbiAqIGEgaHVtYW4tcmVhZGFibGUgcGVyLWNoZWNrIHN1bW1hcnkuIFRoZSBleGl0IGNvZGUgcmVmbGVjdHMgd2hldGhlciBhbnkgY2hlY2tcbiAqIGZhaWxlZCwgbWlycm9yaW5nIHRoZSBsaW50ZXIgY29udmVudGlvbiAoYSBzdWNjZXNzZnVsIHJ1biBjYW4gc3RpbGwgcmVwb3J0XG4gKiBwcm9ibGVtcykuXG4gKi9cbmltcG9ydCBjaGFsayBmcm9tIFwiY2hhbGtcIjtcbmltcG9ydCB7IENvbW1hbmQgfSBmcm9tIFwiY29tbWFuZGVyXCI7XG5pbXBvcnQgcHJvY2VzcyBmcm9tIFwibm9kZTpwcm9jZXNzXCI7XG5cbmltcG9ydCB0eXBlIHsgQ29tbWFuZFByZXNlbnRlciB9IGZyb20gXCIuLi8uLi8uLi9kb21haW4vY29tbWFuZC1wcmVzZW50ZXIuanNcIjtcbmltcG9ydCB0eXBlIHsgRGVwZW5kZW5jaWVzIH0gZnJvbSBcIi4uLy4uLy4uL2RvbWFpbi9kZXBlbmRlbmNpZXMuanNcIjtcbmltcG9ydCB0eXBlIHsgRG9jdG9yUmVzdWx0IH0gZnJvbSBcIi4uLy4uLy4uL2RvbWFpbi9kb2N0b3IuanNcIjtcbmltcG9ydCB0eXBlIHsgVmFsaWRhdGlvbkNoZWNrIH0gZnJvbSBcIi4uLy4uLy4uL2RvbWFpbi92YWxpZGF0aW9uLmpzXCI7XG5pbXBvcnQgdHlwZSB7IENsaUVudiB9IGZyb20gXCIuLi9lbnYuanNcIjtcbmltcG9ydCB0eXBlIHsgR2xvYmFsT3B0aW9ucyB9IGZyb20gXCIuLi9nbG9iYWwtb3B0aW9ucy5qc1wiO1xuXG5pbXBvcnQgeyBDb25maWcgfSBmcm9tIFwiLi4vLi4vLi4vY29uZmlnLmpzXCI7XG5pbXBvcnQgeyBydW5Eb2N0b3IgfSBmcm9tIFwiLi4vLi4vLi4vZG9tYWluL2RvY3Rvci5qc1wiO1xuaW1wb3J0IHtcbiAgY3JlYXRlQ29tbWFuZFByZXNlbnRlcixcbiAgcmVzb2x2ZU91dHB1dE1vZGUsXG59IGZyb20gXCIuLi9wcmVzZW50ZXJzL2luZGV4LmpzXCI7XG5cbmNvbnN0IGZvcm1hdENoZWNrID0gKGNoZWNrOiBWYWxpZGF0aW9uQ2hlY2spOiBzdHJpbmcgPT5cbiAgY2hlY2suaXNWYWxpZFxuICAgID8gY2hhbGsuZ3JlZW4oYOKchSAke2NoZWNrLnN1Y2Nlc3NNZXNzYWdlfWApXG4gICAgOiBjaGFsay5yZWQoYOKdjCAke2NoZWNrLmVycm9yTWVzc2FnZX1gKTtcblxuY29uc3QgcmVwb3J0RG9jdG9yUmVzdWx0ID1cbiAgKHByZXNlbnRlcjogQ29tbWFuZFByZXNlbnRlciwgb3V0cHV0TW9kZTogXCJqc29uXCIgfCBcInRleHRcIikgPT5cbiAgKHJlc3VsdDogRG9jdG9yUmVzdWx0KTogdm9pZCA9PiB7XG4gICAgcHJlc2VudGVyLnJlcG9ydFJlc3VsdChcbiAgICAgIG91dHB1dE1vZGUgPT09IFwianNvblwiXG4gICAgICAgID8gcmVzdWx0XG4gICAgICAgIDogcmVzdWx0LmNoZWNrcy5tYXAoZm9ybWF0Q2hlY2spLmpvaW4oXCJcXG5cIiksXG4gICAgKTtcbiAgfTtcblxuZXhwb3J0IGNvbnN0IG1ha2VEb2N0b3JDb21tYW5kID0gKFxuICBkZXBlbmRlbmNpZXM6IERlcGVuZGVuY2llcyxcbiAgY29uZmlnOiBDb25maWcsXG4gIGVudjogQ2xpRW52LFxuKTogQ29tbWFuZCA9PlxuICBuZXcgQ29tbWFuZCgpXG4gICAgLm5hbWUoXCJkb2N0b3JcIilcbiAgICAuZGVzY3JpcHRpb24oXG4gICAgICBcIlZlcmlmeSB0aGUgcmVwb3NpdG9yeSBzZXR1cCBhY2NvcmRpbmcgdG8gdGhlIERldkV4IGd1aWRlbGluZXNcIixcbiAgICApXG4gICAgLmFjdGlvbihhc3luYyBmdW5jdGlvbiAoKSB7XG4gICAgICBjb25zdCB7IG91dHB1dCB9ID0gdGhpcy5vcHRzV2l0aEdsb2JhbHM8R2xvYmFsT3B0aW9ucz4oKTtcbiAgICAgIGNvbnN0IG91dHB1dE1vZGUgPSByZXNvbHZlT3V0cHV0TW9kZShlbnYsIG91dHB1dCk7XG4gICAgICBjb25zdCBwcmVzZW50ZXIgPSBjcmVhdGVDb21tYW5kUHJlc2VudGVyKG91dHB1dE1vZGUpO1xuXG4gICAgICBjb25zdCByZXN1bHQgPSBhd2FpdCBydW5Eb2N0b3IoZGVwZW5kZW5jaWVzLCBjb25maWcpO1xuXG4gICAgICByZXBvcnREb2N0b3JSZXN1bHQocHJlc2VudGVyLCBvdXRwdXRNb2RlKShyZXN1bHQpO1xuXG4gICAgICAvLyBVc2UgcHJvY2Vzcy5leGl0Q29kZSBpbnN0ZWFkIG9mIHByb2Nlc3MuZXhpdCgpIHNvIHRoYXQgdGhlIGZpbmFsbHlcbiAgICAgIC8vIGJsb2NrIGluIHJ1bkNsaSgpIGNhbiBmbHVzaCB0ZWxlbWV0cnkgYmVmb3JlIHRoZSBwcm9jZXNzIHRlcm1pbmF0ZXMuXG4gICAgICBwcm9jZXNzLmV4aXRDb2RlID0gcmVzdWx0Lmhhc0Vycm9ycyA/IDEgOiAwO1xuICAgIH0pO1xuIl19

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

@@ -24,6 +24,18 @@ export declare class OctokitGitHubService implements GitHubService {
     updateFile(params: UpdateFileParams): Promise<void>;
 }
 export declare const getGitHubPAT: () => Promise<string | undefined>;
+/**
+ * Returns true when the authenticated user is an active member of the PagoPA
+ * GitHub organization.
+ *
+ * Fails closed: any error (network failure, missing `read:org` scope, 403/404)
+ * resolves to `false` so telemetry stays disabled when membership cannot be
+ * confirmed.
+ *
+ * @param octokit injectable client, primarily for testing; defaults to a client
+ * authenticated with the supplied token.
+ */
+export declare const isPagopaOrgMember: (token: string, octokit?: Octokit) => Promise<boolean>;
 export declare const fetchLatestTag: ({ client, owner, repo }: GitHubReleaseParam) => ResultAsync<import("semver").SemVer | null, Error>;
 export declare const fetchLatestRelease: ({ client, owner, repo, }: GitHubReleaseParam) => ResultAsync<import("semver").SemVer | null, Error>;
 export {};

package/dist/adapters/octokit/index.js

@@ -1,7 +1,7 @@
 import { $ } from "execa";
 import sodium from "libsodium-wrappers";
 import { ResultAsync } from "neverthrow";
-import { RequestError } from "octokit";
+import { Octokit, RequestError } from "octokit";
 import semverParse from "semver/functions/parse.js";
 import semverSort from "semver/functions/sort.js";
 import { FileNotFoundError, PullRequest, Repository, RepositoryNotFoundError, } from "../../domain/github.js";
@@ -157,6 +157,30 @@ export const getGitHubPAT = async () => {
     }
     return undefined;
 };
+/** GitHub organization whose members are allowed to emit CLI telemetry. */
+const PAGOPA_ORG = "pagopa";
+/**
+ * Returns true when the authenticated user is an active member of the PagoPA
+ * GitHub organization.
+ *
+ * Fails closed: any error (network failure, missing `read:org` scope, 403/404)
+ * resolves to `false` so telemetry stays disabled when membership cannot be
+ * confirmed.
+ *
+ * @param octokit injectable client, primarily for testing; defaults to a client
+ * authenticated with the supplied token.
+ */
+export const isPagopaOrgMember = async (token, octokit = new Octokit({ auth: token })) => {
+    try {
+        const { data } = await octokit.rest.orgs.getMembershipForAuthenticatedUser({
+            org: PAGOPA_ORG,
+        });
+        return data.state === "active";
+    }
+    catch {
+        return false;
+    }
+};
 export const fetchLatestTag = ({ client, owner, repo }) => ResultAsync.fromPromise(
 // Get repository tags
 client.request("GET /repos/{owner}/{repo}/tags", {
@@ -176,4 +200,4 @@ client.request("GET /repos/{owner}/{repo}/releases/latest", {
     owner,
     repo,
 }), () => new Error(`Failed to fetch latest release for ${owner}/${repo}`)).map(({ data }) => semverParse(data.tag_name));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/adapters/octokit/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { $ } from \"execa\";\nimport sodium from \"libsodium-wrappers\";\nimport { ResultAsync } from \"neverthrow\";\nimport { Octokit, RequestError } from \"octokit\";\nimport semverParse from \"semver/functions/parse.js\";\nimport semverSort from \"semver/functions/sort.js\";\n\nimport {\n  CreateBranchParams,\n  CreateOrUpdateEnvironmentSecretParams,\n  FileContent,\n  FileNotFoundError,\n  GetFileContentParams,\n  GitHubService,\n  PullRequest,\n  Repository,\n  RepositoryNotFoundError,\n  UpdateFileParams,\n} from \"../../domain/github.js\";\n\ntype GitHubReleaseParam = {\n  client: Octokit;\n  owner: string;\n  repo: string;\n};\n\nexport class OctokitGitHubService implements GitHubService {\n  #octokit;\n\n  constructor(octokit: Octokit) {\n    this.#octokit = octokit;\n  }\n\n  async createBranch(params: CreateBranchParams): Promise<void> {\n    try {\n      // Get the SHA of the source branch\n      const { data: refData } = await this.#octokit.rest.git.getRef({\n        owner: params.owner,\n        ref: `heads/${params.fromRef}`,\n        repo: params.repo,\n      });\n\n      // Create the new branch\n      await this.#octokit.rest.git.createRef({\n        owner: params.owner,\n        ref: `refs/heads/${params.branchName}`,\n        repo: params.repo,\n        sha: refData.object.sha,\n      });\n    } catch (error) {\n      throw new Error(`Failed to create branch: ${params.branchName}`, {\n        cause: error,\n      });\n    }\n  }\n\n  async createOrUpdateEnvironmentSecret(\n    params: CreateOrUpdateEnvironmentSecretParams,\n  ): Promise<void> {\n    try {\n      // GitHub requires environment secrets to be encrypted client-side with libsodium.\n      await sodium.ready;\n\n      // Ensure the target environment exists before resolving its public key and storing secrets.\n      await this.#octokit.request(\n        \"PUT /repos/{owner}/{repo}/environments/{environment_name}\",\n        {\n          environment_name: params.environmentName,\n          owner: params.owner,\n          repo: params.repo,\n        },\n      );\n\n      const { data: publicKeyData } =\n        await this.#octokit.rest.actions.getEnvironmentPublicKey({\n          environment_name: params.environmentName,\n          owner: params.owner,\n          repo: params.repo,\n        });\n\n      const publicKeyBytes = sodium.from_base64(\n        publicKeyData.key,\n        sodium.base64_variants.ORIGINAL,\n      );\n      const secretBytes = sodium.from_string(params.secretValue);\n      const encryptedBytes = sodium.crypto_box_seal(\n        secretBytes,\n        publicKeyBytes,\n      );\n      const encryptedValue = sodium.to_base64(\n        encryptedBytes,\n        sodium.base64_variants.ORIGINAL,\n      );\n\n      await this.#octokit.rest.actions.createOrUpdateEnvironmentSecret({\n        encrypted_value: encryptedValue,\n        environment_name: params.environmentName,\n        key_id: publicKeyData.key_id,\n        owner: params.owner,\n        repo: params.repo,\n        secret_name: params.secretName,\n      });\n    } catch (error) {\n      throw new Error(\n        `Failed to create or update secret ${params.secretName} in environment ${params.environmentName}`,\n        { cause: error },\n      );\n    }\n  }\n\n  async createPullRequest(params: {\n    base: string;\n    body: string;\n    head: string;\n    owner: string;\n    repo: string;\n    title: string;\n  }): Promise<PullRequest> {\n    try {\n      const { data } = await this.#octokit.rest.pulls.create({\n        base: params.base,\n        body: params.body,\n        head: params.head,\n        owner: params.owner,\n        repo: params.repo,\n        title: params.title,\n      });\n      return new PullRequest(data.html_url);\n    } catch (error) {\n      throw new Error(\n        `Failed to create pull request in ${params.owner}/${params.repo}`,\n        {\n          cause: error,\n        },\n      );\n    }\n  }\n\n  async getFileContent(params: GetFileContentParams): Promise<FileContent> {\n    try {\n      const { data } = await this.#octokit.rest.repos.getContent({\n        owner: params.owner,\n        path: params.path,\n        ref: params.ref,\n        repo: params.repo,\n      });\n\n      // GitHub API returns an array for directories, single object for files\n      if (Array.isArray(data) || data.type !== \"file\") {\n        throw new Error(`Path ${params.path} is not a file`);\n      }\n\n      const content = Buffer.from(data.content, \"base64\").toString(\"utf-8\");\n      return { content, sha: data.sha };\n    } catch (error) {\n      if (error instanceof RequestError && error.status === 404) {\n        throw new FileNotFoundError(params.path);\n      }\n      throw new Error(`Failed to get file content: ${params.path}`, {\n        cause: error,\n      });\n    }\n  }\n\n  async getRepository(owner: string, name: string): Promise<Repository> {\n    try {\n      const { data } = await this.#octokit.rest.repos.get({\n        owner,\n        repo: name,\n      });\n      return new Repository(data.name, data.owner.login);\n    } catch (error) {\n      if (error instanceof RequestError && error.status === 404) {\n        throw new RepositoryNotFoundError(owner, name);\n      }\n      throw new Error(`Failed to fetch repository ${owner}/${name}`, {\n        cause: error,\n      });\n    }\n  }\n\n  async updateFile(params: UpdateFileParams): Promise<void> {\n    try {\n      await this.#octokit.rest.repos.createOrUpdateFileContents({\n        branch: params.branch,\n        content: Buffer.from(params.content).toString(\"base64\"),\n        message: params.message,\n        owner: params.owner,\n        path: params.path,\n        repo: params.repo,\n        sha: params.sha,\n      });\n    } catch (error) {\n      throw new Error(`Failed to update file: ${params.path}`, {\n        cause: error,\n      });\n    }\n  }\n}\n\n// Follow the same order of precedence of gh cli\n// https://cli.github.com/manual/gh_help_environment\nexport const getGitHubPAT = async (): Promise<string | undefined> => {\n  if (process.env.GH_TOKEN) {\n    return process.env.GH_TOKEN;\n  }\n  if (process.env.GITHUB_TOKEN) {\n    return process.env.GITHUB_TOKEN;\n  }\n  const result = await $({ reject: false })`gh auth token`;\n  if (!result.failed && result.exitCode === 0) {\n    return result.stdout.trim();\n  }\n  return undefined;\n};\n\nexport const fetchLatestTag = ({ client, owner, repo }: GitHubReleaseParam) =>\n  ResultAsync.fromPromise(\n    // Get repository tags\n    client.request(\"GET /repos/{owner}/{repo}/tags\", {\n      owner,\n      repo,\n    }),\n    () => new Error(`Failed to fetch tags for ${owner}/${repo}`),\n  )\n    .map(({ data }) => data.map(({ name }) => name))\n    // Filter out tags that are not valid semver\n    .map((tags) =>\n      tags.map((tag) => semverParse(tag)).filter((tag) => tag !== null),\n    )\n    // Sort tags in ascending order\n    .map(semverSort)\n    // Get the latest tag\n    .map((tags) => tags.pop() ?? null);\n\nexport const fetchLatestRelease = ({\n  client,\n  owner,\n  repo,\n}: GitHubReleaseParam) =>\n  ResultAsync.fromPromise(\n    // Get the latest release for a repository\n    client.request(\"GET /repos/{owner}/{repo}/releases/latest\", {\n      owner,\n      repo,\n    }),\n    () => new Error(`Failed to fetch latest release for ${owner}/${repo}`),\n  ).map(({ data }) => semverParse(data.tag_name));\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/adapters/octokit/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { $ } from \"execa\";\nimport sodium from \"libsodium-wrappers\";\nimport { ResultAsync } from \"neverthrow\";\nimport { Octokit, RequestError } from \"octokit\";\nimport semverParse from \"semver/functions/parse.js\";\nimport semverSort from \"semver/functions/sort.js\";\n\nimport {\n  CreateBranchParams,\n  CreateOrUpdateEnvironmentSecretParams,\n  FileContent,\n  FileNotFoundError,\n  GetFileContentParams,\n  GitHubService,\n  PullRequest,\n  Repository,\n  RepositoryNotFoundError,\n  UpdateFileParams,\n} from \"../../domain/github.js\";\n\ntype GitHubReleaseParam = {\n  client: Octokit;\n  owner: string;\n  repo: string;\n};\n\nexport class OctokitGitHubService implements GitHubService {\n  #octokit;\n\n  constructor(octokit: Octokit) {\n    this.#octokit = octokit;\n  }\n\n  async createBranch(params: CreateBranchParams): Promise<void> {\n    try {\n      // Get the SHA of the source branch\n      const { data: refData } = await this.#octokit.rest.git.getRef({\n        owner: params.owner,\n        ref: `heads/${params.fromRef}`,\n        repo: params.repo,\n      });\n\n      // Create the new branch\n      await this.#octokit.rest.git.createRef({\n        owner: params.owner,\n        ref: `refs/heads/${params.branchName}`,\n        repo: params.repo,\n        sha: refData.object.sha,\n      });\n    } catch (error) {\n      throw new Error(`Failed to create branch: ${params.branchName}`, {\n        cause: error,\n      });\n    }\n  }\n\n  async createOrUpdateEnvironmentSecret(\n    params: CreateOrUpdateEnvironmentSecretParams,\n  ): Promise<void> {\n    try {\n      // GitHub requires environment secrets to be encrypted client-side with libsodium.\n      await sodium.ready;\n\n      // Ensure the target environment exists before resolving its public key and storing secrets.\n      await this.#octokit.request(\n        \"PUT /repos/{owner}/{repo}/environments/{environment_name}\",\n        {\n          environment_name: params.environmentName,\n          owner: params.owner,\n          repo: params.repo,\n        },\n      );\n\n      const { data: publicKeyData } =\n        await this.#octokit.rest.actions.getEnvironmentPublicKey({\n          environment_name: params.environmentName,\n          owner: params.owner,\n          repo: params.repo,\n        });\n\n      const publicKeyBytes = sodium.from_base64(\n        publicKeyData.key,\n        sodium.base64_variants.ORIGINAL,\n      );\n      const secretBytes = sodium.from_string(params.secretValue);\n      const encryptedBytes = sodium.crypto_box_seal(\n        secretBytes,\n        publicKeyBytes,\n      );\n      const encryptedValue = sodium.to_base64(\n        encryptedBytes,\n        sodium.base64_variants.ORIGINAL,\n      );\n\n      await this.#octokit.rest.actions.createOrUpdateEnvironmentSecret({\n        encrypted_value: encryptedValue,\n        environment_name: params.environmentName,\n        key_id: publicKeyData.key_id,\n        owner: params.owner,\n        repo: params.repo,\n        secret_name: params.secretName,\n      });\n    } catch (error) {\n      throw new Error(\n        `Failed to create or update secret ${params.secretName} in environment ${params.environmentName}`,\n        { cause: error },\n      );\n    }\n  }\n\n  async createPullRequest(params: {\n    base: string;\n    body: string;\n    head: string;\n    owner: string;\n    repo: string;\n    title: string;\n  }): Promise<PullRequest> {\n    try {\n      const { data } = await this.#octokit.rest.pulls.create({\n        base: params.base,\n        body: params.body,\n        head: params.head,\n        owner: params.owner,\n        repo: params.repo,\n        title: params.title,\n      });\n      return new PullRequest(data.html_url);\n    } catch (error) {\n      throw new Error(\n        `Failed to create pull request in ${params.owner}/${params.repo}`,\n        {\n          cause: error,\n        },\n      );\n    }\n  }\n\n  async getFileContent(params: GetFileContentParams): Promise<FileContent> {\n    try {\n      const { data } = await this.#octokit.rest.repos.getContent({\n        owner: params.owner,\n        path: params.path,\n        ref: params.ref,\n        repo: params.repo,\n      });\n\n      // GitHub API returns an array for directories, single object for files\n      if (Array.isArray(data) || data.type !== \"file\") {\n        throw new Error(`Path ${params.path} is not a file`);\n      }\n\n      const content = Buffer.from(data.content, \"base64\").toString(\"utf-8\");\n      return { content, sha: data.sha };\n    } catch (error) {\n      if (error instanceof RequestError && error.status === 404) {\n        throw new FileNotFoundError(params.path);\n      }\n      throw new Error(`Failed to get file content: ${params.path}`, {\n        cause: error,\n      });\n    }\n  }\n\n  async getRepository(owner: string, name: string): Promise<Repository> {\n    try {\n      const { data } = await this.#octokit.rest.repos.get({\n        owner,\n        repo: name,\n      });\n      return new Repository(data.name, data.owner.login);\n    } catch (error) {\n      if (error instanceof RequestError && error.status === 404) {\n        throw new RepositoryNotFoundError(owner, name);\n      }\n      throw new Error(`Failed to fetch repository ${owner}/${name}`, {\n        cause: error,\n      });\n    }\n  }\n\n  async updateFile(params: UpdateFileParams): Promise<void> {\n    try {\n      await this.#octokit.rest.repos.createOrUpdateFileContents({\n        branch: params.branch,\n        content: Buffer.from(params.content).toString(\"base64\"),\n        message: params.message,\n        owner: params.owner,\n        path: params.path,\n        repo: params.repo,\n        sha: params.sha,\n      });\n    } catch (error) {\n      throw new Error(`Failed to update file: ${params.path}`, {\n        cause: error,\n      });\n    }\n  }\n}\n\n// Follow the same order of precedence of gh cli\n// https://cli.github.com/manual/gh_help_environment\nexport const getGitHubPAT = async (): Promise<string | undefined> => {\n  if (process.env.GH_TOKEN) {\n    return process.env.GH_TOKEN;\n  }\n  if (process.env.GITHUB_TOKEN) {\n    return process.env.GITHUB_TOKEN;\n  }\n  const result = await $({ reject: false })`gh auth token`;\n  if (!result.failed && result.exitCode === 0) {\n    return result.stdout.trim();\n  }\n  return undefined;\n};\n\n/** GitHub organization whose members are allowed to emit CLI telemetry. */\nconst PAGOPA_ORG = \"pagopa\";\n\n/**\n * Returns true when the authenticated user is an active member of the PagoPA\n * GitHub organization.\n *\n * Fails closed: any error (network failure, missing `read:org` scope, 403/404)\n * resolves to `false` so telemetry stays disabled when membership cannot be\n * confirmed.\n *\n * @param octokit injectable client, primarily for testing; defaults to a client\n * authenticated with the supplied token.\n */\nexport const isPagopaOrgMember = async (\n  token: string,\n  octokit: Octokit = new Octokit({ auth: token }),\n): Promise<boolean> => {\n  try {\n    const { data } = await octokit.rest.orgs.getMembershipForAuthenticatedUser({\n      org: PAGOPA_ORG,\n    });\n    return data.state === \"active\";\n  } catch {\n    return false;\n  }\n};\n\nexport const fetchLatestTag = ({ client, owner, repo }: GitHubReleaseParam) =>\n  ResultAsync.fromPromise(\n    // Get repository tags\n    client.request(\"GET /repos/{owner}/{repo}/tags\", {\n      owner,\n      repo,\n    }),\n    () => new Error(`Failed to fetch tags for ${owner}/${repo}`),\n  )\n    .map(({ data }) => data.map(({ name }) => name))\n    // Filter out tags that are not valid semver\n    .map((tags) =>\n      tags.map((tag) => semverParse(tag)).filter((tag) => tag !== null),\n    )\n    // Sort tags in ascending order\n    .map(semverSort)\n    // Get the latest tag\n    .map((tags) => tags.pop() ?? null);\n\nexport const fetchLatestRelease = ({\n  client,\n  owner,\n  repo,\n}: GitHubReleaseParam) =>\n  ResultAsync.fromPromise(\n    // Get the latest release for a repository\n    client.request(\"GET /repos/{owner}/{repo}/releases/latest\", {\n      owner,\n      repo,\n    }),\n    () => new Error(`Failed to fetch latest release for ${owner}/${repo}`),\n  ).map(({ data }) => semverParse(data.tag_name));\n"]}

package/dist/adapters/plop/actions/setup-pnpm.js

@@ -11,6 +11,10 @@ export default function (plop) {
         // We filter them out here.
         const env = Object.fromEntries(Object.entries(process.env)
             .filter(([key]) => !key.startsWith("npm_config_"))
+            // Strip Node.js debugger env vars so child processes don't try to
+            // attach to the VS Code debugger and hang/fail.
+            .filter(([key]) => key !== "NODE_OPTIONS")
+            .filter(([key]) => !key.startsWith("VSCODE_INSPECTOR"))
             // Disable corepack download prompt
             .concat([["COREPACK_ENABLE_DOWNLOAD_PROMPT", "0"]]));
         const $ = $_({
@@ -27,4 +31,4 @@ export default function (plop) {
         return "Monorepo bootstrapped";
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/plop/actions/sync-repository-environments.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Updates infra/repository/main.tf and applies it so GitHub.com repository
+ * environments exist before deployment scaffolding continues.
+ *
+ * The repository Terraform module remains the source of truth for GitHub
+ * environments, including protection rules and reviewers. This action only
+ * changes the module's `repository.environments` input, then runs Terraform from
+ * infra/repository to create or update the environments on GitHub.
+ */
+import { type NodePlopAPI } from "node-plop";
+import type { Environment } from "../../../domain/environment.js";
+import { type Payload } from "../generators/environment/prompts.js";
+export declare const syncRepositoryTerraformEnvironments: (content: string, environmentName: Environment["name"]) => string;
+export declare const syncRepositoryEnvironments: (payload: Payload) => Promise<void>;
+export default function (plop: NodePlopAPI): void;