@pagopa/dx-cli 0.24.0 → 0.25.0

package/README.md

@@ -66,6 +66,20 @@ npm run build
 node ./apps/cli/bin/index.js --help
 ```
 
+## 🔐 Authentication
+
+The CLI requires GitHub authentication for every command **except** `--version`
+and `--help`. Authenticate using one of the following (checked in this order):
+
+1. The `GH_TOKEN` environment variable
+2. The `GITHUB_TOKEN` environment variable
+3. The [GitHub CLI](https://cli.github.com/) — run `gh auth login`
+
+If no credential is found, the CLI exits with an error asking you to log in.
+
+> Telemetry is emitted only for members of the `pagopa` GitHub organization;
+> all other users can use the CLI normally with telemetry disabled.
+
 ## 🛠️ Usage
 
 ### Available Commands

package/bin/index.js

@@ -1,6 +1,16 @@
 #!/usr/bin/env node
 
-import { runCli } from "../dist/index.js";
-import packageJson from "../package.json" with { type: "json" };
+// The instrumentation module must be loaded first so that the OpenTelemetry
+// module hook (import-in-the-middle) is registered before any of the CLI's
+// modules are imported. Static imports are always hoisted before code runs, so
+// sequential dynamic imports are the only way to guarantee this load order.
+await import("../dist/adapters/azure-monitor/instrumentation.js");
 
-runCli(packageJson.version).catch((error) => console.error(error.message));
+const { runCli } = await import("../dist/index.js");
+const { default: packageJson } = await import("../package.json", {
+  with: { type: "json" },
+});
+
+await runCli(packageJson.version).catch((error) =>
+  console.error(error.message),
+);

package/dist/adapters/azure/cloud-account-service.js

@@ -11,6 +11,8 @@ import { getLogger } from "@logtape/logtape";
 import { Client } from "@microsoft/microsoft-graph-client";
 import * as assert from "node:assert/strict";
 import { createHash } from "node:crypto";
+import { lookup } from "node:dns/promises";
+import { setTimeout as sleep } from "node:timers/promises";
 import { z } from "zod/v4";
 import { environmentShort, } from "../../domain/environment.js";
 import { terraformBackendSchema, } from "../../domain/remote-backend.js";
@@ -45,6 +47,11 @@ const bootstrapIdentityRoleDefinitionIds = [
     builtInRoleDefinitionIds.contributor,
     builtInRoleDefinitionIds.storageBlobDataContributor,
 ];
+const keyVaultDnsErrorSchema = z.object({
+    code: z.enum(["EAI_AGAIN", "ENOTFOUND"]),
+});
+const keyVaultDnsReadyMaxAttempts = 30;
+const keyVaultDnsReadyRetryDelayMs = 10_000;
 export class AzureCloudAccountService {
     #credential;
     #requiredResourceProviders = [
@@ -498,6 +505,10 @@ export class AzureCloudAccountService {
     }
     async #storeRunnerAppSecrets({ cloudAccountId, keyVaultName, runnerAppCredentials, }) {
         const logger = getLogger(["gen", "env"]);
+        await this.#waitForKeyVaultDnsResolution({
+            cloudAccountId,
+            keyVaultName,
+        });
         const secretClient = new SecretClient(`https://${keyVaultName}.vault.azure.net/`, this.#credential);
         await Promise.all([
             secretClient.setSecret("github-runner-app-id", runnerAppCredentials.id),
@@ -506,5 +517,25 @@ export class AzureCloudAccountService {
         ]);
         logger.debug("Created secrets in key vault {keyVaultName} in subscription {subscriptionId}", { keyVaultName, subscriptionId: cloudAccountId });
     }
+    async #waitForKeyVaultDnsResolution({ cloudAccountId, keyVaultName, }) {
+        const logger = getLogger(["gen", "env"]);
+        const hostname = `${keyVaultName}.vault.azure.net`;
+        // Azure can report the vault as created before its public DNS name is ready.
+        // Wait here so writing runner app secrets does not fail with ENOTFOUND.
+        for (let attempt = 1; attempt <= keyVaultDnsReadyMaxAttempts; attempt++) {
+            try {
+                await lookup(hostname);
+                return;
+            }
+            catch (cause) {
+                if (!keyVaultDnsErrorSchema.safeParse(cause).success ||
+                    attempt === keyVaultDnsReadyMaxAttempts) {
+                    throw new Error(`Key vault endpoint '${hostname}' is not resolvable`, { cause });
+                }
+                logger.debug("Waiting for key vault endpoint {hostname} to become resolvable in subscription {subscriptionId}", { hostname, subscriptionId: cloudAccountId });
+                await sleep(keyVaultDnsReadyRetryDelayMs);
+            }
+        }
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-account-service.js","sourceRoot":"","sources":["../../../src/adapters/azure/cloud-account-service.ts"],"names":[],"mappings":"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","sourcesContent":["import type { TokenCredential } from \"@azure/identity\";\n\nimport { AuthorizationManagementClient } from \"@azure/arm-authorization\";\nimport { KeyVaultManagementClient } from \"@azure/arm-keyvault\";\nimport { ManagedServiceIdentityClient } from \"@azure/arm-msi\";\nimport { ResourceGraphClient } from \"@azure/arm-resourcegraph\";\nimport { ResourceManagementClient } from \"@azure/arm-resources\";\nimport { SubscriptionClient } from \"@azure/arm-resources-subscriptions\";\nimport { StorageManagementClient } from \"@azure/arm-storage\";\nimport { SecretClient } from \"@azure/keyvault-secrets\";\nimport { BlobServiceClient } from \"@azure/storage-blob\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { Client } from \"@microsoft/microsoft-graph-client\";\nimport * as assert from \"node:assert/strict\";\nimport { createHash } from \"node:crypto\";\nimport { z } from \"zod/v4\";\n\nimport {\n  CloudAccount,\n  type CloudAccountService,\n} from \"../../domain/cloud-account.js\";\nimport {\n  type EnvironmentId,\n  environmentShort,\n} from \"../../domain/environment.js\";\nimport { type GitHubRepo } from \"../../domain/github-repo.js\";\nimport {\n  GitHubAppCredentials,\n  type GitHubService,\n} from \"../../domain/github.js\";\nimport {\n  type TerraformBackend,\n  terraformBackendSchema,\n} from \"../../domain/remote-backend.js\";\nimport { isAzureLocation, locations, locationShort } from \"./locations.js\";\n\n// We are only interested in these properties for now;\n// the actual result structure contains the full cloud resource object\nexport const resourceGraphDataSchema = z.object({\n  location: z.enum(locations),\n  name: z.string(),\n  resourceGroup: z.string(),\n});\n\nconst graphUserResponseSchema = z.object({\n  id: z.string(),\n});\n\nconst graphGroupMembershipItemSchema = z.object({\n  id: z.string(),\n});\n\nconst graphGroupMembershipResponseSchema = z.object({\n  \"@odata.nextLink\": z.string().optional(),\n  value: z.array(graphGroupMembershipItemSchema),\n});\n\nconst builtInRoleDefinitionIds = {\n  contributor: \"b24988ac-6180-42a0-ab88-20f7382dd24c\",\n  keyVaultSecretsOfficer: \"b86a8fe4-44ce-4948-aee5-eccb2c155cd7\",\n  owner: \"8e3af657-a8ff-443c-a75c-2fe8c4bcb635\",\n  roleBasedAccessControlAdministrator: \"f58310d9-a9f6-439a-9e8d-f62e7b41a168\",\n  storageBlobDataContributor: \"ba92f5b4-2d11-453d-a403-e96b0029c9fe\",\n} as const;\n\nconst bootstrapIdentityRoleDefinitionIds = [\n  // These roles let the bootstrap identity run the bootstrapper module from GitHub Actions without extra manual grants.\n  builtInRoleDefinitionIds.roleBasedAccessControlAdministrator,\n  builtInRoleDefinitionIds.contributor,\n  builtInRoleDefinitionIds.storageBlobDataContributor,\n] as const;\n\nexport class AzureCloudAccountService implements CloudAccountService {\n  #credential: TokenCredential;\n  #requiredResourceProviders = [\n    \"Microsoft.Advisor\",\n    \"Microsoft.AlertsManagement\",\n    \"Microsoft.ApiManagement\",\n    \"Microsoft.App\",\n    \"Microsoft.Authorization\",\n    \"Microsoft.AzureTerraform\",\n    \"Microsoft.Cache\",\n    \"Microsoft.Cdn\",\n    \"Microsoft.ContainerInstance\",\n    \"Microsoft.CostManagement\",\n    \"Microsoft.DBforPostgreSQL\",\n    \"Microsoft.KeyVault\",\n    \"Microsoft.ServiceBus\",\n    \"Microsoft.Sql\",\n    \"Microsoft.Storage\",\n    \"Microsoft.Web\",\n  ] as const;\n  #resourceGraphClient: ResourceGraphClient;\n\n  constructor(credential: TokenCredential) {\n    this.#resourceGraphClient = new ResourceGraphClient(credential);\n    this.#credential = credential;\n  }\n\n  async getTerraformBackend(\n    cloudAccountId: CloudAccount[\"id\"],\n    { name, prefix }: EnvironmentId,\n  ): Promise<TerraformBackend | undefined> {\n    const allLocations = Object.values(locationShort).join(\"|\");\n    const shortEnv = environmentShort[name];\n    // Check if a storage account with the expected name exists\n    // $prefix + environment short + location + \"tfstatest\" + suffix (e.g., \"dxpitntfstatest01\")\n    // it can return multiple results (e.g. for different location or instance number)\n    const resourceName = `${prefix}${shortEnv}(${allLocations})tfstatest(0[1-9]|[1-9]\\\\d)`;\n    const query = `resources\n             | where type == 'microsoft.storage/storageaccounts'\n             | where name matches regex @'${resourceName}'\n            `;\n    const result = await this.#resourceGraphClient.resources({\n      query,\n      subscriptions: [cloudAccountId],\n    });\n    if (result.totalRecords === 0) {\n      return undefined;\n    }\n    const storageAccounts = z.array(resourceGraphDataSchema).parse(result.data);\n    // on multiple results, rank storage accounts by location priority and instance number\n    if (storageAccounts.length > 0) {\n      storageAccounts.sort((a, b) => {\n        // compare locations priority\n        const locationComparison =\n          locations.indexOf(a.location) - locations.indexOf(b.location);\n        if (locationComparison === 0) {\n          // same location, compare by name (to get the highest instance number)\n          return b.name.localeCompare(a.name);\n        }\n        return locationComparison;\n      });\n    }\n    return terraformBackendSchema.parse({\n      resourceGroupName: storageAccounts[0].resourceGroup,\n      storageAccountName: storageAccounts[0].name,\n      subscriptionId: cloudAccountId,\n      type: \"azurerm\",\n    });\n  }\n\n  async hasUserPermissionToInitialize(\n    cloudAccountId: CloudAccount[\"id\"],\n  ): Promise<boolean> {\n    try {\n      // All principal IDs to check (user + all groups)\n      const allPrincipalIds = await this.#getCurrentPrincipalIds();\n\n      // Get role assignments for the subscription\n      const authClient = new AuthorizationManagementClient(\n        this.#credential,\n        cloudAccountId,\n      );\n\n      const requiredRoles = [\n        builtInRoleDefinitionIds.owner, // Owner\n        builtInRoleDefinitionIds.storageBlobDataContributor, // Storage Blob Data Contributor\n        builtInRoleDefinitionIds.keyVaultSecretsOfficer, // Key Vault Secrets Officer\n      ];\n\n      const scope = `/subscriptions/${cloudAccountId}`;\n\n      // Collect all role definition IDs assigned to the user or their groups\n      const assignedRoleDefinitionIds = new Set<string>();\n\n      for await (const assignment of authClient.roleAssignments.listForScope(\n        scope,\n      )) {\n        // Check if this assignment is for the user or any of their groups\n        if (\n          assignment.principalId &&\n          allPrincipalIds.has(assignment.principalId)\n        ) {\n          // Extract role definition ID from the full resource ID\n          // Format: /subscriptions/{sub}/providers/Microsoft.Authorization/roleDefinitions/{roleId}\n          const roleDefId = assignment.roleDefinitionId?.split(\"/\").pop();\n          if (roleDefId) {\n            assignedRoleDefinitionIds.add(roleDefId);\n          }\n        }\n\n        // Short-circuit: stop if all required roles have been found\n        if (\n          requiredRoles.every((requiredRole) =>\n            assignedRoleDefinitionIds.has(requiredRole),\n          )\n        ) {\n          return true;\n        }\n      }\n\n      // Check if all required roles are present\n      const hasAllRoles = requiredRoles.every((requiredRole) =>\n        assignedRoleDefinitionIds.has(requiredRole),\n      );\n\n      return hasAllRoles;\n    } catch (error: unknown) {\n      // Handle authorization errors (403 Forbidden) - user lacks permissions\n      if (\n        error &&\n        typeof error === \"object\" &&\n        \"statusCode\" in error &&\n        error.statusCode === 403\n      ) {\n        return false;\n      }\n      // Re-throw other errors\n      throw error;\n    }\n  }\n\n  async initialize(\n    cloudAccount: CloudAccount,\n    { name, prefix }: EnvironmentId,\n    runnerAppCredentials: GitHubAppCredentials,\n    github: GitHubRepo,\n    gitHubService: GitHubService,\n    tags: Record<string, string> = {},\n  ): Promise<void> {\n    assert.equal(cloudAccount.csp, \"azure\", \"Cloud account must be Azure\");\n    assert.ok(\n      isAzureLocation(cloudAccount.defaultLocation),\n      \"The default location of the cloud account is not a valid Azure location\",\n    );\n\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    // Register required resource providers before creating any resources\n    await this.#registerProviders(cloudAccount.id);\n\n    const resourceManagementClient = new ResourceManagementClient(\n      this.#credential,\n      cloudAccount.id,\n    );\n\n    const short = {\n      env: environmentShort[name],\n      location: locationShort[cloudAccount.defaultLocation],\n    };\n\n    const resourceGroupName = `${prefix}-${short.env}-${short.location}-common-rg-01`;\n\n    const parameters = {\n      location: cloudAccount.defaultLocation,\n      tags: {\n        CreatedBy: \"DX CLI\",\n        Environment: name,\n        ...tags,\n      },\n    };\n\n    await resourceManagementClient.resourceGroups.createOrUpdate(\n      resourceGroupName,\n      parameters,\n    );\n\n    logger.debug(\n      \"Created resource group {resourceGroupName} in subscription {subscriptionId}\",\n      { resourceGroupName, subscriptionId: cloudAccount.id },\n    );\n\n    try {\n      const identityName = `${prefix}-${short.env}-${short.location}-bootstrap-id-01`;\n\n      const msiClient = new ManagedServiceIdentityClient(\n        this.#credential,\n        cloudAccount.id,\n      );\n\n      const identity = await msiClient.userAssignedIdentities.createOrUpdate(\n        resourceGroupName,\n        identityName,\n        parameters,\n      );\n\n      assert.ok(\n        identity.principalId,\n        \"Managed identity principal ID is undefined\",\n      );\n      const identityPrincipalId = identity.principalId;\n      assert.ok(identity.clientId, \"Managed identity client ID is undefined\");\n      const identityClientId = identity.clientId;\n\n      logger.debug(\n        \"Created identity {identityName} in subscription {subscriptionId}\",\n        { identityName, subscriptionId: cloudAccount.id },\n      );\n\n      const authorizationManagementClient = new AuthorizationManagementClient(\n        this.#credential,\n        cloudAccount.id,\n      );\n      const subscriptionClient = new SubscriptionClient(this.#credential);\n      const subscription = await subscriptionClient.subscriptions.get(\n        cloudAccount.id,\n      );\n      assert.ok(subscription.tenantId, \"Subscription tenant ID is undefined\");\n      const tenantId = subscription.tenantId;\n      const subscriptionScope = `/subscriptions/${cloudAccount.id}`;\n\n      // Grant the bootstrap identity the Azure permissions it needs to operate autonomously in the bootstrap workflow.\n      await Promise.all(\n        bootstrapIdentityRoleDefinitionIds.map((roleDefinitionId) =>\n          authorizationManagementClient.roleAssignments.create(\n            subscriptionScope,\n            this.#createRoleAssignmentName(\n              subscriptionScope,\n              identityPrincipalId,\n              roleDefinitionId,\n            ),\n            {\n              principalId: identityPrincipalId,\n              principalType: \"ServicePrincipal\",\n              roleDefinitionId: this.#createRoleDefinitionResourceId(\n                cloudAccount.id,\n                roleDefinitionId,\n              ),\n            },\n          ),\n        ),\n      );\n\n      logger.debug(\n        \"Assigned bootstrap roles to identity {identityName} in subscription {subscriptionId}\",\n        { identityName, subscriptionId: cloudAccount.id },\n      );\n\n      const githubEnvironmentName = `bootstrapper-${name}-cd`;\n      const federatedCredentialName = this.#createFederatedCredentialName({\n        github,\n        githubEnvironmentName,\n      });\n\n      // Include a repository-derived suffix so different repositories can share\n      // the same bootstrap identity without overwriting each other's OIDC trust.\n      await msiClient.federatedIdentityCredentials.createOrUpdate(\n        resourceGroupName,\n        identityName,\n        federatedCredentialName,\n        {\n          audiences: [\"api://AzureADTokenExchange\"],\n          issuer: \"https://token.actions.githubusercontent.com\",\n          subject: `repo:${github.owner}/${github.repo}:environment:${githubEnvironmentName}`,\n        },\n      );\n\n      logger.debug(\n        \"Configured federated identity credential {credentialName} for identity {identityName} in subscription {subscriptionId}\",\n        {\n          credentialName: federatedCredentialName,\n          identityName,\n          subscriptionId: cloudAccount.id,\n        },\n      );\n\n      await this.#storeBootstrapperEnvironmentSecrets({\n        cloudAccountId: cloudAccount.id,\n        github,\n        githubEnvironmentName,\n        gitHubService,\n        identityClientId,\n        runnerAppCredentials,\n        tenantId,\n      });\n\n      const keyVaultName = await this.#createCommonKeyVault({\n        cloudAccount,\n        name,\n        prefix,\n        resourceGroupName,\n        shortEnv: short.env,\n        shortLocation: short.location,\n        tags,\n        tenantId,\n      });\n\n      await this.#storeRunnerAppSecrets({\n        cloudAccountId: cloudAccount.id,\n        keyVaultName,\n        runnerAppCredentials,\n      });\n    } catch (cause) {\n      // Cleanup resource group if initialization fails\n      await resourceManagementClient.resourceGroups.beginDeleteAndWait(\n        resourceGroupName,\n      );\n      logger.debug(\n        \"Deleted resource group {resourceGroupName} in subscription {subscriptionId} due to initialization failure\",\n        { resourceGroupName, subscriptionId: cloudAccount.id },\n      );\n      if (cause instanceof Error) {\n        logger.error(cause.message);\n      }\n      throw new Error(`Error during the initialization of the cloud account`, {\n        cause,\n      });\n    }\n  }\n\n  async isInitialized(\n    cloudAccountId: CloudAccount[\"id\"],\n    { name, prefix }: EnvironmentId,\n  ): Promise<boolean> {\n    const allLocations = Object.values(locationShort).join(\"|\");\n    const shortEnv = environmentShort[name];\n\n    const identityResourceName = `${prefix}-${shortEnv}-(${allLocations})-bootstrap-id-(0[1-9]|[1-9]\\\\d)`;\n    const identityQuery = `resources\n             | where type == 'microsoft.managedidentity/userassignedidentities'\n             | where name matches regex @'${identityResourceName}'\n            `;\n\n    const keyVaultResourceName = `${prefix}-${shortEnv}-(${allLocations})-common-kv-(0[1-9]|[1-9]\\\\d)`;\n    const keyVaultQuery = `resources\n             | where type == 'microsoft.keyvault/vaults'\n             | where name matches regex @'${keyVaultResourceName}'\n            `;\n\n    const [identityResult, keyVaultResult, areProvidersRegistered] =\n      await Promise.all([\n        this.#resourceGraphClient.resources({\n          query: identityQuery,\n          subscriptions: [cloudAccountId],\n        }),\n        this.#resourceGraphClient.resources({\n          query: keyVaultQuery,\n          subscriptions: [cloudAccountId],\n        }),\n        this.#areProvidersRegistered(cloudAccountId),\n      ]);\n\n    const initialized =\n      identityResult.totalRecords > 0 &&\n      keyVaultResult.totalRecords > 0 &&\n      areProvidersRegistered;\n\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    logger.debug(\"subscription {subscriptionId} initialized: {initialized}\", {\n      initialized,\n      subscriptionId: cloudAccountId,\n    });\n\n    return initialized;\n  }\n\n  async provisionTerraformBackend(\n    cloudAccount: CloudAccount,\n    { name, prefix }: EnvironmentId,\n    tags: Record<string, string> = {},\n  ): Promise<TerraformBackend> {\n    assert.equal(cloudAccount.csp, \"azure\", \"Cloud account must be Azure\");\n    assert.ok(\n      isAzureLocation(cloudAccount.defaultLocation),\n      \"The default location of the cloud account is not a valid Azure location\",\n    );\n\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    const resourceManagementClient = new ResourceManagementClient(\n      this.#credential,\n      cloudAccount.id,\n    );\n\n    const short = {\n      env: environmentShort[name],\n      location: locationShort[cloudAccount.defaultLocation],\n    };\n\n    const parameters = {\n      location: cloudAccount.defaultLocation,\n      tags: {\n        Environment: name,\n        ...tags,\n      },\n    };\n\n    const resourceGroupName = `${prefix}-${short.env}-${short.location}-tfstate-rg-01`;\n\n    await resourceManagementClient.resourceGroups.createOrUpdate(\n      resourceGroupName,\n      parameters,\n    );\n\n    logger.debug(\n      \"Created resource group {resourceGroupName} in subscription {subscriptionId}\",\n      { resourceGroupName, subscriptionId: cloudAccount.id },\n    );\n\n    const storageManagementClient = new StorageManagementClient(\n      this.#credential,\n      cloudAccount.id,\n    );\n\n    const storageAccount =\n      await storageManagementClient.storageAccounts.beginCreateAndWait(\n        resourceGroupName,\n        `${prefix}${short.env}${short.location}tfstatest01`,\n        {\n          kind: \"StorageV2\",\n          sku: {\n            name: \"Standard_LRS\",\n            tier: \"Standard\",\n          },\n          ...parameters,\n        },\n      );\n\n    assert.ok(\n      storageAccount.primaryEndpoints?.blob,\n      \"Storage account blob endpoint is undefined\",\n    );\n\n    assert.ok(storageAccount.name, \"Storage account name is undefined\");\n\n    logger.debug(\n      \"Created storage account {storageAccountName} in subscription {subscriptionId}\",\n      {\n        storageAccountName: storageAccount.name,\n        subscriptionId: cloudAccount.id,\n      },\n    );\n    const blobServiceClient = new BlobServiceClient(\n      storageAccount.primaryEndpoints?.blob,\n      this.#credential,\n    );\n\n    const containerClient =\n      blobServiceClient.getContainerClient(\"terraform-state\");\n\n    try {\n      await containerClient.create();\n    } catch (e) {\n      // Cleanup resource group if blob container creation fails\n      // resource group deletion also deletes all contained resources\n      await resourceManagementClient.resourceGroups.beginDeleteAndWait(\n        resourceGroupName,\n      );\n      throw new Error(`Error during the creation of the blob container`, {\n        cause: e,\n      });\n    }\n\n    return terraformBackendSchema.parse({\n      resourceGroupName,\n      storageAccountName: storageAccount.name,\n      subscriptionId: cloudAccount.id,\n      type: \"azurerm\",\n    });\n  }\n\n  async #areProvidersRegistered(subscriptionId: string): Promise<boolean> {\n    const client = new ResourceManagementClient(\n      this.#credential,\n      subscriptionId,\n    );\n    const results = await Promise.all(\n      this.#requiredResourceProviders.map(async (namespace) => {\n        const provider = await client.providers.get(namespace);\n        return provider.registrationState === \"Registered\";\n      }),\n    );\n    return results.every(Boolean);\n  }\n\n  async #createCommonKeyVault({\n    cloudAccount,\n    name,\n    prefix,\n    resourceGroupName,\n    shortEnv,\n    shortLocation,\n    tags,\n    tenantId,\n  }: {\n    cloudAccount: CloudAccount;\n    name: EnvironmentId[\"name\"];\n    prefix: string;\n    resourceGroupName: string;\n    shortEnv: string;\n    shortLocation: string;\n    tags: Record<string, string>;\n    tenantId: string;\n  }): Promise<string> {\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    const kvClient = new KeyVaultManagementClient(\n      this.#credential,\n      cloudAccount.id,\n    );\n\n    const keyVaultName = `${prefix}-${shortEnv}-${shortLocation}-common-kv-01`;\n    const secretsProtectionEnabled = shortEnv === \"p\";\n\n    const result = await kvClient.vaults.checkNameAvailability({\n      name: keyVaultName,\n      type: \"Microsoft.KeyVault/vaults\",\n    });\n\n    await kvClient.vaults.beginCreateOrUpdateAndWait(\n      resourceGroupName,\n      keyVaultName,\n      {\n        location: cloudAccount.defaultLocation,\n        properties: {\n          createMode: result.nameAvailable ? \"default\" : \"recover\",\n          enabledForDiskEncryption: true,\n          enablePurgeProtection: secretsProtectionEnabled ? true : undefined,\n          enableRbacAuthorization: true,\n          sku: {\n            family: \"A\",\n            name: \"standard\",\n          },\n          softDeleteRetentionInDays: secretsProtectionEnabled ? 14 : 7,\n          tenantId,\n        },\n        tags: {\n          Environment: name,\n          ...tags,\n        },\n      },\n    );\n\n    logger.debug(\n      \"Created key vault {keyVaultName} in subscription {subscriptionId}\",\n      { keyVaultName, subscriptionId: cloudAccount.id },\n    );\n\n    return keyVaultName;\n  }\n\n  #createFederatedCredentialName({\n    github,\n    githubEnvironmentName,\n  }: {\n    github: GitHubRepo;\n    githubEnvironmentName: string;\n  }): string {\n    const repoName = github.repo.replaceAll(/[^a-zA-Z0-9-]/g, \"-\");\n\n    return `${repoName}-${githubEnvironmentName}`;\n  }\n\n  #createRoleAssignmentName(\n    scope: string,\n    principalId: string,\n    roleDefinitionId: string,\n  ): string {\n    const hash = createHash(\"sha256\")\n      .update(`${scope}:${principalId}:${roleDefinitionId}`)\n      .digest(\"hex\");\n\n    return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(\n      12,\n      16,\n    )}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;\n  }\n\n  #createRoleDefinitionResourceId(\n    subscriptionId: string,\n    roleDefinitionId: string,\n  ): string {\n    return `/subscriptions/${subscriptionId}/providers/Microsoft.Authorization/roleDefinitions/${roleDefinitionId}`;\n  }\n\n  async #getCurrentPrincipalIds(): Promise<Set<string>> {\n    // Create Graph client with custom auth provider that fetches fresh tokens\n    const graphClient = Client.init({\n      authProvider: async (done) => {\n        try {\n          const tokenResponse = await this.#credential.getToken(\n            \"https://graph.microsoft.com/.default\",\n          );\n          if (!tokenResponse) {\n            done(\n              new Error(\"Failed to acquire token for Microsoft Graph\"),\n              null,\n            );\n            return;\n          }\n          done(null, tokenResponse.token);\n        } catch (error) {\n          done(error as Error, null);\n        }\n      },\n    });\n\n    // Get current user's info\n    const meResponse = await graphClient.api(\"/me\").get();\n    const me = graphUserResponseSchema.parse(meResponse);\n    const userObjectId = me.id;\n\n    // Get all group memberships (transitive - includes nested groups)\n    const groupIds: string[] = [];\n    let nextLink: string | undefined = \"/me/transitiveMemberOf?$select=id\";\n\n    while (nextLink) {\n      const rawResponse = await graphClient.api(nextLink).get();\n      const response = graphGroupMembershipResponseSchema.parse(rawResponse);\n      for (const item of response.value) {\n        groupIds.push(item.id);\n      }\n      nextLink = response[\"@odata.nextLink\"];\n    }\n\n    // All principal IDs to check (user + all groups)\n    const allPrincipalIds = new Set([userObjectId, ...groupIds]);\n    return allPrincipalIds;\n  }\n\n  async #registerProviders(subscriptionId: string): Promise<void> {\n    const logger = getLogger([\"dx-cli\", \"register-providers\"]);\n    const client = new ResourceManagementClient(\n      this.#credential,\n      subscriptionId,\n    );\n\n    logger.info(\n      \"Registering {count} resource providers on subscription {subscriptionId}\",\n      { count: this.#requiredResourceProviders.length, subscriptionId },\n    );\n\n    await Promise.all(\n      this.#requiredResourceProviders.map(async (namespace) => {\n        await client.providers.register(namespace);\n        logger.debug(\"Registered provider {namespace}\", { namespace });\n      }),\n    );\n\n    logger.info(\n      \"All resource providers registered on subscription {subscriptionId}\",\n      { subscriptionId },\n    );\n  }\n\n  async #storeBootstrapperEnvironmentSecrets({\n    cloudAccountId,\n    github,\n    githubEnvironmentName,\n    gitHubService,\n    identityClientId,\n    runnerAppCredentials,\n    tenantId,\n  }: {\n    cloudAccountId: string;\n    github: GitHubRepo;\n    githubEnvironmentName: string;\n    gitHubService: GitHubService;\n    identityClientId: string;\n    runnerAppCredentials: GitHubAppCredentials;\n    tenantId: string;\n  }): Promise<void> {\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    await Promise.all([\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"ARM_CLIENT_ID\",\n        secretValue: identityClientId,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"ARM_TENANT_ID\",\n        secretValue: tenantId,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"ARM_SUBSCRIPTION_ID\",\n        secretValue: cloudAccountId,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"GH_APP_ID\",\n        secretValue: runnerAppCredentials.id,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"GH_APP_CLIENT_ID\",\n        secretValue: runnerAppCredentials.clientId,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"GH_APP_INSTALLATION_ID\",\n        secretValue: runnerAppCredentials.installationId,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"GH_APP_KEY\",\n        secretValue: runnerAppCredentials.key.trimEnd(),\n      }),\n    ]);\n\n    logger.debug(\"Set GitHub environment secrets for {environmentName}\", {\n      environmentName: githubEnvironmentName,\n      subscriptionId: cloudAccountId,\n    });\n  }\n\n  async #storeRunnerAppSecrets({\n    cloudAccountId,\n    keyVaultName,\n    runnerAppCredentials,\n  }: {\n    cloudAccountId: string;\n    keyVaultName: string;\n    runnerAppCredentials: GitHubAppCredentials;\n  }): Promise<void> {\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    const secretClient = new SecretClient(\n      `https://${keyVaultName}.vault.azure.net/`,\n      this.#credential,\n    );\n\n    await Promise.all([\n      secretClient.setSecret(\"github-runner-app-id\", runnerAppCredentials.id),\n      secretClient.setSecret(\n        \"github-runner-app-installation-id\",\n        runnerAppCredentials.installationId,\n      ),\n      secretClient.setSecret(\n        \"github-runner-app-key\",\n        runnerAppCredentials.key.trimEnd(), // strip trailing newlines from PEM keys\n      ),\n    ]);\n\n    logger.debug(\n      \"Created secrets in key vault {keyVaultName} in subscription {subscriptionId}\",\n      { keyVaultName, subscriptionId: cloudAccountId },\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-account-service.js","sourceRoot":"","sources":["../../../src/adapters/azure/cloud-account-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,mCAAmC,CAAC;AAC3D,OAAO,KAAK,MAAM,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,UAAU,IAAI,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAM3B,OAAO,EAEL,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,sBAAsB,GACvB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE3E,sDAAsD;AACtD,sEAAsE;AACtE,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;IAC3B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;CAC1B,CAAC,CAAC;AAEH,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;CACf,CAAC,CAAC;AAEH,MAAM,8BAA8B,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;CACf,CAAC,CAAC;AAEH,MAAM,kCAAkC,GAAG,CAAC,CAAC,MAAM,CAAC;IAClD,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACxC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,8BAA8B,CAAC;CAC/C,CAAC,CAAC;AAEH,MAAM,wBAAwB,GAAG;IAC/B,WAAW,EAAE,sCAAsC;IACnD,sBAAsB,EAAE,sCAAsC;IAC9D,KAAK,EAAE,sCAAsC;IAC7C,mCAAmC,EAAE,sCAAsC;IAC3E,0BAA0B,EAAE,sCAAsC;CAC1D,CAAC;AAEX,MAAM,kCAAkC,GAAG;IACzC,sHAAsH;IACtH,wBAAwB,CAAC,mCAAmC;IAC5D,wBAAwB,CAAC,WAAW;IACpC,wBAAwB,CAAC,0BAA0B;CAC3C,CAAC;AAEX,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;CACzC,CAAC,CAAC;AACH,MAAM,2BAA2B,GAAG,EAAE,CAAC;AACvC,MAAM,4BAA4B,GAAG,MAAM,CAAC;AAE5C,MAAM,OAAO,wBAAwB;IACnC,WAAW,CAAkB;IAC7B,0BAA0B,GAAG;QAC3B,mBAAmB;QACnB,4BAA4B;QAC5B,yBAAyB;QACzB,eAAe;QACf,yBAAyB;QACzB,0BAA0B;QAC1B,iBAAiB;QACjB,eAAe;QACf,6BAA6B;QAC7B,0BAA0B;QAC1B,2BAA2B;QAC3B,oBAAoB;QACpB,sBAAsB;QACtB,eAAe;QACf,mBAAmB;QACnB,eAAe;KACP,CAAC;IACX,oBAAoB,CAAsB;IAE1C,YAAY,UAA2B;QACrC,IAAI,CAAC,oBAAoB,GAAG,IAAI,mBAAmB,CAAC,UAAU,CAAC,CAAC;QAChE,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;IAChC,CAAC;IAED,KAAK,CAAC,mBAAmB,CACvB,cAAkC,EAClC,EAAE,IAAI,EAAE,MAAM,EAAiB;QAE/B,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC5D,MAAM,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACxC,2DAA2D;QAC3D,4FAA4F;QAC5F,kFAAkF;QAClF,MAAM,YAAY,GAAG,GAAG,MAAM,GAAG,QAAQ,IAAI,YAAY,6BAA6B,CAAC;QACvF,MAAM,KAAK,GAAG;;4CAE0B,YAAY;aAC3C,CAAC;QACV,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC;YACvD,KAAK;YACL,aAAa,EAAE,CAAC,cAAc,CAAC;SAChC,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,YAAY,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC5E,sFAAsF;QACtF,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;gBAC5B,6BAA6B;gBAC7B,MAAM,kBAAkB,GACtB,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;gBAChE,IAAI,kBAAkB,KAAK,CAAC,EAAE,CAAC;oBAC7B,sEAAsE;oBACtE,OAAO,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;gBACtC,CAAC;gBACD,OAAO,kBAAkB,CAAC;YAC5B,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,sBAAsB,CAAC,KAAK,CAAC;YAClC,iBAAiB,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,aAAa;YACnD,kBAAkB,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,IAAI;YAC3C,cAAc,EAAE,cAAc;YAC9B,IAAI,EAAE,SAAS;SAChB,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,6BAA6B,CACjC,cAAkC;QAElC,IAAI,CAAC;YACH,iDAAiD;YACjD,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAE7D,4CAA4C;YAC5C,MAAM,UAAU,GAAG,IAAI,6BAA6B,CAClD,IAAI,CAAC,WAAW,EAChB,cAAc,CACf,CAAC;YAEF,MAAM,aAAa,GAAG;gBACpB,wBAAwB,CAAC,KAAK,EAAE,QAAQ;gBACxC,wBAAwB,CAAC,0BAA0B,EAAE,gCAAgC;gBACrF,wBAAwB,CAAC,sBAAsB,EAAE,4BAA4B;aAC9E,CAAC;YAEF,MAAM,KAAK,GAAG,kBAAkB,cAAc,EAAE,CAAC;YAEjD,uEAAuE;YACvE,MAAM,yBAAyB,GAAG,IAAI,GAAG,EAAU,CAAC;YAEpD,IAAI,KAAK,EAAE,MAAM,UAAU,IAAI,UAAU,CAAC,eAAe,CAAC,YAAY,CACpE,KAAK,CACN,EAAE,CAAC;gBACF,kEAAkE;gBAClE,IACE,UAAU,CAAC,WAAW;oBACtB,eAAe,CAAC,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,EAC3C,CAAC;oBACD,uDAAuD;oBACvD,0FAA0F;oBAC1F,MAAM,SAAS,GAAG,UAAU,CAAC,gBAAgB,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;oBAChE,IAAI,SAAS,EAAE,CAAC;wBACd,yBAAyB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;oBAC3C,CAAC;gBACH,CAAC;gBAED,4DAA4D;gBAC5D,IACE,aAAa,CAAC,KAAK,CAAC,CAAC,YAAY,EAAE,EAAE,CACnC,yBAAyB,CAAC,GAAG,CAAC,YAAY,CAAC,CAC5C,EACD,CAAC;oBACD,OAAO,IAAI,CAAC;gBACd,CAAC;YACH,CAAC;YAED,0CAA0C;YAC1C,MAAM,WAAW,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,YAAY,EAAE,EAAE,CACvD,yBAAyB,CAAC,GAAG,CAAC,YAAY,CAAC,CAC5C,CAAC;YAEF,OAAO,WAAW,CAAC;QACrB,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,uEAAuE;YACvE,IACE,KAAK;gBACL,OAAO,KAAK,KAAK,QAAQ;gBACzB,YAAY,IAAI,KAAK;gBACrB,KAAK,CAAC,UAAU,KAAK,GAAG,EACxB,CAAC;gBACD,OAAO,KAAK,CAAC;YACf,CAAC;YACD,wBAAwB;YACxB,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED,KAAK,CAAC,UAAU,CACd,YAA0B,EAC1B,EAAE,IAAI,EAAE,MAAM,EAAiB,EAC/B,oBAA0C,EAC1C,MAAkB,EAClB,aAA4B,EAC5B,OAA+B,EAAE;QAEjC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,6BAA6B,CAAC,CAAC;QACvE,MAAM,CAAC,EAAE,CACP,eAAe,CAAC,YAAY,CAAC,eAAe,CAAC,EAC7C,yEAAyE,CAC1E,CAAC;QAEF,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;QAEzC,qEAAqE;QACrE,MAAM,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;QAE/C,MAAM,wBAAwB,GAAG,IAAI,wBAAwB,CAC3D,IAAI,CAAC,WAAW,EAChB,YAAY,CAAC,EAAE,CAChB,CAAC;QAEF,MAAM,KAAK,GAAG;YACZ,GAAG,EAAE,gBAAgB,CAAC,IAAI,CAAC;YAC3B,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,eAAe,CAAC;SACtD,CAAC;QAEF,MAAM,iBAAiB,GAAG,GAAG,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,QAAQ,eAAe,CAAC;QAElF,MAAM,UAAU,GAAG;YACjB,QAAQ,EAAE,YAAY,CAAC,eAAe;YACtC,IAAI,EAAE;gBACJ,SAAS,EAAE,QAAQ;gBACnB,WAAW,EAAE,IAAI;gBACjB,GAAG,IAAI;aACR;SACF,CAAC;QAEF,MAAM,wBAAwB,CAAC,cAAc,CAAC,cAAc,CAC1D,iBAAiB,EACjB,UAAU,CACX,CAAC;QAEF,MAAM,CAAC,KAAK,CACV,6EAA6E,EAC7E,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,CAAC,EAAE,EAAE,CACvD,CAAC;QAEF,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,GAAG,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,QAAQ,kBAAkB,CAAC;YAEhF,MAAM,SAAS,GAAG,IAAI,4BAA4B,CAChD,IAAI,CAAC,WAAW,EAChB,YAAY,CAAC,EAAE,CAChB,CAAC;YAEF,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,sBAAsB,CAAC,cAAc,CACpE,iBAAiB,EACjB,YAAY,EACZ,UAAU,CACX,CAAC;YAEF,MAAM,CAAC,EAAE,CACP,QAAQ,CAAC,WAAW,EACpB,4CAA4C,CAC7C,CAAC;YACF,MAAM,mBAAmB,GAAG,QAAQ,CAAC,WAAW,CAAC;YACjD,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,yCAAyC,CAAC,CAAC;YACxE,MAAM,gBAAgB,GAAG,QAAQ,CAAC,QAAQ,CAAC;YAE3C,MAAM,CAAC,KAAK,CACV,kEAAkE,EAClE,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,CAAC,EAAE,EAAE,CAClD,CAAC;YAEF,MAAM,6BAA6B,GAAG,IAAI,6BAA6B,CACrE,IAAI,CAAC,WAAW,EAChB,YAAY,CAAC,EAAE,CAChB,CAAC;YACF,MAAM,kBAAkB,GAAG,IAAI,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACpE,MAAM,YAAY,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,GAAG,CAC7D,YAAY,CAAC,EAAE,CAChB,CAAC;YACF,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,qCAAqC,CAAC,CAAC;YACxE,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC;YACvC,MAAM,iBAAiB,GAAG,kBAAkB,YAAY,CAAC,EAAE,EAAE,CAAC;YAE9D,iHAAiH;YACjH,MAAM,OAAO,CAAC,GAAG,CACf,kCAAkC,CAAC,GAAG,CAAC,CAAC,gBAAgB,EAAE,EAAE,CAC1D,6BAA6B,CAAC,eAAe,CAAC,MAAM,CAClD,iBAAiB,EACjB,IAAI,CAAC,yBAAyB,CAC5B,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,CACjB,EACD;gBACE,WAAW,EAAE,mBAAmB;gBAChC,aAAa,EAAE,kBAAkB;gBACjC,gBAAgB,EAAE,IAAI,CAAC,+BAA+B,CACpD,YAAY,CAAC,EAAE,EACf,gBAAgB,CACjB;aACF,CACF,CACF,CACF,CAAC;YAEF,MAAM,CAAC,KAAK,CACV,sFAAsF,EACtF,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,CAAC,EAAE,EAAE,CAClD,CAAC;YAEF,MAAM,qBAAqB,GAAG,gBAAgB,IAAI,KAAK,CAAC;YACxD,MAAM,uBAAuB,GAAG,IAAI,CAAC,8BAA8B,CAAC;gBAClE,MAAM;gBACN,qBAAqB;aACtB,CAAC,CAAC;YAEH,0EAA0E;YAC1E,2EAA2E;YAC3E,MAAM,SAAS,CAAC,4BAA4B,CAAC,cAAc,CACzD,iBAAiB,EACjB,YAAY,EACZ,uBAAuB,EACvB;gBACE,SAAS,EAAE,CAAC,4BAA4B,CAAC;gBACzC,MAAM,EAAE,6CAA6C;gBACrD,OAAO,EAAE,QAAQ,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,gBAAgB,qBAAqB,EAAE;aACpF,CACF,CAAC;YAEF,MAAM,CAAC,KAAK,CACV,wHAAwH,EACxH;gBACE,cAAc,EAAE,uBAAuB;gBACvC,YAAY;gBACZ,cAAc,EAAE,YAAY,CAAC,EAAE;aAChC,CACF,CAAC;YAEF,MAAM,IAAI,CAAC,oCAAoC,CAAC;gBAC9C,cAAc,EAAE,YAAY,CAAC,EAAE;gBAC/B,MAAM;gBACN,qBAAqB;gBACrB,aAAa;gBACb,gBAAgB;gBAChB,oBAAoB;gBACpB,QAAQ;aACT,CAAC,CAAC;YAEH,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC;gBACpD,YAAY;gBACZ,IAAI;gBACJ,MAAM;gBACN,iBAAiB;gBACjB,QAAQ,EAAE,KAAK,CAAC,GAAG;gBACnB,aAAa,EAAE,KAAK,CAAC,QAAQ;gBAC7B,IAAI;gBACJ,QAAQ;aACT,CAAC,CAAC;YAEH,MAAM,IAAI,CAAC,sBAAsB,CAAC;gBAChC,cAAc,EAAE,YAAY,CAAC,EAAE;gBAC/B,YAAY;gBACZ,oBAAoB;aACrB,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,iDAAiD;YACjD,MAAM,wBAAwB,CAAC,cAAc,CAAC,kBAAkB,CAC9D,iBAAiB,CAClB,CAAC;YACF,MAAM,CAAC,KAAK,CACV,2GAA2G,EAC3G,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,CAAC,EAAE,EAAE,CACvD,CAAC;YACF,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;gBAC3B,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAC9B,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,sDAAsD,EAAE;gBACtE,KAAK;aACN,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,KAAK,CAAC,aAAa,CACjB,cAAkC,EAClC,EAAE,IAAI,EAAE,MAAM,EAAiB;QAE/B,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC5D,MAAM,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAExC,MAAM,oBAAoB,GAAG,GAAG,MAAM,IAAI,QAAQ,KAAK,YAAY,kCAAkC,CAAC;QACtG,MAAM,aAAa,GAAG;;4CAEkB,oBAAoB;aACnD,CAAC;QAEV,MAAM,oBAAoB,GAAG,GAAG,MAAM,IAAI,QAAQ,KAAK,YAAY,+BAA+B,CAAC;QACnG,MAAM,aAAa,GAAG;;4CAEkB,oBAAoB;aACnD,CAAC;QAEV,MAAM,CAAC,cAAc,EAAE,cAAc,EAAE,sBAAsB,CAAC,GAC5D,MAAM,OAAO,CAAC,GAAG,CAAC;YAChB,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC;gBAClC,KAAK,EAAE,aAAa;gBACpB,aAAa,EAAE,CAAC,cAAc,CAAC;aAChC,CAAC;YACF,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC;gBAClC,KAAK,EAAE,aAAa;gBACpB,aAAa,EAAE,CAAC,cAAc,CAAC;aAChC,CAAC;YACF,IAAI,CAAC,uBAAuB,CAAC,cAAc,CAAC;SAC7C,CAAC,CAAC;QAEL,MAAM,WAAW,GACf,cAAc,CAAC,YAAY,GAAG,CAAC;YAC/B,cAAc,CAAC,YAAY,GAAG,CAAC;YAC/B,sBAAsB,CAAC;QAEzB,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;QAEzC,MAAM,CAAC,KAAK,CAAC,0DAA0D,EAAE;YACvE,WAAW;YACX,cAAc,EAAE,cAAc;SAC/B,CAAC,CAAC;QAEH,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,KAAK,CAAC,yBAAyB,CAC7B,YAA0B,EAC1B,EAAE,IAAI,EAAE,MAAM,EAAiB,EAC/B,OAA+B,EAAE;QAEjC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,6BAA6B,CAAC,CAAC;QACvE,MAAM,CAAC,EAAE,CACP,eAAe,CAAC,YAAY,CAAC,eAAe,CAAC,EAC7C,yEAAyE,CAC1E,CAAC;QAEF,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;QAEzC,MAAM,wBAAwB,GAAG,IAAI,wBAAwB,CAC3D,IAAI,CAAC,WAAW,EAChB,YAAY,CAAC,EAAE,CAChB,CAAC;QAEF,MAAM,KAAK,GAAG;YACZ,GAAG,EAAE,gBAAgB,CAAC,IAAI,CAAC;YAC3B,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,eAAe,CAAC;SACtD,CAAC;QAEF,MAAM,UAAU,GAAG;YACjB,QAAQ,EAAE,YAAY,CAAC,eAAe;YACtC,IAAI,EAAE;gBACJ,WAAW,EAAE,IAAI;gBACjB,GAAG,IAAI;aACR;SACF,CAAC;QAEF,MAAM,iBAAiB,GAAG,GAAG,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,QAAQ,gBAAgB,CAAC;QAEnF,MAAM,wBAAwB,CAAC,cAAc,CAAC,cAAc,CAC1D,iBAAiB,EACjB,UAAU,CACX,CAAC;QAEF,MAAM,CAAC,KAAK,CACV,6EAA6E,EAC7E,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,CAAC,EAAE,EAAE,CACvD,CAAC;QAEF,MAAM,uBAAuB,GAAG,IAAI,uBAAuB,CACzD,IAAI,CAAC,WAAW,EAChB,YAAY,CAAC,EAAE,CAChB,CAAC;QAEF,MAAM,cAAc,GAClB,MAAM,uBAAuB,CAAC,eAAe,CAAC,kBAAkB,CAC9D,iBAAiB,EACjB,GAAG,MAAM,GAAG,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,QAAQ,aAAa,EACnD;YACE,IAAI,EAAE,WAAW;YACjB,GAAG,EAAE;gBACH,IAAI,EAAE,cAAc;gBACpB,IAAI,EAAE,UAAU;aACjB;YACD,GAAG,UAAU;SACd,CACF,CAAC;QAEJ,MAAM,CAAC,EAAE,CACP,cAAc,CAAC,gBAAgB,EAAE,IAAI,EACrC,4CAA4C,CAC7C,CAAC;QAEF,MAAM,CAAC,EAAE,CAAC,cAAc,CAAC,IAAI,EAAE,mCAAmC,CAAC,CAAC;QAEpE,MAAM,CAAC,KAAK,CACV,+EAA+E,EAC/E;YACE,kBAAkB,EAAE,cAAc,CAAC,IAAI;YACvC,cAAc,EAAE,YAAY,CAAC,EAAE;SAChC,CACF,CAAC;QACF,MAAM,iBAAiB,GAAG,IAAI,iBAAiB,CAC7C,cAAc,CAAC,gBAAgB,EAAE,IAAI,EACrC,IAAI,CAAC,WAAW,CACjB,CAAC;QAEF,MAAM,eAAe,GACnB,iBAAiB,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;QAE1D,IAAI,CAAC;YACH,MAAM,eAAe,CAAC,MAAM,EAAE,CAAC;QACjC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,0DAA0D;YAC1D,+DAA+D;YAC/D,MAAM,wBAAwB,CAAC,cAAc,CAAC,kBAAkB,CAC9D,iBAAiB,CAClB,CAAC;YACF,MAAM,IAAI,KAAK,CAAC,iDAAiD,EAAE;gBACjE,KAAK,EAAE,CAAC;aACT,CAAC,CAAC;QACL,CAAC;QAED,OAAO,sBAAsB,CAAC,KAAK,CAAC;YAClC,iBAAiB;YACjB,kBAAkB,EAAE,cAAc,CAAC,IAAI;YACvC,cAAc,EAAE,YAAY,CAAC,EAAE;YAC/B,IAAI,EAAE,SAAS;SAChB,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,uBAAuB,CAAC,cAAsB;QAClD,MAAM,MAAM,GAAG,IAAI,wBAAwB,CACzC,IAAI,CAAC,WAAW,EAChB,cAAc,CACf,CAAC;QACF,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;YACtD,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACvD,OAAO,QAAQ,CAAC,iBAAiB,KAAK,YAAY,CAAC;QACrD,CAAC,CAAC,CACH,CAAC;QACF,OAAO,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;IAED,KAAK,CAAC,qBAAqB,CAAC,EAC1B,YAAY,EACZ,IAAI,EACJ,MAAM,EACN,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,IAAI,EACJ,QAAQ,GAUT;QACC,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;QAEzC,MAAM,QAAQ,GAAG,IAAI,wBAAwB,CAC3C,IAAI,CAAC,WAAW,EAChB,YAAY,CAAC,EAAE,CAChB,CAAC;QAEF,MAAM,YAAY,GAAG,GAAG,MAAM,IAAI,QAAQ,IAAI,aAAa,eAAe,CAAC;QAC3E,MAAM,wBAAwB,GAAG,QAAQ,KAAK,GAAG,CAAC;QAElD,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC,qBAAqB,CAAC;YACzD,IAAI,EAAE,YAAY;YAClB,IAAI,EAAE,2BAA2B;SAClC,CAAC,CAAC;QAEH,MAAM,QAAQ,CAAC,MAAM,CAAC,0BAA0B,CAC9C,iBAAiB,EACjB,YAAY,EACZ;YACE,QAAQ,EAAE,YAAY,CAAC,eAAe;YACtC,UAAU,EAAE;gBACV,UAAU,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;gBACxD,wBAAwB,EAAE,IAAI;gBAC9B,qBAAqB,EAAE,wBAAwB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;gBAClE,uBAAuB,EAAE,IAAI;gBAC7B,GAAG,EAAE;oBACH,MAAM,EAAE,GAAG;oBACX,IAAI,EAAE,UAAU;iBACjB;gBACD,yBAAyB,EAAE,wBAAwB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC5D,QAAQ;aACT;YACD,IAAI,EAAE;gBACJ,WAAW,EAAE,IAAI;gBACjB,GAAG,IAAI;aACR;SACF,CACF,CAAC;QAEF,MAAM,CAAC,KAAK,CACV,mEAAmE,EACnE,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,CAAC,EAAE,EAAE,CAClD,CAAC;QAEF,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,8BAA8B,CAAC,EAC7B,MAAM,EACN,qBAAqB,GAItB;QACC,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAAC;QAE/D,OAAO,GAAG,QAAQ,IAAI,qBAAqB,EAAE,CAAC;IAChD,CAAC;IAED,yBAAyB,CACvB,KAAa,EACb,WAAmB,EACnB,gBAAwB;QAExB,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC;aAC9B,MAAM,CAAC,GAAG,KAAK,IAAI,WAAW,IAAI,gBAAgB,EAAE,CAAC;aACrD,MAAM,CAAC,KAAK,CAAC,CAAC;QAEjB,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,CAC3D,EAAE,EACF,EAAE,CACH,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;IAClD,CAAC;IAED,+BAA+B,CAC7B,cAAsB,EACtB,gBAAwB;QAExB,OAAO,kBAAkB,cAAc,sDAAsD,gBAAgB,EAAE,CAAC;IAClH,CAAC;IAED,KAAK,CAAC,uBAAuB;QAC3B,0EAA0E;QAC1E,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC;YAC9B,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;gBAC3B,IAAI,CAAC;oBACH,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,CACnD,sCAAsC,CACvC,CAAC;oBACF,IAAI,CAAC,aAAa,EAAE,CAAC;wBACnB,IAAI,CACF,IAAI,KAAK,CAAC,6CAA6C,CAAC,EACxD,IAAI,CACL,CAAC;wBACF,OAAO;oBACT,CAAC;oBACD,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;gBAClC,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,CAAC,KAAc,EAAE,IAAI,CAAC,CAAC;gBAC7B,CAAC;YACH,CAAC;SACF,CAAC,CAAC;QAEH,0BAA0B;QAC1B,MAAM,UAAU,GAAG,MAAM,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC;QACtD,MAAM,EAAE,GAAG,uBAAuB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACrD,MAAM,YAAY,GAAG,EAAE,CAAC,EAAE,CAAC;QAE3B,kEAAkE;QAClE,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,IAAI,QAAQ,GAAuB,mCAAmC,CAAC;QAEvE,OAAO,QAAQ,EAAE,CAAC;YAChB,MAAM,WAAW,GAAG,MAAM,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC;YAC1D,MAAM,QAAQ,GAAG,kCAAkC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YACvE,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC;gBAClC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACzB,CAAC;YACD,QAAQ,GAAG,QAAQ,CAAC,iBAAiB,CAAC,CAAC;QACzC,CAAC;QAED,iDAAiD;QACjD,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC,CAAC,YAAY,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC;QAC7D,OAAO,eAAe,CAAC;IACzB,CAAC;IAED,KAAK,CAAC,kBAAkB,CAAC,cAAsB;QAC7C,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,QAAQ,EAAE,oBAAoB,CAAC,CAAC,CAAC;QAC3D,MAAM,MAAM,GAAG,IAAI,wBAAwB,CACzC,IAAI,CAAC,WAAW,EAChB,cAAc,CACf,CAAC;QAEF,MAAM,CAAC,IAAI,CACT,yEAAyE,EACzE,EAAE,KAAK,EAAE,IAAI,CAAC,0BAA0B,CAAC,MAAM,EAAE,cAAc,EAAE,CAClE,CAAC;QAEF,MAAM,OAAO,CAAC,GAAG,CACf,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;YACtD,MAAM,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YAC3C,MAAM,CAAC,KAAK,CAAC,iCAAiC,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;QACjE,CAAC,CAAC,CACH,CAAC;QAEF,MAAM,CAAC,IAAI,CACT,oEAAoE,EACpE,EAAE,cAAc,EAAE,CACnB,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,oCAAoC,CAAC,EACzC,cAAc,EACd,MAAM,EACN,qBAAqB,EACrB,aAAa,EACb,gBAAgB,EAChB,oBAAoB,EACpB,QAAQ,GAST;QACC,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;QAEzC,MAAM,OAAO,CAAC,GAAG,CAAC;YAChB,aAAa,CAAC,+BAA+B,CAAC;gBAC5C,eAAe,EAAE,qBAAqB;gBACtC,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,UAAU,EAAE,eAAe;gBAC3B,WAAW,EAAE,gBAAgB;aAC9B,CAAC;YACF,aAAa,CAAC,+BAA+B,CAAC;gBAC5C,eAAe,EAAE,qBAAqB;gBACtC,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,UAAU,EAAE,eAAe;gBAC3B,WAAW,EAAE,QAAQ;aACtB,CAAC;YACF,aAAa,CAAC,+BAA+B,CAAC;gBAC5C,eAAe,EAAE,qBAAqB;gBACtC,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,UAAU,EAAE,qBAAqB;gBACjC,WAAW,EAAE,cAAc;aAC5B,CAAC;YACF,aAAa,CAAC,+BAA+B,CAAC;gBAC5C,eAAe,EAAE,qBAAqB;gBACtC,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,UAAU,EAAE,WAAW;gBACvB,WAAW,EAAE,oBAAoB,CAAC,EAAE;aACrC,CAAC;YACF,aAAa,CAAC,+BAA+B,CAAC;gBAC5C,eAAe,EAAE,qBAAqB;gBACtC,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,UAAU,EAAE,kBAAkB;gBAC9B,WAAW,EAAE,oBAAoB,CAAC,QAAQ;aAC3C,CAAC;YACF,aAAa,CAAC,+BAA+B,CAAC;gBAC5C,eAAe,EAAE,qBAAqB;gBACtC,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,UAAU,EAAE,wBAAwB;gBACpC,WAAW,EAAE,oBAAoB,CAAC,cAAc;aACjD,CAAC;YACF,aAAa,CAAC,+BAA+B,CAAC;gBAC5C,eAAe,EAAE,qBAAqB;gBACtC,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,UAAU,EAAE,YAAY;gBACxB,WAAW,EAAE,oBAAoB,CAAC,GAAG,CAAC,OAAO,EAAE;aAChD,CAAC;SACH,CAAC,CAAC;QAEH,MAAM,CAAC,KAAK,CAAC,sDAAsD,EAAE;YACnE,eAAe,EAAE,qBAAqB;YACtC,cAAc,EAAE,cAAc;SAC/B,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,sBAAsB,CAAC,EAC3B,cAAc,EACd,YAAY,EACZ,oBAAoB,GAKrB;QACC,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;QAEzC,MAAM,IAAI,CAAC,6BAA6B,CAAC;YACvC,cAAc;YACd,YAAY;SACb,CAAC,CAAC;QAEH,MAAM,YAAY,GAAG,IAAI,YAAY,CACnC,WAAW,YAAY,mBAAmB,EAC1C,IAAI,CAAC,WAAW,CACjB,CAAC;QAEF,MAAM,OAAO,CAAC,GAAG,CAAC;YAChB,YAAY,CAAC,SAAS,CAAC,sBAAsB,EAAE,oBAAoB,CAAC,EAAE,CAAC;YACvE,YAAY,CAAC,SAAS,CACpB,mCAAmC,EACnC,oBAAoB,CAAC,cAAc,CACpC;YACD,YAAY,CAAC,SAAS,CACpB,uBAAuB,EACvB,oBAAoB,CAAC,GAAG,CAAC,OAAO,EAAE,CACnC;SACF,CAAC,CAAC;QAEH,MAAM,CAAC,KAAK,CACV,8EAA8E,EAC9E,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,CACjD,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,6BAA6B,CAAC,EAClC,cAAc,EACd,YAAY,GAIb;QACC,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;QACzC,MAAM,QAAQ,GAAG,GAAG,YAAY,kBAAkB,CAAC;QAEnD,6EAA6E;QAC7E,wEAAwE;QACxE,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,2BAA2B,EAAE,OAAO,EAAE,EAAE,CAAC;YACxE,IAAI,CAAC;gBACH,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAC;gBACvB,OAAO;YACT,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IACE,CAAC,sBAAsB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO;oBAChD,OAAO,KAAK,2BAA2B,EACvC,CAAC;oBACD,MAAM,IAAI,KAAK,CACb,uBAAuB,QAAQ,qBAAqB,EACpD,EAAE,KAAK,EAAE,CACV,CAAC;gBACJ,CAAC;gBAED,MAAM,CAAC,KAAK,CACV,iGAAiG,EACjG,EAAE,QAAQ,EAAE,cAAc,EAAE,cAAc,EAAE,CAC7C,CAAC;gBACF,MAAM,KAAK,CAAC,4BAA4B,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;IACH,CAAC;CACF","sourcesContent":["import type { TokenCredential } from \"@azure/identity\";\n\nimport { AuthorizationManagementClient } from \"@azure/arm-authorization\";\nimport { KeyVaultManagementClient } from \"@azure/arm-keyvault\";\nimport { ManagedServiceIdentityClient } from \"@azure/arm-msi\";\nimport { ResourceGraphClient } from \"@azure/arm-resourcegraph\";\nimport { ResourceManagementClient } from \"@azure/arm-resources\";\nimport { SubscriptionClient } from \"@azure/arm-resources-subscriptions\";\nimport { StorageManagementClient } from \"@azure/arm-storage\";\nimport { SecretClient } from \"@azure/keyvault-secrets\";\nimport { BlobServiceClient } from \"@azure/storage-blob\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { Client } from \"@microsoft/microsoft-graph-client\";\nimport * as assert from \"node:assert/strict\";\nimport { createHash } from \"node:crypto\";\nimport { lookup } from \"node:dns/promises\";\nimport { setTimeout as sleep } from \"node:timers/promises\";\nimport { z } from \"zod/v4\";\n\nimport {\n  CloudAccount,\n  type CloudAccountService,\n} from \"../../domain/cloud-account.js\";\nimport {\n  type EnvironmentId,\n  environmentShort,\n} from \"../../domain/environment.js\";\nimport { type GitHubRepo } from \"../../domain/github-repo.js\";\nimport {\n  GitHubAppCredentials,\n  type GitHubService,\n} from \"../../domain/github.js\";\nimport {\n  type TerraformBackend,\n  terraformBackendSchema,\n} from \"../../domain/remote-backend.js\";\nimport { isAzureLocation, locations, locationShort } from \"./locations.js\";\n\n// We are only interested in these properties for now;\n// the actual result structure contains the full cloud resource object\nexport const resourceGraphDataSchema = z.object({\n  location: z.enum(locations),\n  name: z.string(),\n  resourceGroup: z.string(),\n});\n\nconst graphUserResponseSchema = z.object({\n  id: z.string(),\n});\n\nconst graphGroupMembershipItemSchema = z.object({\n  id: z.string(),\n});\n\nconst graphGroupMembershipResponseSchema = z.object({\n  \"@odata.nextLink\": z.string().optional(),\n  value: z.array(graphGroupMembershipItemSchema),\n});\n\nconst builtInRoleDefinitionIds = {\n  contributor: \"b24988ac-6180-42a0-ab88-20f7382dd24c\",\n  keyVaultSecretsOfficer: \"b86a8fe4-44ce-4948-aee5-eccb2c155cd7\",\n  owner: \"8e3af657-a8ff-443c-a75c-2fe8c4bcb635\",\n  roleBasedAccessControlAdministrator: \"f58310d9-a9f6-439a-9e8d-f62e7b41a168\",\n  storageBlobDataContributor: \"ba92f5b4-2d11-453d-a403-e96b0029c9fe\",\n} as const;\n\nconst bootstrapIdentityRoleDefinitionIds = [\n  // These roles let the bootstrap identity run the bootstrapper module from GitHub Actions without extra manual grants.\n  builtInRoleDefinitionIds.roleBasedAccessControlAdministrator,\n  builtInRoleDefinitionIds.contributor,\n  builtInRoleDefinitionIds.storageBlobDataContributor,\n] as const;\n\nconst keyVaultDnsErrorSchema = z.object({\n  code: z.enum([\"EAI_AGAIN\", \"ENOTFOUND\"]),\n});\nconst keyVaultDnsReadyMaxAttempts = 30;\nconst keyVaultDnsReadyRetryDelayMs = 10_000;\n\nexport class AzureCloudAccountService implements CloudAccountService {\n  #credential: TokenCredential;\n  #requiredResourceProviders = [\n    \"Microsoft.Advisor\",\n    \"Microsoft.AlertsManagement\",\n    \"Microsoft.ApiManagement\",\n    \"Microsoft.App\",\n    \"Microsoft.Authorization\",\n    \"Microsoft.AzureTerraform\",\n    \"Microsoft.Cache\",\n    \"Microsoft.Cdn\",\n    \"Microsoft.ContainerInstance\",\n    \"Microsoft.CostManagement\",\n    \"Microsoft.DBforPostgreSQL\",\n    \"Microsoft.KeyVault\",\n    \"Microsoft.ServiceBus\",\n    \"Microsoft.Sql\",\n    \"Microsoft.Storage\",\n    \"Microsoft.Web\",\n  ] as const;\n  #resourceGraphClient: ResourceGraphClient;\n\n  constructor(credential: TokenCredential) {\n    this.#resourceGraphClient = new ResourceGraphClient(credential);\n    this.#credential = credential;\n  }\n\n  async getTerraformBackend(\n    cloudAccountId: CloudAccount[\"id\"],\n    { name, prefix }: EnvironmentId,\n  ): Promise<TerraformBackend | undefined> {\n    const allLocations = Object.values(locationShort).join(\"|\");\n    const shortEnv = environmentShort[name];\n    // Check if a storage account with the expected name exists\n    // $prefix + environment short + location + \"tfstatest\" + suffix (e.g., \"dxpitntfstatest01\")\n    // it can return multiple results (e.g. for different location or instance number)\n    const resourceName = `${prefix}${shortEnv}(${allLocations})tfstatest(0[1-9]|[1-9]\\\\d)`;\n    const query = `resources\n             | where type == 'microsoft.storage/storageaccounts'\n             | where name matches regex @'${resourceName}'\n            `;\n    const result = await this.#resourceGraphClient.resources({\n      query,\n      subscriptions: [cloudAccountId],\n    });\n    if (result.totalRecords === 0) {\n      return undefined;\n    }\n    const storageAccounts = z.array(resourceGraphDataSchema).parse(result.data);\n    // on multiple results, rank storage accounts by location priority and instance number\n    if (storageAccounts.length > 0) {\n      storageAccounts.sort((a, b) => {\n        // compare locations priority\n        const locationComparison =\n          locations.indexOf(a.location) - locations.indexOf(b.location);\n        if (locationComparison === 0) {\n          // same location, compare by name (to get the highest instance number)\n          return b.name.localeCompare(a.name);\n        }\n        return locationComparison;\n      });\n    }\n    return terraformBackendSchema.parse({\n      resourceGroupName: storageAccounts[0].resourceGroup,\n      storageAccountName: storageAccounts[0].name,\n      subscriptionId: cloudAccountId,\n      type: \"azurerm\",\n    });\n  }\n\n  async hasUserPermissionToInitialize(\n    cloudAccountId: CloudAccount[\"id\"],\n  ): Promise<boolean> {\n    try {\n      // All principal IDs to check (user + all groups)\n      const allPrincipalIds = await this.#getCurrentPrincipalIds();\n\n      // Get role assignments for the subscription\n      const authClient = new AuthorizationManagementClient(\n        this.#credential,\n        cloudAccountId,\n      );\n\n      const requiredRoles = [\n        builtInRoleDefinitionIds.owner, // Owner\n        builtInRoleDefinitionIds.storageBlobDataContributor, // Storage Blob Data Contributor\n        builtInRoleDefinitionIds.keyVaultSecretsOfficer, // Key Vault Secrets Officer\n      ];\n\n      const scope = `/subscriptions/${cloudAccountId}`;\n\n      // Collect all role definition IDs assigned to the user or their groups\n      const assignedRoleDefinitionIds = new Set<string>();\n\n      for await (const assignment of authClient.roleAssignments.listForScope(\n        scope,\n      )) {\n        // Check if this assignment is for the user or any of their groups\n        if (\n          assignment.principalId &&\n          allPrincipalIds.has(assignment.principalId)\n        ) {\n          // Extract role definition ID from the full resource ID\n          // Format: /subscriptions/{sub}/providers/Microsoft.Authorization/roleDefinitions/{roleId}\n          const roleDefId = assignment.roleDefinitionId?.split(\"/\").pop();\n          if (roleDefId) {\n            assignedRoleDefinitionIds.add(roleDefId);\n          }\n        }\n\n        // Short-circuit: stop if all required roles have been found\n        if (\n          requiredRoles.every((requiredRole) =>\n            assignedRoleDefinitionIds.has(requiredRole),\n          )\n        ) {\n          return true;\n        }\n      }\n\n      // Check if all required roles are present\n      const hasAllRoles = requiredRoles.every((requiredRole) =>\n        assignedRoleDefinitionIds.has(requiredRole),\n      );\n\n      return hasAllRoles;\n    } catch (error: unknown) {\n      // Handle authorization errors (403 Forbidden) - user lacks permissions\n      if (\n        error &&\n        typeof error === \"object\" &&\n        \"statusCode\" in error &&\n        error.statusCode === 403\n      ) {\n        return false;\n      }\n      // Re-throw other errors\n      throw error;\n    }\n  }\n\n  async initialize(\n    cloudAccount: CloudAccount,\n    { name, prefix }: EnvironmentId,\n    runnerAppCredentials: GitHubAppCredentials,\n    github: GitHubRepo,\n    gitHubService: GitHubService,\n    tags: Record<string, string> = {},\n  ): Promise<void> {\n    assert.equal(cloudAccount.csp, \"azure\", \"Cloud account must be Azure\");\n    assert.ok(\n      isAzureLocation(cloudAccount.defaultLocation),\n      \"The default location of the cloud account is not a valid Azure location\",\n    );\n\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    // Register required resource providers before creating any resources\n    await this.#registerProviders(cloudAccount.id);\n\n    const resourceManagementClient = new ResourceManagementClient(\n      this.#credential,\n      cloudAccount.id,\n    );\n\n    const short = {\n      env: environmentShort[name],\n      location: locationShort[cloudAccount.defaultLocation],\n    };\n\n    const resourceGroupName = `${prefix}-${short.env}-${short.location}-common-rg-01`;\n\n    const parameters = {\n      location: cloudAccount.defaultLocation,\n      tags: {\n        CreatedBy: \"DX CLI\",\n        Environment: name,\n        ...tags,\n      },\n    };\n\n    await resourceManagementClient.resourceGroups.createOrUpdate(\n      resourceGroupName,\n      parameters,\n    );\n\n    logger.debug(\n      \"Created resource group {resourceGroupName} in subscription {subscriptionId}\",\n      { resourceGroupName, subscriptionId: cloudAccount.id },\n    );\n\n    try {\n      const identityName = `${prefix}-${short.env}-${short.location}-bootstrap-id-01`;\n\n      const msiClient = new ManagedServiceIdentityClient(\n        this.#credential,\n        cloudAccount.id,\n      );\n\n      const identity = await msiClient.userAssignedIdentities.createOrUpdate(\n        resourceGroupName,\n        identityName,\n        parameters,\n      );\n\n      assert.ok(\n        identity.principalId,\n        \"Managed identity principal ID is undefined\",\n      );\n      const identityPrincipalId = identity.principalId;\n      assert.ok(identity.clientId, \"Managed identity client ID is undefined\");\n      const identityClientId = identity.clientId;\n\n      logger.debug(\n        \"Created identity {identityName} in subscription {subscriptionId}\",\n        { identityName, subscriptionId: cloudAccount.id },\n      );\n\n      const authorizationManagementClient = new AuthorizationManagementClient(\n        this.#credential,\n        cloudAccount.id,\n      );\n      const subscriptionClient = new SubscriptionClient(this.#credential);\n      const subscription = await subscriptionClient.subscriptions.get(\n        cloudAccount.id,\n      );\n      assert.ok(subscription.tenantId, \"Subscription tenant ID is undefined\");\n      const tenantId = subscription.tenantId;\n      const subscriptionScope = `/subscriptions/${cloudAccount.id}`;\n\n      // Grant the bootstrap identity the Azure permissions it needs to operate autonomously in the bootstrap workflow.\n      await Promise.all(\n        bootstrapIdentityRoleDefinitionIds.map((roleDefinitionId) =>\n          authorizationManagementClient.roleAssignments.create(\n            subscriptionScope,\n            this.#createRoleAssignmentName(\n              subscriptionScope,\n              identityPrincipalId,\n              roleDefinitionId,\n            ),\n            {\n              principalId: identityPrincipalId,\n              principalType: \"ServicePrincipal\",\n              roleDefinitionId: this.#createRoleDefinitionResourceId(\n                cloudAccount.id,\n                roleDefinitionId,\n              ),\n            },\n          ),\n        ),\n      );\n\n      logger.debug(\n        \"Assigned bootstrap roles to identity {identityName} in subscription {subscriptionId}\",\n        { identityName, subscriptionId: cloudAccount.id },\n      );\n\n      const githubEnvironmentName = `bootstrapper-${name}-cd`;\n      const federatedCredentialName = this.#createFederatedCredentialName({\n        github,\n        githubEnvironmentName,\n      });\n\n      // Include a repository-derived suffix so different repositories can share\n      // the same bootstrap identity without overwriting each other's OIDC trust.\n      await msiClient.federatedIdentityCredentials.createOrUpdate(\n        resourceGroupName,\n        identityName,\n        federatedCredentialName,\n        {\n          audiences: [\"api://AzureADTokenExchange\"],\n          issuer: \"https://token.actions.githubusercontent.com\",\n          subject: `repo:${github.owner}/${github.repo}:environment:${githubEnvironmentName}`,\n        },\n      );\n\n      logger.debug(\n        \"Configured federated identity credential {credentialName} for identity {identityName} in subscription {subscriptionId}\",\n        {\n          credentialName: federatedCredentialName,\n          identityName,\n          subscriptionId: cloudAccount.id,\n        },\n      );\n\n      await this.#storeBootstrapperEnvironmentSecrets({\n        cloudAccountId: cloudAccount.id,\n        github,\n        githubEnvironmentName,\n        gitHubService,\n        identityClientId,\n        runnerAppCredentials,\n        tenantId,\n      });\n\n      const keyVaultName = await this.#createCommonKeyVault({\n        cloudAccount,\n        name,\n        prefix,\n        resourceGroupName,\n        shortEnv: short.env,\n        shortLocation: short.location,\n        tags,\n        tenantId,\n      });\n\n      await this.#storeRunnerAppSecrets({\n        cloudAccountId: cloudAccount.id,\n        keyVaultName,\n        runnerAppCredentials,\n      });\n    } catch (cause) {\n      // Cleanup resource group if initialization fails\n      await resourceManagementClient.resourceGroups.beginDeleteAndWait(\n        resourceGroupName,\n      );\n      logger.debug(\n        \"Deleted resource group {resourceGroupName} in subscription {subscriptionId} due to initialization failure\",\n        { resourceGroupName, subscriptionId: cloudAccount.id },\n      );\n      if (cause instanceof Error) {\n        logger.error(cause.message);\n      }\n      throw new Error(`Error during the initialization of the cloud account`, {\n        cause,\n      });\n    }\n  }\n\n  async isInitialized(\n    cloudAccountId: CloudAccount[\"id\"],\n    { name, prefix }: EnvironmentId,\n  ): Promise<boolean> {\n    const allLocations = Object.values(locationShort).join(\"|\");\n    const shortEnv = environmentShort[name];\n\n    const identityResourceName = `${prefix}-${shortEnv}-(${allLocations})-bootstrap-id-(0[1-9]|[1-9]\\\\d)`;\n    const identityQuery = `resources\n             | where type == 'microsoft.managedidentity/userassignedidentities'\n             | where name matches regex @'${identityResourceName}'\n            `;\n\n    const keyVaultResourceName = `${prefix}-${shortEnv}-(${allLocations})-common-kv-(0[1-9]|[1-9]\\\\d)`;\n    const keyVaultQuery = `resources\n             | where type == 'microsoft.keyvault/vaults'\n             | where name matches regex @'${keyVaultResourceName}'\n            `;\n\n    const [identityResult, keyVaultResult, areProvidersRegistered] =\n      await Promise.all([\n        this.#resourceGraphClient.resources({\n          query: identityQuery,\n          subscriptions: [cloudAccountId],\n        }),\n        this.#resourceGraphClient.resources({\n          query: keyVaultQuery,\n          subscriptions: [cloudAccountId],\n        }),\n        this.#areProvidersRegistered(cloudAccountId),\n      ]);\n\n    const initialized =\n      identityResult.totalRecords > 0 &&\n      keyVaultResult.totalRecords > 0 &&\n      areProvidersRegistered;\n\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    logger.debug(\"subscription {subscriptionId} initialized: {initialized}\", {\n      initialized,\n      subscriptionId: cloudAccountId,\n    });\n\n    return initialized;\n  }\n\n  async provisionTerraformBackend(\n    cloudAccount: CloudAccount,\n    { name, prefix }: EnvironmentId,\n    tags: Record<string, string> = {},\n  ): Promise<TerraformBackend> {\n    assert.equal(cloudAccount.csp, \"azure\", \"Cloud account must be Azure\");\n    assert.ok(\n      isAzureLocation(cloudAccount.defaultLocation),\n      \"The default location of the cloud account is not a valid Azure location\",\n    );\n\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    const resourceManagementClient = new ResourceManagementClient(\n      this.#credential,\n      cloudAccount.id,\n    );\n\n    const short = {\n      env: environmentShort[name],\n      location: locationShort[cloudAccount.defaultLocation],\n    };\n\n    const parameters = {\n      location: cloudAccount.defaultLocation,\n      tags: {\n        Environment: name,\n        ...tags,\n      },\n    };\n\n    const resourceGroupName = `${prefix}-${short.env}-${short.location}-tfstate-rg-01`;\n\n    await resourceManagementClient.resourceGroups.createOrUpdate(\n      resourceGroupName,\n      parameters,\n    );\n\n    logger.debug(\n      \"Created resource group {resourceGroupName} in subscription {subscriptionId}\",\n      { resourceGroupName, subscriptionId: cloudAccount.id },\n    );\n\n    const storageManagementClient = new StorageManagementClient(\n      this.#credential,\n      cloudAccount.id,\n    );\n\n    const storageAccount =\n      await storageManagementClient.storageAccounts.beginCreateAndWait(\n        resourceGroupName,\n        `${prefix}${short.env}${short.location}tfstatest01`,\n        {\n          kind: \"StorageV2\",\n          sku: {\n            name: \"Standard_LRS\",\n            tier: \"Standard\",\n          },\n          ...parameters,\n        },\n      );\n\n    assert.ok(\n      storageAccount.primaryEndpoints?.blob,\n      \"Storage account blob endpoint is undefined\",\n    );\n\n    assert.ok(storageAccount.name, \"Storage account name is undefined\");\n\n    logger.debug(\n      \"Created storage account {storageAccountName} in subscription {subscriptionId}\",\n      {\n        storageAccountName: storageAccount.name,\n        subscriptionId: cloudAccount.id,\n      },\n    );\n    const blobServiceClient = new BlobServiceClient(\n      storageAccount.primaryEndpoints?.blob,\n      this.#credential,\n    );\n\n    const containerClient =\n      blobServiceClient.getContainerClient(\"terraform-state\");\n\n    try {\n      await containerClient.create();\n    } catch (e) {\n      // Cleanup resource group if blob container creation fails\n      // resource group deletion also deletes all contained resources\n      await resourceManagementClient.resourceGroups.beginDeleteAndWait(\n        resourceGroupName,\n      );\n      throw new Error(`Error during the creation of the blob container`, {\n        cause: e,\n      });\n    }\n\n    return terraformBackendSchema.parse({\n      resourceGroupName,\n      storageAccountName: storageAccount.name,\n      subscriptionId: cloudAccount.id,\n      type: \"azurerm\",\n    });\n  }\n\n  async #areProvidersRegistered(subscriptionId: string): Promise<boolean> {\n    const client = new ResourceManagementClient(\n      this.#credential,\n      subscriptionId,\n    );\n    const results = await Promise.all(\n      this.#requiredResourceProviders.map(async (namespace) => {\n        const provider = await client.providers.get(namespace);\n        return provider.registrationState === \"Registered\";\n      }),\n    );\n    return results.every(Boolean);\n  }\n\n  async #createCommonKeyVault({\n    cloudAccount,\n    name,\n    prefix,\n    resourceGroupName,\n    shortEnv,\n    shortLocation,\n    tags,\n    tenantId,\n  }: {\n    cloudAccount: CloudAccount;\n    name: EnvironmentId[\"name\"];\n    prefix: string;\n    resourceGroupName: string;\n    shortEnv: string;\n    shortLocation: string;\n    tags: Record<string, string>;\n    tenantId: string;\n  }): Promise<string> {\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    const kvClient = new KeyVaultManagementClient(\n      this.#credential,\n      cloudAccount.id,\n    );\n\n    const keyVaultName = `${prefix}-${shortEnv}-${shortLocation}-common-kv-01`;\n    const secretsProtectionEnabled = shortEnv === \"p\";\n\n    const result = await kvClient.vaults.checkNameAvailability({\n      name: keyVaultName,\n      type: \"Microsoft.KeyVault/vaults\",\n    });\n\n    await kvClient.vaults.beginCreateOrUpdateAndWait(\n      resourceGroupName,\n      keyVaultName,\n      {\n        location: cloudAccount.defaultLocation,\n        properties: {\n          createMode: result.nameAvailable ? \"default\" : \"recover\",\n          enabledForDiskEncryption: true,\n          enablePurgeProtection: secretsProtectionEnabled ? true : undefined,\n          enableRbacAuthorization: true,\n          sku: {\n            family: \"A\",\n            name: \"standard\",\n          },\n          softDeleteRetentionInDays: secretsProtectionEnabled ? 14 : 7,\n          tenantId,\n        },\n        tags: {\n          Environment: name,\n          ...tags,\n        },\n      },\n    );\n\n    logger.debug(\n      \"Created key vault {keyVaultName} in subscription {subscriptionId}\",\n      { keyVaultName, subscriptionId: cloudAccount.id },\n    );\n\n    return keyVaultName;\n  }\n\n  #createFederatedCredentialName({\n    github,\n    githubEnvironmentName,\n  }: {\n    github: GitHubRepo;\n    githubEnvironmentName: string;\n  }): string {\n    const repoName = github.repo.replaceAll(/[^a-zA-Z0-9-]/g, \"-\");\n\n    return `${repoName}-${githubEnvironmentName}`;\n  }\n\n  #createRoleAssignmentName(\n    scope: string,\n    principalId: string,\n    roleDefinitionId: string,\n  ): string {\n    const hash = createHash(\"sha256\")\n      .update(`${scope}:${principalId}:${roleDefinitionId}`)\n      .digest(\"hex\");\n\n    return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(\n      12,\n      16,\n    )}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;\n  }\n\n  #createRoleDefinitionResourceId(\n    subscriptionId: string,\n    roleDefinitionId: string,\n  ): string {\n    return `/subscriptions/${subscriptionId}/providers/Microsoft.Authorization/roleDefinitions/${roleDefinitionId}`;\n  }\n\n  async #getCurrentPrincipalIds(): Promise<Set<string>> {\n    // Create Graph client with custom auth provider that fetches fresh tokens\n    const graphClient = Client.init({\n      authProvider: async (done) => {\n        try {\n          const tokenResponse = await this.#credential.getToken(\n            \"https://graph.microsoft.com/.default\",\n          );\n          if (!tokenResponse) {\n            done(\n              new Error(\"Failed to acquire token for Microsoft Graph\"),\n              null,\n            );\n            return;\n          }\n          done(null, tokenResponse.token);\n        } catch (error) {\n          done(error as Error, null);\n        }\n      },\n    });\n\n    // Get current user's info\n    const meResponse = await graphClient.api(\"/me\").get();\n    const me = graphUserResponseSchema.parse(meResponse);\n    const userObjectId = me.id;\n\n    // Get all group memberships (transitive - includes nested groups)\n    const groupIds: string[] = [];\n    let nextLink: string | undefined = \"/me/transitiveMemberOf?$select=id\";\n\n    while (nextLink) {\n      const rawResponse = await graphClient.api(nextLink).get();\n      const response = graphGroupMembershipResponseSchema.parse(rawResponse);\n      for (const item of response.value) {\n        groupIds.push(item.id);\n      }\n      nextLink = response[\"@odata.nextLink\"];\n    }\n\n    // All principal IDs to check (user + all groups)\n    const allPrincipalIds = new Set([userObjectId, ...groupIds]);\n    return allPrincipalIds;\n  }\n\n  async #registerProviders(subscriptionId: string): Promise<void> {\n    const logger = getLogger([\"dx-cli\", \"register-providers\"]);\n    const client = new ResourceManagementClient(\n      this.#credential,\n      subscriptionId,\n    );\n\n    logger.info(\n      \"Registering {count} resource providers on subscription {subscriptionId}\",\n      { count: this.#requiredResourceProviders.length, subscriptionId },\n    );\n\n    await Promise.all(\n      this.#requiredResourceProviders.map(async (namespace) => {\n        await client.providers.register(namespace);\n        logger.debug(\"Registered provider {namespace}\", { namespace });\n      }),\n    );\n\n    logger.info(\n      \"All resource providers registered on subscription {subscriptionId}\",\n      { subscriptionId },\n    );\n  }\n\n  async #storeBootstrapperEnvironmentSecrets({\n    cloudAccountId,\n    github,\n    githubEnvironmentName,\n    gitHubService,\n    identityClientId,\n    runnerAppCredentials,\n    tenantId,\n  }: {\n    cloudAccountId: string;\n    github: GitHubRepo;\n    githubEnvironmentName: string;\n    gitHubService: GitHubService;\n    identityClientId: string;\n    runnerAppCredentials: GitHubAppCredentials;\n    tenantId: string;\n  }): Promise<void> {\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    await Promise.all([\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"ARM_CLIENT_ID\",\n        secretValue: identityClientId,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"ARM_TENANT_ID\",\n        secretValue: tenantId,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"ARM_SUBSCRIPTION_ID\",\n        secretValue: cloudAccountId,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"GH_APP_ID\",\n        secretValue: runnerAppCredentials.id,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"GH_APP_CLIENT_ID\",\n        secretValue: runnerAppCredentials.clientId,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"GH_APP_INSTALLATION_ID\",\n        secretValue: runnerAppCredentials.installationId,\n      }),\n      gitHubService.createOrUpdateEnvironmentSecret({\n        environmentName: githubEnvironmentName,\n        owner: github.owner,\n        repo: github.repo,\n        secretName: \"GH_APP_KEY\",\n        secretValue: runnerAppCredentials.key.trimEnd(),\n      }),\n    ]);\n\n    logger.debug(\"Set GitHub environment secrets for {environmentName}\", {\n      environmentName: githubEnvironmentName,\n      subscriptionId: cloudAccountId,\n    });\n  }\n\n  async #storeRunnerAppSecrets({\n    cloudAccountId,\n    keyVaultName,\n    runnerAppCredentials,\n  }: {\n    cloudAccountId: string;\n    keyVaultName: string;\n    runnerAppCredentials: GitHubAppCredentials;\n  }): Promise<void> {\n    const logger = getLogger([\"gen\", \"env\"]);\n\n    await this.#waitForKeyVaultDnsResolution({\n      cloudAccountId,\n      keyVaultName,\n    });\n\n    const secretClient = new SecretClient(\n      `https://${keyVaultName}.vault.azure.net/`,\n      this.#credential,\n    );\n\n    await Promise.all([\n      secretClient.setSecret(\"github-runner-app-id\", runnerAppCredentials.id),\n      secretClient.setSecret(\n        \"github-runner-app-installation-id\",\n        runnerAppCredentials.installationId,\n      ),\n      secretClient.setSecret(\n        \"github-runner-app-key\",\n        runnerAppCredentials.key.trimEnd(), // strip trailing newlines from PEM keys\n      ),\n    ]);\n\n    logger.debug(\n      \"Created secrets in key vault {keyVaultName} in subscription {subscriptionId}\",\n      { keyVaultName, subscriptionId: cloudAccountId },\n    );\n  }\n\n  async #waitForKeyVaultDnsResolution({\n    cloudAccountId,\n    keyVaultName,\n  }: {\n    cloudAccountId: CloudAccount[\"id\"];\n    keyVaultName: string;\n  }): Promise<void> {\n    const logger = getLogger([\"gen\", \"env\"]);\n    const hostname = `${keyVaultName}.vault.azure.net`;\n\n    // Azure can report the vault as created before its public DNS name is ready.\n    // Wait here so writing runner app secrets does not fail with ENOTFOUND.\n    for (let attempt = 1; attempt <= keyVaultDnsReadyMaxAttempts; attempt++) {\n      try {\n        await lookup(hostname);\n        return;\n      } catch (cause) {\n        if (\n          !keyVaultDnsErrorSchema.safeParse(cause).success ||\n          attempt === keyVaultDnsReadyMaxAttempts\n        ) {\n          throw new Error(\n            `Key vault endpoint '${hostname}' is not resolvable`,\n            { cause },\n          );\n        }\n\n        logger.debug(\n          \"Waiting for key vault endpoint {hostname} to become resolvable in subscription {subscriptionId}\",\n          { hostname, subscriptionId: cloudAccountId },\n        );\n        await sleep(keyVaultDnsReadyRetryDelayMs);\n      }\n    }\n  }\n}\n"]}

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 {};